多态

1.多态:
  1)同一类型的引用指向不同的对象又不同的表现。
  2)同一个对象被造型为不同的类型时由不同的功能。
  1)例1
    public class DuoTaiDamo {
      public static void main(String[] args) {
      Person p1=new Doctor();//同一类型的引用指向不同的对象又不同的表现。
      Person p2=new HairCut();//同一类型的引用指向不同的对象又不同的表现。
      }
      }
      abstract class Person{
      abstract void cut();
      }
      class Doctor extends Person{
      void cut() {
      System.out.println("开刀");
      }
      }
      class HairCut extends Person{
      void cut() {
      System.out.println("剪发");
      }
      }
  2)例2
      public class DuoTaiDamo2 {
      public static void main(String[] args) {
      Me me=new Me();
      Teacher o1=me;//同一个对象被造型为不同的类型时由不同的功能。
      Mother o2=me; //同一个对象被造型为不同的类型时由不同的功能。
      Emp o3=me;      //同一个对象被造型为不同的类型时由不同的功能。
      }
      }
      interface Teacher {
      void teach();
      }
      interface Mother{
      void HitChildren();
      }
      interface Emp{
      void Work();
      }
      class Me implements Teacher,Mother,Emp{
      public void Work() {
      System.out.println("工作");
      }
      public void HitChildren() {
      System.out.println("打孩子");
      }
      public void teach() {
      System.out.println("教学");
      }
      }
2.类型转换
  父类型是大类型，子类型是小类型；接口是大类型，实现接口是小类型；
  1)自动类型转换：从大类型向小类型转，从接口向实现接口转换；
  2)强制类型转换：从子类向父类转换，从实现接口向接口转换；
  1引用指向的对象就是该类型。2引用所指向的对象实现了该接口
  强制转换可能会出错；
  用instanceof检查，引用+instanceof+强转类型
  如果不能成功强制转换编译不会报错，但是运行会报错：ClassCaseDamo
  3)向上造型
  父类型的引用指向子类型的对象。
  可以造型为父类也可以造型为接口。
  4)向上造型的引用能点出什么
  在继承中，父类是抽象类，看类型肯定没意义。所以引用能点出来的东西看对象
  在接口中，能点出来的看类型。
  public class MultypeDemo {
  public static void main(String[] args) {
      Aoo o1=new Boo();
      Boo o2=(Boo)o1;
      inter1 o3=(inter1)o1;
      if(o1 instanceof Coo){//检查转换是否出错，引用+instanceof+强转类型
      Coo o4=(Coo)o1;
      System.out.println("可以转型");
      }else{
      System.out.println("没有转型");
      }
      }
      }
      class Aoo{}
      interface inter1{}
      class Boo extends Aoo implements inter1{}
      class Coo extends Aoo{}
  内部类
  1)类中类 里面的叫内部类，外面的交外部类
  2)内部类只服务于外部类，对外不具有可见性
  3)内部类对象通常在外部类中创建
  4)内部类可以直接访问外部类的成员（包括私有的）内部类有个隐式的引用指向了创建他的外部类对象
      外部类名.this.
    public class InnerClassDamo {
    public static void main(String[] args) {
    Mama m=new Mama();
    }
    }
    class Mama{
    private String name;
    Baby createBaby(){
    return new Baby();
    }
    class Baby{
    void showMamaName(){
    System.out.println(name);
    System.out.println(Mama.this.name);
    }
    }
    }
  匿名内部类
  1)若想创建一个类的对象，并且这个类只会被创建一次，此时这个
      类不必命名称为匿名内部类。
  2)匿名内部类中想访问外部数据，该数据必须用final修饰。

    public class NstInnerClassDamo {
    public static void main(String[] args) {
    Inter2 o1=new Inter2(){};
    final int num=7;
    Inter3 o3=new Inter3(){
    public void show() {System.out.println("show");
    System.out.println(num);}
    };
    o3.show();
    }
    }
    interface Inter3{
    void show();
    }
    interface Inter2{}
  内部类也有独立的class文件