内部类

内部类：

在一个类中，定义在类中的叫成员变量，定义在函数中的叫成员函数，那么根据类定义的位置也可以分为成员内部类和局部内部类。除此还包括匿名内部类。

备注：内部类生产的class文件为 “外部类$内部类”，为了标明该内部类是属于具体哪个外部类的。

一，成员内部类：在一个类中定义另一个类

1.格式：

    a，Outer.Inner 变量名 = new Outer().new Inner();

    b, Outer.Inner 变量名 = new Outer.Inner();[静态内部类]

2.内部类可以直接访问外部类的成员属性。

3.私有的成员内部类不能在其他类中直接创建内部类对象来访问。

4.外部类需要访问内部类的属性时，需要创建内部类的对象访问

5.在外部类的成员函数中创建内部类的对象，通过内部类对象对象直接访问内部类的成员。

6.在其他类中直接创建内部类的对象：

Outer.Inner inner = new Outer().new Inner();

7.如果内部类中包含有静态成员，那么java规定内部类必须声明为静态的访问静态内部类的形式：

Outer.Inner inner = new Outer().new Inner();

二，局部内部类：在一个类的方法中定义一个类

     格式：可以在包含局部内部类的方法中直接创建局部内部类的对象调用局部内部类的成员

三，匿名内部类：没有类名的内部类

 
 
作用        ：简化内部类书写。
使用前提  : 必须继承一个父类或者是实现一个接口。
格式        ：new父类或者接口(){ 执行代码….};

/*内部类和外部类有相同的变量时，默认访问的是内部类变量*/
class Outer{
	String name = "外部类变量";	
	class Inner{
		String name = "内部类变量";	
	
		public void print(){
			System.out.println("内部类访问的是："+name);
		}
	}
	
}
class Demo01{
	public static void main(String[] args) {
		Outer.Inner inner = new Outer().new Inner();
		inner.print();
	}
}

/*内部类可以直接访问外部类的成员变量*/
class Outer{
	String name = "外部类变量";	
	class Inner{
		public void print(){
			System.out.println("内部类访问的是："+name);
		}
	}
	
}
class Demo01{
	public static void main(String[] args) {
		Outer.Inner inner = new Outer().new Inner();
		inner.print();
	}
}

/*内部类和外部类有相同的变量时，可通过[外部类.this.变量名]访问外部类的成员变量*/
class Outer{
	String name = "外部类变量";	
	class Inner{
		String name = "内部类变量";	
		public void print(){
			System.out.println("内部类访问的是："+Outer.this.name);
		}
	}
	
}
class Demo01{
	public static void main(String[] args) {
		Outer.Inner inner = new Outer().new Inner();
		inner.print();
	}
}

/*外部类直接访问内部类的属性时，需要在方法内创建对象访问*/
class Outer{
		
	class Inner{
		String name = "内部类变量";	
	}
	
	public void print(){
		Inner inner = new Inner();
		System.out.println("外部类访问的是："+inner.name);
	}	
}
class Demo01{
	public static void main(String[] args) {
		Outer outer = new Outer();
		outer.print();
	}
}

/*如果内部类中包含有静态成员，那么java规定内部类必须声明为静态*/
静态内部类的形式：Outer.Inner in = new Outer.Inner(); 
class Outer{
	
	static class Inner{
	static	String name = "内部类变量";	
	
		public void print(){
			System.out.println("内部类访问的是："+name);
		}
	}
	
}
class Demo01{
	public static void main(String[] args) {
		Outer.Inner inner = new Outer.Inner();
		inner.print();
	}
}

/*私有的成员内部类不能在其他类中直接创建内部类对象来访问*/
class Outer{
		
	private class Inner{
		String name = "内部类变量";	
	}
	
	public void print(){
		Inner inner = new Inner();
		System.out.println("外部类访问的是："+inner.name);
	}	
}
class Demo01{
	public static void main(String[] args) {
		Outer.Inner inner = new Outer().new Inner();
		inner.print();
	}
}

/*匿名内部类*/
abstract class Inner{
	abstract void inprint();
}
class Outer {
	
	public void outprint(){
		new Inner(){
			public void inprint(){	
				System.out.println("匿名内部类");
			}	
		}.inprint();
	}	
}


class Demo01{
	public static void main(String[] args) {
		new Outer().outprint();	
	}
}

/*匿名内部类用于一次实参使用*/
abstract class  Inner{   //[抽象类]
	 abstract String inprint();
}


//interface Inner{ // 接口
//	 public String inprint();
//}
class Outer {	
	public void outprint(Inner inner){
		System.out.println(inner.inprint());
	}
}
class Demo01{
	public static void main(String[] args) {
		new Outer().outprint(new Inner(){
			public String inprint(){
				return "匿名内部类用于实参";
			}
		});
	}
}