JAVA语言读书笔记-内部类

关于内部类 也就是JAVA中大家熟知的类中定义类的情况

当然类中类并不是那么简单，要知道其中之间的规则还是有点复杂的

特别是关于静态内部类，静态方法的局部内部类，匿名内部类 ，和非静态内部类

其中大家见得最多的就是非静态内部类了，就从它先进行讲起

1-非静态内部类

1.1 外部类中访问内部类

看作一个成员，可以随便的创建对象 。值得一提的便是 一个外部类对象中可以创建多个一个内部类对象

class Outer
{
	int i=2;
	private class Inner
	{
		int ii=3;
	}
	public void myVoid()
	{
		Inner in=new Inner();
		System.out.println("Inner i="+in.ii);
		System.out.println("Outer i="+i);
	}
}
public class a12_3 {
	public static void main(String args[])
	{
		Outer ou=new Outer();
		ou.myVoid();
	}

}

1.2外部类外部访问内部类

这边是main函数也就是静态函数中访问非静态内部类的情况

class Outer
{
	 int i=1;
	 class Inner//注意Private内部类成员外部不可以访问的
	{
		int ii=2;
		public int  F2(){i++; return i;}
		//方法中可以随便调用，但是方法外不可以随便修改，类似C++中的类，只是内部类新元素可以随便初始化
		//i还是属于外部实例而不是内部实例，这点需要牢记  但是一个外部实例可以拥有多个内部实例 也就是外部的I是多个内部类公共的
	}
	 
}
public class a12_2 {
	public static void main(String args[])
	{
		Outer a=new Outer();
		Outer.Inner b=a.new Inner();
		Outer.Inner c=a.new Inner();
		Outer.Inner m=new Outer().new Inner();
	   System.out.println("Outer i "+a.i);
	   System.out.println("Inner i "+b.F2());
	   System.out.println("Inner i "+c.F2());
	}
}

一般是通过 Outer.Inner m=new Outer().new Inner();创建外部类对象

需要确定外部类的话，先创建外部类，在创建内部类

public class a12_1 {
	private  class InClass
	{
		private int i=1;
	}
	int ii=2;
	public static void main(String args[])
	{
		//InClass ic=new InClass();// 需要注意点是这边不可以直接的调用的 必须以 wai.Nei的形式进行调用和分配空间
		a12_1 a=new a12_1();
		a12_1.InClass ic= a.new InClass(); 
		System.out.println("创建一个内部类"+ic.i);
		ic.i=2;
		System.out.println("创建一个内部类"+ic.i);
		
	}

}

1.3关于this指针的运用

顺便一说对于变量的使用执行局部优先的原则

class Outer
{
	int i=8;
	class Inner
	{
		int i=9;
		public void myVoid()
		{
			System.out.println("i="+i);//Inner i
			System.out.println("this.i="+this.i);//inner i
			System.out.println("Outer.this.i="+Outer.this.i);// outer i
		}
	}
}
public class a12_4 {
	public static void main(String args[])
	{
		Outer out=new Outer();
		Outer.Inner in=out.new Inner();
		in.myVoid();
	}
}

2-静态内部类

2.1外部类内部访问内部类

class Outer
{
	int j=9;
	static int i=10;
	public static  void myVoid ()
	{
		class Inner
		{
			public void InnerMyVoid()
			{
				System.out.println("Outer static int i="+i);
				//System.out.println("Outer int j="+j);
			}
		}
		Inner in=new Inner();
		in.InnerMyVoid();
	}
}
public class a12_6 {
	public  static void main(String args[])
	{
		Outer out=new Outer();
		out.myVoid();
	} 
}

2.2外部类之外访问内部类

class Outer
{
	static  class Inner
	{
		int i=5;
	}
	public void myVoid()
	{
		Inner in=new Inner();
		System.out.println("Static class Inner.i="+in.i);
	}
}
public class a12_7 {
	public static void main(String args[])
	{
		Outer out=new Outer();
		out.myVoid();
		//Outer.Inner in=out.new Inner();
		//静态内部类的访问和动态的访问语法并不相同
		Outer.Inner in=new Outer.Inner();
		System.out.println("Static Inner.i="+in.i);
	}
}

3-局部内部类

所谓的局部内部类就是在函数成员之中再创建局部的类成员

3.1 非静态局部内部类成员访问（外部类内-外部类外）

class Outer
{
	int j=9;
	static int a1=0;
	private int a2=10;
	public void myVoid()
	{
		int m=4;
		final  int n=6;
		class Inner
		{
			int i=5;
			public void InnerMyVoid()
			{
				System.out.println("Outer.j="+j);
				//m 为函数内部 但是不为final型 函数结束就会消减 所以不能引用访问				
				//System.out.println("myVoid m="+m);
				System.out.println("myVoid n="+n);
				System.out.println("Inner a1="+a1);
				System.out.println("Inner a2="+a2);
			} 
		}
		Inner in=new Inner();
		System.out.println("Inner.i="+in.i);
		in.InnerMyVoid();
	}
}
public class a12_5 {
	 public static void main(String args[])
	 {
		 Outer out=new Outer();
		 out.myVoid();
	 }

}

3.2静态方法中的局部内部类

class Outer
{
	int j=9;
	static int i=10;
	public static  void myVoid ()
	{
		class Inner
		{
			public void InnerMyVoid()
			{
				System.out.println("Outer static int i="+i);
				//System.out.println("Outer int j="+j);
			}
		}
		Inner in=new Inner();
		in.InnerMyVoid();
	}
}
public class a12_6 {
	public  static void main(String args[])
	{
		Outer out=new Outer();
		out.myVoid();
	} 
}

4-匿名内部类

这个比较特殊 通过继承外部类 然后重写或者重载父类或者接口

来实现想要的类实例

顺便说一下 匿名内部类在类定义的时候就创建了实例，可以直接运用了

4.1 匿名内部类 通过父类继承

class Father
{
	int i=9;
	public void myVoid()
	{
		System.out.println("--  Father myVoid --");
	}
}
public class a12_8 {
	public static void main(String args[])
	{
		Father f1=new Father()
		{
			{
				i=8;
			}
			public void myVoid()
			{
				System.out.println("--NoName Class extends Class Father  myVoid()--");
			}
		};
		f1.myVoid();
		Father f2=new Father();
		f2.myVoid();
	}
}

4.2 匿名内部类 通过接口继承

interface Father
{
	int i=9;//为 abstract final类型  关键词省略 
	public void myVoid();
}
public class a12_9 {
	public static void main(String args[])
	{
		Father f2=new Father()
		{
			public void myVoid()
			{
				System.out.println("--NoName Class extends Interface Father--"+i);
			}
		};
		f2.myVoid();
	}
}