Java30天养成计划 || 08 面向对象特性——封装||继承||多态

写在前面，大家好！我是【跨考菌】，一枚跨界的程序猿，专注于后台技术的输出，目标成为全栈攻城狮！这博客是对我跨界过程的总结和思考。如果你也对Java、后端技术感兴趣，抑或是正在纠结于跨界，都可以关注我的动态，让我们一起学习，一起进步~
我的博客地址为：【跨考菌】的博客

上一篇 Java30天养成计划 || 07一文吃透Java函数 讲解了Java函数的基础语法和面试高频考点。本文开始讲解面向对象的内容，该模块也是Java语言较为核心的知识点，一定要理解其封装、继承、多态的三大特性。

---

1、类与对象

1.1、面向对象思想概述

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。 它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

举例：

• 面向过程：把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来
• 面向对象：把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来

面向过程强调步骤，面向对象强调对象(洗衣机)

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态

1.2、类和对象

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物

• 属性：就是该事物的状态信息。
• 行为：就是该事物能够做什么。

举例：小猫
属性：名字、体重、年龄、颜色。 行为：走、跑、叫。

对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性和行为

类与对象的关系

• 类是对一类事物的描述，是抽象的。
• 对象是一类事物的实例，是具体的。
• 类是对象的模板，对象是类的实体。

1.3、类的定义

格式：

public class ClassName {
	//成员变量
	//成员方法
}

例子：

public class Student {
	//成员变量
	String name；//姓名
	int age；//年龄
	//成员方法
	//学习的方法
	publicvoid study() {
		System.out.println("好好学习，天天向上");
	} 
	//吃饭的方法
	publicvoid eat() {
		System.out.println("学习饿了要吃饭");
	}
}

1.4、对象的使用

创建对象：

类名 对象名 = new 类名();

使用对象的成员：

对象名.成员变量；
对象名.成员方法()；

使用案例

public class Test01_Student {
	public static void main(String[] args) {
		//创建对象格式：类名 对象名 = new 类名();
		Student s = new Student();
		System.out.println("s:"+s); //cn.itcast.Student@100363
		//直接输出成员变量值
		System.out.println("姓名："+s.name); //null
		System.out.println("年龄："+s.age); //0
		System.out.println("‐‐‐‐‐‐‐‐‐‐");
		//给成员变量赋值
		s.name = "赵丽颖";
		s.age = 18;
		//再次输出成员变量的值
		System.out.println("姓名："+s.name); //赵丽颖
		System.out.println("年龄："+s.age); //18
		System.out.println("‐‐‐‐‐‐‐‐‐‐");
		//调用成员方法
		s.study(); // "好好学习，天天向上"
		s.eat(); // "学习饿了要吃饭"
	}
}

成员变量的默认值：

1.5、类和对象的举例

定义手机类：

public class Phone {
	// 成员变量
	String brand; //品牌
	int price; //价格
	String color; //颜色
	// 成员方法
	//打电话
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	} /
	/发短信
	public void sendMessage() {
		System.out.println("群发短信");
	}
}

测试类：

public class Test02Phone {
public static void main(String[] args) {
		//创建对象
		Phone p = new Phone();
		//输出成员变量值
		System.out.println("品牌："+p.brand);//null
		System.out.println("价格："+p.price);//0
		System.out.println("颜色："+p.color);//null
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
		//给成员变量赋值
		p.brand = "锤子";
		p.price = 2999;
		p.color = "棕色";
		//再次输出成员变量值
		System.out.println("品牌："+p.brand);//锤子
		System.out.println("价格："+p.price);//2999
		System.out.println("颜色："+p.color);//棕色
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
		//调用成员方法
		p.call("紫霞");
		p.sendMessage();
	}
}

1.6、对象内存图

1）一个对象的调用内存图

通过上图，我们可以理解，在栈内存中运行的方法，遵循"先进后出，后进先出"的原则。变量p指向堆内存中
的空间，寻找方法信息，去执行该方法。
但是，这里依然有问题存在。创建多个对象时，如果每个对象内部都保存一份方法信息，这就非常浪费内存了，因为所有对象的方法信息都是一样的。那么如何解决这个问题呢？请看如下图解。

2）两个对象调用同一方法内存图

