JAVA基础必备（九）——继承，封装，多态，抽象类，接口

1.方法的重写(函数覆盖)
  父类的方法，在子类中有重新实现
  首先方法的签名一样(签名指的是返回值类型，方法名称，形式参数)
  访问权限到子类中可以扩大不能缩小(首先父类中的方法非private 因为private只能在类的内部访问)
2.动态binding(绑定)
   a.父类的引用引用了子类的实体对象
   b.调用方法时，如果该方法构成重写则调用子类的方法
           如果调用的方法不构成重写，调用父类自己的方法，父类如果

           不存在该方法，则抛出异常

1.继承中的构造函数问题
  a.java中，父类除了构造函数不会被继承，但是能被调用.
    其它元素都被继承但是private的成员被继承不能直接访问,
    只能通过父类继承过来的函数去访问
  b.子类构造函数必须去递归调用父类的构造函数，
         如果没有去调用，默认会调用父类无参数的构造函数
         如果显式调用，需要用super关键字super(参数)
    super对构造函数的调用必须是子类构造函数的第一个
         语句
2.动态binding(多态的实现)
  a.父类的引用引用子类的对象
  b.调用方法时，只能调用父类中有的方法，
         如果父类的该方法被子类重写那么会调用子类的,不重写就调用父类自己的
  c.向上转型，向下转型(引用的确实哪个实例对象，才能往那个类型做转换)
    instanceof
  d.super.方法，调用父类被重写的方法
 
3.子父类初始化过程中的整体顺序
4.变量的隐藏（父类非private成员变量，在子类中有一模一样的声明)
       变量不构成重写  在子类自己声明的方法中访问时，
       只能访问到自己声明的这个变量，要想访问父类继承过来的，
      只能通过父类继承过来的方法访问或者super.i明确指定是父类的

继承的缺点：子类必须依赖父类存在
5.java中的继承是单一继承,直接父类只有一个，
    但是继承具有传递性
6.Object类
   a.如果一个类没有父类，那么它的父类是Object类
   b.Object 是一切类的父类,它的引用可以引用所有对象
   c.equals方法
     equals方法将来是比较两个对象是否相同的标准
         以后在实际应用中如果两个对象比较equals返回true
        我们认为是同一个对象，所以重写equals时候一定要
        注意的是根据现实生活
   d.toString
         直接打印一个对象就会打印该对象toString的返回内容
         
7.final关键字
  修饰变量 ---->
           局部变量:该变量只能赋值一次
           成员变量:final修饰的变量必须通过定义初始化或者构造函数进行初始化
                          这个成员变量也只能赋值一次
 修饰(方法)函数
     该方法不能被重写
 修饰类
    该类不能被继承
  java.lang.String类是final修饰的
  java.lang.Math类是final修饰的
 当内部类访问局部变量时，该变量必须声明为final

1.抽象类
   a.抽象方法  一个方法只有声明没有实现,并且用abstract关键字
          来修饰
   b.如果一个类中含有抽象方法，那么该类就为抽象类,
          需要用abstract关键字来声明,
          只要类声明为abstract就是抽象类,不管是否有抽象方法
   c.抽象体现的还是继承关系（is-a）
           抽象类不能实例化,要实例化只能实例化其子类的对象
          如果看到抽象类类型的引用，那么引用的一定是其子类的对象
   d.继承一个抽象，需要重写其抽象方法，否则自己变成抽象类,就需要用abstract声明

1.抽象类
   a.抽象方法  一个方法只有声明没有实现,并且用abstract关键字
          来修饰
   b.如果一个类中含有抽象方法，那么该类就为抽象类,
          需要用abstract关键字来声明,
          只要类声明为abstract就是抽象类,不管是否有抽象方法
   c.抽象体现的还是继承关系（is-a）
           抽象类不能实例化,要实例化只能实例化其子类的对象
          如果看到抽象类类型的引用，那么引用的一定是其子类的对象
   d.继承一个抽象，需要重写其抽象方法，否则自己变成抽象类,就需要用abstract声明
练习1 完成Shape类，其中的getArea getLength等方法应该为抽象的
           完成Circle类的实现
   e.abstract关键字和final、private关键字是不能一起使用的
   
   
2.接口  是一个标准 体现的是(can-do关系，从语法角度还可以认为is-a)
  案例:制造主板
     主板上可以插显卡，内存条等
     对显卡和内存条有统一的标准
      主板只要遵循这个标准预留出显卡和内存条的插槽即可
      
    如何声明接口通过interface 关键字后面跟接口的名字 和类的地位是等价的
    接口里的所有方法都没有实现，只有声明,而且方法都是public abstract的即使你没有声明
   为public
 
   实现接口用implements关键字,实现接口要重写接口中的所有方法，
   否则该实现类会变成抽象类，要用abstract关键字声明
   
   
  一个类可以实现多个接口
 一个类可以继承另外一个类并同时实现多个接口
 java中是单一继承，但接口除外，一个接口可以继承其它接口，并且可以同时继承多个
 接口中声明的变量都是public static final 的
 
 
 接口抽象类有什么区别
    从语法上分析    区别
    理解上  is-a     can-do
  设计一个报警门
    ---->我认为是门具备了报警的功能，就应该把报警设置为接口
    ---->我认为门只是成了一种报警装置，应该把报警设置为抽象类

练习2:定义接口CanFly
     fly动作
           定义两个类  一个Bird ,Plane
           
3.内部类
  a.成员内部类  Demo8.java
   i.外部内的成员函数创建内部类的对象    
   ii.非静态内部类访问外部类的成员时，前面省略的不是this而是外部类的类名.this
   iii.成员内部类如果非private 如何在外面创建对象
       Outer.Inner 对象 = new 外部类的对象.new Inner();
  b.静态内部类（静态成员） Demo9.java
    i.类似于静态成员变量,就只能访问外部类的静态成员
    ii.如果非private 在外部直接创建对象时，与外部类对象无关
       Outer.Inner 对象 = new Outer.Inner();
  c.局部内部类（类的成员函数中定义的类） Demo10.java
  d.匿名内部类  Demo11.java / Demo12.java
    i.用的是匿名类的对象  
    ii.什么时候用
        已经知道父类，要得到其子类的对象
        已经知道接口,要得到实现了该接口的类的对象
    iii.怎么用
       new 父类名(父类的构造函数参数)
       {
         //子类的实现部分
       }   特别要注意给父类的构造函数传递参数的问题
       or
       new 接口名()
       {
         //实现了接口的类的实现部分
       }
       
 当内部类访问外部类的非成员变量时(局部变量时)该变量必须声明为final

1.成员内部类
2.静态内部类
3.局部内部类
4.匿名内部类
  创建匿名内部类的对象
  已知接口，要获取实现该接口的类的对象时
 new 接口()
 {
   //实现了该接口的类的实现部分
 }
 已知道父类，要获取其子类的对象
 new 父类(要给父类的构造函数传递参数)
 {
    //子类的实现部分
 }