整理人：尚硅谷 - 宋红康

面向对象学习三条主线

1、Java类及类的成员：属性、方法、构造器；代码块、内部类

2、面向对象三大特征：封装性、继承性、多态性、（抽象性）

3、其他关键字：this、super、final、abstract、interface

面向过程(POP) 与 面向对象(OOP)

面向过程：强调功能行为，以函数为最小单位，考虑怎么做

面向对象：强调具备功能的对象，以“类\对象”为最小单位，考虑谁来做

img

如何理解面向对象：万物皆对象。可以以公司运营为例子。初创公司可能是面向过程，以解决方法优先，强调方法。公司发展后设立财务部、人力资源部等部门，按功能设立部门和分配员工，强调具有功能的类\对象。在Java中把功能封装到类中，通过类的实例化来调用功能。

Java类及类的成员

Field = 属性 = 成员变量，Method = (成员)方法 = 函数

类的实例化，即创建类的对象

如果创建了一个类的多个对象，对于类中定义的属性（非static），每个对象都拥有各自的一套副本，且互不干扰。

img

1
2
3
4
5
6
Person p1 = new Person();
p1.age = 13;

Person p3 = p1;
p3.age = 10;
System.out.println(p1.age);//10

内存解析

img

img

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

成员变量与局部变量

相同点：即变量的特点

不同点：

成员变量（属性）直接定义在类中（类{}中）；局部变量声明在方法内、方法形参、代码块内、构造器内。

声明属性的常用权限修饰符修饰：public、private、default（不写即默认）、protected；局部变量不可以用权限修饰符，可以用final

属性有初始值；局部变量在调用前一定要显示赋值（形参调用时赋值就可以）

内存：属性在堆空间（非static，static在方法区），局部变量在栈空间

img

img

img

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

方法的声明格式：

1
2
3
4
修饰符 返回值类型 方法名（参数类型 形参1, 参数类型 形参2, ….）｛
	方法体程序代码
	return 返回值;
｝

static、final、abstract来修饰的方法，后面再讲

返回值类型：

  • 没有返回值：void。
  • 有返回值，声明出返回值的类型。与方法体中“return 返回值”搭配使用

return作用：①return;结束方法②返回值

方法：在使用时可以调用类的属性或方法

1：方法的重载(overload)

重载的概念
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数
类型不同即可。
重载的特点：
与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类
型，包括顺序，但参数名不看)。调用时，根据方法参数列表的不同来区别。
重载示例：

1
2
3
4
5
6
//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}

2：可变个数的形参

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定
义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可
变的实参。

1
2
3
4
//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String…books);

说明：

  1. 声明格式：方法名(参数的类型名 …参数名)
  2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
  3. 可变个数形参的方法与同名的方法之间，彼此构成重载
  4. 可变参数方法的使用与方法参数部分使用数组是一致的
  5. 方法的参数部分有可变形参，需要放在形参声明的最后
  6. 在一个方法的形参位置，最多只能声明一个可变个数形参
