【JAVASE】类与对象

拼搏现实的明天。 2024-04-23 20:26 87阅读 0赞

> ⭐ 作者：小胡\_不糊涂  
> ? 作者主页：[小胡\_不糊涂的个人主页][Link 1]  
> ? 收录专栏：[浅谈Java][Java]  
> ? 持续更文，关注博主少走弯路，谢谢大家支持 ?

#### 类与对象 ####

*  1. 面向对象
 *   *  1.1 什么是面向对象
     *  1.2 面向对象与面向过程
 *  2. 类的定义与使用
 *   *  2.1 简单认识类
     *  2.2 类的定义格式
 *  3. 类的实例化
 *   *  3.1 什么是实例化
     *  3.2 类和对象说明
 *  4. this 引用
 *   *  4.1 为什么要有this引用
     *  4.2 什么是this引用
     *  4.3 this引用的特性
 *  5. 对象的构造级及初始化
 *   *  5.1 如何初始化对象
     *  5.2 构造方法
     *   *  5.2.1 概念
         *  5.2.2 特性
     *  5.3 默认初始化
     *  5.4 就地初始化

![在这里插入图片描述][8b8f6388729a47e1bb45834274bcb31e.gif_pic_center]

## 1. 面向对象 ##

### 1.1 什么是面向对象 ###

Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，**一切皆为对象**。

**面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。** 用面向对象的思想来涉及程序，更符合人们对事物的认知，对于大型程序的设计、扩展以及维护都非常友好。

### 1.2 面向对象与面向过程 ###

举个例子说明一下：

> 传统的洗衣方式，需要我们亲力亲为，准备一盆水 --> 放衣服 --> 放洗衣粉 --> 洗衣服 --> 换水 --> 拧干 --> 晾衣服，过程很多，少了一个环节可能都不行。

如果按照该种方式来写代码，将来扩展或者维护起来会比较麻烦。

> 现代洗衣方式以面向对象方式来进行处理，就不关注洗衣服的过程。  
> 具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，倒入洗衣粉，启动开关即可，通过对象之间的交互来完成的。

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

## 2. 类的定义与使用 ##

### 2.1 简单认识类 ###

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。

> 比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。  
> 属性：产品品牌，型号，产品重量，外观尺寸，颜色…  
> 功能：洗衣，烘干、定时…

在Java语言中，如何对上述的洗衣机类来进行定义呢？

### 2.2 类的定义格式 ###

**在 java 中定义类时需要用到 class 关键字，具体语法如下:**

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

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

类中包含的内容称为**类的成员**。  
**属性**主要是用来描述类的，称之为类的成员属性或者类成员变量。  
**方法**主要说明类具有哪些功能，称为类的成员方法。

class WashMachine{
        
        public String brand; // 品牌
        public String type; // 型号
        public double weight; // 重量
        public double length; // 长
        public double width; // 宽
        public double height; // 高
        public String color; // 颜色
        public void washClothes(){
         // 洗衣服
            System.out.println("洗衣功能");
        }
        public void dryClothes(){
         // 脱水
            System.out.println("脱水功能");
        }
        public void setTime(){
         // 定时
            System.out.println("定时功能");
        }
    }

采用 Java 语言将洗衣机类在计算机中定义完成，经过 javac 编译之后形成 .class 文件，在 JVM 的基础上计算机就可以识别了。

注：

*  **类名注意采用大驼峰定义**
 *  成员前写法统一为public
 *  此处写的方法不带 static 关键字

**实例：定义一个 小狗 类**

![在这里插入图片描述][86424fe0148f4d7590faa898ae68e1ed.png]

class PetDog {
        
    	public String name;//名字
    	public String color;//颜色
    	// 狗的属性
    	public void barks() {
        
    	System.out.println(name + ": 旺旺旺~~~");
    	}
    	// 狗的行为
    	public void wag() {
        
    	System.out.println(name + ": 摇尾巴~~~");
    	}
    }

**实例2：定义一个 学生 类**

![在这里插入图片描述][64c6013dfcb1487281031b8118154ae5.png]

public class Student{
        
    	//属性
    	public String name;//姓名
    	public String gender;//性别
    	public short age;//年龄
    	public double score;//学分
    	//方法
    	public void DoClass(){
        }//上课
    	public void DoHomework(){
        }//写作业
    	public void Exam(){
        }//考试
    }

注：

