欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

java中内部类的使用

程序员文章站 2022-07-12 11:07:02
...
1.定义

 

内部类是指在一个外部类的内部在定义一个类.内部类作为外部类的一个成员,并且依附于外部类而存在的.内部类可为静态,可用protected和private修饰(外部类只能是public和缺省的包访问权限).内部类主要有以下几种:成员内部类,局部内部类,静态内部类,匿名内部类.

 

2.为什么需要内部类

 

典型情况是:内部类继承自某个类或实现某个接口,内部类的代码操作创建其外部类的对象.所以你可以认为内部类提供了某种进入其外部类的窗口.使用内部类最吸引人的原因是:每个内部类都能独立的继承自接口的一个实现,无论外部类是否已经继承了这个实现对于内部类都没有影响.如果没有内部类提供的可以继承多个具体的或抽象的类的能力,一些设计与编程问题很难解决.从这个角度看,内部类是的多重继承的解决方案变得完整:接口解决了部分问题,内部类有效的实现了"多继承".

 

3.成员内部类

 

作为外部类的一个成员存在,与外部类的属性和方法并列:
>>在外部类访问内部类时,需创建一个内部类的对象.
>>每一个内部类的对象都会链接到一个外部类的对象(除非是一个静态内部类,下面会说到).
>>在内部类中,可以访问所有外部类的成员,但自身不能定义静态成员.
>>在内部类中,可以定义与外部类相同名称的实例变量,在内部类访问自己的变量和与外部类的非同名变量可以直接使用;访问外部类的同名变量时,通过"外部类名.this.变量名"使用.
>>内部类是一个编译时的概念,一旦编译成功,会成为完全不同的两类.本例中编译完成后会出现Outer3.class和Outer3$Inner3.class两个文件.
例:

public class Outer3 {
	private static int i = 10;
	private int j = 20;
	private int k = 30;

	public static void outer_method1() {

	}

	public void outer_method2() {

	}

	class Inner3 {
		// static int inner_i;
		private int inner_j = 200;
		private int k = 300;

		public void inner_method() {
			System.out.println(inner_j);
			System.out.println(this.k);
			System.out.println(Outer3.this.k);
			System.out.println(j);
			outer_method1();
			outer_method2();
		}
	}

	public void outer_method3() {
		this.new Inner3().inner_method();
	}

	public static void outer_method4() {
		Outer3 outer = new Outer3();
		Inner3 inner = outer.new Inner3();
		inner.inner_method();
	}

	public static void main(String[] args) {
		outer_method4();
	}
}

 

 

4.局部内部类

 

在方法中定义的内部类,与局部变量类似.除了有和成员内部类一样的特性外:
>>局部内部类不能有访问修饰符,因为它不是外部类的一部分.
>>可以访问作用域内的变量,但是在访问时隐式的将变量当做final处理.
例:

public class Outer4 {

	public void outer_method() {
		int i = 10;
		// i++;
	
		class Inner4 {
			void inner_method() {
				System.out.println(i);
			}
		}
	}
}

 

 

5.静态内部类

 

如果不需要内部来的对象与外部类的对象之间有联系,可以将内部类声明为static.非静态内部类对象都隐含的保存了一个引用,指向外部类的对象,但是静态内部类就不是这样了:
>>可以直接通过外部类创建内部类的对象.
>>不能在内部类的对象中访问非静态的外部类对象.
>>内部类可以定义静态和非静态成员.
>>内部类无法访问外部类的非静态成员.
例:

public class Outer5 {

	private static int i = 10;
	private int j = 20;
	private int k = 30;

	public static void outer_method1() {

	}

	public void outer_method2() {

	}

	static class Inner5 {
		private static int inner_i;
		private int inner_j = 200;
		private int k = 300;

		public void inner_method() {
			System.out.println(inner_j);
			System.out.println(k);
			// System.out.println(j);
			outer_method1();
			// outer_method2();
		}
	}

	public void outer_method3() {
		System.out.println(new Inner5().inner_j);
	}

	public static void outer_method4() {
		new Inner5().inner_method();
	}

	public static void main(String[] args) {
		outer_method4();
	}
}

 

