Error message here!

Hide Error message here!

忘记密码?

Error message here!

请输入正确邮箱

Hide Error message here!

密码丢失?请输入您的电子邮件地址。您将收到一个重设密码链接。

Error message here!

返回登录

Close

Java——内部类

SakuraOne 2019-02-21 18:19:00 阅读数:185 评论数:0 点赞数:0 收藏数:0

前言

将一个类的定义放在另外一个类定义的内部,里面的就叫做内部类。内部类是一种非常有用的特性,它允许你把一些逻辑相关的类组织在一起,并控制内部的类的可视性。内部类看起来像是一种代码隐藏机制:将类的实现定义在了其他类中。但是,内部类的优点远不止于此,它可以访问外围类的任何成员并与之通信、让一个类实现多继承等。本篇博客先介绍内部类的基础语法,然后介绍内部类的一些特性。

内部类的创建及使用

public class Parcel {
//内部类
class Contents{
private int i = 1;
public int value() {return i;}
}
//内部类
class Destination{
private String label;
Destination(String whereTo){
label = whereTo;
}
String readLabel() {return label;}
}
public void ship(String dest) {
Contents c = new Contents();
Destination d = new Destination(dest);
System.out.println(d.readLabel());
}
//获取内部类对象
public Contents contents() {return new Contents();}
public Destination to(String dest) {return new Destination(dest);}
public static void main(String[] args) {
Parcel p = new Parcel();
p.ship("Bermuda");
//获取内部类对象
Parcel.Contents c = p.contents();
Parcel.Destination d = p.to("Borneo");
}
}
/*
output:
Bermuda
*/

若是想在除外围类的非静态方法之外的其他位置创建内部类对象,就需要具体指明这个对象的类型:OuterClassName.InnerClassName

内部类访问外围类

当生成一个内部类对象时,此对象与制造它的外围类对象之间就有了某种联系,它可以访问外围类对象的所有成员,而不需要任何特殊权限。此外,内部类还拥有外围类的所有元素的访问权限

interface Selector{
boolean end();
Object current();
void next();
}
public class Sequence {
private Object[] items;
private int next = 0;
public Sequence(int size) {items = new Object[size];}
public void add(Object x) {
if(next < items.length) {
items[next++] = x;
}
}
//一个迭代器的实现
private class SequenceSelector implements Selector{
private int i = 0;
//访问外围类中的数组
public boolean end() {return i == items.length;} //检查是否到了末尾
public Object current() {return items[i];} //返回当前对象
public void next() {if(i < items.length) i++;} //移到序列中的下一个
}
public Selector selector() {return new SequenceSelector();}
public static void main(String[] args) {
Sequence sequence = new Sequence(10);
for(int i=0; i<10; i++)
sequence.add(Integer.toString(i));
//获取一个内部类对象
Selector selector = sequence.selector();
while(!selector.end()) {
System.out.print(selector.current() + " ");
selector.next();
}
}
}
/*
output:
0 1 2 3 4 5 6 7 8 9
*/

上面的例子是一个迭代器设计模式的例子,从例子中可以看出,内部类是可以访问到外围类的数据成员。当然内部类也是可以访问外围类的方法的,就像自己拥有它们,会使编程十分便利。

那么,内部类自动拥有对外围类所有成员的访问权限这是如何实现的呢?

当某个外围类对象创建了一个内部类对象时,此内部类对象必定会秘密地捕获一个指向那个外围类对象的引用。然后,在你访问此外围类的成员时,就是使用那个引用来选择外围类的成员。这些实现,编译器会处理,我们需要注意的就是:内部类的对象只有在与其外围类对象相关联的情况下才能被创建(此时的内部类是非static的)

需要注意:一个内部类被嵌套多少层不重要,它仍旧可以透明地访问所有它所嵌入的外围类的所有成员。

使用.this和.new

前面我们获取内部类对象时,是使用外围类对象调用它的创建内部类的方法,那么有没有其他方式来创建内部类对象呢?还是有的。使用.new语法。举例如下,没有任何实际意义。

class A{
class B{
// ...
}
//...
public static void main(String args[]){
A a = new A();
A.B b = a.new B(); //错误的做法是 A.B b = new B();
}
}

我们必须使用外部类对象来创建内部类对象,这样也解决了内部类名字作用域问题,不必去声明a.new A.B(),但是需要注意a.new A.B()是错误的。最简单的理由便是内部类对象不能获取到外部类对象的引用。若是创建的是静态内部类,则不需要对外部类对象的引用,后面会介绍静态内部类。

关于.this的使用,是用于生成对外部类对象的引用:外部类的名字后面紧跟圆点和this。这样产生的引用自动地拥有正确的类型,这一点在编译期便可以被知晓并受到检查,因此没有任何运行时开销。

class A{
public void f(){
//...
}
class B{
public A getA(){
return A.this;
}
}
public static void main(String args[]){
A a = new A();
A.B b = a.new B();
b.getA().f();
}
}

private内部类

