四种内部类

一、什么是内部类
定义： 将一个类定义在一个类或者一个方法里面，这样的类称着内部类

二、内部类的种类
内部类的种类有4种：

1、成员内部类
1.可以直接访问外部类的所有成员，包含私有的
2.可以添加任意访问修饰符(public、protected、默认、private),因为它的地
位就是一个成员。
3.作用域和外部类的其他成员一样,为整个类体，在外部类的成员方法中创建成员内部类对象,再调用方法.
4.成员内部类—访问---->外部类成员(比如;属性)[访问方式:直接访问]
5.外部类—访问------>成员内部类 访问方式:创建对象，再访问
6.外部其他类—访问---->成员内部类
7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问
注意： 成员内部类里面不能包含静态的属性和方法

// 外部类
 
class OuterClass04 {
 
// 非静态的成员变量
 
public int i = 2;
 
private int j = 3;
 
// 静态的成员变量
 
public static int x = 4;
 
private static int y = 5;
 
 
 
// 成员内部类
 
class InnerClass04 {
 
// 成员方法
 
public void showByInner() {
 
// 成员内部类对于其所在的外部类的非静态成员变量均可以访问（不论使用public修饰，还是private修饰）
 
System.out.println(i);
 
System.out.println(j);
 
// 成员内部类对于其所在的外部类的静态成员变量均可以访问（不论使用public修饰，还是private修饰）
 
System.out.println(x);
 
System.out.println(y);
 
}
 
}

2、静态内部类
静态内部类就是在成员内部类多加了一个 static 关键字。静态内部类只能访问外部类的静态成员变量和方法（包括私有静态）

说明:静态内部类是定义在外部类的成员位置，并且有static修饰
1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
2.可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。
3.作用域:同其他的成员，为整个类体
4.静态内部类—访问---->外部类(比如:静态属性)[访问方式:直接访问所有静态成员]
5．外部类—访问------>静态内部类访问方式:创建对象，再访问
6．外部其他类—访问----->静态内部类
7．如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近
原则，如果想访问外部类的成员，则可以使用(外部类名.成员)去访问

class Demo {
    public static void main(String[] args) {
        Demo demo=new Demo();
        demo.showByOuter();
    }
// 成员方法

    public void method1() {
        System.out.println("外部类的公有非静态成员方法");
    }
    private void method2() {
        System.out.println("外部类的私有非静态成员方法");
    }
    public static void method3() {
        System.out.println("外部类的公有静态成员方法");
    }
    private static void method4() {
        System.out.println("外部类的私有静态成员方法");
    }
//    
    
// 静态内部类
         static class InnerClass1 {
            // 非静态成员方法成员方法
            public void showByInner() {
 方法1和2是报错 因为不能访问非静态的成员方法
//                method1();
//                method2();
                // 局部内部类对于其所在的外部类的静态成员方法均可以访问（不论使用public修饰，还是private修饰）
                method3();
                method4();
            }
            public  static void InnerClass2(){
//                方法1和2是报错 因为不能访问非静态的成员方法
//                method1();
//                method2();
                method3();
                method4();
    }
        }
        
   
}

3、匿名内部类
匿名内部类：顾名思义就是没有名字的类。什么时候用到匿名内部类呢？在Android中最常见得回调监听事件 就是匿名内部类
一般遇到下面这种情况都会考虑到使用匿名内部类：
当一个内部类需要继承或者实现，而且只使用一次的时候，可以考虑使用匿名内部类。调用的时候直接使用父类的无参构造，并重写父类方法。如下代码：

(1)本质是类
(2）内部类
(3)该类没有名字
(4)同时还是一个对象
说明:匿名内部类是定义在外部类
的局部位置,比如方法中，并且没有类名
1.匿名内部类的基本语法
new类或接口(参数列表){
类体
};

①匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义,同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，,因此可以调用匿名内部类方法。
②.可以直接访问外部类的所有成员，包含私有的
③不能添加访问修饰符,因为它的地位就是一个局部变量
④作用域:仅仅在定义它的方法或代码块中。
⑤匿名内部类—访问---->外部类成员[访问方式:直接访问]
⑥外部其他类—不能访问----->匿名内部类（因为匿名内部类地位是一个局部变量)
⑦如果外部类和匿名内部类的成员重名时，匿名内部类访问的话，默认遵循就近原则,如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问

class Demo {
    // 定义接口
    interface Foo {
        public abstract void show();
    }
// 接口的实现类
    class FooImpl implements Foo {
        @Override
        public void show() {
            System.out.println("接口的实现类的成员方法");
        }
    }
// 外部类
    class OuterClass18 {
// 成员方法
        public Foo showByOuter() {
// 多态的写法，创建接口类型的变量，接收接口实现类类型的对象，并返回
// Foo foo = new FooImpl();
// return foo;
// 对上述写法的变形，匿名对象的写法
// return new FooImpl();
// 实现了Foo接口的匿名内部类（位置位于类似局部内部类的位置）
            return new Foo() {
                @Override
                public void show() {
                    System.out.println("实现了接口的匿名内部类");
                }
            };
        }
    }
}

4、局部内部类说明:局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。
1.可以直接访问外部类的所有成员,包含私有的
2不能添加访问修饰符,因为它的地位就是一个局部变量。局部变量是不能使用修饰符的。但是可以使用final修饰，因为局部变量也可以使用final
3.作用域:仅仅在定义它的方法或代码块中。
4.局部内部类—访问---->外部类的成员[访问方式:直接访问]
5.外部类—访问---->局部内部类的成员
访问方式:创建对象,再访问(注意:必须在作用域内)
记住:
(1)局部内部类定义在方法中/代码块
(2)作用域在方法体或者代码块中
(3)本质仍然是一个类
6.外部其他类—不能访问----->局部内部类（因为局部内部类地位是一个局部变量)
7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问
8. 外部类在方法中，可以创建 内部类 对象，然后调用方法即可。

class Demo {
    public static void main(String[] args) {
        Demo demo=new Demo();
        demo.showByOuter();
    }
// 成员方法

    public void method1() {
        System.out.println("外部类的公有非静态成员方法");
    }
    private void method2() {
        System.out.println("外部类的私有非静态成员方法");
    }
    public static void method3() {
        System.out.println("外部类的公有静态成员方法");
    }
    private static void method4() {
        System.out.println("外部类的私有静态成员方法");
    }
    public void showByOuter() {
// 局部内部类
        class InnerClass14 {
            // 成员方法
            public void showByInner() {
// 局部内部类对于其所在的外部类的非静态成员方法均可以访问（不论使用public修饰，还是private修饰）
                method1();
                method2();
                // 局部内部类对于其所在的外部类的静态成员方法均可以访问（不论使用public修饰，还是private修饰）
                method3();
                method4();
            }
        }
        InnerClass14 innerClass14 = new InnerClass14();
        innerClass14.showByInner();
    }
}

三、内部类的作用
1、内部类可以很好的实现隐藏。
非内部类是不可以使用 private和 protected修饰的，但是内部类却可以，从而达到隐藏的作用。同时也可以将一定逻辑关系的类组织在一起，增强可读性。
2、间接的实现多继承。
每个内部类都能独立地继承自一个(接口的)实现，所以无论外部类是否已经继承了某个(接口的)实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。所以说内部类间接的实现了多继承。