Java中的四种内部类

//1.创建成员内部类的实例，并调用内部类的print方法。
public class Demo {
    private  String name;
    class Inner{
        private int age;
        public void print(){
            System.out.println("内部类的方法被调用了!");
        }
    }
    public static void main(String[] args) {
        Demo.Inner in = new Demo().new Inner();
        in.print();
    }

}

//2.在sell（）方法中创建Demo2的局部内部类，并输出局部内类的print方法。
public class Demo2 {
    public void sell(){
        class Inner{
            public void print(){
                System.out.println("局部内部类的方法被调用了!");
            }
        }
        Inner in = new Inner();
        in.print();
    }
    public static void main(String[] args) {
        Demo2 d = new Demo2();
        d.sell();
    }
}

//3.在Demo3类中创建Inner静态内部类，然后在创建Demo3的实例对象之前和之后，分别创建Inner内部类的实例对象，
//并分别执行他们的introduction方法
public class Demo3 {
    private static String name;
    public Demo3(){
        name = "jacky";
    }
    static class Inner{
        private int age;
        public Inner(int age){
            this.age = age;
        }
        public void introduction(){
            System.out.println("这个人的名字是:"+name);
            System.out.println(name+"的年龄是:"+age);
        }
    }
    public static void main(String[] args) {
        /*
         * 1.创建Demo3的实例之前创建Inner内部类的对象。
         */
//        Demo3.Inner in = new Demo3.Inner(20);//第一次创建Inner对象
//        in.introduction();//第一次执行Inner对象的introduction方法
        
        /*
         * 2.创建Demo3的实例之后创建Inner内部类的对象。
         */
        Demo3 d =  new Demo3();//先创建Demo3对象的实例
        Demo3.Inner in = new Demo3.Inner(20);//第二次创建Inner内部类的实例
        in.introduction();//第二次执行Inner对象的introdu方法
        
    }
}

创建Demo3的实例之前创建Inner内部类的对象主函数中调用的执行结果:

创建Demo3的实例之后创建Inner内部类的对象主函数的执行结果：

//4.实现关系下的内部类与继承关系下的内部类
class Person{
    void eat(){
        System.out.println("在吃饭!");
    }
}
interface Dao{
    void add();
}
public class Demo4{
    public void print(){
        //继承关系下的匿名内部类
        new Person(){
            void sleep(){
                System.out.println("在睡觉!");
            }
        }.eat();
    }
    public void show(){

//实现关系下的内部类
        new Dao(){
            public void add(){
                System.out.println("添加成功!");
            }
        }.add();
    }
    public static void main(String[] args) {
        Demo4 d = new Demo4();
        d.print();
        d.show();
    }
}

内部类需要注意的细节：

内部类: 在一个类的内部定义另外一个类，那么另外一个类则称作为内部类 。
内部类的class文件名： 外部类$内部类.class  
成员内部类：
成员内部类的访问方式：
            方式一： 在外部类提供一个方法创建内部类的对象进行访问。
            方式二：在其他类中直接创建内部的对象进行访问。
                   格式：
                            外部类.内部类  变量名  = new 外部类().new 内部类();
             注意：静态成员内部类在其他类创建对象的格式：
                        外部类.内部类  变量名  =  new 外部类.内部类();
内部类的好处: 直接访问外部类的所有成员。

局部内部类：在一个方法内部定义的类称作为局部内部类。
局部内部类要注意的细节：如果局部内部类要访问局部变量，那么局部变量必须使用final去修饰。
   

匿名内部类：没有类名的内部类就称作为匿名内部类。
匿名内部类的好处： 简化书写。
匿名内部类的使用前提： 必须存在继承或者实现的关系。
注意的事项： 匿名内部类只是没有类名而已，其他的一切成员都是具备的。

2017.11.03Java课后总结！