一、面向对象与面向过程

面向对象OOP和面向过程POP的区别：

  • 面向过程：强调的是功能行为，以函数为最小单位，考虑谁来做。
  • 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
  • 【我的理解：以一盘鱼香肉丝炒饭开始。面向过程就是自己去超市买材料：肉丝、木耳、肉丝，准备调料，自己回家动手做鱼香肉丝。面向对象就是去饭店直接点一盘鱼香肉丝炒饭，坐着等就可以吃到了，不用自己动手去做。】

    面向过程：Procedure Oriented Programming 面向对象：Object Oriented Programming

image.png

面向对象的三大特征：封装性、继承性、多态性

面向对象的思想概述：

  • 程序员从面向过程的执行者转化成了面向对象的指挥者
  • 面向对象分析方法分析问题的思路和步骤：
    • 根据问题需要，选择问题所针对的现实世界中的实体。
    • 从实体中寻找解决问题相关的属性和功能，这些属性和功能就形成了概念世界中的类。
    • 把抽象的实体用计算机语言进行描述，形成计算机世界中类的定义。即借助某种程序语言，把类构造成计算机能够识别和处理的数据结构。
    • 将类实例化成计算机世界中的对象。对象是计算机世界中解决问题的最终工具。

二、 类和对象

2.1 类和对象的定义：

  • 类(Class)和对象(Object)是面向对象的核心概念。
    • 类是对一类事物的描述，是抽象的、概念上的定义。
    • 对象是实际存在的该类事物的每个个体，因而也称为实例(instance)。
  • “万事万物皆对象”

    可以理解为：类 = 抽象概念的人=明星；对象 = 实实在在的某个人 =蔡徐坤 面向对象程序设计的重点是类的设计。 类的设计，其实就是类的成员的设计。

2.2 Java类及类的成员

:::info 设计类，其实就是设计类的成员。 :::

类和类的成员组成：属性、方法（常见）

  • 现实世界的生物体，大到鲸鱼，小到蚂蚁，都是由最基本的细胞构成的。同 理，Java代码世界是由诸多个不同功能的类构成的。
  • 现实生物世界中的细胞又是由什么构成的呢？细胞核、细胞质、… 那么， Java中用类class来描述事物也是如此。常见的类的成员有：
    • 属 性：对应类中的成员变量
    • 行 为：对应类中的成员方法

方法和属性的多种叫法，本质都是同一个。

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

类的成员构造：

QQ截图20220505232641.png
image.png

  1. class Person {
  2.     //属性，或成员变量
  3.     String name;
  4.     int age;
  5.     boolean isMarried;
  6.     //构造器
  7.     public Person(){}
  8.     public Person(String n, blooean im){
  9.         name = n;
  10.         isMarried = im;
  11.     }
  12.     //方法，或函数
  13.     public void eat(){
  14.         System.out.println("人会吃饭。");
  15.     }
  16.     public String display(){
  17.         return "名字是：" + name + "，年龄为："+"," 是否娶嫁" + isMarried;
  18.     }
  19.     //代码块
  20.     {
  21.         name = "CXK";
  22.         age = 20;
  23.         isMarried = false;
  24.     }
  25.     //内部类
  26.     class pet{
  27.         String name;
  28.         float weight;
  29.     }
  30. }

类的语法格式：

修饰符 class 类名 { 属性声明; 方法声明; } 说明：修饰符public：类可以被任意访问。 类的正文要用{ }括起来。

创建Java自定义类步骤：

  1. 定义类（考虑修饰符、类名）
    2. 编写类的属性（考虑修饰符、属性类型、属性名、初始化值）
    3. 编写类的方法（考虑修饰符、返回值类型、方法名、形参等）

2.3 类和对象的使用（面向对象思想落地的实现）：

* 1.创建类，设计类的成员（重心）

* 2.创建类的对象

* 3.通过“对象.属性”或“对象.方法”调用对象的结构

image.png

创建对象语法： 类名 对象名 = new 类名(); 使用“对象名.对象成员”的方式访问对象成员（包括属性和方法）

  • 包名：都小写xxyyzz
  • 类名、接口名：XxxYyyZzz
  • 变量名、方法名：xxxYyyZzz
  • 常量名：XXX_YYY_ZZZ

说明：
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
【我的理解：就是一个独立的对象，也就是 new 出来的对象，可以自己改变原来类的属性（这个属性（=成员变量）就是指的是：类里面的，如 int age =10; 啊等等的这些属性）】

对象的内存解析：

image.png
image.png

  • 第一句：先在栈中声明一个 Person类的对象 p1，new 一个Person类的对象 p1 在堆中开辟一个空间里面会存放 Person类的内容，栈中 p1 存放 p1 在堆中的空间的地址；
  • 第二句：把 p1 指向的堆中的空间里面的name = null 替换为name = Tom;
  • 第三句：把 p1 指向的堆中的空间里面的isMale = false 替换为isMale = true;
  • 第四句：先在栈中声明一个 Person类的对象 p2，new 一个Person类的对象 p2 在堆中开辟一个空间里面会存放 Person类的内容，栈中 p2 存放 p2 在堆中的空间的地址；
  • 第五句：输出 p2.name，输出结果为 null;
  • 第六句：在栈中声明一个 Person类的对象 p3 ，p3 存放 p1 在堆中的空间的地址。（可以理解为 p3 为 p1 的打开快捷方式，p3 和 p1 指向的内容相同。）
  • 第七句：把 p3 指向的堆中的空间里面的 age = 1 替换为 age = 10;（这里要注意，因为 p1 和 p3 指向的堆空间是相同的，所以 p1 的 age也是等于 10。）

