1.外部类

在java中能够把类定义在另个类的外部，咱们称之为外部类，外层的类为外部类。在一个类的外部有一个残缺的构造，而这个内部结构只为外部类提供服务。外部类能够更不便的拜访外部类成员，外部类更好的提供封装性，能够用权限修饰符更好的管制。

// 格局
public class 类名 {
    // 外部类
    权限修饰符 [static] class 外部类名称 {
        ...
    }
}

1.1 动态外部类

动态外部类是应用static润饰的类，属于外部类的一部分。他的特点和一般类一样，只是地位不同。

// 格局
public class Outer {
    public static class Inner {
        ...
    }
}

public class StaticInnerClass1 {
    public static String str = "Version 1.0";
    public static int num = 10;
    private String name;

    public static class Inner {
        private String type;
        private int age;

        public Inner() {
        }

        public Inner(String type, int age) {
            this.type = type;
            this.age = age;
        }

        public void show() {
            System.out.println(str);
            System.out.println(num);
        }

        public String getType() {
            return type;
        }

        public void setType(String type) {
            this.type = type;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void main(String[] args) {
    // 外部类实例化
        StaticInnerClass1.Inner inner = new StaticInnerClass1.Inner();
        inner.show();
    }
}

留神：

动态外部类能够间接拜访外部类动态成员
动态外部类不能间接拜访内部实例成员

1.2 成员外部类

成员外部类和动态外部类类似，只是不加static关键字修饰符。在jdk1.6之前不能在成员外部类定义动态成员，之后版本能够定义。

// 格局
修饰符 class 类名 {
    ...
    修饰符 class 外部类类名 {
        ...
    }
}

// 成员外部类调用
外部类.外部类 对象名 = new 外部类结构器().new 外部类结构器()

// 示例
public class MemberInnerClass {

    public static int flag = 0;

    private String name;
    private int age;

    public MemberInnerClass() {
    }

    public MemberInnerClass(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public class Inner {

        private String sex;
        private int num;

        public Inner() {
        }

        public Inner(String sex, int num) {
            this.sex = sex;
            this.num = num;
        }

        public void show() {
            System.out.println(flag);
            System.out.println(name);
            System.out.println(age);
            System.out.println(sex);
            System.out.println(num);
        }

        public String getSex() {
            return sex;
        }

        public void setSex(String sex) {
            this.sex = sex;
        }

        public int getNum() {
            return num;
        }

        public void setNum(int num) {
            this.num = num;
        }
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static void main(String[] args) {
        MemberInnerClass.Inner inner = new MemberInnerClass("张三", 18).new Inner("男", 1);
        inner.show();
    }
}

特点：

• 属于外部类的对象，与类特色统一
• 不能创立动态成员，动态成员须要应用final
• 能够间接拜访内部成员和动态成员

1.3 部分外部类

这是一个比拟很怪异的语法，失常状况很少应用，只做理解。

部分外部类放在代码块、结构器和办法中。

// 示例
public class PartialInnerClass {
    {
        class Dog{
        }

        Dog dog = new Dog();
    }

    public PartialInnerClass() {
        class Cat{
        }
        Cat cat = new Cat();
    }

    public static void main(String[] args) {
        class Pig{
        }
        Pig pig = new Pig();
    }
}

1.4 匿名外部类

匿名外部类实质上就是一个没有名称的部分外部类，次要定义在办法和代码块中。最次要的指标是为了简化代码。

// 格局
new (类|抽象类|接口) {
    ...
}

特点：
匿名外部类是一个没有名称外部类
匿名外部类编写进去即创立出一个匿名对象
匿名外部类创立进去的为以后类的子类

// 示例
public interface AnonymousInnerClass {

    void show();

    static void main(String[] args) {
        AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass() {
            @Override
            public void show() {
                System.out.println("匿名类创立");
            }
        };
        anonymousInnerClass.show();
    }
}

从下面能够看出，AnonymousInnerClass貌似间接创立了对象，但理论并非如此。anonymousInnerClass实例取得到的对象其实是接口的实现类或者子类。这是匿名外部类的个性，创立即生成子类。子类对象能够间接赋值给父类，这就是多态，面对对象的三大个性之一，接下来咱们行将介绍这部分内容。

1.5 外部类示例

以下示例显示了如何调用局部变量、成员变量和外部类成员变量

public class Other {

    private int number = 10;

    public class Inner {
        private int number = 5;

        public void show() {
            int number = 2;
            // 2
            System.out.println(number);
            // 5
            System.out.println(this.number);
            // 10
            System.out.println(Other.this.number);
        }
    }

    public static void main(String[] args) {
        Inner inner = new Other().new Inner();
        inner.show();
    }
}

2. 多态

同类型对象，在执行雷同行为时会呈现不同的特色。举一个简略的例子，狗和猫都能够形象成类，这些类又能够是动物类的子类。那么猫和狗都是动物的子类，都来实现叫声，当执行不同子类叫声行为时，后果就会不一样。

2.1 格局及成员拜访特点

// 格局
类 对象 = new 子类()

接口 对象 = new 实现类()

拜访特点：

• 变量：编译和调用都看父类
• 办法：编译看父类，调用看子类

2.2 多态优劣

优：

• 解耦、便于扩大和保护
• 形参能够定义父类，传递实参为子类即可，体现出扩展性。

劣：

• 多态状况下，不能应用子类的独有性能

2.3 类型转换

主动类型转换：子类或者实现类实例对象能够间接赋值给父类或接口

强制类型转换：相似根底类型强制转换，子类 对象变量 = （子类）父类类型变量，此种转换也解决了不能应用子类独立性能弊病。

强制类型转换问题：

- 如果子类不是父类真正子类，则会抛出异样ClassCastException
- 强制类型转换个别应用instanceof进行判断

// 格局
类变量 instanceof 类名
// 返回后果为boolean类型

2.4 示例

// 接口
public interface Animal {
    void bark();
}

public class Cat implements Animal{
    @Override
    public void bark() {
        System.out.println("小猫收回喵喵叫声。。。");
    }
}

public class Dog implements Animal {
    @Override
    public void bark() {
        System.out.println("小狗收回汪汪汪叫声。。。");
    }
}

public class Demo {
    public static void getBark(Animal animal) {
        animal.bark();
    }

    public static void main(String[] args) {
        // 收回喵叫
        getBark(new Cat());

        // 收回狗叫
        getBark(new Dog());
    }
}

本章完结，用于集体学习和小白入门，大佬勿喷！心愿大家多多点赞珍藏撑持撑持！

源码 【GitHub】 【码云】