Java基础10--多态--内部类

10-1，接口的应用

小例子：电脑USB接口的实现

interface USB { //暴露的规则public void open();public void close();}class BookPC {public static void main(String[] args) {useUSB(new UPan());useUSB(new UMouse());}public static void useUSB(USB u) {if(u != null) {u.open();u.close();}}}//实现规则//这些设备和电脑的耦合性降低了。class UPan implements USB {public void open() {System.out.println("UPan open...");}public void close() {System.out.println("UPan close...");}}class UMouse implements USB {public void open() {System.out.println("mouse open...");}public void close() {System.out.println("mouse close...");}}

 

10-2，多态-概述

1，对象的多态性（多种形态）：

class 动物{...}class 猫 extends 动物 {...}class 狗 extends 动物 {...}

之前我们创建 猫 对象的时候，用的方法是：

猫 mao = new 猫();

有了多态之后，创建 猫 对象可以这么创建：

动物 dw = new 猫();

多态的创建方式，可以看出，一个对象有两种形态。即猫这个事物既具备着猫的形态，又具备着动物的形态，这就是对象的多态性。

简单的说，就是一个对象对应着不同的类型。

 

多态在代码中的体现：父类或者接口的引用指向其子类的对象。

 

10-3，多态-好处

好处是：提高了代码的扩展性，前期定义的代码可以使用后期的内容。

举例说明：

abstract class Animal {abstract void eat();}class Dog extends Animal {//实现父类中的抽象方法，实现动物的共性功能：吃饭void eat() {System.out.println("啃骨头");}//定义自己的方法，只有狗才具备的功能：看家void lookHome() {System.out.println("看家");}}class Cat extends Animal {void eat() {System.out.println("吃鱼");}void catchMouse() {System.out.println("抓老鼠");}}class Pig extends Animal {void eat() {System.out.println("饲料");}void gongDi {System.out.println("拱地");}}class DuoTaiDemo {public static void main(String[] args) {Cat c = new Cat();Dog d = new Dog();method(new Pig()); //Animal a = new Pig();method(c);method(d);}public static void method(Animal a) {a.eat();}}

Cat,Dog,Pig都继承了Animal，是Animal的子类，Animal的变量a指向了创建的Pig对象，调用Pig中的eat()方法，实现了多态性。

 

10-4，多态-弊端&前提

1，多态的弊端：

