Java-Day011

每天早上都是想干翻这个世界，晚上回来时被这个世界干的服服帖帖。被生活疯狂蹂躏，依然热爱生活。

• 内部类
  • 成员内部类
  • 私有内部类
  • 静态内部类
  • 局部内部类
  • 匿名内部类
• 枚举

零、内部类

内部类就是类中的类

1、内部类的作用

• 内部类可以很好的实现隐藏
  • 一般的非内部类，是不允许有private与protected权限的，但是内部类可以
• 内部类拥有外部类的所有元素的访问权限(包含private)
• 可以实现多重继承
• 匿名内部类优化接口

一、成员内部类

成员内部类就类似与类的成员属性，不在方法内部的类叫做成员内部类。

成员内部类可以无条件的访问外部类所有成员属性和方法(包含priavte和static)

1、成员内部类创建对象

// 外部类
public class A {
    public A() {
        System.out.println("外部类");
    }
    // 成员内部类
    class A1{
        public A1() {
            System.out.println("成员内部类");
        }
    }
}

public class Test1 {
    public static void main(String[] args) {
        A.A1 a1 = new A().new A1();
        A a = new A();
        A.A1 a2 = a.new A1();
    }
}

运行结果
外部类 成员内部类 外部类 成员内部类

成员内部类创建对象格式

外部类.内部类 变量名 = new 外部类().new 内部类();

或者

外部类 变量名1 = new 外部类();
外部类.内部类 变量名2 = 变量名1.new 内部类();

成员内部类创建对象会先创建外部类对象。

2、成员内部类访问外部类属性和方法

// 外部类
public class A {
    private String str = "外部类的String变量";        // 私有的成员属性
    public A() {
        System.out.println("外部类");
    }
    private void ab(){
        System.out.println("外部类ab()方法");
    }
    // 成员内部类
    class A1{
        String str = "内部类的String变量";
        public A1() {
            System.out.println("成员内部类");
        }
        public void a1(){
            System.out.println(str);        // 调用的内部类的属性
            System.out.println(A.this.str); // 调用的外部类的属性
            ab();                           // 调用内部类的方法
            A.this.ab();                    // 调用调用外部类方法

            // 创建外部类对象访问
            A a = new A();
            System.out.println(a.str);
            a.ab();

        }
        public void ab(){
            System.out.println("内部类ab()方法");
        }
    }
}

public class Test1 {
    public static void main(String[] args) {
        A.A1 a1 = new A().new A1();
        a1.a1();
    }
}

运行结果
外部类 成员内部类 内部类的String变量 外部类的String变量 内部类ab()方法 外部类ab()方法 外部类 外部类的String变量 外部类ab()方法

可以通过外部类类名.this.方法名或外部类类名.this.属性来访问外部类的方法或者属性

也可以以普通方式在内部类中创建外部类的对象来访问

内部类可以访问外部类私有的属性和方法

二、私有内部类

如果一个内部类只希望被外部类的方法操作，则可以使用private修饰声明内部类为私有内部类

public class A {
    private class AB{
        void ab1(){
            System.out.println("私有内部类ab1()方法");
        }
    }


    void a(){
        AB ab = new AB();
        ab.ab1();
    }
}

public class Test {
    public static void main(String[] args) {
        A a = new A();
        a.a();
    }
}

运行结果
私有内部类ab1()方法

内部类无法通过外部类.内部类 变量名 = new 外部类().new 内部类();创建对象，只能在外部类中使用内部类，创建内部类对象

三、静态内部类

静态内部类类似静态方法，只能访问静态的外部类的成员变量和方法

public class A {
    static int a;

    public A() {
        System.out.println("外部类");
    }

    static class AB{
        public AB() {
            System.out.println("静态内部类");
        }

        void ab(){
            System.out.println(a);
            System.out.println("我是静态内部方法");
        }
    }
}

public class Test {
    public static void main(String[] args) {
        A.AB ab = new A.AB();
        ab.ab();
    }
}

运行结果
静态内部类 0 我是静态内部方法

静态内部类使用A.AB ab = new A.AB();创建对象

四、局部内部类

局部内部类类似与局部变量，只能在局部内使用

public class Test {
    public static void main(String[] args) {
        class A{
            public A() {
                System.out.println("我是局部内部类");
            }
        }
        A a = new A();
    }
}

运行结果
我是局部内部类

局部内部类只能在方法内使用，超出作用域将不能使用

五、匿名内部类

匿名内部类就是没有名字的类，一般如果某个类只使用一次，则可以将类定义为匿名内部类

public class A {
    void a1(){
    }
}

public abstract class B {
    abstract void a1();
}

public interface C {
    String a1();
}

public class Test {
    public static void main(String[] args) {
        new A(){
            @Override
            void a1() {
                System.out.println("匿名内部类A");
            }
        }.a1();
        B b = new B(){
            @Override
            void a1() {
                System.out.println("匿名内部类B");
            }
        };
        b.a1();
        System.out.println(new C() {
            @Override
            public String a1() {
                return "匿名内部类C";
            }
        }.a1());
    }
}

匿名内部类可以继承一个普通类或者抽象类或者实现一个接口，但是只能同时实继承或实现一个

如果实现了一个接口，该类是Object类的直接子类。匿名类继承一个类或者实现一个类，不需要extends或者implements关键字

由于匿名内部类没有名称，所以类体中不能定义构造器，也不能使用关键字创建该类的实例

匿名内部类的定义、构造、和第一次使用都发生在同一个地方

六、枚举

枚举可以理解为一个特殊的类，通过关键字enum实现，自动继承Enum类

public class Test {
    public static void main(String[] args) {
        Color color = Color.GREEN;
        System.out.println(color.ordinal());        // 获取枚举值的顺序次数，从0开始
        switch (color){
            case RED:
                System.out.println("红色");
                break;
            case YELLOW:
                System.out.println("黄色");
                break;
            case GREEN:
                System.out.println("绿色");
                break;
        }
    }
}

运行结果
2 绿色