16、Inner Class（内部类）

一、Note

1、意义

• 为了更好的封装

  • 为了实现更好的封装，普通类（非内部类）的访问修饰符不能为private或protected，而内部类可以。所以当我们将内部类声明为private时，就可对外隐藏内部类

• 使Java的多继承机制变得更加完善

• 每个内部类都能独立的继承或实现其他的类或接口，所以无论外部类是否已经继承或实现其他的类或接口，对于内部类都没有影响，内部类使得多继承的解决方案变得完整。

• 方便编写线程代码

• 方便编写事件驱动程序

• 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏

2、分类

2.1、按照是否是成员来划分

（按照是否在类体括号中声明来划分）

• Nested Classes（嵌套类）

  • 静态嵌套类（静态内部类）
  • 实例嵌套类（实例内部类）

• Local Classes（局部类）

  • 局部内部类
  • 匿名内部类

• 嵌套类和局部类最重要的界限是作用域不同

  • 嵌套类的作用域是属于类的，嵌套类属于类的成员
  • 局部类的作用域是局部的
  • 所有的匿名内部类都是局部的

2.2、Java语言规范中的分类

• 嵌套类

  • 静态嵌套类（被static修饰的成员内部类）

• 内部类

  • 实例内部类

    • 没有被static修饰的成员内部类
    • 除了常量外，不能声明static修饰的字段；以及方法

  • 因此，实例内部类里可以定义静态变量[相当于常量]

• 局部类

  • 在宿主类类体括号内部的某个局部区域中声明的内部类

  • 除了常量外，不能声明static修饰的字段；以及方法

    • 作用域是局部的

  • 匿名类

    • 不能显式指定类名
    • 因此，也不能显式声明构造方法
    • 但是创建匿名类的实例时，的确会调用父类的指定构造方法
    • 但是通过javac反编译匿名类得到结果可知，匿名类是有构造方法的，只是不公开
    • 除了常量外，不能声明static修饰的字段

3、声明

3.1、静态内部类（静态嵌套类）

public class Computer {
static class Brand { //在类中写，有static修饰
static int x;
}
}

3.2、实例内部类（非静态嵌套类）

public class Computer {
class Brand { //在类中写，没有static修饰
//static int x;
final static int x;
}
}
//内部类未加修饰符时，就是默认修饰符，包私有，外部类也可访问此内部类

3.3、局部内部类

• 出了类之后就无法使用，有局部作用域的限制

public class Computer {
public void show() {
class Printer {
//static int x;
//static void hello(){}
//final static void hello(){}
final static int x;
}
}
}
或者：
public class Compuer{
{
class Printer{
}
}
}

3.4、匿名内部类

package cn.edu.ecut;
public class Computer{
public void welcome(){
// 以{}作为类体，继承Object类
Object o = new Object() {
//只有类体括号，不能显式指定类名

}
System.out.println(o.getClass());
}
public static void main(String[] args){
Computer c = new Computer();
c.welcome();//输出：class cn.edu.ecut.Computer$1
}

3.5、注意

• 局部内部类和匿名内部类绝不会有static修饰，因为它们不是属于类的，它们属于局部代码块

4、字节码文件的名称

• 嵌套类对应的字节码文件名称是 外部类类名$内部类类名.class
• 局部内部类对应的字节码文件名称是 外部类类名$N内部类类名.class
  • 数字N指的是局部内部类在外部类的方法或代码块中出现的次数（顺序）
• 匿名内部类对应的字节码文件名称是 外部类类名$N.class
  • 数字N指的是不同局部内部类在外部类的方法或代码块中出现的顺序
• 注意：文件名把.class去掉，剩下的其实就是类名

5、声明内部类类型变量

• 对于嵌套类来说，使用 外部类类名.内部类类名 来指定变量类型

  • 如：Computer.Brand brand = null ;

• 对于局部类来说，只能在其作用域内部直接使用其类名来声明

  • 如：Printer p = null ;

• 对于匿名内部类来说，因为不能显式指定匿名类的类名，所以也就不能声明匿名类类型的引用变量，但是可以声明匿名类所实现的接口类型的引用变量 或 匿名类所继承父类类型的引用变量

6、创建内部类的实例

• 静态内部类（静态嵌套类）

  • 使用 new 外部类类名.内部类类名(参数) 形式来创建其实例
  • 如：Computer.Brand b = new Computer.Brand();

• 实例内部类（非静态嵌套类）