*  一般一个文件当中只定义一个类
 *  main 方法所在的类一般要使用 public 修饰(注意：Eclipse默认会在 public 修饰的类中找 main 方法)
 *  public 修饰的类必须要和文件名相同
 *  不要轻易去修改 public 修饰的类的名称

## 3. 类的实例化 ##

### 3.1 什么是实例化 ###

> **定义了一个类，就相当于在计算机中定义了一种新的类型**，与 int，double 类似，只不过 int 和 double 是 java 语言自带的内置类型，而**类是用户自定义了一个新的类型**，比如上述的： PetDog 类和 Student 类。  
> 它们都是类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

用 类 类型创建对象的过程，称为**类的实例化**，在 java 中采用 **new** 关键字，配合类名来**实例化对象**。

![在这里插入图片描述][0a40c550063d455fa8d5336e51284556.png]

public class oop {
        
            public static void main(String[] args) {
        
                PetDog dogh = new PetDog(); //通过new实例化对象
                dogh.name = "Jack";
                dogh.color = "黑色";
                dogh.barks();
                dogh.wag();
                
                PetDog dogs = new PetDog();
                dogs.name = "Peter";
                dogs.color = "棕色";
                dogs.barks();
                dogs.wag();
            }
    }
    class PetDog {
        
        // 狗的属性
        public String name;//名字
        public String color;//颜色
    
        //狗的行为
        public void barks() {
        
            System.out.println(name + ": 旺旺旺~~~");
        }
        public void wag() {
        
            System.out.println(name + ": 摇尾巴~~~");
        }
    }

? *运行结果：*

![在这里插入图片描述][cb7d6d650bed4e9cb335da1d041dab8a.png]  
注：

*  new 关键字用于创建一个对象的实例
 *  使用 . 来访问对象中的属性和方法
 *  同一个类可以创建对个实例

### 3.2 类和对象说明 ###

*  类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员
 *  类是一种自定义的类型，可以用来定义变量
 *  **一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量**
 *  做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

## 4. this 引用 ##

### 4.1 为什么要有this引用 ###

先看一个日期类的例子：

public class Date {
        
        public int year;
        public int month;
        public int day;
        public void setDay(int y, int m, int d){
        
            year = y;
            month = m;
            day = d;
        }
        public void printDate(){
        
            System.out.println(year + "/" + month + "/" + day);
        }
        public static void main(String[] args) {
        
    // 构造三个日期类型的对象 d1 d2 d3
            Date d1 = new Date();
            Date d2 = new Date();
            Date d3 = new Date();
    // 对d1，d2，d3的日期设置
            d1.setDay(2023,8,1);
            d2.setDay(2023,8,2);
            d3.setDay(2023,8,3);
    // 打印日期中的内容
            d1.printDate();
            d2.printDate();
            d3.printDate();
        }
    }

> 以上代码定义了一个日期类，然后main方法中创建了三个对象，并通过 Date 类中的成员方法对对象进行设置和打印，代码整体逻辑非常简单，没有任何问题。

但是仔细想想有两个疑问：

1.  **形参名不小心与成员变量名相同：**

public void setDay(int year, int month, int day){
        
    year = year;
    month = month;
    day = day;
    }

那函数体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？

1.  **三个对象都在调用 setDate 和 printDate 函数，但是这两个函数中没有任何有关对象的说明， setDate 和 printDate 函数如何知道打印的是那个对象的数据呢？**

![在这里插入图片描述][7fc987f1c4ea482da969209089cac4bd.png]

一切让this引用来揭开这层神秘的面纱

### 4.2 什么是this引用 ###

> **this引用**指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。  
> 只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

public class Date {
        
        public int year;
        public int month;
        public int day;
    
        public void setDay(int year, int month, int day) {
        
            this.year = year;//this引用的是调用成员方法的对象。
            this.month = month;
            this.day = day;
        }
    
        public void printDate() {
        
            System.out.println(this.year + "/" + this.month + "/" + this.day);
        }
        
        public static void main(String[] args) {
        
            Date d = new Date();
            d.setDay(2023, 8, 1);
            d.printDate();
        }
    }

`?在今后写代码中尽量都用 this`

### 4.3 this引用的特性 ###

*  this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
 *  this只能在"成员方法"中使用
 *  在"成员方法"中，this只能引用当前对象，不能再引用其他对象
 *  this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收

## 5. 对象的构造级及初始化 ##

### 5.1 如何初始化对象 ###

> 在Java方法内部定义一个局部变量时，必须要初始化，否则会编译失败。

