Java内部类

在一个类中定义一个类

语法：

public class 类名{

        修饰符 class 类名{

        }

}

一般情况下修饰符用private

public class cat{
    int a = 10;
    String b;
    private int c;
    public class dog{
        public void read(){
            System.out.println(a);
        }
    }
    public void d(){
        dog s = new dog();
        s.read();
    }
}

内部类可以直接访问外部类的成员

外部类访问内部类的成员必须创建对象

用private修饰的情况

public class outer {
    int a = 10;
    private class inner{
        public  void read(){
            System.out.println(a);
        }
    }
    public void method(){
        inner s = new inner();
        s.read();
    }

}

public class test {
    public static void main(String[] args){
        outer s  = new outer();
        s.method();
    }
}

---

成员内部类

按照内部类在类中的定义位置不同，可分为以下两种情况：

在类的成员位置：

        成员内部类

在类的局部位置：

        局部内部类

成员内部类，外界创建对象

格式：外部类名.内部类名  对象名 = 外部类对象.内部类对象；

public class outer {
    int a = 10;
    public class inner{
        public void read(){
            System.out.println(a);
        }
    }
}




public class test {
    public static void main(String[] args){
        outer.inner s = new outer().new inner();
        s.read();
    }
}

 

---

局部内部类

在方法里面定义内部类

public class outer {
    int a = 10;
   public void read(){
        class inner{        //局部内部类是直接写class
           public void d(){
               System.out.println(a);
           }
       }
       inner s = new inner();

        s.d();
   }

}


public class test {
    public static void main(String[] args){
        outer s = new outer();
        s.read();

    }
}

---

匿名内部类

是局部内部类的一种特殊形式

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

语法：

        new 类名或者接口名（） {

                重写方法；

}；

本质是继承了该类或者实现了该接口的子类匿名对象

public interface inner {
    void show();
}


public class outer {
    int a = 10;
   public void read() {
       new inner(){     //注意此处有括号
           @Override
           public void show() {     //重写方法
                System.out.println("匿名内部类");
           }
       };       //注意此处有分号

   }

}

调用 

public class outer {
    int a = 10;
    //定义匿名内部类
 /*  public void read() {
       new inner(){     //注意此处有括号   此处等价于inner i = new inner(){  因此若要多次调用直接用i.show()即可
           @Override
           public void show() {     //重写方法
                System.out.println("匿名内部类");
           }
       };      //注意此处有分号

   }*/
 //调用内部类
    public void read(){
        new inner(){        //因为本质是继承了该类或者实现了该接口的子类匿名对象，注意对象对象
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();
    }


}