java 内部类 匿名内部类

内部类 ：
在一个类A的内部再定义一个类B，类A叫作外部类，类B叫作内部类

内部类 ： 成员内部类 vs 局部内部类
成员内部类 ： 静态（成员）内部类 vs 非静态（成员）内部类

内部类作为类：

• 可以继承父类,实现接口
• 类内部可以有类的成员（普通类可以做的事情内部类都可以）。

作为类的成员：

• 可以被static修饰
• 可以使用四种权限修饰符
• 内部类还可以调用外部类的成员（属性，方法）

学习目标：
1.如何创建内部类的对象？
静态内部类： new 外部类名.内部类名（）
非静态内部类 ： 外部类的对象.new 内部类名（）

2.内部类如何调用外部类的成员（属性和方法）？
静态内部类 ： 外部类名.类变量名、静态方法 （只能调用外部类的类变量和静态方法）
非静态内部类 ： 外 部类名.this.属性名、方法名

3.如何使用局部内部类？

//外部类
class Number{
	
	public String type = "number";
	public static int age = 5;
	
	public void show(){
		System.out.println("number show");
	}
	
	public static void test(){
		System.out.println("number test");
	}
	
	//非静态内部类 - 可以调用外部类的静态方法和非静态方法，实例变量和类变量
	class A {
		int age = 20;
		public void info(){
			System.out.println("A info " + Number.this.type + " " + Number.this.age);
//			System.out.println(age + " " + type);
			//调用外部类的方法
//			Number.this.show();
//			Number.this.test();
		}
	}
	
	//静态内部类 - 只能调用外部类中的静态方法和类变量
	static class B{
		public void info(){
			System.out.println("B info" + Number.age);
			//调用外部类的静态方法
			Number.test();
		}
	}
	
}
public class InnerClassTest {
	
	public static void main(String[] args) {
		
		//1.创建非静态内部类的对象
		//创建非静态内部类的对象
		Number number = new Number();//创建外部类的对象
		Number.A a = number.new A();
		a.info();
		
		System.out.println("-------------------------------------------------");
		//创建静态内部类的对象
		Number.B b = new Number.B();
		b.info();
		
		System.out.println("-------------------------------------------------");
		
		InnerClassTest ict = new InnerClassTest();
		ict.test();
		
		MyInterface myInterface = ict.test2();
		//可以获取局部内部类的对象但是无法向下转型。
		myInterface.info();
	}

	/*
	 * 如何获取局部内部类的对象 (了解即可)
	 */
	public MyInterface test2(){
		class C implements MyInterface{
			public void info(){
				System.out.println("MyInterface test method info");
			}
		}
		return new C();
	}
	
	public void test(){
		//局部内部类
		class C{
			public void info(){
				System.out.println("test method info");
			}
		}
		
		new C().info();
	}
	
}

interface MyInterface{
	void info();
}

运行结果：

匿名内部类的特点:

1. 匿名内部类必须继承父类或实现接口
2. 匿名内部类只能有一个对象
3. 匿名内部类对象只能使用多态形式引用

interface MyInterface{
	void add(int a,int b);
}

public class AnonymousTest {

	public static void main(String[] args) {
		

		class Computer implements MyInterface{
			
			public void add(int a,int b){
				System.out.println(a + b);
			}
		}
		MyInterface computer1 = new Computer();

		//创建了一个实现类MyInterface接口的匿名实现类的对象
		MyInterface computer = new MyInterface(){
			public void add(int a,int b){
				System.out.println("匿名实现类的对象");
			}
		};
		
		//可以使用alt + /
		new MyInterface() { //创建的是该接口的实现类的对象
			@Override
			public void add(int a, int b) {
				// TODO Auto-generated method stub
			}
		};
		
		test(computer);
	}
	
	//如果形参是一个接口的类型，那么实参只能是接口实现类的对象
	public static void test(MyInterface mi){
		
		mi.add(5, 10);
	}
}

运行结果：