内部类

内部类

• 将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
• 访问特点：
  • 内部类可以直接访问外部类中的成员，包括私有成员。
  • 而外部类要访问内部类中的成员必须要建立内部类的对象。

class  InnerDemo{
	public static void main(String[] args) {
		//在外部访问内部类
		Outer out = new Outer();
		Outer.Inner inner = out.new Inner();
		inner.test();
	}
}
class Outer{
	private  static String name="1111";

	class Inner{
		public void test(){
			System.out.println(name);
		}
	}
	public Inner getInner(){
		return new Inner();
	}
}

使用static定义内部类

class  InnerDemo
{
	public static void main(String[] args) 
	{
		//new Outer().getInner().print();
		new Outer.Inner().print();
	}
}
class Outer
{
	private static String name = "haoren";
	static class Inner
	{
		public void print(){
			System.out.println(name);
		}
	}
}

将内部写在方法中

​ 如果内部类想要访问方法中的参数，那么参数必须是final定义的(jdk1.8就可以不写final)

class Outet{							//定义外部类
	private String info = "hello world";
	public void fun(final int temp){	//参数要被访问必须用final
		class Inner{					//在方法中定义内部类
			public void print(){
				System.out.println("类中的属性:"+info);
				System.out.println("方法中的参数:"+temp);
			}
		}
	}
}

匿名内部类

• 就是内部类的简化写法

• 前提：

  • 内部类可以继承或实现一个外部类或者接口。

• 格式为：

  • new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}

• 简单理解：

  • 就是建立一个建立一个带内容的外部类或者接口的子类匿名对象。

class NoNameDemo {
	public static void main(String[] args) {
		Do d = new Do();
		//d.print(new B());
		d.print(
	new A(){public void test(){
	System.out.println("haha");
	}});
	}
}
interface A{
	void test();
}
/*
class C implements A{
	public void test(){
		System.out.println("hahah");
	}
}
*/
class Do{
	public void print(A a){
		a.test();
	}
}

内部类的扩展

• 接口里边可以定义内部接口和抽象类
• 抽象类里也可以定义接口和抽象类

public class Inner {
	public static void main(String[] args) {
		A.B b = new X().new Y();//实例化内部接口
		b.printB();				//调用内部接口的抽象方法
	}
}
abstract class A{					//定义抽象类A
	public abstract void printA();	//定义抽象方法
	interface B{					//定义内部接口B
		public void printB();		//定义抽象方法
	}	
}
class X extends A{				//继承抽象类
	public void printA() {		//实现抽象方法
		System.out.println("HELLO----A");
	}
	class Y implements B{		//定义内部类实现内部接口
		public void printB() {	//实现内部接口的抽象方法
			System.out.println("HELLO----B");
		}
	}
}

public class InnerDemo {
	public static void main(String[] args) {			
		A.B b = new X().new Y();	//实例化内部接口	
		b.printB();					//调用内部接口的抽象方法
	}
}
interface A{						//定义接口A
	public abstract void printA();//定义抽象方法
	abstract class B{				//定义内部抽象方法
		public abstract void printB();//定义抽象方法
	}
}
class X implements A{
	public void printA() {			//实现接口A
		System.out.println("HELLO--A");
	}
	class Y extends B{				//在接口实现类中定义内部类
		public void printB() {		//实现内部抽象的抽象方法
			System.out.println("HELLO--B");
		}
	}
}