理解类和对象

一、面向对象的初步认识

       我们在学习Java语言前，我们就明白Java是面向对象的编程语言。那么，我们该如何理解面向对象呢？

       大家可这样理解：在以前科技不发达的时候，我们洗衣服是不是要亲力亲为，首先要打水，那盆，放衣服，放洗衣粉，搓洗等等。这中间少了一个环节都不行。但是，面向对象，你可以理解为到了现代，科技发展迅速，有了洗衣机，我们洗衣服时，不必像之前一样亲力亲为，只需采取以下步骤即可：把衣服放入洗衣机里，加入洗衣粉，启动洗衣机即可。

       以前洗衣服可以看做面向过程编程，现在洗衣服可看作面向对象编程。面向对象编程的特点为：不理会过程如何实现，只用找到能实现的东西即可（也就是你现在是老大，要办一件事，只需找到最适合做这件事的小弟，给他下命令，人家会为你办事）。

       注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景。

二、类

       什么是类？类可以理解为：说明书。里面包含了最基本的属性。例如：洗衣机说明书里会包含:尺寸，大小，颜色，型号等等。使我们来了解这个产品。

       2.1 语法格式

       了解完什么是类，接下来我们要明白，类是怎么定义的。具体语法如下：

1. // 创建类
2. class ClassName{
3.     field; // 字段(属性) 或者 成员变量
4.     method; // 行为 或者 成员方法
5. }

       class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

       类中包含的内容称为类的成员。

       属性主要是用来描述类的，称之为类的成员属性或者类成员变量。

       方法主要说明类 具有哪些功能，称为类的成员方法。

       我们来试一试定义狗这个类：

1. public class dog {
2. public String name;//名字
3. public String color;//颜色
4. // 狗的属性
5. public void barks() {
6.         System.out.println(name + ": 旺旺旺~~~");
7.     }
8. // 狗的行为
9. public void wag() {
10.         System.out.println(name + ": 摇尾巴~~~");
11.     }
12. }

        注意：

      1. 一般一个文件当中只定义一个类

       2. main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)

       3. public修饰的类必须要和文件名相同

       2.2 类的实例化

       在我们定义了一个类后，就相当与在C语言定义了一个类型，用类的类型创建对象的过程，称为类的实例化。如下：

1. class dog {
2. public String name;//名字
3. public String color;//颜色
4. // 狗的属性
5. public void barks() {
6.         System.out.println(name + ": 旺旺旺~~~");
7.     }
8. // 狗的行为
9. public void wag() {
10.         System.out.println(name + ": 摇尾巴~~~");
11.     }
12. }
13. public class Main {
14. public static void main(String[] args) {
15. dog dog = new dog();
16.     dog.name = "小明";
17.     dog.color = "黄";
18.     dog.barks();
19.     dog.wag();
20. 
21.     }
22. }

       注意事项：

       new 关键字用于创建一个对象的实例

       使用 . 来访问对象中的属性和方法

       同一个类可以创建对个实例

2.3 类和对象的联系

       在面向对象编程中，类（Class）和对象（Object）是密切相关的概念，它们之间有以下关系：

       类是对象的模板：类是用于创建对象的模板或蓝图。它定义了对象的属性和行为，描述了对象的结构和功能。

       对象是类的实例：对象是根据类定义创建的实体。通过实例化类，可以在内存中创建一个对象。对象具体化了类的属性和行为，拥有自己的状态和行为。

       类是对象的类型：类确定了对象的类型。对象属于某个类的实例，继承了类的属性和行为，并遵循类的定义。

       对象具有独立性：每个对象都是独立的实体，它们可以有自己的状态（成员变量的值）和行为（成员方法的调用）。对象之间相互独立，拥有各自的内存空间。

       类提供了对象的创建和访问方式：类定义了对象的属性和行为，并提供了对象的创建和访问方式。通过类，可以创建对象的实例，并使用对象调用类的成员变量和成员方法。

       对象是类的多个实例：一个类可以创建多个对象实例，每个实例都是类的独立副本。每个对象都可以拥有不同的状态和行为，但遵循同一个类的定义。

       简单来说，类是对象的模板和类型，描述了对象的结构和行为。对象是类的实例，具体化了类的属性和行为，拥有独立的状态和行为。通过类，可以创建多个对象的实例，并对每个对象进行操作和访问。

