将一个类的定义放到另一个类的定义内部,这就是内部类。
平凡内部类
平凡内部类就是最普通的内部类,没有static修饰类名,就像这样的类
public class Outer{
class Inner {}
}
普通内部类能访问其外部类的所有成员,拥有所有成员的访问权,而不需要任何特殊条件。这是如何做到的呢?弄白这一点很重要,普通内部类的很多特性都是由此而来。来看一段代码
class Outer {
//内部类
class Inner {
public void f() {
//查看此内部类的所有属性
Field[] fields = Inner.class.getDeclaredFields();
for(Field f : fields) {
System.out.println(f.getName());
}
}
}
}
Inner.f()方法是输出Inner类的所有属性名称,但是在Inner类中没有定义任何属性,那么执行f()方法的结果是什么呢?结果会打印:
this$0
也就是说在Inner类里有一个this$0的属性,通过名字就可以看出这是Java自动给Inner类添加的属性,使用javap反编译Inner.class,果然发现了一个final的this$0域
这就是问题的答案,内部类就是通过this$0来访问其外部类的成员,this$0就是用来保存创建该内部类对象的外部类对象。也就是说,当某个外部类对象创建了一个内部类对象时,内部类对象会拥有那个外部类对象的引用,就是this$0,在访问外部类的成员时,就是使用this$0实现的。所有的这一切都由编译器来处理。由此我们发现,内部类的对象必须依附某个外部类对象,于是平凡内部类的几个特性均可由此而得到解释:
(1)在内部类里面需要外部类的引用时,可以使用.thi语法,.this就是this$0属性,也就是创建该对象的外部类对象,如
public Outer outer {
return Outer.this;
}
(2)在外部类的非静态方法中可以直接创建内部类,但是在外部类的静态方法中则不行,如
//在外部类的非静态方法中可以直接创建
//因为必须要通过外围类的对象才可以调用非静态方法,内部类对象正是由这个外围类对象创建
public Inner getInner() {
Inner in = new Inner();
return in;
}
//错误,因为不需要外围类对象调用静态方法,没有外围类对象就不能创建内部类
public static Inner sgetInner() {
return new Inner();
}
只有外部类的对象才能创建平凡内部类的对象,这句话我们一定要记住。
(3)在外部类的静态方法或者其他类里面,需要使用外围类对象.new创建内部类对象,如
//需要外部类的对象调用.new语法来创建内部类对象,在其他类中也是如此
public static Inner sgetInner(Outer outer) {
Inner in = outer.new Inner();
return in;
}
(4)在平凡内部类不能有static修饰的东西,因为内部类需要依赖外部类对象。
static内部类(嵌套类)
使用static修饰的内部类叫做嵌套类,嵌套类的对象与外部类的对象之间没有联系,它的内部也不会保存对外部类对象的引用。嵌套类和普通的类没有什么分别,它只是置于外部类的命名空间。但是它到底是在外部类的内部,所以还是可以访问外部类的所有成员的,只不过需要一个显式的外部类对象
class Outer {
private String s;
//拥有外部类的私有成员的访问权限
static class SIn {
public void f(Outer outer) {
String ss = outer.s;
}
}
}
内部类可以作为接口的一部分,放在接口的内部类自动都是public static的,它可以作为所有实现该接口的公共代码,甚至可以在内部类实现外围接口
interface A{
//自动是public static
class B implements A{
公共代码
}
}
普通的Java类不可以使用private和pretected修饰,但是内部类可以。在其他类里使用某个类的内部类时,必须显式的使用外部类.内部类这种形式:Outer.Inner。
局部内部类
内部类不仅可以在类里面,还可以定义在方法和任意作用域内。这样做的理由:
(1)方法可以返回某接口,可以在方法内部定义一个类,该类实现了要返回的接口,创建该类的实例,并返回,这样对就对外界完全屏蔽了。
(2)为了解决一个复杂的问题,想创建一个类来辅助你的解决方案,但是又不希望这个类是公共可用的。
这些内部类的作用域跟普通变量一样,都是属于块作用域,出了作用域,它就没有意义了。
{
class Inner {}
//可以在这里创建
Inner in = new Inner();
}
//这里已经出了作用域了
Inner in = new Inner();//错误
关于匿名内部类
a.匿名内部类被自动转型为父类的引用,所以里面创建的方法如果超出了父类的接口,那是无法访问的,包括属性。匿名内部类可以看成是父类的“无名”子类,所以在创建匿名内部类的对象时,首先还是要创建父类的对象,根据父类构造器中参数的不同,来调用不同的父类构造器,当然了,父类的成员定义处的初始化,语句块的执行也是肯定会有的。
//父类
class Base {
{
System.out.println("父类的语句块");
}
Base(int x) {
System.out.println("调用执行父类的构造器:" + x);
}
public Base getBase(int x) {
//匿名内部类,自动调用父类的构造器
return new Base(x) {
//匿名内部类的语句块
{
System.out.println("匿名内部类的语句块");
}
//匿名内部类实现的自己的方法,根本没有任何用处
public void anoyMethod() {
System.out.println("匿名内部类实现的方法");
}
};
}
如果调用Base的getBase(1),则执行结果是:
父类的语句块
调用执行父类的构造器:1
匿名内部类的语句块
超出父类接口的anoyMethod()没有任何机会得到执行。
b.匿名内部类是没有名字呢,怎么创建它的构造器呢?
通过上面的示例,我们可以看到,通过非静态语句块可以达到这个效果,非静态语句块就是匿名内部类的构造器,只是语句块不能重载。
c.传递到匿名内部类的参数和局部变量,必须得是final的;回顾一下:非静态内部类,必须要保存一个外部类的引用。匿名内部类也是内部类,也可以无条件的访问外部类的成员变量,也可以使用.this语句,所以在匿名内部类中使用外部类的成员属性是没有任何限制的,外部类的成员属性不需要是final的。
class Outer {
private String name = "cxy";
//注意label和age都是final,而name则无所谓
public Base getBase(final String label) {
final int age = 25;
return new Base() {
{
System.out.println("label: " + label + ",name: " + name + ",age: " + age);
//使用.this语法
System.out.println(Outer.this.getClass().getName());
}
} ;
}
}
d.匿名内部类和工厂方法结合,会产生非常优美的代码,不需要为每个子类额外的添加一个工厂类,而是在子类内部使用一个匿名内部类代替
//业务接口
interface Service {
定义业务方法
}
//工厂接口,返回逻辑类的实例
interface ServiceFactory {
Service getService();
}
//看看使用了匿名内部类的工厂方法
class ServiceImp implements Service {
实现逻辑
//使用内部类完全就不需要对应的工厂类了,这让类的接口瞬间清晰了很多
public static ServiceFactor factory = new ServiceFactory() {
public Service getService() {
return new ServiceImp();
}
};
}
使用匿名内部类确实可以让工厂方法变得相当优雅,可以减少一半的类
内部类的命名规则
内部类也会生成.class文件,即使是匿名内部类。内部类有自己的一套命名规则,有时候在看反编译出来的代码时或许会用到。最基本的是在外部类的后面加上$,然后紧接内部类的名称。一例胜千言
public class NamedInnderClass {
//静态内部类:NamedInnderClass$StaticInner
static class StaticInner {
//嵌套在内部类中:NamedInnderClass$StaticInner$StaticInnerInner
static class StaticInnerInner {}
}
//普通内部类:NamedInnderClass$InnerClass
class InnerClass { }
//方法内部的类
public void f() {
//NamedInnderClass$1MethodInnder,注意加上了一个数字,数字是递增的
class MethodInner { }
//NamedInnderClass$1,匿名内部类,直接加数字,数字递增
new NamedInnderClass() { };
}
}
内部类还是有些复杂,基本的使用方法上面都做了介绍,但是为什么要使用内部类呢?使用内部类最吸引人的原因是:每个内部类都能独立地继承一个实现(类或者接口),不管外部类是否继承了某个实现,对内部类都不会影响。从这个角度看,内部类使得多重继承的解决方案更加完整。
class A{}
abstract class B{}
class C extends A {
//使用内部类实现"多重继承"
B makeB() {
return new B() {};
}
}
转载请注明出处:喻红叶《Java中的内部类》
分享到:
相关推荐
Java 内部类 实例化 在Outer类的静态方法中实例化内部类 在同一个包的其它类中实例化Outer类中的内部类
java中内部类的分类及用法.pdf
java中内部类的使用.doc
在java语言中,有一种类叫做内部类(inner class),也称为嵌入类(nested class),它是定义在其他类的内部。
java中内部类与外部类的学习资料.docx
JAVA从JDK1.1开始引入了内部类,可以参见代码,感觉好处就是设计类的时候可以偷懒,呵呵。主要是可以引用类的内部其他元素,差不多是把这个内部类当成原类的元素。还有可以隐藏类的一些设计细节,好处还是很多的。
java 匿名内部类的使用规范 java 匿名内部类的使用规范 java 匿名内部类的使用规范
14.java局部内部类(方法中类).zip14.java局部内部类(方法中类).zip14.java局部内部类(方法中类).zip14.java局部内部类(方法中类).zip14.java局部内部类(方法中类).zip14.java局部内部类(方法中类).zip14...
Java 接口 内部类Java 接口 内部类Java 接口 内部类
16.java匿名内部类.zip16.java匿名内部类.zip16.java匿名内部类.zip16.java匿名内部类.zip16.java匿名内部类.zip16.java匿名内部类.zip16.java匿名内部类.zip16.java匿名内部类.zip16.java匿名内部类.zip16.java匿名...
java 局部内部类的使用规范 java 局部内部类的使用规范
Java内部类Java内部类Java内部类Java内部类Java内部类Java内部类Java内部类
主要讲述了JAVA中内部类和匿名内部类的相关问题。
java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用java 内部类应用
java 成员内部类的使用规范 java 成员内部类的使用规范
15.java静态内部类(相当于外部类).zip15.java静态内部类(相当于外部类).zip15.java静态内部类(相当于外部类).zip15.java静态内部类(相当于外部类).zip15.java静态内部类(相当于外部类).zip15.java静态内部...
Java内部类是Java言语的一个很重要的概念,《Java编程思想》花了很大的篇幅来讲述这个概念。但是我们在实践中很少用到它,虽然我们在很多时候会被动的使用到它,但它仍然像一个幕后英雄一样,不为我们所知,不为我们...
java内部类详解
12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类.zip12.java内部类...