四时宝库

多态

• 同类型的对象，执行同一行为，体现出不同的行为特征
• 常见形式

① 父类类型 对象名称 = new 子类构造器

② 接口 对象名称 = new 实现类构造器

• 方法调用，编译时看左边，运行时看右边
• 变量调用，都看左边

public class PolymorphicDemo {
    public static void main(String[] args) {
        Animal d = new Dog();
        d.run();
        
        Animal c = new Cat();
        c.run();
    }
}

class Animal {
    public void run() {
        System.out.println("Animal");
    }
}

class Dog extends Animal {
    @Override
    public void run() {
        System.out.println("Dog");
    }
}

class Cat extends Animal {
    @Override
    public void run() {
        System.out.println("Cat");
    }
}

• 作用

① 多态下，右边对象可以解耦，便于维护和扩展

② 定义变量时，使用父类类型作为参数接受类型，该方法可以接受父类一切子类对象

public class PolymorphicDemo1 {
    public static void main(String[] args) {
        Dog d = new Dog();
        going(d);
        
        Cat c = new Cat();
        going(c);
    }

    public static void going(Animal g) {
        g.run();
    }
}

• 多态下不能使用子类的独有功能

• 强制类型转化，调用子类独有功能

public class PolymorphicDemo1 {
    public static void main(String[] args) {
        // 自动类型转换
        Animal d = new Dog();
        d.run();

        // 强制类型转换，获取子类独有行为
        Dog dog = (Dog) d;
        dog.lay();
    }

}

内部类

• 定义在一个类里面的类
• 部分功能需要一个完整的描述，但是只为外部类提供服务
• 内部类方便访问外部类成员，包括私有属性
• 内部类类型

① 静态内部类，static修饰，可以直接外部类静态成员，不能访问外部类的实例成员

② 成员内部类，无static修饰，属于外部类的对象，可以直接访问外部类的实例成员

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

public class InnerClassDemo {
    public static void main(String[] args) {
        // 访问静态内部类
        Outer.inner in = new Outer.inner();
        in.run();

        // 访问成员内部类
        Outer.inner1 in1 = new Outer().new inner1();
        in1.run();
    }
}


class Outer {
    /**
     * 静态内部类
     */
    public static class inner {
        public void run() {
            System.out.println("inner-run");
        }
    }

    /**
     * 成员内部类
     */
    public class  inner1 {
        public void run() {
            System.out.println("inner1-run");
        }
    }

    /**
     * 局部内部类
     */
    public void run() {
        class Cat {
            
        }
    }
}

④ 匿名内部类，没有名称的局部内部类，相当于new之前类型的子类类型

public class InnerClassDemo1 {
    public static void main(String[] args) {
        Animal a = new Animal() {
            @Override
            public void run() {
                System.out.println("跑");
            }
        };
        a.run();
    }
}

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