【JAVA入门】Day05 - 面向对象

---

---

        面向对象编程通俗来讲就是“拿东西来做对应的事情”，这里的“对象”自然是指“能干活的东西”。在面向对象编程时，你想做一件事情，就可以用专门做这件事情的“对象”来进行编程。

一、对象的设计和使用

1.1 类和对象

        对象是帮助人们解决问题的实例。而类是对这些对象共同特征的一种描述，它是对象的一种”上层设计“。
        在 JAVA 中，必须先设计类，才能获得对象。
        类的定义：

public class 类名 {1.成员变量（代表属性，一般是名词）2.成员方法（代表行为，一般是动词）3.构造器4.代码块5.内部类
}

例：

public class Phone {// 属性（成员变量）String brand;double price;// 行为（成员方法）public void call() { System.out.println("手机在打电话");}public void playGame() { System.out.println("手机在玩游戏");}
}

类的使用——生成对象：

public static void main(String[] args) {//创建手机的对象Phone p = new Phone();//给手机的品牌变量和价格变量赋值p.brand = "白象";p.price = 2999.99;//打印手机里的变量System.out.println(p.brand);System.out.println(p.price);//调用手机中的方法，玩手机p.call();p.playGame();
}

1.2 类的分类

• 用来描述一类事物的类，专业叫做：Javabean类。在 Javabean 类中，是不写 main 方法的。
• 而含有 main 方法的类，叫做测试类。我们可以在测试类中创建 Javabean 类的对象并进行赋值调用。

public class Student {String name;double height;public void study() { }public void sleep() {}
}

• 类名的首字母建议大写。
• 一个 Java 文件中可以定义多个 class 类，但是只能有一个 public class，而且 public 修饰的 class 名必须和代码的文件名一致。

二、封装

        对象代表什么，就得封装对应的数据，并提供数据对应的行为。

public class Circle {double radius;public void draw() {System.out.println("根据半径" + radius + "画一个圆");}
}

        人画圆，并不是人画，而是圆画，圆调用了自己的 draw 方法完成的，这才是类设计的正常思想。

三、private 关键字

• private 关键字是一个权限修饰符
• private 关键字可以修饰成员变量和成员方法
• 被 private 修饰的成员只能在本类中才能访问

public class GirlFriend {private String name;private int age;private String gender;
}

        如上代码所示，被 private 修饰的变量，只能在本类中才能访问，而用该类创建的对象则不可直接使用之。

GirlFriend gf1 = new GirlFriend();
gf1.age = 18;

        如此就会使程序报错，原因是直接访问了类的私有变量。
        如果想使用这些私有变量，就要按照如下的写法：

public class GirlFriend {private int age;private String name;//set方法（赋值）public void setAge(int a) {if(a >= 18 && a <= 50) {age = a;   //这里的 age 就是类里面的私有变量 age}else{System.out.println("非法数据");}}public void setName(String n) {name = n;}//get方法（取值）public int getAge() {return age;}public String getName() {return name;}
}

        只要给属性添加 public 的 set 和 get 方法，利用这两个方法间接调用这俩属性，就可以实现对它们的操纵。set 方法负责给变量赋值，get 方法负责获取变量的值。

GirlFriend gf1 = new GirlFriend();
gf1.setAge(18);
System.out.println(gf1.getAge());

四、this 关键字

public void setName(String n) {name = n;
}

        刚才的代码中，我们用形参 n 给 name 赋值，但是这个 n 并不能明确表达 name 的含义，有没有一种办法可以让 n 也体现 name呢？
        在 Java 中，区分两个同名变量的方法采用的是就近原则，谁离得近，就使用谁。

public class GirlFriend {private int age;public void method() {int age = 10;System.out.println(age);}
}

        以上述代码为例，我们定义了一个成员变量 age，之后又在成员方法 method() 里，重新定义了一个局部变量 age，那么这里的 sout 输出的到底是那个成员变量，还是这个局部变量呢？
        答案是输出10，因为就近原则，这个局部变量离得近，所以 age 被识别为这个局部变量。
        那如何令其输出那个成员变量呢？这时就可以引入 this 关键字了。

public class GirlFriend {private int age;public void method() {int age = 10;System.out.println(this.age);}
}

        因此，this 关键字，代指的就是当前类。这个时候的 age 被指明为该类的成员变量 GirlFriend.age。
        综上，利用 this 关键字，可以改写 set 方法，让它变得更加可读。

public void setName(String name) {this.name = name;
}

        this.name 和 name 完全不同的两个变量。this.name 代表该类的成员变量，name 表示传递给该函数的局部变量。

五、构造方法

        构造方法又叫构造器、构造函数。它的作用就是在创建对象时，给成员变量进行赋值。
构造方法的格式：

public class Student {修饰符 类名(参数) {方法体;}}

注意：

• 方法名与类名必须完全相同，大小写也要一致。
• 没有返回值类型，连 void 都没有。
• 没有具体的返回值（不能由 return 带回结果数据）。

以下是两个不同参数的构造方法（一个空参一个有参数，属于重载）：

public class Student {private String name;private int age;public Student() {//空参构造方法}public Student(String name, int age) {//带全部参数的构造方法}}

构造方法的调用：
        构造方法在创建对象的时候由虚拟机调用，不能手动调用构造方法。每创建一个对象，就会调用一次构造方法。
        如果我们没有写任何构造方法，虚拟机在运行时，也会自动给我们添加一个空参的构造方法。如果我们写了新的空参构造方法，就会替换掉虚拟机自动生成的那个。
        我们还可以利用有参构造方法，在对象生成之初，就给对象包含的成员变量赋初值。

public Student(String name, int age) {this.name = name;this.age = age;
}

Student s = new Student("丁真",22);

