【内部类】内部类的概念及成员内部类

1.内部类的主要特点

• 内部类可以很好的实现隐藏，使用private，protected关键字。而这些，外部类是不能使用的。
• 内部类可以直接访问外部类的所有成员，包括私有的成员
• 外部类不能直接访问内部类的成员，必须首先要建立内部类的对象才能访问
• 内部类可以解决一些问题，比如间接地实现多继承，可以避免修改接口而实现同一个类中两种同名方法的调用（一般不这么做）

2.成员内部类

特点：
- 可以看作是外部类的一个实例成员
- 可以使用所有的权限修饰符：public，private，default，protected
- 访问所在外部类的成员方法和属性时，要使用”外部类名.this.成员方法”和“外部类名.this.成员属性”

创建成员内部类：
- 外部类调用自己的内部类，可以直接用：内部类名 实例名=new 内部构造方法（参数）的形式
- 调用非自己的内部类要用：外部类名.内部类名 实例名=外部类实例名.new 内部类构造方法（参数）的形式，因此要创建一个内部类，先要创建一个外部类
- 编译后会产生自己的class文件，文件名：外部类$内部类.class

限制：

• 成员内部类不能与外部类重名
• 不能定义静态属性，方法和类（static final除外）因为一个成员内部类实例必然与一个外部类实例关联，static成员完全可以移到外部类中去。

3.成员内部类的应用

成员内部类引用

public class MemberInnerClass{
     public static void main(String[] args){
     Outer1 outer=new Outer1();//先创建外部类
     Outer1.Inner1 inner=outer.new Inner();//在创建内部类
     inner.InnterShow()//调用内部类方法
}

class Outer1{
     private String name="Lily";
     private int age=22;
     public void outerShow(){
          System.out.println(name);
          System.out.println(age)；
     //外部类不能直接访问内部类的成员，必须首先要建立内部类的对象才能访问
     Inner1 inner1=new Inner();
     System.out.println(inner1.age);
}
     }
     public class Inner1{
          private String name="Jasmine";
          private int age=26;
          public void InnterShow(){
              System.out.println(name);
              System.out.pringln(age);
              System.out.println(Outer1.this.name);//与创建内部类的方法呼应，这里用this调用的外部类的成员
              outerShow();//非重名属性和方法还可以直接从外部类调用
          }  
     }
}

内部类实现多继承

通过内部类实现多继承，在要继承的子类内创建两个内部类
再创建两个与继承父类的同名方法。方法里面做一件事：创建内部类对象，并引用继承类的方法
看起来c.showA()是调用了多继承父类的方法，实际上，是c引用了内部类对象继承的方法
public class MultiExtendsDemo {

     public static void main(String[] args) {
          C c=new C();//创建外部类的对象
          //C间接地继承了A和B
          c.showA();
          c.showB();
     }
}
class A{
     public void showA(){
          System.out.println("A");
     }
}

class B{
     public void showB(){
          System.out.println("B");
     }
}
//在class C内部创建多个类，实现多继承
class C{
     //内部类A1继承A
     private class A1 extends A{
          public void showA(){
              super.showA();
          }
     }
     private class B1 extends B{
          public void showB(){
              super.showB();
          }
     }
     public void showA(){
          new A1().showA();
     }
     public void showB(){
          new B1().showB();
     }

}

避免修改接口实现同一个类中，两个同名方法的调用

public class Demo2 {

     public static void main(String[] args) {
          Son son=new Son();
          son.show();//继承父类的show方法
          son.show2();//子类对象Inner（）实现接口的show方法
     }
}
abstract class Parent{
     public abstract void show();

}
interface Ishow{
     public abstract void show();
}

//上述Parent抽象类和Ishow接口，
//二者里面都有一个叫show()的抽象方法
//如何同时对这两个show()方法做改写
//并且不能修改方法名
class Son extends Parent{
     public void show(){
          System.out.println("抽象类中的show方法");
     }
     private class Inner implements Ishow{
          public void show(){
              System.out.println("接口中的show方法");
          }
     }
     public void show2(){
          new Inner().show();
     }
}