Java面向对象中的---强转向下造型，内部类，匿名内部类

1. 多态：多种形态

• 意义：

  • 同一个对象被造型为不同的类型时，有不同的功能------所有对象都是多态的(明天才能体会)

    ------对象的多态：我、水、你…

  • 同一类型的引用在指向不同对象时，有不同的实现-------所有抽象方法都是多态的

    ------行为的多态：cut()、getImage()、getScore()…

• 向上造型/自动类型转换：--------就是多态

  • 超类型的引用指向派生类的对象
  • 能点出来什么，看引用的类型
  • 能造型成为的类型有：超类+所实现的接口

• 强制类型转换/向下转换，成功的条件只有如下两种：

  • 引用所指向的对象，就是该类型
  • 引用所指向的对象，实现了该接口或继承了该类

• 强转时若不符合如上条件，则发生ClassCastException类型转换异常

  建议：在强转之前先通过instanceof来判断引用的对象是否是该类型

  何时需要强转：若想访问的变量/方法在超类中没有，则需要强转

  public class MultiTypeDemo {
      public static void main(String[] args) {
          //条件1:引用所指向的对象，就是该类型
          //条件2:引用所指向的对象，实现了该接口或继承了该类
          Aoo o = new Boo(); //向上造型
          Boo o1 = (Boo)o;     //引用o所指向的对象，就是Boo类型--------满足条件1
          Inter o2 = (Inter)o; //引用o所指向的对象，实现了Inter接口----满足条件2
          //Coo o3 = (Coo)o; //运行时会发生ClassCastException类型转换异常
          if(o instanceof Coo){
              Coo o4 = (Coo)o;
          }else{
              System.out.println("o不是Coo类型");
          }
      }
  }
  interface Inter{
  }
  class Aoo{
  }
  class Boo extends Aoo implements Inter{
  }
  class Coo extends Aoo{
  }
  

2. 成员内部类：应用率低-----------了解

• 类中套类，外面的称为外部类，里面的称为内部类

• 内部类通常只服务于外部类，对外不具备可见性

• 内部类对象通常在外部类中创建

• 内部类中可以直接访问外部类的成员(包括私有的)，

  内部类有个隐式的引用指向了创建它的外部类对象----------外部类名.this-----------------API时会用

  public class InnerClassDemo {
      public static void main(String[] args) {
          Mama m = new Mama();
          //Baby b = new Baby(); //编译错误，内部类对外不可见
      }
  }
  
  class Mama{ //外部类
      private String name;
      void create(){
          Baby b = new Baby(); //正确
      }
      class Baby{ //内部类
          void show(){
              System.out.println(name); //简写
              System.out.println(Mama.this.name); //完整写法
              //System.out.println(this.name); //编译错误，this指代当前Baby对象
          }
      }
  }
  

3. 匿名内部类：------------------------简化代码

• 若想创建一个类(派生类)的对象，并且对象只被创建一次，此时可以设计为匿名内部类

• 匿名内部类中不能修饰外面局部变量的值，因为该变量在此处默认为final的------------API时会用

• 常见面试题：

  • 问：内部类有独立的.class吗？
  • 答：有

  public class NstInnerClassDemo {
      public static void main(String[] args) {
          //1)创建了Aoo的一个派生类，但是没有名字
          //2)为该派生类创建了一个对象，名为o1
          //  ---new Aoo(){}是在创建Aoo的派生类的对象
          //3)大括号中的派生类的类体
          Aoo o1 = new Aoo(){
          };
  
          //1)创建了Aoo的一个派生类，但是没有名字
          //2)为该派生类创建了一个对象，名为o2
          //3)大括号中的派生类的类体
          Aoo o2 = new Aoo(){
          };
  
          int num = 5;
          num = 55;
          //1)创建了Boo的一个派生类，但是没有名字
          //2)为该派生类创建了一个对象，名为o3
          //3)大括号中的派生类的类体
          Boo o3 = new Boo(){
              void show(){ //重写超类Boo的抽象show()方法
                  System.out.println("showshow");
                  //num = 88; //编译错误，匿名内部类中不能修改外面局部变量的值，
                              //因为该变量在此处默认为final的
              }
          };
          o3.show(); //派生类对象o3调用派生类中的方法show()
      }
  }
  
  abstract class Boo{
      abstract void show();
  }
  
  abstract class Aoo{
  }