JavaSE-13 内部类

学习要点

内部类的定义
内部类的应用

内部类

定义

Java的一个类中包含着另一类。

A类和B类是C类的外部类。B类是C类的外部类。A类也称为顶层类。

如何使用内部类

public class MyFatherClass {

}

public interface MyInterface {

    public abstract int getValue();

}

public class MyClass extends MyFatherClass implements MyInterface {

    int value = 0;

    public int getValue() {

        return value;

    }

    public String getValue() {

        return "这是一个神奇的时代!";

    }

}

以上代码会存在什么问题？编译器提示出错，提示方法重复。即编译器搞不清楚getValue()是继承接口重写的还是重载的。如何解决？使用内部类。

public class MyClass extends MyFatherClass {

    int value = 0;

    public int getValue() {

        return value;

    }

    public class MyInnerClass implements MyInterface {

        public int getValue() {

            return 0;

        }

    }

}

内部类可以访问外部类的所有资源，如果内部类是继承其他类或者接口，不影响外部类的继承和接口实现。轻松实现Java的“多继承”。

例如：

class A{}

class B{}

public class S extends A {

    public class E extends B{      

    }

}

内部类主要作用

访问外部类所有成员，包括private成员。
多重继承。
封装类型。
编写事件驱动程序。
回调。

内部类的分类

内部类主要分为成员内部类、局部内部类。
其中，成员内部类根据数据访问权限的不同，又分为静态内部类和非静态内部类。
还有一种称为匿名内部类，匿名内部类在程序运行过程中只使用一次，用完即销毁。
成员内部类和类的属性、方法、构造方法一样，属于类的成员。而局部内部类或者匿名内部类则不属于类的成员。
因此，成员内部类就同其他成员一样，可以采用private、public等修饰，可以被继承。
例如：直接把抽象类Person在Demo类中实现了。

abstract class Person {

    public abstract void read();

}

public class MyClass {

    public static void main(String[] args) {

        Person p = new Person() {//匿名内部类

            public void read() {

                System.out.println("读书！");

            }

        };

        p.read();

    }

}

内部类的语法结构

[访问修饰符]  外部类类名{

   ………

   [访问修饰符]  内部类类名{

      ……

}

……

}

语法示例

/**外部类A*/

public class A {

    private String mess = "这是外部类私有成员变量mess";

    /**内部类B*/

    class B {

        public String getMess() {

            return mess;

        }

    }

    private B b = new B();//类A的私有成员变量

    /**通过外部类访问内部类获取信息方法*/

    public void showMess() {

        System.out.println(b.getMess());

    }

    /**测试方法*/

    public static void main(String[] args){

        A a=new A();

        a.showMess();

    }

}

直接访问内部类

  /**测试方法*/

    public static void main(String[] args){

        //A a=new A();

        //a.showMess();

        A.B in=new A().new B();//如果内部类不希望被外部访问，使用private修饰

        System.out.println(in.getMess());

    }

非静态内部类

定义

非静态内部类不采用static修饰。

特性

内部类和外部类同名成员变量的访问

示例代码：

class Outer {

   int number=2000;

   public class Inner{

       int number=1888;

       public int getNum(){

           return number;

       }

   }

}

public class Test{

   public static void main(String[] args){

       Outer.Inner in = new Outer().new Inner();

       System.out.println(in.getNum());       

   }

}

在测试类中，输出的number值是多少？---1888

当内部类的方法访问同名变量时，采用就近原则，先访问最近的一个成员，如果满足条件，就取最近一个成员变量的值，如果不满足，再依次向外部类寻找同名变量。如果找不到，编译器则报错。

外部类访问内部类成员

需要显示的实例化非静态内部类，通过对象名访问内部类成员。例如语法示例中的代码：

/**外部类A*/

public class A {

   private String mess = "这是外部类私有成员变量mess";

   /**内部类B*/

   class B {

       public String getMess() {

           return mess;

       }

   }

   private B b = new B();//类A的私有成员变量

   /**通过外部类访问内部类获取信息方法*/

   public void showMess() {

       System.out.println(b.getMess());

   }

   /**测试方法*/

   public static void main(String[] args){

       A a=new A();

       a.showMess();

   }

}

非静态内部类不允许有静态成员：包括静态属性、方法、代码块。

外部类的静态成员不能访问非静态内部类。

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

定义

静态内部类采用static修饰，他是属于类成员。而非静态内部类则属于类的某个对象。

语法结构

class Outer {

   public static class Inner{

   }

}

特性

静态内部类不能访问外部非静态成员，只能访问外部类的静态成员，即类成员。

示例代码：

class Outer {

   static int number=1000;

   public static class Inner{

       static void printNumber(){

           System.out.println(number);

       }

   }

}

public class Test{

   public static void main(String[] args){

       Outer.Inner.printNumber();

   }

}

实例化静态内部类，不需要创建外部类引用。

示例代码：

class Outer {

   static int number=1000;

   public static class Inner{

       static void printNumber(){

           System.out.println(number);

       }

   }

}

public class Test{

   public static void main(String[] args){

       //Outer.Inner in = new Outer().new Inner();

       Outer.Inner in = new Outer.Inner();

       in.printNumber();

   }

}

局部内部类

定义

如果将一个类定义在一个方法内部，则称为局部内部类。和局部变量类似，局部内部类是不允许采用访问修饰符的。（局部变量只允许使用final修饰）。

特性

局部内部类不能在外部类以外的地方使用。局部内部类的作用域只在方法内部，方法外部无法访问局部内部类。

示例代码

class Outer {

