JAVA中的内部类

/*
 * 内部类的访问规则：
 * 	1、内部类可以直接访问外部类中的成员，包括私有
 * 		之所以可以直接访问外部类成员，是因为内部类中持有一个外部类的引用，格式：外部类名.this
 * 	2、外部类要访问内部类必须建立内部类对象
 * 
 * 
 * 内部类可以被私有或静态等修饰
 * */

/*class Outer {
	private int x = 3;

	class Inner { // 内部类
		int x=4;
		void function() {
			int x=6;
			System.out.println("Inner:" + this.x);
			System.out.println("Outer:" + Outer.this.x);
		}
	}

	void method() {
		Inner in=new Inner();
		in.function();
		System.out.println(x);
	}
}

public class InnerClassDemo {
	public static void main(String args[]) {
		//Outer out = new Outer();
		//out.method();
		
		//直接访问内部类成员
		Outer.Inner in =new Outer().new Inner();
		in.function();		
	}
}*/

class Outer {
	private static int x = 3;

	static class Inner { // 内部类
		void function() {
			System.out.println("Inner:" + x);
		}
	}
}

public class InnerClassDemo {
	public static void main(String args[]) {
		new Outer.Inner().function();
	}
}

下面是匿名内部类

/*
 * 匿名内部类
 * 1、匿名内部类就是内部类的简写格式
 * 2、定义匿名内部类前提，内部类必须继承一个类或者实现接口
 * 3、匿名内部类的格式：new父类或者接口（）{ 定义子类内容 }
 * 4、其实匿名内部类就是一个匿名子类对象，可以理解为带内容的对象
 * 
 * */
abstract class AbsDemo {
	abstract void show();
}

class Outer2 {
	int x = 3;

	/*
	 * class Inner extends AbsDemo {
	 * 
	 * void show() { System.out.println("show:"+x); } }
	 */

	public void function() {
		// new Inner().show();
		new AbsDemo() {
			void show() {
				System.out.println("show:" + x);
			}

			void abc() {
				System.out.println("abc");
			}
		}.show();// 这是匿名内部类，即简化后的绿色注释部分
	}
}

public class InnerClassDemo3 {
	public static void main(String args[]) {
		new Outer2().function();
	}
}

如果要调用abc()和show()两个方法那么就给匿名内部类起个名字，但是注意，使用的方法必须是父类中有的方法（就是多态）

如下面，注意AbsDemo类和上面有不同

abstract class AbsDemo {
	abstract void show();

	abstract void abc();
}

class Outer2 {
	int x = 3;

	public void function() {
		AbsDemo a1 = new AbsDemo() {
			void show() {
				System.out.println("show:" + x);
			}

			void abc() {
				System.out.println("abc");
			}
		};
		a1.show();
		a1.abc();
	}
}

如果AbsDemo类中没有abc方法，那么就算起了名字，也不能调用，会编译错误。

那么我要用abc方法的话就可以直接写成     

new AbsDemo(){ void show(){}      void abc(){} }.abc();

当然这个时候和继承关系不大，可以不继承单独写个内部类或者函数，只是举个例子。

下面是个练习，可以自己试一下

interface Inter2{
	void method();
}

class Test2{
	//补足代码，通过匿名内部类
	
}

public class InnerClassTest {
	public static void main(String args[]){
		Test2.function().method();		
	}
}

答案如下

interface Inter2{
	void method();
}

class Test2{
	//补足代码，通过匿名内部类
	static Inter2 function(){
		return new Inter2(){
			public void method(){
				System.out.println("abc");
			}
		};
	}
}

public class InnerClassTest {
	public static void main(String args[]){
		Test2.function().method();
		//test.function    test类中有一个静态的方法function
		//.method   说明function方法运算后的结果是一个对象，而且是一个Inter类型的对象
		//因为只有Inter类型的对象，才可以调用method方法
		
	}
}

                                                                                    ----------------------By   仔鸡