比如：

public static void main(String[] args) {
        
    int a;
    System.out.println(a);
    }

编译器就会提示你，使用了未初始化的变量 a：  
![在这里插入图片描述][c7f03b85556644c9bff6a25989249012.png]  
要让上述代码通过编译，非常简单，只需在正式使用 a 之前，给 a 设置一个初始值即可。

如果是对象：

public class Date {
        
    		public int year;
       		public int month;
       		public int day;
        	
        	public void setDay(int year, int month, int day) {
        
            this.year = year;
            this.month = month;
            this.day = day;
        }
        
        public void printDate() {
        
            System.out.println(this.year + "/" + this.month + "/" + this.day);
        }
        
        public static void main(String[] args) {
        
            Date d = new Date();
            d.printDate();
            d.setDay(2023,8,1);//初始化具体日期
            d.printDate();
        }
    }

? *运行结果：*

![在这里插入图片描述][e4568cfa75e14f71824f158879424cbf.png]  
通过上述例子发现两个问题：

*  每次对象创建好后调用 SetDay 方法设置具体日期，比较麻烦，那对象该如何初始化？
 *  局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

### 5.2 构造方法 ###

#### 5.2.1 概念 ####

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

例如：

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

`?构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。`

#### 5.2.2 特性 ####

1.  名字必须与类名相同。
2.  没有返回值类型，设置为void也不行。
3.  创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)。
4.  构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)。

public class Date {
        
    	public int year;
    	public int month;
    	public int day;
    	
    	// 无参构造方法
    	public Date(){
        
    		this.year = 1900;
    		this.month = 1;
    		this.day = 1;
    	}
    
    	// 带有三个参数的构造方法
    	public Date(int year, int month, int day) {
        
    		this.year = year;
    		this.month = month;
    		this.day = day;
    	}
    	
    	public void printDate(){
        
    		System.out.println(year + "-" + month + "-" + day);
    	}
    	public static void main(String[] args) {
        
    		Date d = new Date();
    		d.printDate();
    	}
    }

**上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载**

`?构造方法可以有多个`  
`?构造方法之间构成重载`

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

public class Date {
        
    	public int year;
    	public int month;
    	public int day;
    	public void printDate(){
        
    		System.out.println(year + "-" + month + "-" + day);
    	}
    	public static void main(String[] args) {
        
    		Date d = new Date();
    		d.printDate();
    	}
    }

? *运行结果：*

![在这里插入图片描述][c2e32a146aed4e4891ced8ba102734fb.png]

注： 一旦用户定义，编译器则不再生成。

public class Date {
        
    	public int year;
    	public int month;
    	public int day;
    	public Date(int year, int month, int day) {
        
    		this.year = year;
    		this.month = month;
    		this.day = day;
    	}
    	
    	public void printDate(){
        
    		System.out.println(year + "-" + month + "-" + day);
    	}
    
    	public static void main(String[] args) {
        
    		// 如果编译器会生成，则生成的构造方法一定是无参的
    		// 则此处创建对象是可以通过编译的
    		// 但实际情况是：编译期报错
    		Date d = new Date();
    		d.printDate();
    	}
    }

报错：

![在这里插入图片描述][40b5407fab5b40eb8ebd81252f762213.png]

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

public class Date {
        
    	public int year;
    	public int month;
    	public int day;
    	
    	// 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
    	// 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    	// 但是this(2023,8,1);必须是构造方法中第一条语句
    	
    	public Date(){
        
    		//System.out.println(year); 注释取消掉，编译会失败
    		this(2023, 8, 1);
    		//this.year = 2023;
    		//this.month = 8;
    		//this.day = 1;
    	}
    	
    	// 带有三个参数的构造方法
    	public Date(int year, int month, int day) {
        
    		this.year = year;
    		this.month = month;
    		this.day = day;
    	}
    	
      public void printDate() {
        
            System.out.println(year + "-" + month + "-" + day);
        }
        public static void main(String[] args) {
        
            Date d = new Date();
            d.printDate();
        }
    }

? *运行结果：*

![在这里插入图片描述][0a75d04b317e486f96014e66aac5762a.png]

注：

*  this(…)必须是构造方法中第一条语句
 *  不能形成环

例如：

public Date(){
        
    	this(1900,1,1);
    }
    public Date(int year, int month, int day) {
        
    	this();
    }

1.  绝大多数情况下使用public来修饰，特殊场景下会被private修饰。