   int number = 1000;

   public void method(){

       class LocalInner{  

           int count=10;

       }      

       LocalInner localInner=new LocalInner();

       System.out.println("count="+localInner.count);

   }

}

public class Test {

   public static void main(String[] args) {

       Outer outer = new Outer();

       outer.method();

   }

}

局部内部类可以访问外部类的所有资源

局部内部类只能访问所在方法final修饰的局部变量（包括方法的形参）

示例代码：

class Outer {

   int number = 1000;

   public void method(){

       int money=100;//局部内部类无法访问局部变量

       final int score=168;//局部内部类可以访问final修饰的局部变量

       class LocalInner{  

           int count=10;

           public void printNum(){

               System.out.println(number);//局部内部类访问外部类成员

               System.out.println(money); //无法访问，报错

               System.out.println(score);

           }

       }      

       LocalInner localInner=new LocalInner();

       System.out.println("count="+localInner.count);

       localInner.printNum();

   }

}

public class Test {

   public static void main(String[] args) {

       Outer outer = new Outer();

       outer.method();

   }

}

匿名内部类

定义

匿名内部类是一种特殊的内部类，没有名字。

例如：

public class Test {

    public static void main(String[] args) {

        Test test = new Test(){        

        };

    }

}

在直接“实例化”接口或者抽象类的时候，可以采用匿名类的方式进行实例化。

特性

匿名内部类必须继承一个父类或者实现一个接口。当且仅当只能继承一个父类，或者实现一个接口。

匿名类定义中的示例，匿名类继承了Test类。

创建完匿名类对象，匿名类自动消失。

匿名类本身没有构造方法，但他会调用父类的构造方法。

代码示例：

public class Test {

   public Test(){

       System.out.println("这是父类Test的构造方法！");

   }

   public void method(){

       System.out.println("这是父类普通方法！");

   }

   public static void main(String[] args) {

       Test test = new Test(){        

       };

       test.method();

}

以上代码将会输出：

匿名类本身没有构造方法，但可以有初始化代码。

代码示例：

public class Test {

   public Test(){

       System.out.println("这是父类Test的构造方法！");

   }

   public void method(){

       System.out.println("这是父类普通方法！");

   }

   public static void main(String[] args) {

       Test test = new Test(){

           {System.out.println("匿名内部类的初始化代码块！");}

       };

       test.method();

   }

}

初始化代码使用{}标识，其初始化的顺序类似继承关系构造方法的执行顺序，输出结果：

成员变量定义成匿名内部类

除了可以在外部类的方法中定义匿名内部类，还可以在成员变量定义匿名内部类。

abstract class AC{}

public class Test {

   AC ac = new AC(){};//匿名类成员变量 

   public static void main(String[] args) {   

   }

}

封装数据类型

常见的顶层类只能用public或者默认访问修饰符，而成员内部类可以使用任意访问级别的修饰符。

如果一个类仅仅只是为一个方法提供服务，那么这个类就可以定义为方法内的局部内部类，只在该方法内可见。

面向对象核心思想是封装，我们已经学习了属性和方法的封装，内部类也是一种封装方式。

示例代码：

interface Tool{}

public class Outer {  

   private class InnerTool implements Tool{//实现了工具接口的内部类 

   }  

   public Tool getTool(){

       return new InnerTool();

   }

}

测试类访问不了private修饰的InnerTool内部类，但是可以通过Outer外部类提供的getTool（）方法访问获得InnerTool对象。从而实现数据类型的封装，即把Tool类型封装成InnerTool类型。

回调（闭包）

定义

某个方法获得内部类对象的引用后，就可以在合适的时候反过来调用外部类对象的引用。即，允许测试类通过内部类引用来调用其外部类的方法。

示例代码：

/**修改英语成绩接口*/

public interface ReMarkENAble {

    /**修改成绩*/

    public abstract void modify(int score);

}

/** 修改语文成绩类 */

public class ReMarkCN {

    private int scoreCN;//语文成绩

    /**修改语文分数*/

    public void modify(int scoreCN) {

        this.scoreCN = scoreCN;

    }

    public int getScoreCN(){

        return this.scoreCN;

    }

}

问题：如果一个学生类既想修改语文成绩又想修改英语成绩要如何实现？定义一个学生类，继承ReMarkCN类，实现ReMarkENAble接口，问题是这两个类中modify方法重名，导致学生类只能实现修改语文成绩的方法。

如何实现学生类既可以修改语文成绩，又可以修改英语成绩？使用内部类回调。

示例代码：

/** 学生类 */

public class Student extends ReMarkCN {

    private int scoreEN;//英文成绩

    public void outerModify(int scoreEN) {

        this.scoreEN = scoreEN;

    }

    /**闭包:接口+内部类*/

    private class Inner implements ReMarkENAble {

        @Override

        public void modify(int scoreEN) {

            outerModify(scoreEN);

        }

    }

    /**获得修改英语成绩内部类对象*/

    public ReMarkENAble getReMarkENAble(){

        return new Inner();

    }

    /**打印成绩单*/

    public void print(){

        System.out.println("*****成绩单*****");

        System.out.println("语文成绩："+this.getScoreCN());

        System.out.println("英语成绩："+this.scoreEN);

    }

}

/**测试类*/

public class Test {

    public static void main(String[] args) {

        Student student=new Student();

        //修改语文成绩

        student.modify(60);

        //修改英语成绩

        ReMarkENAble reMarkENAble=student.getReMarkENAble();

        reMarkENAble.modify(61);

        //输出成绩

        student.print();

    }

}