Java面向对象（上）

约定不等于承诺〃 2023-07-17 07:27 59阅读 0赞

面向对象部分分3部分进行总结：

**1. 面向对象（上）**：（本编）总结内容为，

*  类与对象
 *  类的结构（属性、方法、构造器）
 *  封装性
 *  this

**2. 面向对象（中）**：（[传送][Link 1]）总结内容为：

*  继承性
 *  方法的重写
 *  super关键字
 *  对象实例化
 *  多态性

**3. 面向对象（下）**：（[传送][Link 2]）总结内容为：

*  static关键字
 *  final关键字
 *  abstract关键字
 *  interface关键字
 *  代码块
 *  内部类

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

## 类和对象 ##

**1. 面向对象学习的三条主线**：

*  1.Java类及类的成员：属性、方法、构造器；代码块、内部类
 *  2.面向对象的大特征：封装性、继承性、多态性、(抽象性)
 *  3.其它关键字：this、super、static、final、abstract、interface、package、import等

**2. 面向对象与面向过程（理解）**

*  1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
 *  2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

举例对比：人把大象装进冰箱。

**3.完成一个项目（或功能）的思路**  
![在这里插入图片描述][20200320171148612.png]  
**4.面向对象中两个重要的概念**  
类：对一类事物的描述，是抽象的、概念上的定义  
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)

> 面向对象程序设计的重点是类的设计  
> 设计类，就是设计类的成员。

二者的关系：  
对象，是由类new出来的，派生出来的。

**5.面向对象思想落地实现的规则一**

*  1.创建类，设计类的成员
 *  2.创建类的对象
 *  3.通过“对象.属性”或“对象.方法”调用对象的结构

补充：几个概念的使用说明

*  属性 = 成员变量 = field = 域、字段
     *  方法 = 成员方法 = 函数 = method
     *  创建类的对象 = 类的实例化 = 实例化类

**6. 对象的创建与对象的内存解析**  
典型代码：

Person p1 = new Person();
    Person p2 = new Person();
    Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。

说明：  
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）  
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

内存解析：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjA1MTQ1_size_16_color_FFFFFF_t_70]

**7. 匿名对象**:我们创建的对象，没显式的赋给一个变量名。即为匿名对象  
特点：匿名对象只能调用一次。  
举例：

new Phone().sendEmail();
    		new Phone().playGame();
    		
    		new Phone().price = 1999;
    		new Phone().showPrice();//0.0

应用场景：

PhoneMall mall = new PhoneMall();
    
    //匿名对象的使用
    mall.show(new Phone());
    其中，
    class PhoneMall{ 
    	public void show(Phone phone){ 
    		phone.sendEmail();
    		phone.playGame();
    	}
    	
    }

**8.理解"万事万物皆对象"**  
1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

*  Scanner,String等
 *  文件：File
 *  网络资源：URL

2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

## 属性 ##

对比：属性 vs 局部变量

**1.相同点**：

*  定义变量的格式：数据类型 变量名 = 变量值
 *  先声明，后使用
 *  变量都其对应的作用域

**2.不同点**：  
2.1 在类中声明的位置的不同

*  属性：直接定义在类的一对\{\}内
 *  局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2.2 关于权限修饰符的不同

*  属性：可以在声明属性时，指明其权限，使用权限修饰符。
 *  常用的权限修饰符：private、public、缺省、protected —>封装性，目前，大家声明属性时，都使用缺省就可以了。
 *  局部变量：不可以使用权限修饰符。

2.3 默认初始化值的情况：

*  属性：类的属性，根据其类型，都默认初始化值。

* 			整型（byte、short、int、long：0）
     * 			浮点型（float、double：0.0）
     * 			字符型（char：0  （或'\u0000'））
     * 			布尔型（boolean：false）
     * 
     * 			引用数据类型（类、数组、接口：null）

*  局部变量：没默认初始化值。意味着，我们在调用局部变量之前，一定要显式赋值。特别地：**形参在调用时，我们赋值即可**。

2.4 在内存中加载的位置：

*  属性：加载到堆空间中 （非static）
 *  局部变量：加载到栈空间

补充：回顾变量的分类：  
方式一：按照数据类型：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjA1MTQ1_size_16_color_FFFFFF_t_70 1]

方式二：按照在类中声明的位置：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjA1MTQ1_size_16_color_FFFFFF_t_70 2]

## 方法 ##

方法：描述类应该具的功能。

*  比如：Math类：sqrt()\\random() …
 *  Scanner类：nextXxx() …
 *  Arrays类：sort() \\ binarySearch() \\ toString() \\ equals() \\ …

**1. 举例**：

public void eat(){ }
     public void sleep(int hour){ }
     public String getName(){ }
     public String getNation(String nation){ }

**2. 方法的声明**：

权限修饰符  返回值类型  方法名(形参列表){ 
      					方法体
     		  }

*  注意：static、final、abstract 来修饰的方法，后面再讲。

**3. 说明**：  
3.1 关于权限修饰符：默认方法的权限修饰符先都使用public

*  Java规定的4种权限修饰符：private、public、缺省、protected

3.2 返回值类型： 返回值 vs 没返回值

*  如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用 return关键字来返回指定类型的变量或常量：“return 数据”。

*  如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。

*  方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
 *  形参列表： 方法可以声明0个，1个，或多个形参。
 *  格式：数据类型1 形参1,数据类型2 形参2,…

3.3 方法体：方法功能的体现。

**4. 方法的使用中，可以调用当前类的属性或方法**

*  特殊的：方法A中又调用了方法A:递归方法。
 *  方法中，不可以定义方法。