### 5.3 默认初始化 ###

> 在上文中提出的第二个问题：为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？

public class Date {
        
    	public int year;
    	public int month;
    	public int day;
    	public Date(int year, int month, int day) {
        
    	// 成员变量在定义时，并没有给初始值, 为什么就可以使用呢？
    		System.out.println(this.year);
    		System.out.println(this.month);
    		System.out.println(this.day);
    	}
    	public static void main(String[] args) {
        
    		 //int a;
    		 //System.out.println(a);
    		Date d = new Date(2021,6,9);
    	}
    }

? *运行结果：*

![在这里插入图片描述][73235d0ade3242a19de86e27641d31d9.png]

![在这里插入图片描述][3340e52d0cd44f888cf126a321ae2cd1.png]

要搞清楚这个过程，就需要知道 new 关键字背后所发生的一些事情：

Date d = new Date(2021,6,9);

在程序层面只是简单的一条语句，在JVM层面需要做好多事情，下面简单介绍下：

1.  检测对象对应的类是否加载了，如果没有加载则加载
2.  为对象分配内存空间
3.  处理并发安全问题  
    比如：多个线程同时申请对象，JVM要保证给对象分配的空间不冲突
4.  初始化所分配的空间  
    即：对象空间被申请好之后，对象中包含的成员已经设置好了初始值，比如：

<table> 
 <thead> 
  <tr> 
   <th>数据类型</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>‘\u0000’</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>0</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>0L</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>false</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>0.0f</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>0.0</td> 
  </tr> 
  <tr> 
   <td>reference</td> 
   <td>null</td> 
  </tr> 
 </tbody> 
</table>

1.  设置对象头信息
2.  调用构造方法，给对象中各个成员赋值

### 5.4 就地初始化 ###

> 在声明成员变量时，就直接给出了初始值

public class Date {
        
        public int year = 1900;//赋初值
        public int month = 1;
        public int day = 1;
        public Date(){
        
        }
        public Date(int year, int month, int day) {
        
       		this.year = year;
    		this.month = month;
    		this.day = day;
        }
        public void printDate() {
        
            System.out.println(year + "-" + month + "-" + day);
        }
        public static void main(String[] args) {
        
            Date d1 = new Date(2023,8,1);
            Date d2 = new Date();
            d1.printDate();
            d2.printDate();
        }
    }

? *运行结果：*

![在这里插入图片描述][4a9420faa5374c149a1fd3dd9126fbf9.png]

`?代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中`

--------------------

![在这里插入图片描述][8a9449837ac440eaa55e35f667db5bc7.png]

[Link 1]: https://blog.csdn.net/iLoyo_
[Java]: http://t.csdn.cn/P9HTz
[8b8f6388729a47e1bb45834274bcb31e.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/606cbb4819f1459bab79165a34196348.gif
[86424fe0148f4d7590faa898ae68e1ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/7c5c26a0261c472fa63693a176ff8276.png
[64c6013dfcb1487281031b8118154ae5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/443e2d34b81b42549ae204cb3fad23f9.png
[0a40c550063d455fa8d5336e51284556.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/671fb54cf2964c64920b6c99e73f3ea4.png
[cb7d6d650bed4e9cb335da1d041dab8a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/6201c7202e5842bb962a045e61b0f324.png
[7fc987f1c4ea482da969209089cac4bd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/ade75c5ec70247ab9da264098226e989.png
[c7f03b85556644c9bff6a25989249012.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/ad19c0a427f1448a8fb749c8645e434d.png
[e4568cfa75e14f71824f158879424cbf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/6fcd787129d946ef9a7e6660218b7c8a.png
[c2e32a146aed4e4891ced8ba102734fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/0f8c6a47a6b24e6fae2663e124e0d943.png
[40b5407fab5b40eb8ebd81252f762213.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/6290155a2db94cc38a8a11a34109a6bb.png
[0a75d04b317e486f96014e66aac5762a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/be15236195224425841eb7de3ed5289d.png
[73235d0ade3242a19de86e27641d31d9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/37db576979974848ab8e44092e0e6808.png
[3340e52d0cd44f888cf126a321ae2cd1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/f074410ceeec412f92b406f0028866ff.png
[4a9420faa5374c149a1fd3dd9126fbf9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/ce7fcf9920964e92b40b09a2f2061f7b.png
[8a9449837ac440eaa55e35f667db5bc7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/0798ce2be67242668a43c85f7c0bd05b.png