Java学习第九天-CSDN博客

本文链接：https://blog.csdn.net/phqde/article/details/7608060

内部类：

在非静态内部类实例里面，保存着一个它寄存的外部类实例的引用（当使用一个非静态内部类的实例时，该实例必须有一个外部类的实例引用。也即是说，非静态内部类实例必须寄存在外部类实例里面）。

内部类（静态或非静态）本质上是类的成员变量。

局部内部类（方法内类）是方法的局部变量。就如方法内变量 int i;一样，不能使用任何访问修饰符或static。

如果匿名内部类使用了外部类的成员，则该成员必须是final修饰的。

如果局部内部类使用了方法或方法参数的变量，则该变量必须是final修饰的。

非静态内部类不能有静态声明，无论是静态初始快，还是静态属性、方法。

class  OutterClass
{
	private int count;

	//内部类
	private class InnerClass
	{
		/*static 非静态内部类不能有静态声明，无论是静态初始快，还是静态属性、方法
		{
			System.out.println("内部类静态初始化块执行！");
		}*/
		{
			System.out.println("内部类普通初始化块执行！");
		}
		public InnerClass()
		{
			System.out.println("内部类构造方法执行！");
		}
	}
}

关于内部类访问级别的代码测试：

package lesson8;
//外部类
class  OutterClass
{
	private int count=1008;
	private static int eyecount;

	//内部类
	private class InnerClass
	{
		/*static 非静态内部类不能有静态声明，无论是静态初始快，还是静态属性、方法
		{
			System.out.println("内部类静态初始化块执行！");
		}*/

		//Error:原因 非静态内部类不能有静态声明，无论是静态初始快，还是静态属性、方法
		private static int count = 100;

		//Error: 非静态内部类不能有静态声明，无论是静态初始快，还是静态属性、方法
		public static void hello()
		{
		}

		private int id=1000;
		{
			System.out.println("内部类普通初始化块执行！");
		}
		public InnerClass()
		{
			System.out.println("内部类构造方法执行！");
		}

		public int getID()
		{
			eyecount = 128128;//外部类静态成员
			eyecount++;
			return count;//外部类中的count
		}

		
	}

	//外部类代码
   public InnerClass getInner()//如果内部类为private，则返回的InnerClass实例不能用来访问其属性或方法.尽管可以返回实例引用！
		{
			InnerClass inner = new InnerClass();
			System.out.println("外部类count="+inner.getID()+" ;外部类静态成员eyecount="+eyecount);
			System.out.println("OutterClass.eyecount(static)="+OutterClass.eyecount);
			
			return inner;
		}

     //外部类静态方法
     public static test()
    {
     new InnerClass();//Error : 外部类静态方法不能访问非静态内部类。就如静态方法不能访问非静态成员变量。
    }
}

//测试
class Test
{

    public static void main(String[] args) 
	{
		OutterClass outer = new OutterClass() ;
		System.out.println(outer.getInner());//OK
		//System.out.println(outer.getInner().getID());//错误。不能调用getID()，因为内部类为private，尽管可以返回实例
	}

}

package lesson8;
//外部类
class  OutterClass
{
	private int count=1008;
	private static int eyecount;

	//内部类
	private class InnerClass
	{
		/*static 非静态内部类不能有静态声明，无论是静态初始快，还是静态属性、方法
		{
			System.out.println("内部类静态初始化块执行！");
		}*/

		//Error:原因 非静态内部类不能有静态声明，无论是静态初始快，还是静态属性、方法
		//private static int count = 100;

		//Error: 非静态内部类不能有静态声明，无论是静态初始快，还是静态属性、方法
		/*public static void hello()
		{
		}*/
		
		public int innerID = 518;

		private int id=1000;
		{
			System.out.println("内部类普通初始化块执行！");
		}
		public InnerClass()
		{
			System.out.println("内部类构造方法执行！");
		}

		

		public int getID()
		{
			/*
			内部类可以直接访问外部类的成员变量（或方法），无论外部类成员变量（或方法）访问权限如何
			*/
			Hello();
			eyecount = 128128;//外部类静态成员
			eyecount++;
			return count;//外部类中的count

		}

		
	}


	//外部类代码
	private void Hello()
		{
			
			System.out.println("外部类 Hello！");
		}


   public InnerClass getInner()//如果内部类为private，则返回的InnerClass实例不能用来访问其属性或方法.尽管可以返回实例引用！
		{
			InnerClass inner = new InnerClass();

            /*
			外部类不能直接访问内部类的属性或方法，必须通过实例引用才可以访问。无论内部类成员变量（或方法）访问权限如何
			*/
			//innerID = 518518;//Error:必须通过实例引用才可使使用内部类变量或方法

			inner.innerID = 518518;//OK

			System.out.println("外部类count="+inner.getID()+" ;外部类静态成员eyecount="+eyecount);
			System.out.println("OutterClass.eyecount(static)="+OutterClass.eyecount);

			
			return inner;
		}
}

//测试类
class Test
{

    public static void main(String[] args) 
	{
		OutterClass outer = new OutterClass() ;
		System.out.println(outer.getInner());//OK
		//System.out.println(outer.getInner().getID());//错误。不能调用getID()，因为内部类为private，尽管可以返回实例
	}

}