赵雅智_java 内部类

 内部类 

• 描述事物时，如果事物中包含事物，可使用内部类。例如：人体，心脏
• 内可直接访问外所以成员，包括privte，但外访内先建立对象。
  • 其他外访问：外.内 对象 = new 外().内();
  • 内static，方法不是：外.内().方法;
  • 都是static：new 外.内.方法;
• 声明：static、非static、private、protected、public及默认。

class EnclosingClass{
                    ……
             class ANestedClass{                            ……         }
}




 
 
编译之后，内部类也可产生单独的.class文件，文件名为：外部类名$内部类名.class
内部类实例

public class OuterClass {
          private int x=10;
          class InnerClass{
                   int y=20;
	     }
          public static void main (String[] args){
	              OuterClass oc=new OuterClass();
	              OuterClass.InnerClass ic=oc.new InnerClass();//内部类是外部类的一个成员，内部类对象不能单独存在，它必许依赖一个外部类对象
	              System.out.println("Outer:x="+oc.x);
	              System.out.println("InnerClass:y="+ic.y);	
          }
}
Outer：x = 10;




Inner：y = 20;



 
 
同一个包中，内部类可以隐藏起来（private）
局部内部类，通过OuterClass.this引用外部类实例，只能使用final常量
内部类可被定义为抽象类或接口，但必须被其他的内部类继承或实现






class Outer
{
	int y = 10;
	static class Inner
	{
		static int y = 5;
		//int y = 5;
		static public void fun(){
			int y = 3;
			System.out.println(y);        //3
		}
		/*public void fun(){
			int y = 3;
			System.out.println(y);//
			System.out.println(this.y);
			System.out.println(Outer.this.y);
		}*/
	}
	public void method(){
		Inner i = new Inner();
		i.fun();
		final int a = 7;
		class B
		{
			B(){
				System.out.println(a);
			}
		}
	}
}
class InnerTest 
{
	public static void main(String[] args) 
	{
		//Outer.Inner in = new Outer().new Inner();//普通
		//in.fun();
		//Outer o = new Outer();
		//o.method();

		//new Outer.Inner().fun();//静态类，成员访问方法
		Outer.Inner.fun();//静态类，方法，成员访问方法
	}
}
 静态内部类 



 
 
静态内部类没有父类，不能引用外部类实例成员或其他内部成员
权限修饰符：public、private、defaul
不能与外部类重名
局部静态类：声明中去掉static，将其定义植入其外部类的静态方法或静态初始化代码中
public class StaticInnerClass{
          private static class Student{
		int studID;
		String name;
		static int count;
		public Student(int id,String na){
			studID = id;
			name = na;
			count++;
		}
		public void printStuDetalis(){
			System.out.println("序号："+count+"学号："+studID+"姓名："+name);
		}
	}
	public static void main (String[] args){
		StaticInnerClass.Student stu1 = new StaticInnerClass.Student(1001,"Jones");
		stu1.printStuDetalis();
		StaticInnerClass.Student stu2 = new StaticInnerClass.Student(1002,"Smith");
		stu2.printStuDetalis();
		StaticInnerClass.Student stu3 = new StaticInnerClass.Student(1003,"Nace");
		stu3.printStuDetalis();
	}
}
序号：1 学号：1001姓名：Jones




序号：2 学号：1002姓名：Smith



序号：3 学号：1003姓名：Nace



匿名内部类


 
 
只用到类的一个实例
类在定义后马上用到
类非常小（推荐在4行代码以下）
给类命名并不会导致你的代码更容易被理解
前提：必须继承一个父类，或实现一个接口

new 父类构造方法名()|实现的接口名(){};



class 类名 implements ActionListener{
           public void actionPerformed(ActionEvent e){…}

}    

|
new ActionListener(){ public void actionPerformed(ActionEvent e){ … } };  

由于匿名内部类没有名称，因此创建匿名内部类对象时，new运算符后是超类或接口的名称，其后的{}内部为匿名类的定义（匿名类对象的创建和匿名类的声明是在一起的）。



 
 
匿名类不能是抽象类，因为系统在创建匿名类的时候，会立即创建匿名类的对象。因此不允许将匿名类定义成抽象类。
匿名类不能有构造方法，因为匿名类没有类名，无法定义构造方法，但匿名类可以定义实例初始化块，通过实例初始化块来完成构造方法需要完成的事情
匿名类不能定义任何静态成员、方法和类；
匿名类不能是public、protected、private、static；