对象调用方法时，根据对象中方法标记（地址值），去类中寻找方法信息。这样哪怕是多个对象，方法信息只保存一份，节约内存空间。

3）一个引用，作为参数传递到方法中内存图

引用类型作为参数，传递的是地址值

1.7、局部变量和成员变量

1）在类中的位置不同 重点

• 成员变量：类中，方法外
• 局部变量：方法中或者方法声明上(形式参数)

2）作用范围不一样 重点

• 成员变量：类中
• 局部变量：方法中

3）初始化值的不同 重点

• 成员变量：有默认值
• 局部变量：没有默认值。必须先定义，赋值，最后使用

4）在内存中的位置不同 了解

• 成员变量：堆内存
• 局部变量：栈内存

5）生命周期不同 了解

• 成员变量：随着对象的创建而存在，随着对象的消失而消失
• 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

2、抽象类

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

抽象方法 ： 没有方法体的方法。
抽象类：包含抽象方法的类。

2.1、abstract用法

1）抽象方法

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

格式：

修饰符 abstract 返回值类型 方法名 (参数列表)；

案例

public abstract void run()；

2）抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。

格式:

abstract class 类名字 {
}

例子：

public abstract class Animal {
	public abstract void run()；
}

3）抽象的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

2.2、注意事项

1） 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。
理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
2）抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。
理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
3）抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

4）抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义

3、接口

3.1、接口概述

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，接口。

接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类

3.2、接口格式

public interface 接口名称 {
// 抽象方法
// 默认方法
// 静态方法
// 私有方法
}

含有抽象方法

public interface InterFaceName {
	public abstract void method();
}

含有默认和静态方法

public interface InterFaceName {
	public default void method() {
		// 执行语句
	} 
	public static void method2() {
		// 执行语句
	}
}

含有私有和私有静态方法

public interface InterFaceName {
	private void method() {
		// 执行语句
	}
}

3.3、接口实现

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。

非抽象子类实现接口：

1. 必须重写接口中所有抽象方法。
2. 继承了接口的默认方法，即可以直接调用，也可以重写。

class 类名 implements 接口名 {
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【可选】
}

1）抽象方法的使用

public interface LiveAble {
	// 定义抽象方法
	public abstract void eat();
	public abstract void sleep();
}




public class Animal implements LiveAble {
	@Override
	public void eat() {
		System.out.println("吃东西");
	} 
	@Override
	public void sleep() {
		System.out.println("晚上睡");
	}
}

2）默认方法的使用

可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

①、继承默认方法

public interface LiveAble {
	public default void fly(){
		System.out.println("天上飞");
	}
}



public class Animal implements LiveAble {
	// 继承，什么都不用写，直接调用
}

②、实现默认方法

public interface LiveAble {
	public default void fly(){
		System.out.println("天上飞");
	}
}



public class Animal implements LiveAble {
	@Override
	public void fly() {
		System.out.println("自由自在的飞");
	}
}

3）静态方法的使用

静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用

public interface LiveAble {
	public static void run(){
		System.out.println("跑起来~~~");
	}
}


// 实现类
public class Animal implements LiveAble {
	// 无法重写静态方法
}

// 测试类
public class InterfaceDemo {
	public static void main(String[] args) {
		// Animal.run(); // 【错误】无法继承方法,也无法调用
		LiveAble.run(); //
	}
}

4）私有方法的调用

• 私有方法：只有默认方法可以调用。
• 私有静态方法：默认方法和静态方法可以调用。

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。

public interface LiveAble {
	default void func(){
		func1();
		func2();
	} 
	private void func1(){
		System.out.println("跑起来~~~");
	} 
	private void func2(){
		System.out.println("跑起来~~~");
	}
}

3.4、接口的多实现

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

格式：

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【不重名时可选】
}

1）抽象方法

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：

定义多个接口：

interface A {
	public abstract void showA();
	public abstract void show();
}
interface B {
	public abstract void showB();
	public abstract void show();
}

实现类：

public class C implements A,B{
	@Override
	public void showA() {
		System.out.println("showA");
	} 
	@Override
	public void showB() {
		System.out.println("showB");
	} 
	@Override
	public void show() {
		System.out.println("show");
	}
}

2）默认方法

接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。代码如下：定义多个接口：