    前期定义的内容不能使用(调用)后期子类的特有内容。

2，多态的前提：

(1)必须有关系，继承或实现，Animal a = new Cat();Cat要继承Animal。

(2)要有覆盖，不然方法不能用。Cat中的方法要重写Animal中的方法。

弊端：参考10-3的代码：

如：

Cat c = new Cat();method(c);...public static void method(Animal a) {a.eat();a.catchMouse();}

创建Cat对象，把c传给method方法，Animal的a指向c，因为在Animal中没有定义catchMouse方法，所以会报错，只能调用Animal中定义过的并且被覆盖实现的方法。也就是不能调用Cat类中的特有内容catchMouse方法。

 

10-5，多态-转型：

1，Animal a = new Cat();

a.eat();

这是自动类型提升，猫对象被提升为动物类型。但是特点功能无法访问。

其作用就是限制对特有功能的访问。

专业讲：向上转型，向上造型，上溯造型。

2，Cat c = (cat)a;

如果还想用具体动物猫的特有功能，可以将该对象进行向下转型。

向下转型的目的是为了使用子类中的特有方法。

Cat c = (Cat)a;//强制转换为Cat类型

c.eat();

c.catchMouse();

3，注意：对子转型，自始至终都是子类对象在做着类型的变化。

Animal a1 = new Pig();

Cat c1 = (Cat)a1;//ClassCastException

类型转换失败，子类间不能转换。

 

10-6，多态-类型判断-instanceof

public static void method(Animal a) {a.eat();if(a instanceof Cat) { //判断a是不是Cat类型Cat c = (Cat)a;c.catchMouse();} else if (a instanceof Dog) {Dog d = (Dog)a;d.lookHome();}}

instanceof:用于判断对象的具体类型。只能用于引用数据类型判断。

通常在向下转型前用于健壮性的判断。

向下造型时通常用instanceof判断一下，提高健壮性，若传入的不是相同类型，在转型时会报错。若把Cat改为Animal，则下面些什么都没有用，因为所有的对象都继承于Animal，都属于Animal类型。

 

10-7，多态-成员变量

1，多态时，成员变量的特点：

编译时，参考引用类型变量所属的类中是否有调用的成员变量，有则编译通过，没有则编译失败。

运行时，参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量。

简单说：编译和运行都参考等号左边。

class Fu {int num = 3;}class Zi extends Fu {int num = 4;}class DuoTaiDemo {public static void main(String[] args) {Fu f = new Zi();System.out.println(f.num);}}

结果：3

左边为父类，就看父类中的num，若没有，则编译失败，若为Zi f = new Zi();则打印Zi中的num，此时Zi类中不定义num打印为3，因为继承了父类的num。

开发是不会出现此类情况，因为父类中定义的东西直接拿过来用就可以，不用再在子类中定义。

 

10-8，多态-成员函数

1，成员函数(非静态)

编译时，参考引用型变量所属的类中是否有调用的函数，有则编译通过，没有则编译失败。

运行时，参考的是对象所属的类中是否有调用的函数。

简单说：编译看等号左边，运行看等号右边。

class Fu {void show() {System.out.println("fu show...");}}class Zi extends Fu {void show() {System.out.println("zi show...");}}class DuoTaiDemo {public static void main(String[] args) {Fu f = new Zi();f.show();}}

f为引用变量，Zi为对象，在堆中开辟空间，引用变量f指向Zi对象的地址，调用show方法时，show方法进栈，带有this引用，指向Zi对象的地址，在Zi对象中找有没有show方法，若有，则执行Zi中的show方法，若没有，则在super指向的父类中找show方法，有则执行父类中的show方法，若没有则编译失败。

 

10-9，多态-静态函数

静态函数：

编译时，参考引用变量所属的类中是否有调用的静态方法。

运行时，参考引用变量所属的类中是否有调用的静态方法。

简单说：编译和运行都看等号左边。

其实对于静态方法是不需要有对象的，直接用类名调用即可。

class Fu {static void method() {System.out.println("fu static method");}}class Zi extends Fu {static void method() {System.out.println("zi static method");}}class DuoTaiDemo {public static void main(String[] args) {Fu f = new Zi();f.method(); //打印fu static methodFu.method();Zi.method();}}

静态方法加载进静态方法区。Static修饰的函数不受对象控制，不需要创建对象直接用类名调用即可。

Fu f是创建了一个Fu类对象的引用，若用f调用静态方法，则直接执行Fu类静态方法区中的method函数，静态方法中没有this。

10-10，内部类-概述

1，内部类也生成.class文件，文件名格式为：外部类名$内部类名.class。

2，内部类访问特点：

(1)内部类可以直接访问外部类中的成员，包括私有的。

(2)外部类要访问内部类，必须建立内部的对象。

内部类一般用于类的设计。

3，何时使用内部类？

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时就将这个内部的事物定义成内部类来描述。

例如：

class Outer {private int num = 3;class Inner { //内部类void show() {System.out.println("show run..." + num);}}public void method() {Inner in = new Inner(); //在外部类中定义内部类的对象，访问内部类中的内容in.show();}}class InnerClassDemo {public static void main(String[] args) {Outer out = new Outer();out.method();}}

 

10-11，内部类-修饰符

1，内部类可以被修饰符修饰，如private ,public ,static等。

2，例如：

class Outer {private static int num = 31; //静态函数访问静态成员class Inner { //内部类void show() {System.out.println("show run ... " + num);}/*static void function() {System.out.println("function run ... " + num);}*/}public void method() {Inner in = new Inner();in.show();}}class InnerClassDemo {public static void main(String[] args) {Outer out = new Outer();out.method();//直接访问外部类中的内部类中的成员。Outer.Inner in = new Outer().new Inner();in.show();//如果内部类是静态的，相当于一个外部类Outer.Inner in = new Outer.Inner(); //外部类一加载，该静态内部类就存在了。in.show();//如果内部类是静态的，成员是静态的Outer.Inner.function();//静态直接用类名调用}}

10-12，内部类-细节

细节1：

class Outer {int num = 3;class Inner {int num = 4;void show() {int num = 5;System.out.println(num);//打印5}}void method() {new Inner.show();}}class InnerClassDemo {public static void main(String[] args) {new Outer().method();}}

若内部类的show方法打印this.num，则这个this指代的是Inner类的对象，打印4；

若内部类的show方法打印Outer.this.num，则指代了Outer类的对象，打印3。

 

细节2：

为什么内部类能直接访问外部类中的成员呢？

因为内部类持有了外部类的引用。格式为：外部类名.this，如：Outer.this.num，指的是Outer中的num。

 

10-13，内部类-局部内部类

内部类可以存放在局部位置上。

内部类在局部位置上只能访问局部中被final修饰的局部变量。

例如：

class Outer {int num = 3;Object method(final int y) {final int x = 9;class Inner { //局部内部类，在method方法中void show() {//局部内部类访问局部变量，局部变量必须被final修饰。System.out.println("show..." + y);}}Object in = new Inner();return in;}}class InnerClassDemo {public static void main(String[] args) {Outer out = new Outer();Object obj = out.method();}}

10-14，匿名内部类-概述

匿名内部类就是内部类的简写格式。

必须有的前提是：

    内部类必须继承或实现一个外部类或接口。

匿名内部类：

    其实就是一个匿名子类对象。

格式：

    new父类 or 接口() { 子类内容 }

 

例如：

abstract class Demo {abstract void show();}class Outer {int num = 4;/* 非匿名方法class Inner extends Demo {void show() {System.out.println("show ... " + num);}}*/public void method() {//new Inner().show(); //对应上面非匿名方法，new Demo { //匿名内部类，继承了外部类Demo//new了一个匿名子类对象并调用show方法，子类中重写Demo的抽象方法void show() {System.out.println("show ..." + num);}}.show();}}class InnerClassDemo {public static void main(String[] args) {new Outer().method();//new 一个Outer对象并调用其method方法。}}

10-15，匿名内部类-应用

使用场景：

当函数参数是接口类型时，而且接口中的方法不超过三个。

可以用匿名内部类作为实际参数进行传递。

class InnerClassDemo {class Inner {}public static void main(String[] args) {/* 接口类型参数传递，在传递时直接实现方法show(new Inter(){public void show1() {System.out.println("show1...");}public void show2() {System.out.println("show2...");}});*/new Inner();}public void method() {new Inner();}public static void show(Inter in) {//接口形参in.show1();in.show2();}}interface Inter {void show1();void show2();}class Outer {/* 非匿名方式class Inner implements Inter {public void show1() {System.out.println("show1...");}public void show2() {System.out.println("show2...");}}*/public void method() {Inner in = new Inner();in.show1();in.show2();//给匿名内部类起个名字，用该名字调用里面的show1，show2方法。Inter in = new Inter() {public void show1() {System.out.println("show1...");}public void show2() {System.out.println("show2...");}};in.show1();in.show2();}}

若匿名内部类中只有一个方法，可以这么调用：

new Inter() {public void show() {System.out.println("show run ... ");}}.show();

 

10-16，匿名内部类-细节

class Outer {void method() {//前面的Object表示父类对象，后面的Object表示子类对象。//这里是多态，把new Object向上转型为Object型，编译时看等号左边，//因为Object类中没有show方法，所以编译失败。Object obj = new Object() {public void show() {System.out.println("show run ... ");}};obj.show(); // 报错，找不到show方法。}}class InnerClassDemo {public static void main(String[] args) {new Outer().method();}}

报错原因：因为匿名内部类这个子类对象被向上转型为了Object类型，这样就不能再使用子类的特有方法了。

 

10-17，对象的初始化过程：

代码示例：

class Fu {int num = 9;{ // 构造代码块System.out.println("Fu"); //第一步：打印 Fu}Fu() {super();//显示初始化//构造代码块初始化show();}void show() {//这个show会被子类的show覆盖System.out.println("fu show " + num); //第二步：打印Zi类中的show：Zi show 0}}class Zi extends Fu {int num = 8;{System.out.println("Zi"); //第三步：打印 Zi}Zi() {super();//显示初始化//构造代码块初始化show();}void show() {System.out.println("Zi show " + num); //第四步：打印Zi show 8}}public class Demo {public static void main(String[] args) {new Zi();}}

步骤：

(1)Demo类加载进方法区，Demo的构造函数加载进方法区。

(2)main方法加载进静态方法区，main进栈。

(3)new Zi()在堆中创建子类对象，在这个内存块中开辟两块空间，分别为Zi的num = 0，Fu的num = 0。

(4)Fu类先加载进方法区，Zi类后加载进方法区。

(5)new Zi();时调用Zi的构造函数，Zi中的super调用Fu的构造函数，Fu()先执行super这里super调用的是Object，然后执行成员变量的显示初始化，然后执行本类中构造代码块的初始化，这时输出Fu，然后再执行show方法，由于Zi继承了Fu，并且重写了Fu中的show方法，所以这类输出Zi类中的show方法，输出Zi show 0。因为Zi类还未进行显示初始化，所以输出默认初始值0。

(6)Zi()中的super()运行完毕，进行Zi类成员变量的显示初始化，这时Zi中的num=8，再进行Zi类构造代码块的初始化，输出Zi，再执行show方法，这时因为已经进行了显示初始化，所以输出Zi show 8。

(7)main方法弹栈，运行结束。