Java 内部类浅析
内部类
内部类是指在一个外部类的内部再定义一个类，是一个编译时的概念，一旦编译成功，内部类与其外部类就会成为完全不同的两类，只是内部类的前面会冠以外部类的类名和$符号，如一个outer类内部定义了一个inner的内部类，那么编译完成后会生成outer.class和outer$inner.class两个类，因此内部类的成员变量与方法可以与外部类相同。
从内部类的定义上来看，其实内部类严重破坏了良好的代码结构，那么为什么还要使用内部类呢？因为内部类可以随意使用外部类的成员变量（包括私有的）而不用生成外部类对象，这也是内部类的唯一优点。
内部类的分类及示例
内部类分为成员内部类、局部内部类、静态内部类和匿名内部类。下面针对各个内部类进行介绍：
成员内部类
作为外部类的一个成员存在，与外部类的属性、方法并列。成员内部类中可以访问外部类的所有成员，当外部类的变量与内部类的变量名重复时，使用外部类名.this.变量名可以对外部类的变量进行调用，如果没有重复时可直接使用变量名进行调用。在普通外部类方法中访问静态内部类可new出成员内部类对象进而直接调用其中的方法，而在静态外部类方法中需要先new出外部类对象，再调用外部类对象名.new 内部类的方式来获得成员内部类对象。
成员内部类中不能定义静态变量，因为成员内部类需要先创建了外部类，才能创建它自己的。
成员内部类可以使用外部类的私有成员和属性，同时其在外部类中定义了不可访问的属性，这样就在外部类中实现了比外部类的private还要小的访问权限。
示例代码如下：
/**
*
* @ClassName: MemberInnerClass
* @Description: 成员内部类
* @author ADAM
* @date 2014年7月25日 上午9:20:28
*
*/
public class MemberInnerClass {
private int i = 0;
public class Inner {// 成员内部类可加权限修饰符
int i = 3;
public void print() {
System.out.println(i);// 输出为内部类的i，值为3
System.out.println(this.i);// 输出为内部类的i，值为3
System.out.println(MemberInnerClass.this.i);// 输出外部类的i，值为0
}
}
public void print() {
(new Inner()).print();// 外部类普通方法调用成员内部类直接new出内部类进行调用
}
public static void main(String[] args) {
((new MemberInnerClass()).new Inner()).print();// 外部类静态方法中调用成员内部类首先new出外部类然后new出内部类进行调用
}
}
局部内部类
即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。局部内部类中不可定义静态变量，可以访问外部类（即方法）中的变量，但是变量必须是final。局部内部类与外部类的命名重名时的调用方法与成员内部类相同，访问局部内部类必须得先有外部类对象。
在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。要想使用局部内部类时需要生成外部类对象，对象再去调用方法，在方法中才能调用其局部内部内。通过内部类与接口达到了一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。
示例代码如下：
/**
*
* @ClassName: LocalInnerClass
* @Description: 局部内部类
* @author ADAM
* @date 2014年7月25日 上午10:36:26
*
*/
public class LocalInnerClass {
private int j = 3;
private int i = 2;
public void test() {
MemberInnerClass memberInnerClass = new MemberInnerClass();
// 若要访问其他类中的成员内部类只能当该成员内部类的修饰符为public才可
// 否则编译错误，即成员内部类可以再类内部实现比private还要小的权限
memberInnerClass.new Inner();
final int i = 0;
class Inner {// 此处不得加上private等修饰符，否则编译错误
int i = 1;
public void print() {
System.out.println(j);饰符，否则编译错误
System.out.println(i);// 此时输出局部内部类的i,外部方法中的变量只能通过传参的形式进行调用
System.out.println(LocalInnerClass.this.i);// 此时输出的是外部类中的i
}
}
Inner inner = new Inner();// 局部内部类只能在方法内实例化并进行调用
inner.print();
}
public static void main(String[] args) {
(new LocalInnerClass()).test();
}
}
public class Parcel4 {
public Destination destination(String s) {
class PDestination implements Destination {
private String label;
private PDestination(String whereTo) {
label = whereTo;
}
public String readLabel() {
return label;
}
}
return new PDestination(s);
}
public static void main(String[] args) {
Parcel4 p = new Parcel4();
Destination d = p.destination("Tasmania");
}
}
public class Parcel5 {
private void internalTracking(boolean b) {
if (b) {
class TrackingSlip {
private String id;
TrackingSlip(String s) {
id = s;
}
String getSlip() {
return id;
}
}
TrackingSlip ts = new TrackingSlip("slip");
String s = ts.getSlip();
}
}
public void track() {
internalTracking(true);
}
public static void main(String[] args) {
Parcel5 p = new Parcel5();
p.track();
}
}
/**
*
* @ClassName: StaticInnerClass
* @Description: 静态内部类
* @author ADAM
* @date 2014年7月25日 上午10:37:04
*
*/
public class StaticInnerClass {
private int i = 1;
public static int j = 1;
public int k = 0;
public static class Inner {
private int i = 0;
private static int j = 0;// 可定义静态与非静态成员
public static void print() {
// System.out.println(k);// 编译错误，不得调用外部类中的非静态成员
System.out.println(new StaticInnerClass().i);//访问外部类中的非静态成员变量需要先实例化外部类
System.out.println(j);
System.out.println(new StaticInnerClass().j);// 静态内部类使用外部类中的静态成员
}
}
public static void main(String[] args) {
Inner.print();// 外部类静态方法或者非静态方法调用静态内部类中的静态成员时直接内部类名.成员即可
StaticInnerClass.Inner inner = new StaticInnerClass.Inner();// 静态内部类的实例化不需要先实例化外部类
System.out.println(inner.i);// 访问静态内部类中的非静态成员时需要先实例化静态内部类
}
}
/**
*
* @ClassName: Pencil
* @Description: 笔类
* @author ADAM
* @date 2014年7月25日 上午10:42:59
*
*/
public abstract class Pencil {
public abstract void write();
}
/**
*
* @ClassName: Eraser
* @Description: 橡皮擦类
* @author ADAM
* @date 2014年7月25日 上午10:43:28
*
*/
public abstract class Eraser {
public abstract void erase();
}
/**
*
* @ClassName: PencilWithEraser
* @Description: 多继承类
* @author ADAM
* @date 2014年7月25日 上午10:43:53
*
*/
public class PencilWithEraser {
private MyPencil pencil = new MyPencil();
private MyEraser eraser = new MyEraser();
private class MyPencil extends Pencil {//继承笔类
@Override
public void write() {
System.out.println("To Write");
}
}
private class MyEraser extends Eraser {//继承橡皮擦类
@Override
public void erase() {
System.out.println("To Erase");
}
}
// 本类自己的方法，调用继承类中的方法
public void write() {
pencil.write();
}
public void erase() {
eraser.erase();
}
public static void main(String[] args) {
PencilWithEraser pencilWithEraser = new PencilWithEraser();
pencilWithEraser.write();
pencilWithEraser.erase();
}
}
/**
*
* @ClassName: AnonymousInnerClass
* @Description: 匿名内部类
* @author ADAM
* @date 2014年7月25日 上午10:38:25
*
*/
public class AnonymousInnerClass {
public void click(OnClickListener onClickListener) {
System.out.println("click,click");
}
public static void main(String[] args) {
AnonymousInnerClass anonymousInnerClass = new AnonymousInnerClass();
anonymousInnerClass.click(new OnClickListener() {// 直接new出匿名内部类，不需要保存对象，一般用于继承其他类或是实现接口
@Override
public void onClick() {
System.out.println("Inner Click");
}
});
}
}
本博客所有文章除特别声明外，均采用 CC BY-NC-SA 4.0 许可协议。转载请注明来自 gezilinLL！
评论