继续以前面的内部类访问外部类的代码说明。SequenceSelector是private的,在外部不能直接被创建,于是在Sequence中使用了一个创建方法获取该类对象。使用接口Selector引用指向该内部类对象操纵其内部方法。我们可以看出,在外部我们只是使用接口引用去操作,对内部类的具体实现是一无所知,甚至内部类的名称我们也不知道。这真的是很方便的隐藏了实现细节。private内部类给类的设计者提供了一种途径,通过这种方式可以完全阻止任何依赖于类型的编码,并且完全隐藏了实现的细节。

以上介绍了内部类的基本使用,看起来和使用普通的类并无两样,但是这只是内部类的简单使用,下面介绍内部类中的一些复杂的技术。

在方法和作用域内的内部类

不仅可以在类里面定义内部类,也可以在一个方法或者任意的作用域内定义内部类。

在方法的作用域内创建一个完整的类叫做局部内部类

class A{
int i = 0;
public void fun(){
class B{
i = 10; //可以访问外围类的成员
//...
}
}
//...
}

在任意作用域内嵌入一个内部类

class A{
public void fun(boolean b){
if(b){
class B{
...
}
//...
}
}
//...
}

B类被嵌入在if语句的作用域中,不是说明该类的创建时由条件的。其实,B类与其他类都一同编译过了,只是它将在if这个作用域内使用。

匿名内部类

interface Destination{
String readLabel();
}
interface Contents{
int value();
}


public class Parcel2 {
public Contents contents() {
//创建匿名内部类
return new Contents() {
private int i = 1;
@Override
public int value() { return i;}
};
}
public static void main(String[] args) {
Parcel2 p2 = new Parcel2();
Contents c = p2.contents();
}
}

contents()方法将返回值的创建与表示这个返回值的类的定义结合在了一起,并且这个类是匿名没有名字。这种语法指出的是:创建一个继承自Contents的匿名内部类的对象。通过new表达式返回的引用被自动向上转型为对Contents的引用。上述匿名内部类的语法是下述形式的简化:

public class Parcel2b{
class MyContents implements Contents{
private int i = 1;
public int value() { return i; }
}
public Contents contents() { return new MyContents();}
public static void main(String[] args) {
Parcel2b p2b = new Parcel2b();
Contents c = p2b.contents();
}
}

在匿名内部类中使用的是默认构造器生成Contents。但是,若基类需要一个有参数的构造器怎么办?

public class Wrapping {
private int i;
public Wrapping(int ii) { i = ii;}
public int value() {return i;}
}

使用普通的具体类作为基类。

public class Parcel3 {
public Wrapping wrapping(int ii) {
//将参数传给基类带参数的构造器
return new Wrapping(ii) {
@Override
public int value() {
return super.value() * 31;
}
};
}
public static void main(String[] args) {
Parcel3 p = new Parcel3();
Wrapping w = p.wrapping(21);
}
}

若是基类构造器带参数,则简单地将合适的参数传递给基类的构造器即可。在匿名内部类末尾的分号不是用来标记内部类结束标志的。实际上,是表达式的结束。

为匿名内部类创建一个构造器

在匿名内部类中定义字段时,可以使用形参为其进行初始化,但是使用的参数引用必须使用final修饰。

class A{
public void fun(final String str){
return new Destination(){
private String label = str;
public String readLabel { return label;}
}
}
}

我们可以使用此方法为匿名内部类中的字段进行初始化,那么有没有可能为匿名内部类创建一个构造器,使用构造器为字段进行初始化呢?我们要知道,匿名类是没有名字的,所以不可能创建一个有名字的构造器。但是,我们可以通过实例初始化的方式,达到构造器的效果

abstract class Base{
public Base(int i) {
System.out.println("Base 构造器, i="+i);
}
public abstract void f();
}
public class AnonymousConstructor {
//变量i不要是final的,因为是给匿名内部类的基类使用,不会再匿名内部类的内部直接被使用
public static Base getBase(int i) {
return new Base(i) {
//实现构造器效果
{
System.out.println("内部类初始化");
}
@Override
public void f() {
System.out.println("匿名内部类f()");
}
};
}
public static void main(String[] args) {
Base base = getBase(31);
base.f();
}
}
/*
output:
Base 构造器, i=31
内部类初始化
匿名内部类f()
*/

对于匿名内部类而言,实例初始化的效果就是构造器。这也受到了限制,不能重载实例初始化方法。匿名内部类与正常的类的继承也有一些限制:匿名内部类可以扩展类也可以实现接口,但是一次只能选一个

使用匿名内部类实现工厂方法

使用匿名内部类改善上篇博客中的工厂方法的模板。

interface Service{
void method1();
void method2();
}
interface ServiceFactory{
Service getService();
}
class Implementation1 implements Service{
Implementation1(){}
public void method1(){System.out.println("Implementation1 method1");}
public void method2(){System.out.println("Implementation1 method2");}
//使用匿名内部类
public static ServiceFactory factory = new ServiceFactory() {
@Override
public Service getService() {
return new Implementation1();
}
};
}
class Implementation2 implements Service{
Implementation2(){}
public void method1(){System.out.println("Implementation2 method1");}
public void method2(){System.out.println("Implementation2 method2");}
public static ServiceFactory factory = new ServiceFactory() {
@Override
public Service getService() {
return new Implementation2();
}
};
}
public class Factories{
public static void serviceConsumer(ServiceFactory fact){
Service s = fact.getService();
s.method1();
s.method2();
}
public static void main(String args[]){
serviceConsumer(Implementation1.factory);
serviceConsumer(Implementation2.factory);
}
}
/*
output:
Implementation1 method1
Implementation1 method2
Implementation2 method1
Implementation2 method2
*/

