JAVA——多态、内部类

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

多态的概述，多态的形式

什么是多态？
同类型的对象，执行同一个行为，会表现出不同的行为特征。
多态的场景形式

父类类型 对象名称 = new 子类构造器;
接口 对象名称 = new 实现类构造器；

多态中成员访问特点
1、方法调用：编译看左边，运行看右边。
2、变量调用：编译看左边，运行也看左边。（多态侧重行为多态）

多态的前提
有继承/实现关系；有父类引用指向子类对象；有方法重写。

多态的优势

1、在多态形式下，右边对象可以实现解耦合，便于扩展和维护。

Animal a = new Tortorise();
a.run;//后续业务行为随对象而变，后续代码无需修改。

2、定义方法的时候，使用父类型作为参数，该方法就可以接收这父类的一切子类对象，体现出多态的扩展性与便利。

多态下会产生的一个问题：
多态下不能使用子类的独有功能

多态下引用数据类型的类型转换

自动类型转换（从子到父）：子类对象赋值给父类类型的变量指向。
强制类型转换（从父到子）
1、此时必须进行强制类型转换：子类 对象变量 = (子类) 父类类型的变量
2、作用：可以解决多态下的劣势，可以实现调用子类独有的功能。
3、注意：如果转型后的类型和对象真实类型不是同一种类型，那么在转换的时候就会出现ClassCastException

Animal t = new Tortoise();
Dog d = (Dog)t;//出现异常 ClassCastException

Java建议强转转换前使用instanceof判断当前对象的真是类型，再进行强制转换

变量名 instanceof 真实类型
判断关键字左边的变量指向的对象的真是类型，是否是右边的类型或者是其子类类型，是则返回true，反之返回flase。

总结：
1、引用数据类型的类型转换，有几种方式？
自动类型转换、强制类型转换
2、强制类型转换能解决什么问题？强制类型转换需要注意什么？
Ⅰ、可以转换成真正的子类类型，从而调用子类独有功能。
Ⅱ、有继承关系/实现的2个类型就可以强制转换，编译无问题。
Ⅲ、运行时，如果发现强制转换后的类型不是对象真实类型则报错。
Ⅳ、类型转换异常ClassCastException

内部类

内部类的概述

1、内部类就是定义在一个类里面的类，里面的类可以理解成（寄生），外部类可以理解成（宿主）。

public class People{
	public class Heart{
	}
}

###内部类的使用场景、作用
1、当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构可以选择使用内部类来设计。
2、内部类通常可以方便访问外部类的成员，包括私有的成员。
3、内部类提供了更好的封装性，内部类本身就可以用private protected等修饰，封装性可以做更多控制。

内部类的分类

1、静态内部类——了解
2、成员内部类（非静态内部类）——了解
3、局部内部类——了解
4、匿名内部类——重点

什么是静态内部类

1、有static修饰，属于外部类本身
2、它的特点和使用与普通类是完全一样的，类有的成分他都有，只是位置在别人里面而已。

public class Outer{
	//静态成员内部类
	public static class Inner{
	}
}

3、静态内部类创建对象的格式：

格式：外部类名.内部类名 对象名 = new 外部类名.内部类构造器;
范例：Outer.Inner in = new Outer.Inner();

静态内部类的访问拓展：
1、静态内部类中是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
2、静态内部类中是否可以直接访问外部类的实例成员？
不可以的，外部类的实例成员必须用外部类对象访问。

总结
1、静态内部类的使用场景、特点、访问总结
一个类中包含了一个完整的部分，如汽车类的发动机类。
2、特点、使用与普通类是一样的，类有的成分他都有，只是位置在别人里面而已。
3、可以直接访问外部类的静态成员，不能直接访问外部类的实例成员。
4、注意：开发中实际上用的还是比较少。

什么是成员内部类

1、无static修饰，属于外部类的对象。
2、JDK16之前，成员内部类中不能定义静态成员，JDK16开始也可以定义静态成员了。

public class Outer{
	//成员内部类
	public class Inner{
	}
}

3、成员内部类创建对象的格式：

格式：外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器();
范例：Outer.Inner in = new Outer().new Inner();

成员内部类的访问拓展：
1、成员内部类中是否可以直接访问外部类的静态成员？
可以，外部类的静态成员只有一份可以被共享访问。
2、成员内部类中是否可以直接访问外部类的实例成员？
可以的，因为必须先有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员。

总结
1、成员内部类是什么样的、有什么特点？
无static修饰，属于外部类的对象；
可以直接访问外部类的静态成员，实例方法中可以直接访问外部类的实例成员。
2、成员内部类如何创建对象？
外部类名.内部类名 对象名 = new 外部类构造器.new 内部类构造器();

public class Test{
	public static void main(String[] args){
		People.Heart heart = new People().new Heart();
		heart.show();
	}
}

class People{
	private int heartbeat = 150;

	/**
		成员内部类
	*/
	public class Heart{
		private int heartbeat = 110;
		public void show{
			int heartbeat = 78; //78
			System.out.println(heartbeat);
			System.out.println(this.heartbeat); //110
			System.out.println(People.this.heartbeat); //150
		}
	}
}

注意：在成员内部类中访问所在外部类对象，格式：外部类名.this。

局部内部类（鸡肋语法，了解即可）

1、局部内部类放在方法、代码块、构造器等执行体中。
2、局部内部类的类文件名为：外部类$N内部类.class。

匿名内部类（重点）

1、本质上是一个没有名字的局部内部类，定义在方法中、代码块中，等。
2、作用：方便创建子类对象，最终目的为了简化代码编写。
格式：

new 类|抽象类名|接口名() {
	重写方法;
};

Employee a = new Employee() {
	public void work() {
	}
}；
a.work();

示例如下：

public class Test {
	public static void main(String[] args){
		Animal a = new Animal(){
			@Override
			public void run() {
				System.out.printlb("老虎跑得快！");
			}
		}
		a.run();
	}
}

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

特点总结：
1、匿名内部类是一个没有名字的内部类。
2、匿名内部类写出来就会产生一个匿名内部类的对象。
3、匿名内部类的对象类型相当于是当前new的那个的类型的子类类型。

匿名内部类常见使用形式

1、匿名内部类可以作为方法的实际参数进行传输。
2、开发中不是我们主动去定义匿名内部类的，而是别人需要我们写或者我们写的时候才会使用。
3、匿名内部类的代码可以实现代码进一步的简化（回扣主题）