JAVA内部类的定义与使用

 

内部类的定义；

              在一个类中进行其他类结构的嵌套；

内部类的优点；

            （1）内部类和外部类可以互相访问彼此的私有域；

            （2）内部类可以实现Java的单继承局限；

            （3）内部类可以对同一包中的其他类隐藏；仅供外部类使用（保护性）

  缺点：

               结构复杂；

class Outer {
	private String msg = "Hello World";       //外部类的私有属性

	 class Inner {                      //定义一个内部类
		public void print() {
			System.out.println(msg);
		}
	}

	public void fun() {                      //创建一个public方法；供外部使用
		Inner in = new Inner();
		in.print();
	}
}
public class Test {
	public static void main(String[] args) {
		Outer out=new Outer();
		//System.out.println(out.msg);      //错误！！在类的外部无法调用其私有属性
		out.fun();                          //但是通过内部类可以间接访问其私有属性
				
	}
}

 

内部类与外部类的关系：

               1：对于非静态内部类而言；内部类的创建需要倚赖外部类的实例化对象；在没有外部类对象之前

                               是无法创建内部类的；

               2：内部类是一个相对独立的个体；与外部类不是 is - a 的关系

               3：内部类可以访问外部类的元素；（包括私有域） ，但是外部类不可以直接访问内部类元素；需要通过

                               内部类的引用间接访问；

 

创建内部类对象的语法：（在外部类之外）

               1；创建非静态内部类对象：

                                                    外部类.内部类 内部类引用=new 外部类（）.new 内部类（）；

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

class Outer {
	private String msg = "Hello World";       //外部类的私有属性

	 class Inner {                            //创建一个非静态内部类
		public void print() {
			System.out.println(msg);
		}
	}	 		 	
}
public class Test {
	public static void main(String[] args) {
		Outer.Inner in=new Outer().new Inner();  //创建内部类的实例化对象
		   in.print();
	}	
}

               

               2：创建静态内部类

                                                  外部类.内部类  内部类引用 = new 外部类. 内部类（）；

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

class Outer {
	private static String msg = "Hello World";       //外部类的私有属性

	static class Inner {                            //创建一个静态内部类
		public void print() {
			System.out.println(msg);
		}
	}	 		 	
}
public class Test {
	public static void main(String[] args) {
		Outer.Inner in=new Outer.Inner();  //创建内部类的实例化对象
		   in.print();
	}	
}

 

内部类的分类：

        （1）成员内部类（普通内部类）- -成员方法

                                a: 成员内部类不能存在任何  static  变量方法；可以访问外部类的静态域

                                b: 成员内部类需要依附外部类 new Outter().new Inner();

                                c: 内部类可以使用 private 封装；表示私有内部类；该内部类仅供外部类使用

 

        （2）静态内部类--静态方法

                                静态内部类的创建不需要外部类；可以直接创建

                                静态内部类不可以访问外部类的任何非 static 域

                                静态内部类可以拥有成员变量；

                      

 

        （3）方法内部类（在方法内部定义的类）（类比成员内部类）

                                方法内部类不能使用任何访问权限修饰符；（public  private  prodetcted  都不允许)

                                方法内部类对外（方法外）完全隐藏；除了该方法外可以访问外；其余地方均不得访问；

                                方法内部类想要使用方法形参；该形参必须使用final声明（系统自动产生和隐藏）；

                                               

class Outer {
	private  String msg = "Hello World";    // 外部类的私有属性

	public void fun() {
		
		class Inner {                       // 创建一个方法内部类
			public void print() {
				System.out.println(msg);
			}
		}
		new Inner().print();                //产生内部类对象并且调用方法
	}
}

public class Test {
	public static void main(String[] args) {
		Outer out = new Outer();
		out.fun();
	}
}

                   

 

        （4）匿名内部类（方法内部类的特殊版本  ）

                                 new 接口名（）｛｝；

                                 具有方法内部类的所有特征；

                                 匿名内部类必须继承一个抽象类或者实现一个接口

                                 匿名内部类没有构造方法；因为它没有类名；