java 复习笔记——内部类及其实例化

1）在方法中定义的内部类，如果要访问方法中定义的本地变量或方法的参数，则变量必须被声明final。
2）内部类可以声明为private或protected；还可以声明为abstract或final。
3）内部类可以声明为static的，但此时就不能再使用外部类的非static的成员变量和非static的成员方法；
4）非static的内部类中的成员不能声明为static的，只有在顶层类或static的内部类中才可声明static成员。

5)若在某个方法中声明一个内部类，则这个内部类的执行周期限于这个方法中，只在这个方法中可见。

6）实例化内部类

class Outer
{
	private static int index=100;
	class Inner
	{
		private int index=50;
		void print()
		{
			int index=30;
			System.out.println(index);			
		}
	}
	Inner getInner(){
		return new Inner();
	}
}

class Test
{
	public static void main(String[] args)
	{
		Outer outer=new Outer();
		Outer.Inner inner1=outer.getInner();//实例化内部类方法1
		Outer.Inner inner2=outer.new Inner();//实例化内部类方法2
	}
}

7）实例化 继承了内部类的子类

class Car
{
	class Wheel
	{
	}
}

class PlaneWheel extends Car.Wheel
{
	PlaneWheel(Car car)
	{
		car.super();//步骤2)再实例化内部类Car.Wheel,利用了super()函数
	}
	public static void main(String[] args)
	{
		Car car=new Car();//步骤1)先实例化Car类
		PlaneWheel pw=new PlaneWheel(car);
	}
}

7.1）
理解好 7）中步骤2）中的car.super()，它为当前子类的父类的构造方法。进一步构造代码如下：

class Car
{
	
	class Wheel
	{
			Wheel(){
		       System.out.println("Base1"); 
	    }
	}
}

class Car2
{
	
	class Wheel2
	{
			Wheel2(){
		       System.out.println("Base2"); 
	    }
	}
}

class PlaneWheel2 extends Car2.Wheel2
{
	PlaneWheel2(Car2 car2)
	{
		car2.super();
	}
}

class PlaneWheel extends Car.Wheel
{
[color=red]	PlaneWheel(Car car)
	{
		car.super();
	}[/color]
	public static void main(String[] args)
	{
		Car2 car2=new Car2();
		PlaneWheel2 pw=new PlaneWheel2(car2);
	}
}

程序运行结果为：Wheel2

7.2)
即是形参所在(子)类的父类，而不是实参所在(子)类的父类。具体如下：

class Car
{	
	class Wheel
	{
			Wheel(){
		       System.out.println("Wheel1"); 
	    }
	}
}

class Car2
{	
	class Wheel2
	{
			Wheel2(){
		       System.out.println("Wheel2"); 
	    }
	}
}

class PlaneWheel2 extends Car2.Wheel2
{
	PlaneWheel2(Car2 car2)
	{
		car2.super();
	}
}

class PlaneWheel extends Car.Wheel
{
[color=red]	PlaneWheel(Car car)
	{
		car.super();
	}[/color]
	static Car2 car2=new Car2();//必须声明为static,静态main()方法中才能引用。
	public static void main(String[] args)
	{		
		PlaneWheel2 pw=new PlaneWheel2(car2);
	}
}

7.3)
注意：7.1)和7.2)中标红部分代码不能去掉。（貌似是必须的构造函数。）

8.1）内部类的应用1:内部类实现接口，同时隐藏接口的具体实现细节。

interface Animal
{
	void eat();
	void sleep();
}

class Zoo
{
	private class Tiger implements Animal
	{
		public void eat()
		{
			System.out.println("tiger eat");
		}
		public void sleep()
		{
			System.out.println("tiger sleep");
		}
	}
	Animal getAnimal()
	{
		return new Tiger();
	}
}

class Test
{
	public static void main(String[] args)
	{
		Zoo z=new Zoo();
		Animal an=z.getAnimal();
		an.eat();
		an.sleep();
	}
}

8.2）内部类的应用2：解决多个接口或父类中有方法名重名的问题。

interface Machine
{
	void run();
}

class Person
{
	void run()
	{
		System.out.println("run");
	}
}

class Robot extends Person
{
	private class MachineHeart implements Machine
	{
		public void run()
		{
			System.out.println("heart run");
		}
	}
	Machine getMachine()
	{
		return new MachineHeart();
	}
}

class Test
{
	public static void main(String[] args)
	{
		Robot robot=new Robot();
		Machine m=robot.getMachine();
		m.run();
		robot.run();
	}
}

8.3）内部类的应用3:解决类的多继承问题

class A
{
	void fn1()
	{
	}
}

abstract class B
{
	abstract void fn2();
}

class C extends A
{
	B getB()
	{
		return new B()
		{
			public void fn2()
			{
			}
		};
	}
}

class Test
{
	static void method1(A a)
	{
		a.fn1();
	}
	static void method2(B b)
	{
		b.fn2();
	}
	public static void main(String[] args)
	{
		C c=new C();
		method1(c);
		method2(c.getB());
	}
}

摘自：孙鑫老师的java视频。