interface A {
	public default void methodA(){}
	public default void method(){}
} 
interface B {
	public default void methodB(){}
	public default void method(){}
}

实现类：

public class C implements A,B{
	@Override
	public void method() {
		System.out.println("method");
	}
}

3）静态方法

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

4）优先级问题

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。代码如下：

定义接口：

interface A {
	public default void methodA(){
		System.out.println("AAAAAAAAAAAA");
	}
}

定义父类

class D {
	public void methodA(){
		System.out.println("DDDDDDDDDDDD");
	}
}

定义子类：

class C extends D implements A {
	// 未重写methodA方法
}

定义测试类：

public class Test {
	public static void main(String[] args) {
		C c = new C();
		c.methodA();
	}
} 

输出结果:
DDDDDDDDDDDD

3.5、接口的多继承

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。代码如下：

定义父接口：

interface A {
	public default void method(){
		System.out.println("AAAAAAAAAAAAAAAAAAA");
	}
} 

interface B {
	public default void method(){
		System.out.println("BBBBBBBBBBBBBBBBBBB");
	}
}

定义子接口：

interface D extends A,B{
	@Override
	public default void method() {
		System.out.println("DDDDDDDDDDDDDD");
	}
}

子接口重写默认方法时，default关键字可以保留。
子类重写默认方法时，default关键字不可以保留。

3.6、其他成员特点

• 接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
• 接口中，没有构造方法，不能创建对象。
• 接口中，没有静态代码块。

4、面向对象特性

4.1、封装

4.1.1、封装概述

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则:
将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问

4.1.2、封装的步骤

1. 使用 private 关键字来修饰成员变量。
2. 对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法

4.1.3、封装的操作【private关键字】

private的含义

1. private是一个权限修饰符，代表最小权限。
2. 可以修饰成员变量和成员方法。
3. 被private修饰后的成员变量和成员方法，只在本类中才能访问。

格式：

private 数据类型 变量名 ；

案例：

public class Student {
	private String name;
	private int age;
	public void setName(String n) {
		name = n;
	} 
	public String getName() {
		return name;
	}
	public void setAge(int a) {
		age = a;
	} 
	public int getAge() {
		return age;
	}
}

4.1.4、封装优化【this关键字】

this的含义：
this代表所在类的当前对象的引用（地址值），即对象自己的引用。

记住 ：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

使用格式：

this.成员变量名；

案例：使用 this 修饰方法中的变量，解决成员变量被隐藏的问题

public class Student {
	private String name;
	private int age;
	public void setName(String name) {
		//name = name;
		this.name = name;
	} 
	public String getName() {
		return name;
	} 
	public void setAge(int age) {
		//age = age;
		this.age = age;
	} 
	public int getAge() {
		return age;
	}
}

4.1.5、封装优化2【构造方法】

Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

格式：

修饰符 构造方法名(参数列表){
	// 方法体
}

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。使用构造方法后，代码如下：

public class Student {
	private String name;
	private int age;
	// 无参数构造方法
	public Student() {}
		// 有参数构造方法
		public Student(String name,int age) {
		this.name = name;
		this.age = age;
	}
}

注意事项：

1. 如果你不提供构造方法，系统会给出无参数构造方法。
2. 如果你提供了构造方法，系统将不再提供无参数构造方法。
3. 构造方法是可以重载的，既可以定义参数，也可以不定义参数。

4.1.6、开发中的标准代码JavaBean

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set 和 get 方法。

public class ClassName{
	//成员变量
	//构造方法
	//无参构造方法【必须】
	//有参构造方法【建议】
	//成员方法
	//getXxx()
	//setXxx()
}

4.2、继承

4.2.1、概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。如图所示。

其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。

继承描述的是事物之间的所属关系，这种关系是： is-a 的关系。例如，图中兔子属于食草动物，食草动物属于动物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

定义：

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的非私有的属性和行为。

继承的好处：

1. 提高代码的复用性。
2. 类与类之间产生了关系，是多态的前提。

4.2.2、继承的格式

class 父类 {
	...
} 
class 子类 extends 父类 {
	...
}

案例：