三、this引用

       我们为什么要有this引用？来看一个简单的例子：

1. public class Date {
2. public int year;
3. public int month;
4. public int day;
5. public void setDay(int y, int m, int d){
6.         year = y;
7.         month = m;
8.         day = d;
9.     }
10. public void printDate(){
11.         System.out.println(year + "/" + month + "/" + day);
12.     }
13. public class Main {
14. public static void main(String[] args) {
15. 
16. Date D1 = new Date();
17. Date D2 = new Date();
18.     D1.setDay(2024,5,18);
19.     D2.setDay(2024,5,19);
20.     D1.printDate();
21.     D2.printDate();
22.     }
23. }

        这个例子很简单，但细看之下又会有以下问题：两个对象都在调用setDate和printDate函数，但是这两个函数中没有任何有关对象的说明，setDate和 printDate函数如何知道打印的是那个对象的数据呢？

       别担心，一切交给this吧！

       3.1 什么是this引用

       this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该 引用去访问。

1. public class Date {
2. public int year;
3. public int month;
4. public int day;
5. public void setDay(int year, int month, int day){
6. this.year = year;
7. this.month = month;
8. this.day = day;
9.     }
10. public void printDate(){
11.         System.out.println(this.year + "/" + this.month + "/" + this.day);
12.     }
13. }

       注意：this引用的是调用成员方法的对象。

       3.2 this引用的特性

       1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

       2. this只能在"成员方法"中使用

       3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象

四、对象

       4.1 如何初始化对象

               我们在学习编程语言时都明白，创建了一个变量就要对其初始化，你创建了一个对象，也应该对其初始化，如下：

1. public static void main(String[] args) {
2. Date d = new Date();
3.     d.printDate();
4.     d.setDate(2021,6,9);
5.     d.printDate();
6. }

       4.2 构造方法

               构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且 在整个对象的生命周期内只调用一次。

1. public class Date {
2. public int year;
3. public int month;
4. public int day;
5. // 构造方法：
6. // 名字与类名相同，没有返回值类型，设置为void也不行
7. // 一般情况下使用public修饰
8. // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
9. public Date(int year, int month, int day){
10. this.year = year;
11. this.month = month;
12. this.day = day;
13.     System.out.println("Date(int,int,int)方法被调用了");
14. }
15. public void printDate(){
16.         System.out.println(year + "-" + month + "-" + day);
17.     }
18. public static void main(String[] args) {
19. // 此处创建了一个Date类型的对象，并没有显式调用构造方法
20. Date d = new Date(2021,6,9); // 输出Date(int,int,int)方法被调用了
21.         d.printDate(); // 2021-6-9
22.     }
23. }

       特性：

       1. 名字必须与类名相同

       2. 没有返回值类型，设置为void也不行

       3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)

       4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

       5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

       6. 构造方法中，可以通过this调用其他构造方法来简化代码.

       4.3 默认初始化

       为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情：Date date = new Date();。

       原来，对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如：

       这就是默认初始化。

       4.4 就地初始化

       在声明成员变量时，也可以直接对成员变量赋初始值，成为就地初始化，如下：

1. public class Date {
2. public int year = 1900;
3. public int month = 1;
4. public int day = 1;
5. public Date(){
6.     }
7. public Date(int year, int month, int day) {
8.     }
9. public static void main(String[] args) {
10. Date d1 = new Date(2021,6,9);
11. Date d2 = new Date();
12.     }
13. }

       这就是就地初始化。

       好了本次学习到这里就结束了，希望能有所帮助。

完！