6.匿名内部类

 

匿名内部类就是没有类名的内部类,一般适用的条件有:
>>只用到类的一个实例.
>>类在定义后马上用到.
>>类非常的小(推荐是4行代码以下).
>>给类命名并不会使你的代码更容易理解.
在使用匿名内部类时,需要记住的原则:
>>匿名类不能有构造方法.
>>匿名类内部不能定义任何静态成员(属性,方法,类).
>>匿名类不能是public,protected,private,static.
>>只能创建一个实例.
>>一定是在new关键字的后面,用其隐含实现一个接口或类.
>>其他内部类的特性.
例:

import java.util.List;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;

public class Outer6 {

	public static void main(String[] args) {
		List<String> name = Arrays.asList("James", "Kobe", "Yao");
		Collections.sort(name, new Comparator<String>() {
			public int compare(String s1, String s2) {
				return s1.compareTo(s2);
			}
		});
	}
}

 

静态方法Collections.sort接收一个list和一个Comparator作为输入参数,实现对输入的list中的元素进行比较并排序. 看上去我们直接new了一个Comparator,实际上是定义了一个实现Comparator的匿名类,通过new创建了这个匿名类的一个对象.在本例中编译成功后会出现Outer6$1.class文件,代表匿名类通过编译.

 

7.多层嵌套类

 

在多层嵌套类中,一个内部类被嵌套多少层并不重要,它能访问所有他所嵌入的外部类的成员(即使是private的).例:

public class Outer7 {
	private int i = 10;

	private void outer_method() {

	}

	class A {
		int j = 20;

		void a() {

		}

		class B {
			void b() {
				outer_method();
				a();
				System.out.println(i);
				System.out.println(j);
			}
		}
	}

	public static void main(String[] args) {
		new Outer7().new A().new B().b();
	}
}

 

8.内部类重载

 

如果创建了一个类,继承了外部类并重新定义了次内部类时,是否内部类会被重载呢?但是"重载"内部类好像它是外部类的一个方法,并不起什么作用.例:

public class Outer8 {
	private Inner inner;

	class Inner {
		public Inner() {
			System.out.println("Outer8.Inner()");
		}
	}

	public Outer8() {
		System.out.println("new Outer8()");
		inner = new Inner();
	}
}

 

public class SubOuter8 extends Outer8 {
	private Inner subinner;

	class Inner {
		public Inner() {
			System.out.println("SubOuter8.Inner()");
		}
	}

	public SubOuter8() {
		System.out.println("new SubOuter8()");
		subinner = new Inner();
	}

	public static void main(String[] args) {
		new SubOuter8();
	}
}

 

运行结果:
new Outer8()
Outer8.Inner()
new SubOuter8()
SubOuter8.Inner()

由此可见,当继承外部类的时候,内部类并没有什么特别的变化,这两个内部类完全是相对独立的两个实体,各自在自己的命名空间内.当然也可以明确的继承某个内部类.例:

public class Outer8 {
	private Inner inner;

	class Inner {
		public Inner() {
			System.out.println("Outer8.Inner()");
		}
	}

	public Outer8() {
		System.out.println("new Outer8()");
		inner = new Inner();
	}
}

 

public class SubOuter8 extends Outer8 {
	private Inner subinner;

	class Inner extends Outer8.Inner {
		public Inner() {
			System.out.println("SubOuter8.Inner()");
		}
	}

	public SubOuter8() {
		System.out.println("new SubOuter8()");
		subinner = new Inner();
	}

	public static void main(String[] args) {
		new SubOuter8();
	}
}

 

运行结果:
new Outer8()
Outer8.Inner()
new SubOuter8()
Outer8.Inner()
SubOuter8.Inner()

和前面的结果相比多输出了一个"Outer8.Inner()",说明子类的内部类在实例化时先创建了父类内部类的对象.

 

小结:不同环境下的内部类有着不同的特性,成员内部类与类的其他成员特性相似;局部内部类与局部变量特性相似;静态内部类与静态变量特性相似;匿名内部类经常在为了某个功能而实现某个接口时使用.同时内部类也是类的一种表现形式.