  • 首先需要创建外部类类型的实例（比如Computer c = new Computer();）
  • 然后再在外部类的实例的基础上来创建实例内部类的实例（比如Computer.Mainboard m = c.new Minboard()）
  • 即：Computer.Mainboard m = null; m = new Computer().new Mainboard();

• 局部内部类

  • 直接在 其有效作用域{} 中使用new关键字创建即可

• 匿名内部类

  • 创建实现了某个接口的匿名类的实例

    • 此时匿名类的直接父类是Object类
    • 此时匿名类实现了指定的接口（单个）

  • 创建继承了某个抽象类并实现其中所有抽象方法的匿名类的实例

    • 匿名类的直接父类就是相应的抽象类
    • 在创建匿名类实例时可以调用父类中带参数的构造方法

  • 创建继承了某个具体类的匿名类的实例

    • 匿名类的直接父类就是相应的具体类
    • 可以在匿名类中重写被继承类中的某些方法（根据需求来确定）
    • 在创建匿名类实例时可以调用父类中带参数的构造方法

7、不关注内部类的继承

• 内部类主要是为了封装

二、Code

1、理解嵌套内部类和局部内部类的区别

Computer.java

package cn.edu.ecut;
// Computer 是个外部类，它对应的 字节码 文件是 Computer.class
public class Computer { // 电脑
// 直接在 外部类 的 类体括号中声明的 类，就是 嵌套类 ( Nested Classes )
// 嵌套类 也被称作 成员内部类
// 有 static 修饰的 嵌套类，也被称作 静态嵌套类 或 静态内部类
static class Brand { // 铭牌
// 对应的 字节码 文件名称是 Computer$Brand.class
}
// 没有 static 修饰的 嵌套类，也被称作 非静态嵌套类 或 非静态内部类 或 实例嵌套类 或 实例内部类
class Mainboard { // 主板
// 对应的 字节码 文件名称是 Computer$Mainboard.class
//static int x;//错误，因为x是类加载时就创建的，但是Mainboard内部类是创造一个类对象时才创建的
final static int x = 100; //定义一个常量是可以的
}
public void show() {
// 局部内部类
class Printer {
// 对应的 字节码 文件名称是 Computer$1Printer.class
}
Printer p = new Printer();
System.out.println( p );
}
public void hello() {
// 局部内部类
class Printer {
// 对应的 字节码 文件名称是 Computer$2Printer.class
}
Printer p = new Printer();
System.out.println( p );
}
//Object o = new Object() { };// 若放在类{}里面，也可以，但此时它不是成员内部类，它仍然是局部内部类，因为它只能用一次
public void welcome() {
Object o = new Object() {
// 只有类体括号、不能显式指定类名的局部内部类-匿名内部类
};
System.out.println( o.getClass() );
}
public void baby() {
Object o = new Object() {
};
System.out.println( o.getClass() );
}
public static void main(String[] args) {
Computer c = new Computer();
c.welcome(); // 输出：class cn.edu.ecut.Computer$1
c.welcome(); //class cn.edu.ecut.Computer$1
c.baby(); //class cn.edu.ecut.Computer$2
}
}

ComputerTest.java

package cn.edu.ecut;
public class ComputerTest {
public static void main(String[] args) {
// 声明 静态嵌套类 ( 静态内部类 ) 的 引用变量
Computer.Brand b =
null ;
// 创建 静态嵌套类 ( 静态内部类 ) 的实例
b = new Computer.Brand();
System.out.println( b );
// 获得 Brand 类的全限定名称
System.out.println( b.getClass().getName() );
// 获得 Brand 类的规范化名称（规范化类名），以原点隔开。对以后类加载有用（毕竟类加载的是类，不是文件==>把全限定名称即文件名中的$换为.）
System.out.println( b.getClass().getCanonicalName() );
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
// m所指向的对象包围在c的对象内部，称作包围实例；
// Computer.Mainboard m= new Computer().new Mainboard();
// 声明 非静态嵌套类 ( 实例内部类 ) 的 引用变量
Computer.Mainboard m = null ;
// 创建 非静态嵌套类 ( 实例内部类 ) 的实例
Computer c = new Computer() ; // 首先创建外部类的实例
m = c.new Mainboard(); // 在 外部类实例 基础之上创建 实例内部类 实例
System.out.println( m ); //m.toString()形式，即m指向的对象的【类型（包名.类名）@地址】
System.out.println( m.getClass().getName() ); // 全限定名称
System.out.println( m.getClass().getCanonicalName() ); //规范化名称
}
}

输出：

cn.edu.ecut.Computer$Brand@4d591d15
cn.edu.ecut.Computer$Brand
cn.edu.ecut.Computer.Brand
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
cn.edu.ecut.Computer$Mainboard@6a6824be
cn.edu.ecut.Computer$Mainboard
cn.edu.ecut.Computer.Mainboard

2、在实例内部类中使用 外部类类名.this 来引用外部类的实例

CellPhone.java

package cn.edu.ecut;
public class CellPhone {
public String brand = "一加" ;
public class Screen {
String brand = "京东方" ;
public void show() {
String brand ="";
// 在 实例内部类 中 使用 this 可以引用 该实例内部类的当前实例
// 有this.则brand指的是“京东方”；没有this.则brand指的是“”
System.out.println( this.brand );
// 通过 "外部类类名.this.字段名" 来引用外部类的实例变量
System.out.println( CellPhone.this.brand );
}
public CellPhone getOuter() {
// 在 实例内部类 中 可以使用 "外部类类名.this" 来引用 外部类的 当前实例
return CellPhone.this ;
}
} // end : Screen
public static class A{
public void show(){
//System.out.println(CellPhone.this); // 错误
//静态内部类只能访问静态成员，不能访问外部类的实例（非静态成员）；实例内部类可以访问外部类的实例，不能访问静态成员
}
}
/*
static class B{
CellPhone p = new CellPhone();
}
此代码有些问题，若没有 static，则更加极有可能造成内存溢出，因为在创建实例（new CellPhone()）时，就会产生B这个类，但无法确定产生多少B这个类
class B{
CellPhone p = new CellPhone();
}
*/
}

CellPhoneTest.java

package cn.edu.ecut;
public class CellPhoneTest {
public static void main(String[] args) {
/*
// 引用变量 p 指向了 一个 CellPhone 类型的实例
CellPhone p = new CellPhone();
// 引用变量 s 指向了一个 Screen 类型的实例
CellPhone.Screen s = p.new Screen();
*/
// 创建 实例内部类 Screen 类的实例
CellPhone.Screen s = new CellPhone().new Screen(); // 标记
System.out.println( s );
s.show();
// 用p接收外部类 CellPhone的实例
CellPhone p = s.getOuter(); // 此处的p不是重新new出来的，是在“标记”这行new的这两个实例时就存在的，当时创建外部类Cellphone的实例是什么，p就接收什么
System.out.println( p );
}
}

输出：

cn.edu.ecut.CellPhone$Screen@65ae6ba4
京东方
一加
cn.edu.ecut.CellPhone@7960847b

3、创建实现了某个接口的匿名类的实例

Flyable.java

package cn.edu.ecut;
public interface Flyable {
void fly();
}

AnonymousClassTest1.java

package cn.edu.ecut;
import java.util.Arrays;
/**
* 【最常见的应用】使用 匿名类 实现 接口，并创建该类的实例
*/
public class AnonymousClassTest1 {
public static void main(String[] args) {
// 声明 Flyable 类型的引用变量，并将 null 赋值给该变量
Flyable f = null ; // 引用变量 f
的 编译时类型 是 Flyable
// f = new Flyable() ; // 接口都没有构造方法，也不能被实例化
// 形式上，似乎是在通过 new 关键字 创建 Flyable 接口的实例 【尸体】
// 本质上，创建一个实现了 Flyable 接口的 匿名类 的实例
【借尸还魂】
// {}作为一个类体，实现了接口，实现了接口里的抽象方法
f = new Flyable() { // 匿名类开始
【魂】
@Override
public void fly() { // 在匿名类中实现 Flyable 接口中所有的抽象方法
System.out.println( "飞飞飞，在梦里飞，想飞哪里飞哪里" );
}
}; // 匿名类结束
f.fly();
/*
//匿名内部类只使用这一次；若想再次使用这个类的实例，则需要再写一个匿名类，或者可以重新声明一个类实现接口
f = new Flyable() {
@Override
public void fly() {
System.out.println( "飞飞飞，在梦里飞，想飞哪里飞哪里" );
}
};
//若是再写了一个匿名类，则此时字节码文件有：
//AnonymousClassTest1$1.class，AnonymousClassTest1$2.class
*/
Class<?> c = f.getClass() ;
// 获得运行时类型
System.out.println( c.getName() ); // 全限定名称-cn.edu.ecut.AnonymousClassTest1$1
System.out.println( c.getCanonicalName() ); // 规范化类名 ( 注意这里是 null )
// 匿名内部类不能显式书写类名，因此输出类名为null
Class<?> p = c.getSuperclass(); // 获得 c 所表示类型的父类
System.out.println( p.getName() ); //java.lang.Object
// 获得 c 所表示的类所实现的接口 （或 c所表示的接口 所继承的接口）
Class<?>[] interfaces = c.getInterfaces();
System.out.println( Arrays.toString( interfaces ) );
//此处调用的是Arrays/toString(Object[] a)，Class是Object的子类，因此可直接写Class类型的
}
}

输出：

飞飞飞，在梦里飞，想飞哪里飞哪里
cn.edu.ecut.AnonymousClassTest1$1
null
java.lang.Object
[interface cn.edu.ecut.Flyable]

4、创建继承了某个抽象类并实现其中所有抽象方法的匿名类的实例

Human.java

package cn.edu.ecut;
public abstract class Human {
public String name ;
public Human() {
super();
System.out.println( "Human()" );
}
public Human( String name ) {
super();
this.name = name ;
System.out.println( "Human( String )" );
}
public abstract void eat( String food );
}

AnonymousClassTest2.java

package cn.edu.ecut;
/**
* 创建继承了某个抽象类并实现其中所有抽象方法的匿名类的实例
*/
public class AnonymousClassTest2 {
public static void main(String[] args) {
Human h = null ;
// h = new Human( "张三丰" ); // 抽象类有构造方法，但是抽象类不能实例化
// 形式上，似乎是在通过 new 关键字 创建抽象类 Human 的实例 【尸体】
// 本质上，创建一个继承了 Human 类 并实现了其中所有抽象方法的 匿名类 的实例
【借尸还魂】
h = new Human(
"张三丰" ) { // 匿名类开始 【魂】
@Override
public void eat(String food) { // 重写抽象类中的抽象方法
System.out.println( this.name + "吃" + food );
}
} ; // 匿名类结束
h.eat( "西瓜" );
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
h = new Human() {
@Override
public void eat(String food) {
System.out.println( this.name + "吃" + food );
}
};
h.name = "张君宝" ;
h.eat( "冬瓜" );
}
}

输出：

Human( String )
张三丰吃西瓜
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
Human()
张君宝吃冬瓜

5、创建继承了某个具体类的匿名类的实例

Aircraft.java

package cn.edu.ecut;
public class Aircraft {
public String type ;
public Aircraft(){
super();
}
public Aircraft( String type ){
super();
this.type = type ;
}
public void fly() {
System.out.println( "飞行中..." );
}
public void travel() {
System.out.println( "行驶中..." );
}
}

AnonymousClassTest3.java

package cn.edu.ecut;
import java.util.Arrays;
/**
* 1、创建继承了某个具体类的匿名类实例
* 2、可以在匿名类中重写被继承类中的某些方法
*/
public class AnonymousClassTest3 {
public static void main(String[] args) {
Aircraft a = new Aircraft();
a.fly();
a.travel();
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
Aircraft b = new Aircraft() { } ; // 父类引用 指向 子类对象 ( 因为最后的 { } 就是一个匿名类的类体 )，子类即为匿名类
System.out.println( b.getClass() );
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
// 调用 父类无参数构造方法
Aircraft c = new Aircraft() {
// 在匿名类中声明实例变量
String name = "航天飞机" ;
@Override
public void fly() { // 重写从父类 中继承的 fly 方法
System.out.println( this.name + "正在飞行" );
}
} ;
c.fly(); // 调用重写后的方法
System.out.println( c.getClass() );
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
// 调用 父类有参数构造方法
Aircraft d = new Aircraft( "飞船" ) {
// 在匿名类中声明实例变量
String name = "嫦娥二号" ;
@Override
public void fly() { // 重写从父类 中继承的 fly 方法
System.out.println( this.name + this.type + "正在月球上空飞行" );
}
} ;
d.fly(); // 调用重写后的方法
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
Class<?> cc = d.getClass() ;
// 获得运行时类型
System.out.println( cc.getName() ); // 全限定名称
System.out.println( cc.getCanonicalName() ); // 规范化类名 ( 注意这里是 null )
Class<?> p = cc.getSuperclass(); // 获得 cc 所表示类型的父类
System.out.println( p.getName() );
Class<?>[] interfaces = cc.getInterfaces(); // 获得 cc 所表示的类所实现的接口
System.out.println( Arrays.toString( interfaces ) );
}
}

输出：

飞行中...
行驶中...
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
class cn.edu.ecut.AnonymousClassTest3$1
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
航天飞机正在飞行
class cn.edu.ecut.AnonymousClassTest3$2
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
嫦娥二号飞船正在月球上空飞行
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
cn.edu.ecut.AnonymousClassTest3$3
null //匿名类在语言规范中不能显式书写类名，因此输出null
cn.edu.ecut.Aircraft
[] //说明没有实现任何接口，因为匿名类直接继承了父类Aircraft.java

6、理解匿名类不能显式声明构造方法（但匿名类是有构造方法的）

AnonymousClassTest4.java

package cn.edu.ecut;
import java.lang.reflect.Constructor;
import java.util.Arrays;
/**
* 尝试获取匿名类的构造方法
*/
public class AnonymousClassTest4 {
public static void main(String[] args) {
// 在 java.lang.Cloneable 接口中没有声明任何方法
Cloneable c = new Cloneable() { // 创建 实现了接口Cloneable的 匿名类实例
// 这里什么都不用写
};
/*
// {}作为一个类体，继承了父类Human，调用父类Human中的带参数构造（通过匿名类中的带参构造调用父类构造，匿名类中的带参构造中第一行为：super("张翠山");，只不过匿名类中的构造对我们不可见）
Human c = new Human( "张翠山" ) { // 创建 继承了具体类Human的 匿名类实例
@Override
public void eat(String food) {
}
};
*/
System.out.println( c );
System.out.println( "~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~" );
Class<?> clazz = c.getClass();
// 通过 反射 来获取 匿名类 中所有的构造方法组成的数组
Constructor<?>[] constructors = clazz.getDeclaredConstructors();
System.out.println( Arrays.toString( constructors ) );
}
}

输出：

cn.edu.ecut.AnonymousClassTest4$1@4d591d15
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
[cn.edu.ecut.AnonymousClassTest4$1()]
//获取到一个无参的构造
若换成注释里的内容，并且将Cloneable一行注释，则输出：
Human( String )
cn.edu.ecut.AnonymousClassTest4$1@4aa8f0b4
~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
[cn.edu.ecut.AnonymousClassTest4$1(java.lang.String)]

7、匿名内部类应用举例：在实参中传入匿名类的实例

Printable.java

package cn.edu.ecut;
// 打印接口
public interface Printable {
// 打印
void print( String content );
// 复印
String copy( String content );
}

Store.java

package cn.edu.ecut;
public class Store {
public void print( Printable p , String content ) {
p.print(content); // 这里调用的是 Printable 实例的 print 方法
}
public String copy( Printable p , String content ) {
return p.copy(content) ; // 这里调用的是 Printable 实例的 copy 方法
}
}

StoreTest.java

package cn.edu.ecut;
public class StoreTest {
public static void main(String[] args) {
Store s = new Store();
// 方法一：传入匿名类实例
Printable p = new Printable() { // 引用变量p指向 实现了接口Printable的 匿名内部类的对象
String name = "HP打印机" ; // 匿名类的实例变量
@Override
public void print(String content) {
System.out.println( this.name + " 正在打印 " + content );
}
@Override
public String copy(String content) {
System.out.println( this.name + " 正在复印 " + content );
String s = new String( content );
return s ;
}
};
s.print( p , "犯我中华者虽远必诛" );
// 方法二：传入匿名类实例
s.print( new Printable() {
String name = "爱普生打印机" ; // 匿名类的实例变量
@Override
public void print(String content) {
System.out.println( this.name + " 正在打印 " + content );
}
@Override
public String copy(String content) {
System.out.println( this.name + " 正在复印 " + content );
String s = new String( content );
return s ;
}
} ,
"犯我中华者虽远必诛" );
}
}

输出：

HP打印机 正在打印 犯我中华者虽远必诛
爱普生打印机 正在打印 犯我中华者虽远必诛

最后

以上就是活泼学姐最近收集整理的关于16、Inner Class（内部类）的全部内容，更多相关16、Inner内容请搜索靠谱客的其他文章。