嵌套类

如果需要内部类对象与其外围类对象之间有联系,那么就可以将内部类声明为static。这通常称为嵌套类

嵌套类与普通内部类的不同在于:

  • 创建嵌套类对象不需要外围类对象。嵌套类对象没有外围类对象的隐式引用。
  • 不能从嵌套类对象访问非静态的外围类对象。

普通的内部类不能含有static数据和static方法,也不可以包含嵌套类。但是嵌套类可以包含这些东西。

public class Parcel4 {
//嵌套类
public static class PContents implements Contents{
private int i = 1;
public int value() {return i;}
}
//嵌套类
protected static class PDestination implements Destination{
private String label;
private PDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {return label;}
//包含其他的嵌套类
public static void f() {}
static int x = 10;
static class AnotherLevel{
public static void f() {}
static int x = 10;
}
}
public static Destination destination(String s) { return new PDestination(s);}
public static Contents contents() {return new PContents();}
public static void main(String[] args) {
Contents c = contents();
Destination d = destination("Bermuda");
}
}

接口内的类

正常情况下,不能在接口中防止任何代码,但是嵌套类可以是接口的一部分。放置到接口中的任何类自动的都是public和static的。可以在接口的内部类中实现该外围接口。

public interface ClassInInterface {
void howdy();
//内部类实现外围接口
class Test implements ClassInInterface{
public void howdy() { System.out.println("Howdy!"); }
}
public static void main(String[] args) {
new Test().howdy();
}
}
/*
output:
Howdy!
*/

为什么需要内部类

使用内部类最吸引人的原因在于:

每个内部类都能独立地继承自一个接口的实现,无论外围类是否已经继承了某个接口的实现,对于内部类都没有影响。

内部类可以提供继承多个具体或抽象类的能力,使得一个类可以实现多继承。前面交给接口也实现了类的多继承问题,而内部类更有效地实现了“多重继承”。一个类可以使用内部类可以继承多个非接口类型(具体类或者抽象类)。如果拥有的是抽象类或具体类,而不是接口,那么只能使用内部类才能实现多重继承。

内部类除了可以解决“多重继承”,还有一些其他特性:

  • 内部类可以有多个实例,每个实例都有自己的状态信息,与外围类对象的信息相互独立。
  • 在单个外围类中,可以让多个内部类以不同的方式实现同一个接口,或者继承同一个类。
  • 内部类没有令人迷惑的“is-a”关系,它就是一个独立的实体。

内部类的继承

内部类对象会隐式拥有外部类对象的引用,但是内部类的导出类却不会隐式拥有外部类的引用,所以需要在导出类的构造器中显式传递外部类的引用。

class Outer{
class Inner{}
}
public class InheritInner extends Outer.Inner{
public InheritInner(Outer o) {
//使用enclosingClassReference.super()语法提供必要的引用
o.super();
}
public static void main(String[] args) {
Outer outer = new Outer();
InheritInner ii = new InheritInner(outer);
}
}

内部类可以被覆盖吗?

如果创建了一个内部类,然后继承其外围类并又定义了一个与此内部类同名的内部类,会覆盖掉原来的内部类吗?答案是不会的。两个内部类是完全独立的两个实体,在自己的命名空间内。

内部类标识符

每个类都会产生一个.class文件,其中包含了如何创建该类型的对象的全部信息(此信息产生一个“meta-class”,叫做Class对象),当然,内部类也会生成一个.class文件已包含它们的Class对象信息。这些文件的命名有严格的规则:外围类的名字,加上$,在加上内部的名字。若内部类是匿名的,编译器则会简单地产生一个数组作为其标识符

如下代码生成的.class文件为

class A{
class B{}
}
class C{}
class D{
public C getC() {
return new C() {
};
}
public static class E{}
}
public class ClassFile {
public static void main(String[] args) {
new D().getC();
}
}

小结

本篇博文主要讲了内部类的定义以及一些特殊的用途,其实在Java的GUI编程中也经常使用内部类,博主没有过多介绍,感兴趣的看官可以去搜搜了解。内部类的如何使用,还是要根据实际的设计情况去安排,先了解有这些用法,用时再取也不迟。不再做过多总结了,有问题的地方望各位看官指出。

参考:

《Java编程思想》第四版

版权声明
本文为[SakuraOne]所创,转载请带上原文链接,感谢
https://www.cnblogs.com/myworld7/p/10414401.html

编程之旅,人生之路,不止于编程,还有诗和远方。
阅代码原理,看框架知识,学企业实践;
赏诗词,读日记,踏人生之路,观世界之行;