/
* *
定义员工类Employee，做为父类
*/
class Employee {
	String name; // 定义name属性
	// 定义员工的工作方法
	public void work() {
		System.out.println("尽心尽力地工作");
	}
} 
/
* *
定义讲师类Teacher 继承 员工类Employee
*/
class Teacher extends Employee {
	// 定义一个打印name的方法
	public void printName() {
		System.out.println("name=" + name);
	}
} 
/
* *
定义测试类
*/
public class ExtendDemo01 {
	public static void main(String[] args) {
		// 创建一个讲师类对象
		Teacher t = new Teacher();
		// 为该员工类的name属性进行赋值
		t.name = "小明";
		// 调用该员工的printName()方法
		t.printName(); // name = 小明
		// 调用Teacher类继承来的work()方法
		t.work(); // 尽心尽力地工作
	}
}

4.2.3、继承后的特点【成员变量】

1）成员变量不重名

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。代码如下：

class Fu {
	// Fu中的成员变量。
	int num = 5;
}
class Zi extends Fu {
		// Zi中的成员变量
		int num2 = 6;
		// Zi中的成员方法
		public void show() {
			// 访问父类中的num，
			System.out.println("Fu num="+num); // 继承而来，所以直接访问。
			// 访问子类中的num2
			System.out.println("Zi num2="+num2);
	}
} 
class ExtendDemo02 {
	public static void main(String[] args) {
		// 创建子类对象
		Zi z = new Zi();
		// 调用子类中的show方法
		z.show();
	}
}

演示结果：
Fu num = 5
Zi num2 = 6

2）成员变量重名

class Fu {
	// Fu中的成员变量。
	int num = 5;
} 
class Zi extends Fu {
	// Zi中的成员变量
	int num = 6;
	public void show() {
		// 访问父类中的num
		System.out.println("Fu num=" + num);
		// 访问子类中的num
		System.out.println("Zi num=" + num);
	}
} 
class ExtendsDemo03 {
	public static void main(String[] args) {
		// 创建子类对象
		Zi z = new Zi();
		// 调用子类中的show方法
		z.show();
	}
}


演示结果：
Fu num = 6
Zi num = 6

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字，修饰父类成员变量，类似于之前学过的 this 。

使用格式：

super.父类成员变量名

子类方法修改：

class Zi extends Fu {
	// Zi中的成员变量
	int num = 6;
	public void show() {
		//访问父类中的num
		System.out.println("Fu num=" + super.num);
		//访问子类中的num
		System.out.println("Zi num=" + this.num);
	}
} 
演示结果：
Fu num = 5
Zi num = 6

Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu 类中的成员变量私有了，子类是不能
直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法

4.2.4、继承后的特点【成员方法】

1）成员方法不重名

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

2）成员方法重名【重写(Override)】

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做方法重写 (Override)。

方法重写 ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现覆盖效果，也称为重写或者复写。声明不变，重新实现。

注，这里将重载和重写区分：

重载：是在同一个类中，多个方法的方法名相同，参数和返回值可以不同。
重写：存在于父子类中，多个方法返回字、方法名、参数列表一摸一样，实现不同。

4.2.5、继承后的特点【构造方法】

1. 构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2. 构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。代码如下：

class Fu {
	private int n;
	Fu(){
		System.out.println("Fu()");
	}
}


class Zi extends Fu {
	Zi(){
		// super（），调用父类构造方法
		super();
		System.out.println("Zi（）");
	}
} 
public class ExtendsDemo07{
	public static void main (String args[]){
		Zi zi = new Zi();
	}
} 
输出结果：
Fu（）
Zi（）

4.2.6、super和this

父类空间优先于子类对象发生
在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。代码体现在子类的构造方法调用时，一定先调用父类的构造方法。理解图解如下：

super和this的含义

• super ：代表父类的存储空间标识(可以理解为父亲的引用)。
• this ：代表当前对象的引用(谁调用就代表谁)。

super和this的用法：

①、访问成员

this.成员变量 ‐‐ 本类的
super.成员变量 ‐‐ 父类的
this.成员方法名() ‐‐ 本类的
super.成员方法名() ‐‐ 父类的

②、访问构造

this(...) ‐‐ 本类的构造方法
super(...) ‐‐ 父类的构造方法

4.2.7、继承的特点

1）.Java只支持单继承，不支持多继承。

//一个类只能有一个父类，不可以有多个父类。
class C extends A{} //ok
class C extends A，B... //error

2） Java支持多层继承(继承体系)

