内部类讲解

内部类：

1： Java中允许将一个类A声明在另一个类B中，则类A就称为内部类。
2： 内部类分类：成员内部类（静态，非静态）vs 局部内部类（方法内，代码块内，构造器内）
3：成员内部类

一方面，作为外部类的成员

• 可以调用外部类的结构
• 可以被static修饰
• 可以被四种不同权限修饰

另一方面，作为一个类

• 可以定义属性，方法，构造器等
• 可以被final修饰，表示此类不能被继承
• 可以被abstract修饰

4：局部内部类

不能使用任何的访问修饰符。
会生成两个.class文件，一个是Outer.class ，另一个是Outer$LocalInner.class。
局部内部类只能访问方法中声明的final类型的变量。

成员内部类代码

package java_04;

public class Test {
    public static void main(String[] args) {
        //调用静态的成员内部类
        Persion.Dog dog = new Persion.Dog();
        dog.show();

        //调用非静态的成员内部类
        Persion persion = new Persion();
        Persion.Cat cat = persion.new Cat();
        cat.show();
        cat.display("喵喵");

    }
}


class Persion{
    private String name = "人族";
    private int age = 18;

    public void eat(){
        System.out.println("人吃饭");
    }

    /*
    * 静态成员内部类*/
    static class Dog{
        String name;
        int age;
        public void show(){
            System.out.println("dog-----");
        }
    }

    /*
    * 非静态成员内部类*/
    class Cat{
        String name = "猫族";
        int age = 18;

        public Cat() {
        }

        public void show(){
            Persion.this.eat();
            System.out.println("cat-----");
        }

        public void display(String name){
            System.out.println("cat = "+name); //输出  cat = 喵喵
            System.out.println(this.name);//猫族
            System.out.println(Persion.this.name);//人族
        }
    }

}

局部内部类代码

package java_04;

public class Test02 {

    public static void main(String[] args) {
        InnerClass innerClass = new InnerClass();
        innerClass.drink();

    }
}

class InnerClass{

    String ssm = "良人怎奈变凉人，旧城之下念旧人";

    /**
     * 代码块中，属于局部内部类
     * 随着对象的加载而加载
     */
    {
        class Pig{
            String name;
            int age;
            public void show(){
                System.out.println("Pig-----");
            }
        }
        Pig pig = new Pig();
        pig.show();
    }

    /**
     * 外部类方法中，属于局部内部类
     * 开发中少见
     */
    public void drink(){
        class Animal{
            String name = "内部类";
            int age = 18;
            public void show(){
                System.out.println("animal-----");
                System.out.println(name+"   "+age);
                System.out.println(InnerClass.this.ssm);
            }
        }
        Animal animal = new Animal();
        animal.show();


        /**
         * 注意 匿名对象没有引用变量，只能使用一次，
         * 每次创建一个匿名对象都在堆中分配内存，都具有不同的内存地址。
         * 创建多了比较浪费资源。
         */
        //new Animal().show();
    }


    /**
     * 返回一个实现了Comparable接口的类的对象
     * 开发中常用方式
     * @return
     */
    public Comparable comparable(){
        class MyComparable implements Comparable{
            @Override
            public int compareTo(Object o) {
                System.out.println("MyComparable");
                return 0;
            }
        }
        return new MyComparable();
    }

}

内部类的继承

package java_04;

public class Test03 extends Persion{
    public static void main(String[] args) {
        Persion.Dog dog =new Test03.Dog();
        dog.show();


        Persion persion = new Test03();
        persion.eat();
    }


    @Override
    public void eat() {
        System.out.println("6666666");
    }
}