匿名对象：

1.理解：我们创建的对象，没有显式的赋给一个变量名。即为匿名对象
2.特征：匿名对象只能调用一次。
3.使用：如下

  1. public class InstanceTest {
  2.     public static void main(String[] args) {
  3.         Phone p = new Phone();
  4. //        p = null;
  5.         System.out.println(p);
  7.         p.sendEmail();
  8.         p.playGame();
  11.         //匿名对象
  12. //        new Phone().sendEmail();
  13. //        new Phone().playGame();
  15.         new Phone().price = 1999;
  16.         new Phone().showPrice();//0.0
  18.         //**********************************
  19.         PhoneMall mall = new PhoneMall();
  20. //        mall.show(p);
  21.         //匿名对象的使用
  22.         mall.show(new Phone());
  24.     }
  25. }
  27. class PhoneMall{
  30.     public void show(Phone phone){
  31.         phone.sendEmail();
  32.         phone.playGame();
  33.     }
  35. }
  38. class Phone{
  39.     double price;//价格
  41.     public void sendEmail(){
  42.         System.out.println("发送邮件");
  43.     }
  45.     public void playGame(){
  46.         System.out.println("玩游戏");
  47.     }
  49.     public void showPrice(){
  50.         System.out.println("手机价格为：" + price);
  51.     }
  53. }

三、类的成员之一： 属性(field)

属性（成员变量） vs 局部变量

相同点：

:::tips

  1. 都是变量，定义变量的格式：数据类型 变量名 = 变量值
  2. 先声明，后使用
  3. 变量都有其对应的作用域 :::

不同点：

image.png

1.在类中声明的位置的不同

:::warning 属性：直接定义在类的一对{}内（就是class 类名{这个位置}） :::

局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量

2.关于权限修饰符的不同

:::warning 属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected —->封装性细说
目前，大家声明属性时，都使用缺省就可以了。（就是比如 int age;） :::

局部变量：不可以使用权限修饰符。

3. 默认初始化值的情况：

:::warning 属性：类的属性，根据其类型，都有默认初始化值。
（与数组相同的默认初始化值）
整型（byte、short、int、long）：0
浮点型（float、double）：0.0
字符型（char）：0 （或’\u0000’）
布尔型（boolean）：false

  1. 引用数据类型（类、数组、接口）：null

:::

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

4. 在内存中加载的位置：

:::warning 属性：加载到堆空间中 （非static） :::

局部变量：加载到栈空间

四、类的成员之二： 方法(method)

什么是方法(method、函数):？描述类应该具有的功能。

  • 方法是类或对象行为特征的抽象，用来完成某个功能操作。在某些语言中也称为函数或过程。
  • 将功能封装为方法的目的是，可以实现代码重用，简化代码。
  • Java里的方法不能独立存在，所有的方法必须定义在类里。

方法的声明：

方法的声明：权限修饰符 返回值类型 方法名([形参列表]){ 方法体 }

权限修饰符:void、public、static、final、abstract

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

image.png

4.1 关于权限修饰符：默认方法的权限修饰符先都使用public

Java规定的4种权限修饰符：private、public、缺省、protected —>封装性再细说

4.2 返回值类型：

有返回值 vs 没有返回值

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

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

我们定义方法该不该有返回值？
① 题目要求
② 凭经验：具体问题具体分析

4.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”

4.4 形参列表： 方法可以声明0个，1个，或多个形参。

格式：数据类型1 形参1,数据类型2 形参2,…

我们定义方法时，该不该定义形参？
① 题目要求
② 凭经验：具体问题具体分析

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

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

特殊的：方法A中又调用了方法A:递归方法。（比如快速排序）
方法中，不可以定义方法。

return关键字的使用：

  • 1.使用范围：使用在方法体中

  • 2.作用：① 结束方法

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

  • 3.注意点：return关键字后面不可以声明执行语句。（就是执行到return 后面的语句就会再执行了）

五、类的构造之三：构造器(constructor)

（或构造方法、constructor）的使用。construct：建设、建造。 construction:CCB constructor:建设者

定义构造器的格式：

语法格式： 权限修饰符 类名 (参数列表) { 初始化语句； }

5.1 构造器的特征

  • 它具有与类相同的名称
  • 它不声明返回值类型。（与声明为void不同）

  • 不能被static、final、synchronized、abstract、native修饰，不能有 return语句返回值

    5.2 构造器的作用：

    1.创建对象 //创建类的对象:new + 构造器(如：Person p1 = new Person())
    2.初始化对象的信息

    5.3 说明：

    根据参数不同，构造器可以分为如下两类： :::tips

  • 隐式无参构造器（系统默认提供）

  • 显式定义一个或多个构造器（无参、有参） ::: 注 意： :::tips
  1. Java语言中，每个类都至少有一个构造器
  2. 默认构造器的修饰符与所属类的修饰符一致
  3. 一旦显式定义了构造器，则系统不再提供默认构造器
  4. 一个类可以创建多个重载的构造器
  5. 父类的构造器不可被子类继承 :::

    5.4 构造器重载

  • 构造器一般用来创建对象的同时初始化对象。 如：

image.png

  • 构造器重载使得对象的创建更加灵活，方便创建各种不同的对象。如：

image.png

  • 构造器重载，参数列表必须不同

总结：属性赋值过程

赋值的位置：
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 通过“对象.属性“或“对象.方法”的方式赋值
赋值的先后顺序： ① - ② - ③ - ④

“万事万物皆对象” 的理解：

理解一：https://www.bilibili.com/video/BV1Kb411W75N?p=201