内部类（2）

内部类的继承

1.内部类的继承与外围类的继承类似

   class A{
      void f1(){
         System.out.println("A.f1()");
      }
   }
   public class Outer{
      class Inner extends A{
      }
      public static void main(String[] args){
         Outer a = new Outer();
         Inner inner = a.new Inner();
         inner.f1();
      }
   }
//运行结果：
//ly@HP:~/TIJ4/exercise$ javac Outer.java 
//ly@HP:~/TIJ4/exercise$ java Outer 
//A.f1()

2.内部类可以被继承,但父类和子类都需要外围类的实例

内部类的子类构造器需要指定父类的外围类实例作为参数，否则子类无法对父类进行初始化

   class Outer1{
      class Inner1{
         Inner1(){System.out.println("Outer1.Inner1");}
      }
   }
   public class Outer{
      class Inner extends Outer1.Inner1{
       //Inner(){}  //编译错误，需要一个父类的外围类实例
         Inner(Outer1 a){
           a.super();
           System.out.println("Outer.Inner");
         }
      }
      public static void main(String[] args){
         Outer a = new Outer();
         Outer1 a1= new Outer1();
         Inner b = a.new Inner(a1);
      }
   }
//运行结果：
//ly@HP:~/TIJ4/exercise$ javac Outer.java 
//ly@HP:~/TIJ4/exercise$ java Outer
//Outer1.Inner
//Outer.Inner

3.外部类的子类重定义一个相同名字的内部类，基类的内部类不会被覆盖，两个类是独立的个体，没有出现动态绑定

   class Base{
      class Inner{
         Inner(){System.out.println("Base.Inner");}
      }
   }
   public class Outer extends Base{
      class Inner{
         Inner(){System.out.println("Outer.Inner");}
      }
      public static void main(String[] args){
         Base a = new Outer();//将子向上转型为父类
         Base.Inner b = new a.new Inner();//调用父类的Inner构造器，而不是子类
       //Outer.Inner b = a.new Inner(); //Base.Inner不可以被转换成Outer.Inner
      }
   }
//运行结果：
//ly@HP:~/TIJ4/exercise$ javac Outer.java 
//ly@HP:~/TIJ4/exercise$ java Outer
//Base.Inner

4.如果没有在子类中覆盖父类的内部类，则父类中的内部类也会被继承到基类中

   class Base{
      class Inner{
         Inner(){System.out.println("Base.Inner");}
      }
   }
   public class Outer extends Base{
/*      class Inner{
         Inner(){System.out.println("Outer.Inner");}
      }
*/
      public static void main(String[] args){
         Outer a = new Outer();
         Inner b = a.new Inner();//调用父类的Inner构造器
      }
   }
//运行结果：
//ly@HP:~/TIJ4/exercise$ javac Outer.java 
//ly@HP:~/TIJ4/exercise$ java Outer
//Base.Inner

5.修改上面的代码，验证动态绑定只对函数有效，对内部类无效

   class Base{
      void f1(){
        System.out.println("Base.f1()");
      }
      class Inner{
         Inner(){
            System.out.println("Base.Inner");
            f1();
         }
      }
   }
   public class Outer extends Base{
        void f1(){
          System.out.println("Outer.f1()");
        }
      class Inner{
         Inner(){
           System.out.println("Outer.Inner");
           f1();
         }
      }

      public static void main(String[] args){
         Base a = new Outer();
         Base.Inner b = a.new Inner();//子类调用父类的内部类构造器，调用子类的f1()方法。
      }
   }
//运行结果
//ly@HP:~/TIJ4/exercise$ javac Outer.java 
//ly@HP:~/TIJ4/exercise$ java Outer
//Base.Inner
//Outer.f1()

内部类的作用

使用同一个接口，实现同一个函数不同的功能，与多态结合

 
interface Interface1{
      void f1();
   }
   public class LightControl{
      class LightOn implements Interface1{
         public void f1(){
            System.out.println("light on");
         }
      }
      class LightOff implements Interface1{
         public void f1(){
            System.out.println("ligth off");
         }
      }
      public static void main(String[] args){
         LightControl a = new LightControl();
         Interface1 lightOn = a.new LightOn();//创建开灯实例，向上转型为父类
         Interface1 lightOff = a.new LightOff();//创建关灯实例，向上转型为父类
         lightOn.f1();
         lightOff.f1();
      }
   }
//运行结果：
//ly@HP:~/TIJ4/exercise$ javac LightControl.java 
//ly@HP:~/TIJ4/exercise$ java LightControl 
//light on
//ligth off