1
2
3
4
5
6
public void test1(String book){
System.out.println(“****与可变形参方法构成重载的test1方法****");
}
public void test1(String ... books){
System.out.println("****形参长度可变的test1方法****");
}

▲方法3：方法参数的值传递机制

方法，必须由其所在类或对象调用才有意义。若方法含有参数：
形参：方法声明时的参数
实参：方法调用时实际传给形参的参数值
 Java的实参值如何传入方法呢？
Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

  • 形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参
  • 形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参

详细可以再看课程或课件

对象数组的内存解析

数组是引用类型，那元素既可以是基本类型也可以是引用类型。

引用类型的变量，只可能存储两类值：null和地址值（包含变量类型）

img

引用类型数组小细节

一般对象数组返回的是地址值，而char[]返回的是字符串，是因为sout.println方法对两者的重载

img

匿名对象

1、创建的对象，没有显示赋给变量名，即匿名对象

2、特征：只能调用一次

new Student().number();

面向对象特征之一：封装和隐藏

1、为什么需要封装？封装的作用和含义？
我要用洗衣机，只需要按一下开关和洗涤模式就可以了。有必要了解洗衣机内部的结构吗？有必要碰电动机吗？
我要开车，…
2、我们程序设计追求“高内聚，低耦合”。
高内聚 ：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合 ：仅对外暴露少量的方法用于使用。
3、隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

  • 隐藏一个类中不需要对外提供的实现细节；
  • 使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
  • 便于修改，增强代码的可维护性；

封装性体现：①类的属性私有化，然后提供公共方法（get、set）②不对外暴露的私有方法③单例模式

权限修饰符可以修饰类及类的内部结构：属性、方法、构造器、内部类（代码块不可以）

类的成员之三：构造器

构造器的特征

  • 它具有与类相同的名称
  • 它不声明返回值类型。（与声明为void不同）
  • 不能被static、final、synchronized、abstract、native修饰，不能有
    return语句返回值

构造器的作用：创建对象；给对象进行初始化

  • 如：Order o = new Order(); Person p = new Person(“Peter”,15);
  • 如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

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

  • 隐式无参构造器（系统默认提供）
  • 显式定义一个或多个构造器（无参、有参）

注 意：

  • Java语言中，每个类都至少有一个构造器
  • 默认构造器的修饰符与所属类的修饰符一致
  • 一旦显式定义了构造器，则系统不再提供默认构造器
  • 一个类可以创建多个重载的构造器
  • 父类的构造器不可被子类继承

总结：属性赋值过程

截止到目前，我们讲到了很多位置都可以对类的属性赋值。现总结这几个位
置，并指明赋值的先后顺序。
赋值的位置：
① 默认初始化
② 显式初始化
③ 构造器中初始化
④ 通过“对象.属性“或“对象.方法”的方式赋值
赋值的先后顺序：
① - ② - ③ - ④

JavaBean

JavaBean是一种Java语言写成的可重用组件。所谓javaBean，是指符合如下标准的Java类：

  • 类是公共的
  • 有一个无参的公共的构造器
  • 有属性，且有对应的get、set方法

用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用Java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

UML类图

img

关键字this

在Java中，this关键字比较难理解，它的作用和其词义很接近。

  • 它在方法内部使用，即这个方法所属对象的引用；
  • 它在构造器内部使用，表示该构造器正在初始化的对象。

1、this 可以调用类的属性、方法和构造器

什么时候使用this关键字呢？

  • 当在方法内需要用到调用该方法的对象时，就用this。
  • 具体的：我们可以用this来区分属性和局部变量。比如：this.name = name;

2、使用this调用本类的构造器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Person{ // 定义Person类
	private String name ;
	private int age ;
	public Person(){ // 无参构造器
		System.out.println("新对象实例化") ;
	}
	public Person(String name){
		this(); // 调用本类中的无参构造器
		this.name = name ;
	}
	public Person(String name,int age){
		this(name) ; // 调用有一个参数的构造器
		this.age = age;
	}
	public String getInfo(){
		return "姓名：" + name + "，年龄：" + age ;
	} 
}

注意：

  • 可以在类的构造器中使用”this(形参列表)”的方式，调用本类中重载的其他的构造器！
  • 明确：构造器中不能通过”this(形参列表)”的方式调用自身构造器
  • 如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了”this(形参列表)”
  • this(形参列表)”必须声明在类的构造器的首行！
  • 在类的一个构造器中，最多只能声明一个”this(形参列表)

package关键字

1、为了更好实现项目中类的管理，提供包的概念

2、使用package声明类或接口所属的包，声明在源文件的首航

3、包，属于标识符，遵循标识符的命名规则、规范（xxxyyyzzz）、“见名知意”

4、每“.”一次，就代表一层文件目录

补充：

  • 同一个包下，不能命名同名的接口、类
  • 不同包下，可以命名同名的接口、类

img

MVC设计模式

img

import关键字

img

继承性

为什么要有继承？

  • 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
  • 此处的多个类称为子类(派生类)，单独的这个类称为父类(基类或超类)。
  • 类继承语法规则:class Subclass extends SuperClass{ }

作用：

  • 继承的出现减少了代码冗余，提高了代码的复用性。
  • 继承的出现，更有利于功能的扩展。
  • 继承的出现让类与类之间产生了关系，提供了多态的前提。

注意：不要仅为了获取其他类中某个功能而去继承

子类继承了父类，就继承了父类的方法和属性（包括私有的方法和属性）。

在子类中，可以使用父类中定义的方法和属性，也可以创建新的数据和方法。
在Java 中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”。

关于继承的规则：子类不能直接访问父类中私有的(private)的成员变量和方法。

Java只支持单继承和多层继承，不允许多重继承：

  • 一个子类只能有一个父类
  • 一个父类可以派生出多个子类

所有类都直接或间接继承了Object类（根父类）

  • 如果我们没有显示声明一个类的父类，则此类继承于Object类
  • 意味着该类具有java.lang.Object类声明的功能

项目要求

1、独立完成一遍以上的项目代码

2、积累完成项目的过程中常见的bug的调试：

  • “硬”看，必要时，添加输出语句
  • Debug

3、捋顺思路，强化逻辑

4、对象、数组等内存结构的解析

5、遵循编码的规范，标识符的命名规范等

6、类前、方法前、属性前：文档注释；逻辑步骤：单行、多行注释

Debug

参考视频：https://www.bilibili.com/video/BV1Kb411W75N?p=269&spm_id_from=pageDriver&vd_source=ccf90130d80396981859cd525be711f0

想知道哪个部分具体情况，就设置断点（如想知道int age = …赋值是多少，就在这打断点），然后Debug as

step over：下一步；step into：进入代码具体执行内容（如进入某个方法内部）；step return：退出代码具体执行内容；resume：执行下一个断点处；jump to frame：回到方法首行

Debug问题： 点击step into没有进入方法内部，而是跳到了下一行代码

解决方法： 右键Debug as中的Debug Configuration，把Alternate JRE路径（原来可能是jre）改成jdk（如jdk 1.8）

img

方法的重写(override/overwrite)

java中overload、override、overwrite的区别：https://juejin.cn/post/6997755459260121101

Overload是重载，Override重写(覆盖)，Overwrite java中没有（C++有）

定义：在子类中可以根据需要对从父类中继承来的方法进行改造，也称
为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。
要求：

  1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
  2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
    比如：父类void子类就只能是void；父类返回值是A类，子类的返回值可以是A类或A的子类；如果父类是基本类型，子类必须相同，如double必须是double
  3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
    子类不能重写父类中声明为private权限的方法
  4. 子类方法抛出的异常不能大于父类被重写方法的异常
    如父类Exception，子类可以是RuntimeException

实际开发中，重写可以直接复制父类的方法，改一下方法体就可以；或者直接按IDE提示写

注意：子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为
static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。

关键字—super

在Java类中使用super来调用父类中的指定操作：

  • super可用于访问父类中定义的属性
  • super可用于调用父类中定义的成员方法
  • super可用于在子类构造器中调用父类的构造器

通常都是忽略super，当要显式调用父类和子类的同名属性和方法时，需要super和this来区分

注意：

  • 尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
  • super的追溯不仅限于直接父类
  • super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

调用父类的构造器

  • 子类中所有的构造器默认都会访问父类中空参数的构造器,在构造器首行，没有this(参数列表)或者super(参数列表)，则默认调用父类无参构造器
  • 当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时，只能“二选一”，且必须放在构造器的首行。
  • 如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错
  • 在类的多个构造器中，至少有一个构造器使用了super(参数列表)【即调用父类构造器】。一个构造器不是使用super(参数列表)就是使用this(参数列表)

img

子类对象实例化的全过程

img

思考：
1).为什么super(…)和this(…)调用语句不能同时在一个构造器中出现？
2).为什么super(…)或this(…)调用语句只能作为构造器中的第一句出现？

