1、面向过程
以函数（方法）为最小单位，数据独立于函数之外，以过程步骤为主，考虑怎么做，他是一个执行者。
2、面向对象
以类、对象为最小单位，类包括：数据+方法，以对象为主，考虑谁来做，谁能做，指挥者。
3、面向对象的基本特征
封装，继承，多态。
4、类和对象
1、类
类是一类具有相同特征的事物的抽象描述，是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该事件。
2、属性
属性：状态信息。
3、行为
行为：能做什么。
4、例
1、属性：颜色，名字，年龄，性别，体重，品种。
2、行为：走，跑，跳，叫，吃，睡。
5、类与对象的关系
1、类是对⼀类事物的描述，是抽象的。
2、对象是⼀类事物的实例，是具体的。
3.、类是对象的模板，对象是类的实体。 6、创建类 1、成员变量：对应事物的属性。 2、成员方法：对应事物的行为。 7、类的定义 1、public class 类名{ 成员变量 成员⽅法}。 2、定义类，就是定义类的成员，包括成员变量和成员⽅法。 3、成员变量：和以前定义变量⼏乎是⼀样的，只不过位置发⽣了改变，在类中，⽅法外。 4、成员⽅法：和以前写的main⽅法格式类似，只不这功能和形式更丰富，在类中，⽅法外。 8、例public class Person {
//定义成员变量
String name;//姓名
int age;//年龄
String gander;//性别
double height=1.68;//身高
//定义成员方法
public void walk() {
System.out.println("人会走路");
}
//成员方法，显示信息
public String display() {
return "名字是：" + name + ",年龄是：" + age + ",性别是：" + gander+"，身高："+height;
}
}
9、对象的创建
1、new 类名() //匿名对象。 2、类名 对象名 = new 类名(); //把创建的对象保存下来，⽅便后续使用。 3、public class PersonTest {
public static void main(String[] args) {
//创建对象
Person person=new Person();//person就是创建的一个Person对象
System.out.println(person.display());
person.name="小白";
person.age=18;
person.gander="女";
System.out.println(person.display());
}
}
4、对象是引用数据类型
5、成员变量
1、分类
1、实例变量：也叫对象属性，属于某个对象的，通过对象来使用。
2、类变量：属于整个类，不属于某个实例。
//public class PersonTest {
// public static void main(String[] args) {
// //创建对象
// Person person=new Person();//person就是创建的一个Person对象
// System.out.println(person.display());
// person.name="小白";
// person.age=18;
// person.gander="女";
// System.out.println(person.display());
// }
//}
public class PersonTest {
public static void main(String[] args) {
//创建对象
Person person1 = new Person(); //person1就是创建的⼀个Person对象
System.out.println(person1.display());
person1.name = "⼩红";
person1.age = 18;
person1.gender = "⼥";
System.out.println(person1.display());
System.out.println(person1);
System.out.println(Person.guoJi);
Person.guoJi = "中华⼈⺠共和国";
System.out.println(person1.guoJi);//不建议，建议使⽤ 类名.类属性
//创建对象
Person person2 = new Person(); //person2就是创建的⼀个Person对象
System.out.println(person2.display());
person2.name = "⼩艳";
person2.age = 22;
person2.gender = "⼥";
System.out.println(person2.display());
System.out.println(person2);
System.out.println(Person.guoJi);
System.out.println(person2.display());
//Person对象
person2.name="⼩艳";
person2.age=22;
person2.gender="⼥";
System.out.println(person2.display());
System.out.println(person2);
System.out.println(Person.guoJi);
}
}
1、声明一个实例变量
1、 [修改符]class 类名{ [修改符] 数据类型 属性名；//属性是有默认值; [修改符] 数据类型 属性名=值；//给属性赋值初始值； } 2、属性的类型可以 是任意类型，基本数据类型，引⽤数据类型（类，接⼝，数组，字符串）。 3、 实例变量在其他类中使⽤，需要通过对象名.实例变量的⽅式。 4、实例变量的特点 1、成员变量有默认值 1、基本数据类型 1、 整数byte short int long 0 2、浮点数 float double 0.0 3、 字符 char '\u0000' 4、布尔 boolean false 2、引⽤数据类型 数组，类，接⼝，字符串 null。 2、实例变量的值，相对 于每个对象来说都是独⽴的。 5、实例变量的赋值 1、在声明属性时，显⽰赋值，在创建每个对象后，这个属性的值就不是默认值了，就是这个初始值。 2、通过对象属性来赋值。 6、实例变量和局部变量区别 1、在类中的位置不⼀样 1、实例变量： 在类中，⽅法外。 2、局部变量： 在⽅法中，或⽅法声明上（形式参数）。 2、作⽤范围不⼀样 1、实例变量：在类中直接⽤，其他类中的可以通过对象名.实例变量 来使⽤。 2、局部变量：当前⽅法的作⽤域中。 3、初始化的值不同 1、实例变量有默认值。 2、局部变量：没有默认值，必须先定义，赋值，再使⽤。 4、在内存中的位置不同 1、实例变量 ：堆内存。 2、局部变量： 栈内存。 5、生命周期不同 1、实例变量：随着对象的创建或类的加载⽽存在，随着对象的消失⽽消失。 就是说没有创建对象，就不对在堆内存中分配空间，创建⼀个，就会分配⼀个。 2、局部变量： 1、随着⽅法的调⽤⽽存在，随着⽅法的调⽤完成⽽消失。 2、就是说⽅法在没有被调⽤时，该局部变量不会在栈中分配空间，调⽤⼀次，分配⼀次。 6、练习//练习：声明长方形类，包含长宽，两个实例变量，并创建长方形对象，求面积
public class Rectangle {
double length;//长
double width;//宽
public String area(){
return "面积为："+length*width;
}
}
class RectangleTest{
public static void main(String[] args) {
Rectangle rectangle = new Rectangle();
rectangle.length=4.0;
rectangle.width=3.0;
System.out.println(rectangle.area());
}
}
//练习：声明一个员工类，包含姓名，性别，薪资，三个实例变量，并创建员工对象，打印员工信息
public class Staff {
String name;
String gender;
double salary;
public String display() {
return "姓名：" + name + ",性别：" + gender + ",薪资" + salary;
}
}
class StaffTest {
public static void main(String[] args) {
Staff staff = new Staff();
staff.name = "张三";
staff.gender = "男";
staff.salary = 20000;
System.out.println(staff.display());
}
}
7、成员方法
1、⽅法也叫函数，是⼀个独⽴的功能的定义，是⼀个类中最基本的功能单元，把⼀个功能封装成⼀个⽅法，可以实现代码的重⽤，减少代码量。 2、方法的使用原则 1、必须先声明后使⽤（先定义后调⽤）。 2、不调⽤，不执⾏，调⽤⼀次执⾏⼀次，⽅法压栈⼀次。 3、成员方法的分类 1、实例⽅法：属于对象的⽅法，由对象来调⽤。 2、静态⽅法：也叫类⽅法，属于整个类的，不是属于某个实例，由类名来调⽤ 后有static。 4、语法： 1、修饰符 返回值类型 ⽅法名（参数类型1 参数1， 参数类型2 参数2.。。）{ ⽅法体 【 return 返回值】 } 2、返回值类型：表⽰⽅法运⾏的结果的数据类型，⽅法执⾏结果返回给调⽤者。 1、基本数据类型，引⽤数据类型。 2、⽆返回值时，void。 3、⽅法名：见名知意，⼩驼峰 4、return: 1、结束⽅法的作⽤，并将⽅法的执⾏结果返回给调⽤者。 2、如果返回值类型不是void,⽅法体中必须有return 返回值，返回值的类型要与声明时返回的类型⼀致。 3、如果返回值类型是void，return 后不⽤跟返回值，甚⾄可以不写return语句。 4、return 语句后，不写其他代码，否则会报错。 5、方法声明时，必须在类内，方法外。 6、方法的调用： 1、单独调用：对象名.⽅法名（参数）； 2. 输出调用：System.out.println(对象名.⽅法名(参数)); 3、赋值调用：数据类型 变量名= 对象名.⽅法名(参数); 7、练习 1、//定义两个整数的和，差，积，商方法，返回值类型，计算两个整数的和，差，积，商
import java.util.Scanner;
public class JiSuan {
public int sum(int a, int b) {
return a + b;
}
public int difference(int a, int b) {
return a - b;
}
public int product(int a, int b) {
return a * b;
}
public double quotient(double a, double b) {
return a / b;
}
}
class JiSuanTest {
public static void main(String[] args) {
JiSuan js = new JiSuan();
Scanner sc = new Scanner(System.in);
System.out.print("请输入第一个整数");
int a = sc.nextInt();
System.out.print("请输入第二个整数");
int b = sc.nextInt();
System.out.println("和：" + js.sum(a, b));
System.out.println("差：" + js.difference(a, b));
System.out.println("积：" + js.product(a, b));
if (b == 0) {
System.out.println("0不能做除数");
} else {
System.out.println("商：" + js.quotient(a, b));
}
}
}
2、形参：在定义⽅法时，⽅法名后⾯括号中的变量名就是形式参数，简称形参，即形参出现在⽅法定义中。
3、实参：调⽤者⽅法中调⽤另⼀个⽅法时，⽅法名后边的括号中的参数称为实际参数,简称实参，即实参出现在调⽤者⽅法中。
4、总结
1、调⽤时，需要通过⽅法名来识别调⽤的哪个⽅法。
2、调⽤时，需要传实参，实参的个数，类型，顺序，都需要与形参列表⼀⼀对应，如果⽅法没有形参，就不需要也不能传实参。
3. 调⽤时，如果⽅法有返回值，可以 接收或处理返回值结果，如果⽅法返回值类型是void，不需要也不能接收和处理返回的结果。
5、练习//比较两个整数是否相等，需要定义一个方法，两个参数，有返回值
import java.util.Scanner;
public class Equal {
public boolean compare(int a, int b) {
return a == b;
}
}
class EqualTest {
public static void main(String[] args) {
Equal e = new Equal();
Scanner scanner = new Scanner(System.in);
System.out.print("请输入第一个数：");
int a = scanner.nextInt();
System.out.print("请输入第二个数：");
int b = scanner.nextInt();
System.out.println(e.compare(a, b));
}
}
标签：Person,int,System,面向对象,println,public,out From： https://www.cnblogs.com/hsk991213/p/17671519.html