二十八.内部类

内部类基本概念

一般我们定义的成员都是属性和方法。但是在代码中任何结构都是可以嵌套的，在类里面再嵌套一个类，这就叫做内部类。

定义：

/**
 * 测试类
 * @author Administrator
 *
 */
public class CeShiText {

	 public static void main( String[] args ){
		 Class c = new Class();	
		 c.getInner();
	 }
}


class Class{	//外部类
	
	private String mssage = "Hello Wold";		//私有属性
	
	class Inner{	//内部类
		public void show(){		//内部类方法
			System.out.println(mssage);
		}
	}
	
	public void getInner(){		//调用内部类的方法
		Inner inner = new Inner();		//内部类实例化
		inner.show();
	}
	
}

内部类的优势：可以随时访问外部类的私有属性
如果是两个外部类那么要访问私有属性需要封装起来才能访问

内部类的相关说明

通过上面我们了解了内部类的结构和优势，也知道怎么创建和使用最基本的内部类了。接下来我们还需要对内部类进行一些相关的说明。 内部类可以轻松的访问外部类的私有成员，相反外部类也可以轻松的访问内部类的私有成员。

例子：外部类访问内部类私有成员

public class CeShiText {

	 public static void main( String[] args ){
		 Class c = new Class();	
		 c.getInner();
	 }
}


class Class{	//外部类
	
	private String className = "外部类私有成员";
	
	class Inner{	//内部类
		private String innerName = "内部类私有成员";
		
		public void show(){		//内部类方法
			System.out.println(className);
		}
	}
	
	public void getInner(){		//调用内部类的方法
		Inner inner = new Inner();		//内部类实例化
		inner.show();
		System.out.println(inner.innerName);
	}
	
}

输出结果:

外部类私有成员
内部类私有成员

使用了内部类后，外部类和内部类之间的私有属性就可以不用去进行封装setter、getter访问私有属性了。有一点要注意，内部类也是一个类，所以不要以为内部类被外部类括起来就不能实例化了，只要是类都能实例化。

内部类实例化语法:

外部类.内部类 内部类对象名 = new 外部类().new 内部类();

例子：内部类实例化

public class CeShiText {

	 public static void main( String[] args ){
		 Class.Inner inner = new Class().new Inner();	//实例化内部类
		 
		 inner.show();
	 }
}


class Class{	//外部类
	
	private String className = "外部类私有成员";
	
	class Inner{	//内部类
		private String innerName = "内部类私有成员";
		
		public void show(){		//内部类方法
			System.out.println(className);
		}
	}
	
	public void getInner(){		//调用内部类的方法
		Inner inner = new Inner();		//内部类实例化
		inner.show();
		System.out.println(inner.innerName);
	}
	
}

输出结果：

外部类私有成员

那么如果内部类只允许外部类使用，那么要给内部类定义私有的访问修饰符private
例子：私有的内部类

public class CeShiText {

	 public static void main( String[] args ){
		 Class.Inner inner = new Class().new Inner();	//实例化内部类
		 
		 inner.show();
	 }
}


class Class{	//外部类
	
	private String className = "外部类私有成员";
	
	private class Inner{	//内部类
		private String innerName = "内部类私有成员";
		
		public void show(){		//内部类方法
			System.out.println(className);
		}
	}
	
	public void getInner(){		//调用内部类的方法
		Inner inner = new Inner();		//内部类实例化
		inner.show();
		System.out.println(inner.innerName);
	}
	
}

输出结果：

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
	The type Class.Inner is not visible
	The type Class.Inner is not visible
	The type Class.Inner is not visible

	at amazon.CeShiText.main(CeShiText.java:11)

当内部类加上了private那么调用范围只能在外部类里面，如果在其他类中调用会发生报错。

之前上面也说过任何结构都能嵌套，那么接口和抽象类同样也是能嵌套的，接下来给大家演示内部接口和内部抽象类。
例子：内部接口

public class CeShiText {

	 public static void main( String[] args ){	
		 OuterPort out = new OuterClass();
		 out.show(((OuterClass)out).new InnerClass());
	 }
}

class OuterClass implements OuterPort{		//外部类
	
	class InnerClass implements InnerPort{		//内部类

		@Override
		public String getContest() {
			// TODO Auto-generated method stub
			return "萝莉赛高";
		}
		
	}