        值得一提的是，虚拟机调用哪个构造方法，是根据生成对象时括号里有没有参数，因此，有参构造方法和空参构造方法可以同时存在，这也是一种重载。

public Student(String name, int age) {this.name = name;this.age = age;System.out.println("我是有参构造方法");
}public Student() {System.out.println("我是空参构造方法");
}

Student s1 = new Student("丁真",22); // 我是有参构造方法
Student s2 = new Student();		 	 // 我是空参构造方法

        但是，如果我们只写一个有参构造方法，不写空参构造方法，虚拟机也不会自动生成那个空参构造方法了，这个时候无参调用就会报错。

public Student(String name, int age) {this.name = name;this.age = age;
}

Student s1 = new Student();  //报错，虚拟机没有自动给无参构造方法
Student s2 = new Student("丁真",22);

        综上，我们在编程时，往往都会同时写上有参构造和无参构造，防止出错。

六、JavaBean

        一个标准的 JavaBean 书写有以下规则：

1. 类名需要见名知意。
2. 成员变量使用 private 修饰。
3. 提供至少两个构造方法——无参构造方法、带全部参数的构造方法。
4. 成员方法——提供每一个成员变量对应的setXxx() / getXxx() ，如果该成员变量还有其他行为，一并写上。

【例】写一个用户的 JavaBean 。

public class User {// 属性private String username;private String password;private String email;private String gender;private int age;// 空参public User() {}// 带全部参数的构造public User(String username, String password, String email, String gender, int age) {this.username = username;this.password = password;this.email = email;this.gender = gender;this.age = age;}// get和set方法public void setUsername(String username) {this.username = username;}public String getUsername() {return username;}//其他成员变量的省略
}

七、对象的内存图

        从 JDK8 开始，JAVA 的内存取消了方法区，新增元空间，将方法区的职能拆分给了堆和元空间。

        在 JDK7 以前，元空间的名字叫“方法区”并且和堆是一段连续的空间，顾名思义，方法区是 JAVA 在运行一个类（class）时存储的区域，其工作原理如下：
        当运行一个类时，它的字节码文件会进入方法区。当类中的方法运行时，该方法会进入栈中。如果类中使用了 new 关键字，就会在堆内存中开辟空间并产生一个地址值。

7.1 一个对象的内存图

Student s1 = new Student();

        当生成一个对象时，虚拟机会按以下步骤执行：

1. 加载 class 文件。（加载 Student 类的代码到方法区内存中）
2. 申明局部变量。（就是等号左边的 s）
3. 在堆内存中开辟一个空间。（等号右边的 new 关键字）
4. 默认初始化。
5. 显示初始化。
6. 构造方法初始化。
7. 将堆内存中的地址值赋值给左边的局部变量。
   

7.2 两个对象的内存图

Student s1 = new Student();
System.out.println(s1);
s1.name = "阿强";
s1.age = 23;
System.out.println(s1.name + "..." + s1.age);
s1.study();
Student s2 = new Student();
System.out.println(s2);
s2.name = "阿杰";
s2.age = 24;
System.out.println(s2.name + "..." + s2.age);
s2.study();

        注意，两个对象的时候，class 文件只需要加载一次，因为 class 文件是通用的，因此在第一个对象生成时，class 文件已经加载好了，之后就仅对栈和堆进行操作了。
        因为 s1 和 s2 申请的是不同的两块堆空间，所以它们之间相互独立。

7.3 两个引用指向同一个对象

Student stu1 = new Student();
stu1.name = "阿强";
Student stu2 = stu1;
stu2.name = "阿杰";
sout(stu1.name + "..." + stu2.name);

        如上述代码所示，此时的 stu1 对象是生成的，而 stu2 是直接由 stu1 赋值而来的，相当于是把 stu1 的引用给了 stu2，换句话说，stu2 就是 stu1 的同名异构（引用），因此 stu1 和 stu2 应该指向同一块堆空间。因此在 stu2.name = “阿杰” 执行后，会覆盖 stu1.name = “阿强” 这句代码影响到的堆空间相应地址上的变量值。
        这就是，两个引用指向了同一个对象。

7.4 null

Student stu1 = new Student();
stu1.name = "阿强";
Student stu2 = stu1;
stu2.name = "阿杰";
sout(stu1.name + "..." + stu2.name);
stu1 = null;
sout(stu1.name);
sout(stu2.name);
stu2 = null;

         null 就是空，把 null 赋值给 stu1，也就是令 stu1 不再指向之前的那块堆内存，因此 stu1.name 就空了。但此时 stu2 还指向那块堆内存，因此 stu2.name 可以输出“阿杰”。当 stu2 = null；执行后，所有指向那块堆内存的链接都被删除，因此，那块堆内存变为了垃圾内存。

7.5 this 的内存原理

        this 是用于区分局部变量和成员变量的关键字。它的本质其实是：所在方法调用者的地址值。
        因此，this 在成员参数赋值时所代表的，大概率是该对象本身的地址值。

public void setName(String name) {this.name = name;
}

Student s1 = new Student();
s1.setName("竹小玲");

        在上面的代码中，this.name 代指 s1 对象内的成员变量 s1.name， name 代表传递过来的形参 name，其值也就是“竹小玲”。this 指向的内存地址，也即为 s1 指向的内存地址。

7.6 成员变量和局部变量的区别

        成员变量是指类中方法外的变量；局部变量是指方法中的变量。它们之间的区别如下表格总结：