class A{}
class B extends A{}
class C extends B{}

顶层父类是Object类。所有的类默认继承Object，作为父类

3）子类和父类是一种相对的概念

4.3、多态

4.3.1、概述

多态是继封装、继承之后，面向对象的第三大特性。
生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。

多态： 是指同一行为，具有多个不同表现形式。

前提：

1. 继承或者实现【二选一】
2. 方法的重写【意义体现：不重写，无意义】
3. 父类引用指向子类对象【格式体现】

4.3.2、多态实现

格式：

父类类型 变量名 = new 子类对象；
变量名.方法名();

代码如下：

Fu f = new Zi();
f.method();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，执行的是子类重写后方法。

定义父类：

public abstract class Animal {
	public abstract void eat();
}

定义子类

class Cat extends Animal {
	public void eat() {
		System.out.println("吃鱼");
	}
} 
class Dog extends Animal {
	public void eat() {
		System.out.println("吃骨头");
	}
}

测试类：

public class Test {
	public static void main(String[] args) {
		// 多态形式，创建对象
		Animal a1 = new Cat();
		// 调用的是 Cat 的 eat
		a1.eat();
		// 多态形式，创建对象
		Animal a2 = new Dog();
		// 调用的是 Dog 的 eat
		a2.eat();
	}
}

4.3.3、多态的好处

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。

4.3.4、引用类型转换

多态的转型分为向上转型与向下转型两种：

1）向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

格式：

父
类类型 变量名 = new 子类类型();
如：Animal a = new Cat();

2）向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;

3）为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

4）转型的异常

