继承:
  面向对象的三大特征之一:
  
  是类和类之间的一种拓展关系,是一种从一般到特殊的关系;
  
  格式: sub   extends Super,  我们把sub称为子类或者拓展类, 把super称为父类或者基类(超类)
  
 泛化: 把子类中的共性抽取到父类的过程;
 特化: 子类在父类的基础之上,拓展自己特有的状态和特征;
  
  Object: 是所有类的直接父类后间接父类;
  
  
  class  Student{} 等价于  class  Student extends Object{}
  
  直接父类:  直接继承的父类,有且只有一个,也就是说Java只支持单继承;
  间接父类: 直接父类或间接的父类的父类;
  
 方法和字段:
  private 修饰的成员不能被继承;
  默认访问权限的成员能不能被继承?  要是在同一个包中就能被继承
  protected 修饰的成员,可以被继承;
  public 修饰的成员,可以被继承;
  
  构造方法能不能被继承? 不能
  
  class Person{
   
   public Person(){}
  }
  
  class Student extends Person
  {
   //public Person(){}//ERROR
  }
  
  若父类所有的构造方法是用 private 修饰,不能有子类;
  
 
 子类实例化:
  子类初始化,会先默认调用父类的一个无参的构造方法,自己再初始化;
  
  子类的构造方法里,有一个隐式的 super();
  
  若我们显示的让子类去调用父类有参数的构造方法,默认的隐式的构造方法就不会被调用了;
  
  子类对象创建之前,必须有一个父类对象;
  
  
 方法覆写:
   当父类的某一个方法不适合子类对象的时候,就应当重新修改方法体;
   
  遵循的原则:  一同 两小 一大:
  
  一同: 方法签名相同
  两小: 
   1.返回值类型可以是父类返回值类型的子类或相同;
    父类的:Object show(){
     return null;
    }
    
    子类的:  String show()
    {
     return null;
    }
   2.异常更小
  一大: 子类方法的访问权限 >= 父类方法的访问权限
    父类的: private Object show(){
     return null;
    }
    
    子类的:  String show()
    {
     return null;
    }
  
   上面这个不是覆写:因为私有成员不能被继承
  
 必杀技:  若子类方法是覆写方法的话,  那么在方法上加上 @Override  是可以编译通过的;
 
  静态方法能不能被覆写: 不能!
   
   方法的覆写:属于多态,而多态是基于对象的(父类的一个变量指向子类的一个对象);
   
   而静态方法不属于对象,属于类;
 
 super:
  用在子类.,
  super:表示父类对象
  用于调用父类的方法或字段,用法和this一模一样
  
  调用父类的构造方法:
  
  super(参数);和this(参数);
  都表示在构造方法里调用构造方法;都必须写在构造方法的第一行
  
  不同:  this(参数),调用的当前类里面的构造方法,super(参数),调用的是直接父类里构造方法
   
 多态:
 
  面向对象的三大特征之一:
  
  Person  p = new Student();
  
  p的真正类型是学生;当是我们只把他当一般人看待;
  
  编译类型: 申明变量的类型  Person ,  是我们把它当做什么
  运行类型: 创建对象的类型  Student ,  是对象真正的类型
  
  多态的产生前提:继承
  当编译类型和运行类型不一致的时候,就会产生多态;
  
  多态定义:  同一个实体有多种形态;
  
  多态的作用: 可以屏蔽不同子类对象之间的差异,从而能写出更加通用的代码,能提高效率,维护性;
  
 引用类型转换:
  
  向上转型:  小->大, 自动转换, 这里说的小和大,说的是 继承关系中的子类和父类.
    
   可以把子类对象赋给父类变量;
   Person  p = new Student();
   
   Object类是所有类的父类.那么Object类型的变量能不能接受一切值? 可以!
  
   
  向下转型: 大 -> 小
  
   父类对象强制转换成子类对象;
   
   Student  s = (Student)p;
   
   一般的,再强转之前,要先判断该对象时候属于这个类类型;
    boolean b = 对象 instanceof 类
    
    对象的类型和类必须有继承关系;
   
   先判断 p是否是学生类型: 
   
   if(p instanceof Student)
   {
    Student  s = (Student)p;
   }
   
 多态方法调用:
  
  
  1.调用的方法不是覆写方法,子类有,父类没有;
   
  2.调用的方法是覆写的方法,父类有,子类也有;
  
  class Dog
  {
   public void eat()
   {
    System.out.println("0001");
   }
  }

  class Hasiqi extends Dog
  {
   public void eat()
   {
    System.out.println("0002");
   }
  }

  class ZangDog extends Dog
  {
   public void eat()
   {
    System.out.println("0003");
   }
  }

  class Zoo
  {
   public void feed(Dog d)
   {
    d.eat();
   }
  }

  class  DogDemo
  {
   public static void main(String[] args)
   {
    Zoo zoo=new Zoo();
    Hasiqi xiaoha=new Hasiqi();
    zoo.feed(xiaoha);

    ZangDog zd=new ZangDog();
    zoo.feed(zd);
   }
  }
 
 组合:
   extends  继承是一种从一般到特殊的关系,  也就是说 子类是父类的一种特殊情况;
  
   子类 is  父类的一种  is  A 关系
   
  组合,包含:  比如手机和手机卡,  手机里有手机卡 ,has  A关系
  
  class Card
  {
   private String num;//卡号

   public String getNum()
   {
    return num;
   }

   public void setNum(String num)
   {
    this.num=num;
   }

   public Card(String num)
   {
    this.num=num;
   }
  }

  //手机
  class CellPhone
  {
   private Card c;//卡是手机所包含的

   public CellPhone(Card c)
   {
    this.c=c;
   }

   public void connectied(String num) //联系
   {
    System.out.println(c.getNum()+"正在给"+num);
   }
  }

  //人
  class Person
  {
   public void call(CellPhone c,String num)
   {
    c.connectied(num);
   }
  }

  class PhoneDemo
  {
   public static void main(String[] args)
   {
    Person lucy=new Person();
    Person will=new Person();
    Card c=new Card("18720076967");

    CellPhone iphone=new CellPhone(c);
    lucy.call(iphone,"10086");
   }
  }