解答：https://www.yisu.com/zixun/276824.html

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class A {
     A()
       {
            System.out.println("You call super class non-args constructor!");
  
       }
} 
class B extends A {   
   B()   
   {
      //这里，编译器将自动加上 super(); 
     System.out.println("You call subclass constructor!");   
  }

    B(String n)
    {   
    super(); 
    this();   
    //实际就是调用了B(){...}，而在B(){...}中编译器自动加上了   
    //super();这样就相当于两次调用了super();也就是说对父类进
    //行了两次初始化。而在实例化一个对象时，一个构造方法只能调用一次，这说明this和super不能同时存在一个构造方法中。
    //同时因为系统没有在第一行发现this()或super()调用，就会自动加上super(),如果没有将this()和super()放在第一行就会产生矛盾。  
    //因为总有一个super()在第二句上。所以该程序不能通过编译！！！   
    }
}

结论：也就是说你必须在构造器的第一行放置super或者this构造器，否则编译器会自动地放一个空参数的super构造器的，其他的构造器也可以调用super或者this，调用成一个递归构造链，最后的结果是父类的构造器（可能有多级父类构造器）始终在子类的构造器之前执行，递归的调用父类构造器。无法执行当前的类的构造器。也就不能实例化任何对象，这个类就成为一个无为类。
从另外一面说，子类是从父类继承而来，继承了父类的属性和方法，如果在子类中先不完成父类的成员的初始化，则子类无法使用，应为在java中不允许调用没初始化的成员。在构造器中是顺序执行的，也就是说必须在第一行进行父类的初始化。而super能直接完成这个功能。This()通过调用本类中的其他构造器也能完成这个功能。
因此，this()或者super()必须放在第一行。

简而言之：img

面向对象特征之三：多态性

多态性，是面向对象中最重要的概念，在Java中的体现：
对象的多态性：父类的引用指向子类的对象。

简单理解：事物的多种形态

  • 可以直接应用在抽象类和接口上。

多态性的比喻举例：三个类：一个父类Person，有eat()方法和walk()方法；一个Person的子类Man，有重写的eat()方法和walk()方法，还有另外的earnmoney()方法；Person的子类Woman，有重写的eat()方法和walk()方法，还有另外的shop()方法。 Person p1 = new Man()，相当于找一个人来（只不过这个人是男性）。p1只能调用eat()和walk()方法，也就是只能做person“人”能做的事。但是eat()和walk()却会执行man重写的方法，也就是找来的人，他做事的方式是男性的方式。