**5. return返回值**  
return关键字：  
1.使用范围：使用在方法体中  
2.作用：

*  ① 结束方法

*  ② 针对于返回值类型的方法，使用"return 数据"方法返回所要的数据。

3.注意点：return关键字后面不可以声明执行语句。

**6. 方法的重载**  
1.方法的重载的概念

*  定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
 *  总结：“两同一不同”:同一个类、相同方法名  
    参数列表不同：参数个数不同，参数类型不同

2.构成重载的举例：  
举例一：

Arrays类中重载的sort() / binarySearch()；
    PrintStream中的println()

举例二：  
//如下的4个方法构成了重载

public void getSum(int i,int j){ 
    		System.out.println("1");
    	}
    	
    	public void getSum(double d1,double d2){ 
    		System.out.println("2");
    	}
    	
    	public void getSum(String s ,int i){ 
    		System.out.println("3");
    	}
    	
    	public void getSum(int i,String s){ 
    		System.out.println("4");
    	}

不构成重载的举例：

//如下的3个方法不能与上述4个方法构成重载
    // public int getSum(int i,int j){ 
    // return 0;
    // }
    	
    // public void getSum(int m,int n){ 
    // 
    // }
    	
    // private void getSum(int i,int j){ 
    // 
    // }

1.  如何判断是否构成方法的重载？  
    严格按照定义判断：两同一不同。  
    跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！
2.  如何确定类中某一个方法的调用：  
    方法名 —> 参数列表

方法的重载与重写的区别？

throws\\throw  
String\\StringBuffer\\StringBuilder  
Collection\\Collections  
final\\finally\\finalize  
…

抽象类、接口  
sleep() / wait()

**7. java的值传递机制**

1.针对于方法内变量的赋值举例：

System.out.println("***********基本数据类型：****************");
    	int m = 10;
    	int n = m;
    	
    	System.out.println("m = " + m + ", n = " + n);
    	
    	n = 20;
    	
    	System.out.println("m = " + m + ", n = " + n);
    	
    	System.out.println("***********引用数据类型：****************");
    	
    	Order o1 = new Order();
    	o1.orderId = 1001;
    	
    	Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
    	
    	System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
    	
    	o2.orderId = 1002;
    	
    	System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);

规则：  
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。  
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

2.针对于方法的参数概念  
形参：方法定义时，声明的小括号内的参数  
实参：方法调用时，实际传递给形参的数据

3.java中参数传递机制：值传递  
规则：

*  如果参数是基本数据类型，此时实参赋给形参的是实参真实存储的数据值。
 *  如果参数是引用数据类型，此时实参赋给形参的是实参存储数据的地址值。

推广：  
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。  
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。

4.典型例题与内存解析：  
【例题1】  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjA1MTQ1_size_16_color_FFFFFF_t_70 3]

【例题2】

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjA1MTQ1_size_16_color_FFFFFF_t_70 4]

## 封装性 ##

[传送门][Link 3]：https://blog.csdn.net/qq\_38605145/article/details/104994856

## 构造器 ##

**1.构造器（或构造方法**）：Constructor  
构造器的作用：

*  1.创建对象
 *  2.初始化对象的信息

**2.使用说明**：

*  如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
 *  定义构造器的格式：权限修饰符 类名(形参列表)\{\}
 *  一个类中定义的多个构造器，彼此构成重载
 *  一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
 *  一个类中，至少会有一个构造器。

**3.举例**：

//构造器
    	public Person(){ 
    		System.out.println("Person().....");
    	}
    	
    	public Person(String n){ 
    		name = n;
    		
    	}
    	
    	public Person(String n,int a){ 
    		name = n;
    		age = a;
    	}

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

**赋值问题**

*  总结：属性赋值的先后顺序
 *  ① 默认初始化
 *  ② 显式初始化
 *  ③ 构造器中初始化
 *  ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
 *  以上操作的先后顺序：① - ② - ③ - ④

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

**JavaBean**  
所谓JavaBean，是指符合如下标准的Java类：  
>类是公共的  
>一个无参的公共的构造器  
>属性，且对应的get、set方法

## this关键字 ##

1.  可以调用的结构：属性、方法；构造器
2.  this调用属性、方法：  
    this理解为：当前对象 或 当前正在创建的对象

*  2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式 的使用"this.变量"的方式，表明此变量是属性，而非形参。

*  2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

1.  this调用构造器：  
    ① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器  
    ② 构造器中不能通过"this(形参列表)“方式调用自己  
    ③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”  
    ④ 规定："this(形参列表)“必须声明在当前构造器的首行  
    ⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器

[Link 1]: https://editor.csdn.net/md?articleId=104995849
[Link 2]: https://editor.csdn.net/md?articleId=104996765
[20200320171148612.png]: /images/20230528/b57b0c6fa0dd45e9b8aa8716b2338115.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjA1MTQ1_size_16_color_FFFFFF_t_70]: /images/20230528/cd1087f2d95a4a8eb724cd9d3654601b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjA1MTQ1_size_16_color_FFFFFF_t_70 1]: /images/20230528/da5589f2b98a442c8972699711fc7549.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjA1MTQ1_size_16_color_FFFFFF_t_70 2]: /images/20230528/1c78aa59e3104eb293326a88e6680be5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjA1MTQ1_size_16_color_FFFFFF_t_70 3]: /images/20230528/891193374d6e466287fad53d9c968fda.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM4NjA1MTQ1_size_16_color_FFFFFF_t_70 4]: /images/20230528/f3a12f3b150443139d45cc304477f540.png
[Link 3]: https://blog.csdn.net/qq_38605145/article/details/104994856