java中的内部类：成员内部类，局部内部类，匿名内部类

内部类概述

内部类是指定义在一个类体内部的类。包括成员内部类，局部内部类，匿名内部类，如下所示

public class External{
	class Inner{//内部类Inner
	
	}
}

成员内部类

如下代码阐述内部类的访问特点

package InnerClasss;
public class External {
    private int a=1;
    
    private class Inner {
        public int b=2;
        
        public void Imethod() {
            System.out.println(a);//内部类可以直接访问外部类成员
        }
    }
    
    public void Emethod(){
  		//外部类无法直接访问内部类成员
		//System.out.println(b);

		//在外部类中创建对象以调用内部类的方法和属性
		Inner inner=new Inner();
        inner.Imethod();
        System.out.println(inner.b);
	}
}

package InnerClass;

public class Test {//测试类
    public static void main(String[] args) {
        /*成员内部类的访问方式一：
        格式：外部类名.内部类名 对象名=外部类对象.内部类对象，但是只有当Inner类为public时才可以使用这种调用方式
 	 	External.Inner inner=new External().new Inner();
        inner.Imethod();
        System.out.println(inner.b);
		*/
		
        /**
         *成员内部类的访问方式二：
         **/
        External external=new External();
        external.Emethod();
    }
}

局部内部类

package 局部内部类;

public class External {
    public void method() {
        class Inner {//局部内部类不使用访问修饰符,外部类和其他类无法直接访问，需要在方法内部创建对象使用
            private void show() {
                System.out.println("hhhhh");
            }
        }
        
        Inner inner = new Inner();
        inner.show();
    }
    
	//Inner inner=new Inner();报错，外部类无法直接访问
}

package 局部内部类;

public class Test {//测试类
    public static void main(String[] args) {
    //访问方式：
        External external=new External();
        external.method();
    }
}

匿名内部类

匿名内部类是局部内部类中的一种，定义在方法内部，其本质是继承某个类（具体类或抽象类）或实现某个接口的对象

package 匿名内部类;

public interface Inter {
    public abstract void show();
}

package 匿名内部类;

public class External {
    public void method(){
    	//匿名内部类没有名字，本质是一个对象，需要以分号
    	//定义：
        new Inter(){
            @Override
            public void show() {
                System.out.println("hhh");
            }
        };

        /**
         *匿名内部类的访问方式一：
         *匿名内部类本质是一个对象，因此直接在末尾使用 .方法 即可
         */

        new Inter(){
            @Override
            public void show() {
                System.out.println("匿名内部类");
            }
        }.show();

        /**
         * 匿名内部类访问方式二：
         * 定义一个引用变量，将匿名对象给变量
         */

        Inter inter=new Inter(){
            @Override
            public void show() {
                System.out.println("第二种方式访问匿名内部类");
            }
        };
        inter.show();
    }
}

package 匿名内部类;

public class Test {//测试类
    public static void main(String[] args) {
        External external=new External();
        external.method();
    }
}

匿名内部类的用途

package 匿名内部类用途;

public interface Jump {
    void jump();
}

package 匿名内部类用途;

public class GoJump {
    public void method(Jump j){
        j.jump();
    }
}

package 匿名内部类用途;

public class Cat implements Jump {
    @Override
    public void jump() {
        System.out.println("猫跳高");
    }
}

package 匿名内部类用途;

public class Dog implements Jump{
    @Override
    public void jump() {
        System.out.println("狗跳");
    }
}

package 匿名内部类用途;

public class Test {
    public static void main(String[] args) {
        //在没使用匿名内部类时，每次调用GoJump的方法都要新建一个Jump接口的实现类并实例化，如Cat，Dog

        GoJump goJump=new GoJump();
        Jump j=new Cat();
        goJump.method(j);
        Jump j2=new Dog();
        goJump.method(j2);


        //使用匿名内部类以后，直接用接口的匿名内部类作为参数
        goJump.method(new Jump() {
            @Override
            public void jump() {
                System.out.println("某某跳高");
            }
        });
    }
}