Lesson_for_java_day18--java中的内部类(成员内部类、局部内部类，静态内部类，匿名内部类)

内部类：

-------------------------------------内部类-------------------------------------------------

内部类：	
	1、内部类是指在一个外部类的内部再定义一个类。
	2、内部类作为外部类的一个成员，并且依附于外部类而存在的。
	3、内部类可为静态，可用protected和private修饰。（而外部类不可以：外部类只能使用public和default）。
	（注：所有使用内部类的地方都可以不用内部类，使用内部类可以使程序更加的简洁，便于命名规范和划分层次结构）。
	
内部类的分类：
	成员内部类、局部内部类、静态内部类、匿名内部类（图形是要用到，必须掌握）。

成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列。
		1、内部类和外部类的实例变量可以共存。
		2、在内部类中访问实例变量：this.属性
		3、在内部类访问外部类的实例变量：外部类名.this.属性。
		4、成员内部类不可以有静态属性。
		5、如果在外部类的外部访问内部类，使用out.inner.
	成员内部类的优点：
		⑴内部类作为外部类的成员，可以访问外部类的私有成员或属性。
			（即使将外部类声明为private，但是对于处于其内部的内部类还是可见的。）
		⑵用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的
			private还要小的访问权限。
		注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。
			对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后
			出现outer.class和outer$inner.class两类。

	建立内部类对象时应注意：
		1、在外部类的内部可以直接使用inner s=new inner();（因为外部类知道inner是哪个类，
			所以可以生成对象。）
		2、而在外部类的外部，要生成（new）一个内部类对象，需要首先建立一个外部类对象
				（外部类可用），然后在生成一个内部类对象。
			eg：Outer.Inner in=Outer.new.Inner()。
			错误的定义方式：Outer.Inner in=new Outer.Inner()。
		注意：当Outer是一个private类时，外部类对于其外部访问是私有的，
			所以就无法建立外部类对象，进而也无法建立内部类对象。

局部内部类：在方法中定义的内部类称为局部内部类。
		与局部变量类似，在局部内部类前不加修饰符public和private，其范围为定义它的代码块。

	注意：局部内部类不仅可以访问外部类实例变量，还可以访问外部类的局部变量
		（但此时要求外部类的局部变量必须为final）
		在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。
		要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。

静态内部类：（注意：前三种内部类与变量类似，所以可以对照参考变量）
		1、静态内部类定义在类中，任何方法外，用static定义。
		2、静态内部类只能访问外部类的静态成员。
		3、生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。
			而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。
		4、静态内部类的对象可以直接生成：Outer.Inner in=new Outer.Inner()；
		5、静态内部类不可用private来进行定义。
			例子：对于两个类，拥有相同的方法：
				People
				{
				  run();
				}
				Machine{
				   run();
				}
				此时有一个robot类：
				class Robot extends People implement Machine.
				此时run()不可直接实现。
		注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。
			用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。

匿名内部类（必须掌握）：匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口。
			eg：IA被定义为接口。IA I=new IA(){};
		1、一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，
			没有类名，根据多态，我们使用其父类名。
		2、因其为局部内部类，那么局部内部类的所有限制都对其生效。
		3、匿名内部类是唯一一种无构造方法类。
		4、匿名内部类在编译的时候由系统自动起名Out$1.class。
		5、如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
			因匿名内部类无构造方法，所以其使用范围非常的有限。
           

一、成员内部类：

package cn.imcore.test;
/**
 * 成员内部类
 */
public class Test1 {
    private int a = 1000;//成员变量
    static int b = 99; //静态变量

	public class Inner1 {//成员内部类
		int a = 100;
		int c;

		Inner1() {
	
		}

		Inner1(int c) {
			this.c = c;
		}

		public void print(){
			System.out.println("c:" + c);
			System.out.println("a:" + a);
			System.out.println("a:" + Test1.this.a);
			System.out.println("访问外部类的静态变量：" + b);
		}	
	}

	public void print() {//成员方法
		System.out.println("Test1");
	}

	public Inner1 getInner() {
		return new Inner1();
	}

	public static void main(String[] args) {
		//如何创建成员内部类
		Test1 t1 = new Test1();
		//方式1
		//Test1.Inner1 inner = t1.new Inner1(3);
		//方式2
		Test1.Inner1 inner = t1.getInner();	
		inner.print();//调用内部类的打印方法
	}
}
           

二、局部内部类：

package cn.imcore.test;
/**
 * 局部内部类
 */
public class Test2 {
	private int a = 97;
	static int b = 98;
	
	public void f1() {
		//int c = 99;
		final int c = 99;//必须是常量 final
		
		class Inner2 {
			int d = 100;		
			public Inner2() {			
			}
			
			public void print() {
				System.out.println("d:" + d);
				System.out.println("c:" + c);
				System.out.println("a:" + a);
				System.out.println("b:" + b);
				m1();//
			}
		}	
		Inner2 inner = new Inner2();//创建局部内部类对象
		inner.print();
	}

	public void m1() {
		System.out.println("Test2");
	}
		
	public static void main(String[] args) {
		Test2 test2 = new Test2();
		test2.f1();	
	}
}
           

三、静态内部类：

package cn.imcore.test;
/**
 * 静态内部类
 */
public class Test3 {
	private int a = 100;//成员变量
	static int b = 101;//静态变量

	static class Inner3 {
		int c = 102;
		Inner3() {	
		}
		
		public void print(){
			System.out.println("c:" + c);
			//System.out.println("a:" + a);//不能访问外部类的非静态成员
			//plus(2, 3);
			div(4,2);
		}
	}

	public int plus(int a, int b) {//成员方法
		return a+b;
	}

	public static int div(int a, int b) {//静态方法
		return a/b;
	}

	public static void main(String[] args) {
		//静态内部类如何创建对象
		Test3.Inner3 inner = new Test3.Inner3();
		inner.print();//调用内部类的打印方法
	}
}
           

四、匿名内部类：

package cn.imcore.test;
/**
 * 匿名内部类
 */
public class Test4 {
	public static void main(String[] args) {	
		Person p1 = new Person(){
			@Override
			public void sing() {
				System.out.println("yayaaaaaaaaaaaa!!!!");
			}	
		};

		Person p2 = new Person(){
			@Override
			public void sing() {
				System.out.println("do re mi fa so!!!!");				
			}		
		};
		p1.sing();
		p2.sing();
	}
}

interface Person {
	public void sing();
}