	@Override
	public void show(InnerPort innerPort) {
		System.out.println(innerPort.getContest());
	}
}

interface OuterPort{			//外部接口
	
	public void show(InnerPort innerPort);
	
	interface InnerPort{			//内部接口
		public String getContest();
	}
}

输出结果:

萝莉赛高

接下里来看内部抽象类
例子：内部抽象类

public class CeShiText {

	 public static void main( String[] args ){	
		 OuterPort out = new OuterClass();
		 out.show();
	 }
}

class OuterClass implements OuterPort{		//外部类
	
	class InnerClass extends InnerAbstract{		//内部类

		@Override
		public String getContest() {
			// TODO Auto-generated method stub
			return "萝莉赛高";
		}
		
	}

	@Override
	public void show() {
		InnerAbstract innerAbstract = new InnerClass();
		System.out.println(innerAbstract.getContest());
	}
}

interface OuterPort{			//外部接口
	
	public void show();
	
	abstract class InnerAbstract{			//内部抽象类
		public abstract String getContest() ;
	}
}

输出结果：

萝莉赛高

还有一个更有意思的结构就是用内部类来实例化外部接口。
例子：接口内部进行接口实现

public class CeShiText {

	 public static void main( String[] args ){	
		 OuterPort out = OuterPort.getInnerClass();
		 out.show();
	 }
}

interface OuterPort{			//外部接口
	
	public void show();
	
	class InnerClass implements OuterPort{//内部类
		@Override
		public void show() {
			// TODO Auto-generated method stub
			System.out.println("萝莉永远滴神");
		}			
		
	}
	
	public static OuterPort getInnerClass(){
		return new InnerClass();
	}
}

输出结果：

萝莉永远滴神

static定义内部类

一般被static修饰的成员我们都称为静态成员，内部类被static修饰，就叫静态内部类。
静态内部类在实例化的时候不用通过外部类实例化而实例化了，可以直接实现静态内部类实例化。

• 外部类不能被static修饰，java唯一可以被static修饰的就是静态内部类
• 静态内部类可以包含静态成员，也可以包含非静态成员，但是在非静态内部类中不可以声明静态成员。
• 静态类内部不可以访问外部类的实例成员，只能访问外部类的类成员，即使是静态内部类的实例方法也不能访问外部类的实例成员，只能访问外部类的静态成员

语法：

外部类.内部类  内部类对象名 = new 外部类.内部类();

栗子

public class CeShiText {

	 public static void main( String[] args ){	
		 Outter.Inner inner = new Outter.Inner();
		 inner.show();
	 }
}

class Outter{	//外部类
	
	private static String msg = "Hello Wold";
	
	static class Inner{			//静态内部类
		public void show(){
			System.out.println(msg);
		}
	}
}

输出结果：

Hello Wold

方法中定义内部类

内部类可以在类中、方法中、代码块中创建

栗子：

public class CeShiText {

	 public static void main( String[] args ){	
		 Outter outter = new Outter();
		 outter.fun(10);
	 }
}

class Outter{	//外部类
	
	private String msg = "Hello Wold";
	
	public void fun(int num){		//方法
		class Inner{			//内部类
			public void show(){
				System.out.println(Outter.this.msg);
				System.out.println(num);
			}
		}
		
		new Inner().show();			//在方法中实例化
	}
}

输出结果

Hello Wold
10

匿名内部类

匿名内部类就是一个实现一次子类的操作，一般用作在抽象类或者接口上。

例子：实现接口

public class CeShiText {

	 public static void main( String[] args ){	
		 new Outter() {
			@Override
			public void show() {
				// TODO Auto-generated method stub
				System.out.println("萝莉");
			}
		}.show();
	 }
}

interface Outter{
	
	public void show();
}


输出结果：萝莉

那么当我们实现多个方法的时候呢？
用多态来实现

例子：实现接口多个方法

public class CeShiText {

	 public static void main( String[] args ){	
		 Outter o = new Outter() {
			
			@Override
			public void show() {
				// TODO Auto-generated method stub
				System.out.println("萝莉");
			}
			
			@Override
			public void fun(int num) {
				// TODO Auto-generated method stub
				System.out.println("等于："+num);
			}
		};
		
		o.show();
		o.fun(14);
	 }
}

interface Outter{
	
	public void show();
	
	public void fun(int num);
}

输出结果：

萝莉
等于：14