public class Test {
	public static void main(String[] args) {
		// 向上转型
		Animal a = new Cat();
		a.eat(); // 调用的是 Cat 的 eat
		// 向下转型
		Dog d = (Dog)a;
		d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】
	}
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。
为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false

改进

public class Test {
	public static void main(String[] args) {
	// 向上转型
	Animal a = new Cat();
	a.eat(); // 调用的是 Cat 的 eat
	// 向下转型
	if (a instanceof Cat){
		Cat c = (Cat)a;
		c.catchMouse(); // 调用的是 Cat 的 catchMouse
	} else if (a instanceof Dog){
		Dog d = (Dog)a;
		d.watchHouse(); // 调用的是 Dog 的 watchHouse
	}
	}
}

5、内部类

5.1、概述

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则称为外部类。

1）成员内部类

成员内部类 ：定义在类中方法外的类。

格式:

class 外部类 {
	class 内部类{
	}
}

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构。比如，汽车类 Car 中包含发动机类 Engine ，这时， Engine 就可以使用内部类来描述，定义在成员位置。

举例：

class Car { //外部类
	class Engine { //内部类
	}
}

2）访问特点

• 内部类可以直接访问外部类的成员，包括私有成员。
• 外部类要访问内部类的成员，必须要建立内部类的对象。

创建内部类对象的格式：

外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

举例：

public class Person {
	private boolean live = true;
	class Heart {
		public void jump() {
		// 直接访问外部类成员
		if (live) {
			System.out.println("心脏在跳动");
		} else {
			System.out.println("心脏不跳了");
		}
	}
	} 
	public boolean isLive() {
		return live;
	} 
	public void setLive(boolean live) {
		this.live = live;
	}
}

测试类：

// 创建外部类对象
Person p = new Person();
// 创建内部类对象
Heart heart = p.new Heart();
// 调用内部类方法
heart.jump();
// 调用外部类方法
p.setLive(false);
// 调用内部类方法
heart.jump();


输出结果:
心脏在跳动
心脏不跳了

5.2、匿名内部类

匿名内部类 ：是内部类的简化写法。它的本质是一个 带具体实现的 父类或者父接口的 匿名的 子类对象。开发中，最常用到的内部类就是匿名内部类了。以接口举例，当你使用一个接口时，似乎得做如下几步操作，

1. 定义子类
2. 重写接口中的方法
3. 创建子类对象
4. 调用重写后的方法

匿名内部类必须继承一个父类或者实现一个父接口。

格式：

new 父类名或者接口名(){
	// 方法重写
	@Override
	public void method() {
		// 执行语句
	}
};

案例：

定义接口：

public abstract class FlyAble{
	public abstract void fly();
}

创建匿名内部类：

public class InnerDemo {
	public static void main(String[] args) {
		/*
		1.等号右边:是匿名内部类，定义并创建该接口的子类对象
		2.等号左边:是多态赋值,接口类型引用指向子类对象
		*/
		FlyAble f = new FlyAble(){
		public void fly() {
		System.out.println("我飞了~~~");
		}
		};
		//调用 fly方法,执行重写后的方法
		f.fly();
	}
}

测试类：

public class InnerDemo3 {
	public static void main(String[] args) {
		/*
		创建匿名内部类,直接传递给showFly(FlyAble f)
		*/
		showFly( new FlyAble(){
		public void fly() {
		System.out.println("我飞了~~~");
		}
		});
		} 
		public static void showFly(FlyAble f) {
		f.fly();
	}
}

6、面试高频问题

6.1、抽象类和接口的区别？

1. 接口的方法默认是 public，所有方法在接口中不能有实现(Java 8 开始接口方法可以有默认实现），而抽象类可以有非抽象的方法。
2. 接口中除了 static、final 变量，不能有其他变量，而抽象类中则不一定。
3. 一个类可以实现多个接口，但只能实现一个抽象类。接口自己本身可以通过 extends 关键字扩展多个接口。
4. 接口方法默认修饰符是 public，抽象方法可以有 public、protected 和 default 这些修饰符（抽象方法就是为了被重写所以不能使用 private 关键字修饰！）。
5. 从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范。

备注：

1. 在 JDK8 中，接口也可以定义静态方法，可以直接用接口名调用。实现类和实现是不可以调用的。如果同时实现两个接口，接口中定义了一样的默认方法，则必须重写，不然会报错。
2. jdk9 的接口被允许定义私有方法 。

总结一下 jdk7~jdk9 Java 中接口概念的变化:

1. 在 jdk 7 或更早版本中，接口里面只能有常量变量和抽象方法。这些接口方法必须由选择实现接口的类实现。
2. jdk8 的时候接口可以有默认方法和静态方法功能。
3. Jdk 9 在接口中引入了私有方法和私有静态方法。

6.2、静态方法和实例方法的区别？

1. 在外部调用静态方法时，可以使用"类名.方法名“的方式，也可以使用”对象名.方法名"的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。

2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。

总结一句话：静态只能访问静态！

6.3、面向对象和面向过程的区别？

• 面向过程 ：面向过程性能比面向对象高。 因为类调用时需要实例化，开销比较大，比较消耗资源，所以当性能是最重要的考量因素的时候，比如单片机、嵌入式开发、Linux/Unix 等一般采用面向过程开发。但是，面向过程没有面向对象易维护、易复用、易扩展。
• 面向对象 ：面向对象易维护、易复用、易扩展。 因为面向对象有封装、继承、多态性的特性，所以可以设计出低耦合的系统，使系统更加灵活、更加易于维护。但是，面向对象性能比面向过程低。

6.4、无参构造方法的作用？

Java 程序在执行子类的构造方法之前，如果没有用 super()来调用父类特定的构造方法，则会调用父类中“没有参数的构造方法”。

因此，如果父类中只定义了有参数的构造方法，而在子类的构造方法中又没有用 super()来调用父类中特定的构造方法，则编译时将发生错误，因为 Java 程序在父类中找不到没有参数的构造方法可供执行。

解决办法是在父类里加上一个不做事且没有参数的构造方法。

总结一句话：为了子类访问父类时，父类构造方法的初始化！

6.5、构造方法的作用时什么？

主要作用是完成对类对象的初始化工作。

即便没有构造方法，成语也可以执行(因为默认使用的无参构造)。因为一个类即使没有声明构造方法也会有默认的不带参数的构造方法。如果我们自己添加了类的构造方法（无论是否有参），Java 就不会再添加默认的无参数的构造方法了，这时候，就不能直接 new 一个对象而不传递参数了，所以我们一直在不知不觉地使用构造方法，这也是为什么我们在创建对象的时候后面要加一个括号（因为要调用无参的构造方法）。如果我们重载了有参的构造方法，记得都要把无参的构造方法也写出来（无论是否用到），因为这可以帮助我们在创建对象的时候少踩坑。

最后，如果您觉得对您有帮助的话，不要忘记帮助帮博主一键三连😊哦