【JAVA】多态、内部类

1 多态

多态：同类型的对象，执行同一个行为，会表现出不同的行为特征

优势

• 右边对象可以实现随意更改，更改后续业务只需改右边对象，其它代码无需更改，便于扩展和维护
• 定义方法时，使用父类型作为参数，该方法就可以接受这父类的一切子类对象

劣势：多态下不能使用子类的独有功能

常见形态

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

// 一般形态
Dog a = new Dog();
a.run()

Tortoise t= new Tortoise();
t.run();

// 多态（Dog和Tortoise都继承父类Animal）
Animal a = new Dog();
a.run()

Animal t= new Tortoise();
t.run();

多态中成员访问特点

方法调用	编译看左边(run方法在写代码时写的是Animal方法），运行看右边（运行的时候运行Dog里的方法）
变量调用	编译看左边，运行也看左边（运行的时候变量值还是父类变量的值）。（多态侧重行为多态）

强制类型转换

有继承关系/实现的两个类型就可以强制转换

作用：可以解决多态下的劣势，实现调用子类独有的功能

Animal a = new Dog();
a.run()
// 强制类型转换
Tortoise t = (Tortoise) a;
t.layEggs();

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

若转型后的类型与对象的真是类型不是同一个类型，会出现异常ClassCastException

解决办法：强制类型转换前用instanceof判断当前对象的真是类型，再转换

// 变量是否为真是类型，是返回true
变量名 instanceof 真实类型

2 内部类

内部类是定义在类里面的类

public class People{
    public class Student{
    }
}

使用场景、作用

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

静态内部类

有static修饰，属于外部类本身，它的特点和使用与普通类完全一样，类中有的成分也都具备，只是位置在类里面

public class People{
    // 静态成员内部类
    public static class Student{
    }
}

// 静态内部类创建对象格式
People.Student s = new People.Student();

• 静态内部类可以直接访问外部类的静态成员，因为外部类的静态成员只有一份，可以共享
• 静态内部类不可以直接访问外部类的实例成员，因为外部类的实例成员必须外部类成员访问

成员内部类

无static修饰，属于外部类的对象，JDK16开始成员内部类可以定义静态成员

public class Outer{
    public class Inner{
    }
}

// 成员内部类创建对象格式
Outer.Inner in = new Outer().new Inner();

• 成员内部类可以直接访问外部类的静态成员，因为外部静态成员只有一份可以被共享访问
• 成员内部类的实例方法可以直接访问外部类的实例成员方法，因为必须现有外部类对象，才能有成员内部类对象，所以可以直接访问外部类对象的实例成员

若为了使用方便，定义为静态内部类；若希望访问外部类的所有成员，则定义为成员内部类

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

局部内部类

局部内部类放在方法、代码块、构造器等执行体中。

public class Test {
    static {
        //在代码块中定义
        class C{
        }
    }
    public static void main(String[] args) {
        class A{
            private String name;
            public static int num = 100; // JDK 16开始支持。
            public void show() {
            }
        }
        A a = new A();
        a.show();
    }
    
    public static void test(){
        // 定义在普通方法中
        class B{

        }
    }
}

匿名内部类*

本质上是一个没有名字的局部内部类，定义在方法、代码块等中

作用：方便创建子类对象，最终目的是为了简化代码编写

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

public class Test1 {
    public static void main(String[] args) {
        // 匿名内部类的形式（Animal是抽象类不能调用，不用再创建子类了）
        Animal a = new Animal(){
            @Override
            public void run() {
                System.out.println("动物动物跑");
            }
        };
        a.run();
    }
}

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