JAVA内部类

JAVA内部类

内部类就是将类定义在一个类中
注意:
1.内部类都可以直接访问外部类所有的成员，就像访问自己的，没有限制
2.外部类如果想要访问内部类数据，就需要创建对象
3.内部类中的this指的是内部类实例的对象，要想调用外部类的实例对象外部名.this的方式获得
4.内部类中不能有静态成员，因为内部类的实例对象就是外部类实例对象的一个成员
根据位置的不同分为成员内部类和局部内部类

成员内部类

成员内部类就是定义在外部类方法外类中的类
可以在测试类中用  外部类名.内部类名 对象名=new 外部类名().内部类名() 直接访问内部类数据
成员内部类可以用 private static 修饰

public class Mytest {
    public static void main(String[] args) {
        Outer outer = new Outer();    //间接访问内部类数据
        outer.show();
        System.out.println("============"); //可用外部类名.内部类名 对象名=new 外部类名().
        Outer.Inner inner = new Outer().new Inner();  //内部类名()直接访问内部类数据
        inner.show();
    }
}
class Outer{
    int a=10;
    private int b=20;
    class Inner{
        int c=30;
        private int d=40;
        int a=60;
        public void show(){
            System.out.println(a);
            System.out.println(b);             
            System.out.println(Outer.this.a);   //内部类出现和外部类同名的变量时可用
                                                 //外部类名.this.变量名 访问外部类变量
        }
    }
    public void show(){
        Inner inner = new Inner();        //外部类如果想要调用内部类的数据需要创建内部类对象调用
        System.out.println(inner.c);
        System.out.println(inner.d);
    }
}

静态内部类

当在成员内部类用static修饰类时，就变成静态内部类
静态内部类访问外部类数据必须用static修饰
内部类的成员方法可以是静态也可以是非静态的
成员内部类被static修饰后在测试类中直接访问的格式:
外部类名.内部类名 对象名=new 外部类名.内部类名()

public class MyTest {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        inner.show();
    }
}
class Outer{
    static int a=10;    
    static class Inner{
        public void show(){
            System.out.println(a);    //静态内部类只能访问外部类静态的成员
        }
    }
}

因为静态内部类和静态方法一样只能访问其他静态的成员，而不能访问实例成员。因此静态内部类和外部类联系就少了，他们之间可能也就是命名空间上的关系

局部内部类

局部内部类定义在外部类的方法中的类
局部内部类一样可以访问所有外部类的成员，没有限制
局部内部类在外界没有直接创建的语法，可以间接调用局部内部类中的数据
局部内部类想要访问局部变量必须用final修饰
	因为局部内部类是随着方法的调用完毕而消失的，这个时候局部内部类对象没有立马从堆内存中消失，还要使用那个变量。为了让数据能够继续使用，就用final修饰，这样在堆内存中存储的就是一个常量值。
	JDK1.8之后final系统会默认加上

public class MyTest3 {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.show();
    }
}
class Outer{
    int a=10;
    private int b=20;
    public void show(){
        class Inner{
            Inner(){
                System.out.println(a);
                System.out.println(b);
            }
        }
        Inner inner = new Inner();   //想要访问局部内部类就需要在外部类方法中new内部类的对象
    }                               //通过这种间接的方式来访问
}

匿名内部类

匿名内部类:就是局部内部类的简写形式。通常都定义在方法种，因为只能调用一次。
匿名内部类的定义格式:
	new 对象名或接口名(){
        重写方法
	};
匿名内部类本质上就是继承了该类或者实现了该接口的子类匿名对象

public class MyTest {
    public static void main(String[] args) {
        MyInterface myInterface=new MyInterface() {    //这里就是定义了个对象顺便重写了接口方法
            @Override               //new Myinterface{...};就是把声明接口和创建接口的实例合二为
            public void show() {                               //一
                System.out.println("我重写了我的接口方法");
            }
        };
        myInterface.show();
        test(new MyInterface() {     //匿名内部类也可以作为方法参数，因为匿名内部类就是一个对象
            @Override                //test方法的参数就是接口这个对象
            public void show() {
                System.out.println("我重写了接口的show方法");
            }
        });
    }
    public static void test(MyInterface myInterface){
        myInterface.show();   
    }
}
interface MyInterface{
    public void show();
}