理解认识内部类

内部类

在一个类中的相互访问条件

内部类访问外部类的内容，直接访问即可，包括private的

同一个类的外部方法想要访问内部类的内容，则必须要通过建立对象去调用

public class Outer { //外部类 
    private int a = 10;
    class Inner{ //内部类
        public void method(){
            System.out.println(a);
        }
    }
    public void show(){
//        method(); //编译错误
        Inner inner =  new Inner();
        inner.method();
    }
}

不在一个类中的相互访问

例如测试类中如何访问Outer中的Inner类的方法呢 ？不妨先看代码

public class Outer { //外部类 
    private int a = 10;
    class Inner{ //内部类
        public void method(){
            System.out.println(a);
        }
    }
    public void show(){
//        method(); //编译错误
        Inner inner =  new Inner();
        inner.method();
    }
}

/*测试类 主方法*/
public class Test{
    public static void main(String[] args){
        Outer.Inner oi = new Outer().new Inner();
        oi.method();
    }
}

Outer.Inner 这样写的原因是直接写 Inner 找不到这个类，因为Inner是在这个Outer类里面的

Outer.Inner oi = new Outer().new Inner(); 为什么会这么写呢？因为Inner类不是静态的一个类，非静态成员是随着类对象的存在而存在的，这个就是Inner类是随着Outer类对象的存在而存在的。如果改为 static class Inner ，则创建对象的时候就可以写成Outer.Inner io= new Outer.Inner(); 因为静态成员是随着类的存在而存在的。

深入认识内部类

public class Outer {
  	 int a = 10;
    class Inner{
        int a = 20;
        public void method(){
            int a =30;
            System.out.println(a);
            System.out.println(this.a);
            System.out.println(Outer.this.a);
            System.out.println(new Outer().a);
        }
    }
}

public class Test {
    public static void main(String[] args) {
      /*  Outer.Inner io = new Outer().new Inner();
        io.method(); //输出的是30 20 10 */
        Outer o = new Outer();
        o.a = 5;
        Outer.Inner oi = o.new Inner();
        oi.method();//输出的是30 20 5 10
    }
}

讨论一下最后两行输出的为什么是5 和 10；原因是 System.out.println(new Outer().a); 是创造了一个新的 Outer() 对象，但是Outer类中的a值没有改变；而System.out.println(Outer.this.a); 是 Inner 对象所在的Outer对象的a的值。而上述代码中 Inner 对象所在的Outer对象是o ，o.a = 5; 已经改变了a的值，所以输出的是5。

局部内部类

一个内部类的方法私有化以后还如何对外展示？（多用在架构封装上）

/*先定义一个接口*/
interface Breast{
    public void beat();
}

public class Person{
    int a = 10;
//    a = 20; 编译报错
    /*成员内部类*/
    private class Heart implements Breast{
        @override
        public void beat(){
            System.out.println("心脏在跳动");
            System.out.println(a);
        }
    }
    /*添加一个方法，来生成Heart的对象去调用beat()方法*/
    public void showBreast(){
        Heart heart = new Heart();
        heart.beat();
    }
}

public class Test {
    public static void main(String[] args) {
     	Person p = new Person();
        p.showBreast();
    }
}

因为Heart()类是私有的，外界不能直接通过调用Person.Heart对象去调用beat()方法，所以就需要另外在同一个类中添加一个方法，来生成Heart的对象去调用beat()方法。这样既可以避免外界直接调用beat()方法，又可以在另外的类中可以用到 beat() 方法。同时，在局部内部类中定义一个局部变量如 a = 10 ,这里的变量是必须是final修饰，但是可以省略。

匿名内部类

假设有一个接口，在主方法中有三种办法可以实现这个方法的重写。如以下代码（有清楚的注释）

interface Face{
    public void show();
}

/*main()主方法*/
public class Test {
    public static void main(String[] args) {
     	//第一种方法
        Face f = new faceshow();
        f.show;
        
        /*第二种，直接来建立一个类来继承*/
    public faceshow implements Face{
        @override
        public void show(){
            System.out.println("展示");
        }
    }
    Face f1 = new faceshow();
    f1.show();
      
     /*第三种，建立一个匿名内部类*/
     Face f1 = 
         new // new是在创建一个匿名内部类的对象
         Face(){
         public void show(){
         System.out.println("展示");
   		}
     }
        f1.show();

   }
}

/*第一种，创建一个Java文件，来建立一个类来继承*/
public faceshow implements Face{
    @override
    public void show(){
        System.out.println("展示");
    }
}

匿名内部类的格式：new 接口名(){ 重写方法; }