img

5、对象的多态性：只适用于方法，不适用于属性【调用属性时只会调用父类的属性】

Object类的clone方法是protected的

Object类的equals方法的形参是Object类型的【多态性的好处体现，如果没有多态性，给equals方法的参数就只能是Object类型的，就不能是Object的子类如String。多态性能减少方法重载，提高通用性】

多态性好处的另一体现：

img

数据库连接可以是mysql，也可以是oracle，体现了多态

多态性的意义：抽象类和接口的应用，没有多态性，抽象类和接口就不能造对象了，那抽象类和接口就没有意义了

虚拟方法调用(Virtual Method Invocation)

正常的方法调用

1
2
3
4
Person e = new Person();
e.getInfo();
Student e = new Student();
e.getInfo();

虚拟方法调用(多态情况下)
子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

1
2
Person e = new Student();
e.getInfo(); //调用Student类的getInfo()方法

编译时类型和运行时类型
编译时e为Person类型，而方法的调用是在运行时确定的，所以调用的是Student类的getInfo()方法。——动态绑定【虚拟方法调用的过程】。

多态是运行时行为

举例：如下图，随机对象给animal，只有运行后才知道是哪个类型

img

小结：方法的重载与重写

  1. 二者的定义细节：略
  2. 从编译和运行的角度看：
    重载，是指允许存在多个同名方法，而这些方法的参数不同。编译器根据方法不同的参数表，对同名方法的名称做修饰。对于编译器而言，这些同名方法就成了不同的方法。它们的调用地址在编译期就绑定了。Java的重载是可以包括父类和子类的，即子类可以重载父类的同名不同参数的方法。
    所以：对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”。
    引用一句Bruce Eckel的话：“不要犯傻，如果它不是晚绑定，它就不是多态。”
    重载不体现多态性，重写体现多态性

向下转型的使用

当多态不能调用子类特有的属性和方法时，可以向下转型

img

img

强转和基本数据类型的情况一样，都是有风险的。基本数据类型强转可能损失精度，而不同类型强转可能会失败（如Man转成Woman）。

instanceof关键字的使用

为了避免向下转型异常，用instanceof进行判断来转型

类B是类A的父类，若a instanceof A返回true，那么a instanceof B也返回true

img

转型常见问题

img

多态练习：调用方法和属性

img

实际开发不要在子类父类定义同名的属性

重写方法小细节

img

int… 和 int[] 在形参中视为一样

如果Sub1里再来个 add(int a, int b, int c)，那调用时还是调用 add(int a, int[] arr)方法，因为该方法才是重写的方法。

但如果main方法改为下图形式，那就是调用 add(int a, int b, int c)，因为确定形参优先级大于不确定形参

Object类

object类的功能（属性、

img

clone()、equals()、toString()…

equals()方法

“==”运算符的使用

img

基本数据类型出了boolean都可以用“==”运算符互相比较，且只看两个变量保存的数据是否相同，如 int i = 10; char c = 10;，那么 i==c

但引用类型使用“==”运算符时，两类型必须一致，否则编译不通过

equals()方法的使用

img

开发中常常需要重写的equals方法来达到自己想要的效果，写法可以参考String的equals方法。实际开发用IDE的功能重写equals，IDE往往写的比自己写的要全面。

null.equals会报空指针异常

重写equals()方法的原则

img

重写equals时的小细节【String类型要用equals而不是==】8:10

因为 String a1 = "AA"; String a2 = "AA"; a1 == a2//true。由于”AA”存放在方法区常量池中，由于赋值a2时，常量池中已有该值，因此a2会直接复用指向。但如果 a2 = new String("AA")，那么 a1 == a2//false。因此比较String还是要equals。

只要基本数据类型就==，引用类型就equals。

包装类

1
2
3
4
5
Integer in1 = new Integer("123")//ok
Integer in2 = new Integer("123abc")//报异常

Boolean b2 = new Boolean("trUe")//ok
Boolean b3 = new Boolean("true123")//false，只要不是true，其他全是false

img

static关键字

image-20220802210803095

static修饰变量

image-20220802211749235

image-20220802214259242

static修饰变量，打个比方就像书房的书，改动都会影响书，调用时都会调用同一本书。非static变量就像每间卧室的床，每个对象都独立拥有自己的床，互不影响。

实例对象加载晚于对象创建，静态对象加载早于对象创建。

类变量与实例变量内存解析

image-20220802215043089

static修饰方法

image-20220802221517311

开发如何确定是否要用static

image-20220802222757167