java知识点总结06-继承多态抽象类

继承：class 子类名 extends 父类名{}

  1 继承的好处：让类和类之间产生联系，是多态的前提

  2 如果父类的方法不能满足需求时，可以在子类中重写方法，将父类的方法覆盖

  3 访问父类的成员：super

  4 子类中所有的构造方法的第一行都会默认给出一个super，访问父类中的无参构造方法

    这是因为子类初始化前一定要先完成父类数据的初始化、

  注意：

     super(…)或者this(….)必须出现在第一条语句上。

     因为如果可以放后面的话，就会对父类的数据进程多次初始化。所以，只能放在第一条语句上。

final ： 可以修饰类，方法，变量          

    特点：

       修饰方法，方法不能被重写。

       修饰类，类不能被继承。

       修饰变量，变量的值不能再改动。其实这个时候变量已经变成了常量。

多态：多态的前提：

           1   有继承关系

           2   有方法的重写（不是必要条件，但只有了方法的重写多态才有意义）

           3   有父类指向子类的引用      Fu  f = new Zi();

          成员访问特点：

                1 成员变量：编译看左边，运

                2 构造方法：子类构造方法默认访问父类的构造方法               Fu f =  new Zi();

                3 成员方法：编译看左边，运行看右边                                     左边      右边

                                     原因：因为有子类方法的重写                              f.show()    f.num 看父类中有没有，有的话就调父类的

                4 静态成员方法：编译看左边，运行看左边                              

                                            因为静态内容和类有关，和对象无关

                 

抽象类： abstract

                        多态分类：

                       A:具体类多态

                       B:抽象类多态

                       C:接口多态

            A  抽象类和抽象方法必须用abstract修饰         

            B  抽象类不一定有抽象方法，有抽象方法的一定是抽象类

            C  抽象类不能实例化

                 1  为什么不能被实例化呢？  因为抽象类中的方法是抽象方法，实例化对象调用里面的方法没有意义

                     所以需要在子类中重写它的抽象方法，并在子类中实例化调用

                 2  抽象方法是没有方法体的方法

                 3  子类初始化前必须完成父类数据的初始化，因为子类会继承父类的数据，可能会用到父类中的数据

                 4  抽象方法只需声明而不需要实现，抽象类的子类必须覆盖所有的抽象方法后才能被实例化，否则这

                    个子类还是一个抽象类，里面的方法是不是抽象的没有本质的影响

            D 抽象类的子类 

                     要么是抽象类

                     要么实现抽象类中的所有抽象方法 

                     抽象类的作用：   强制要求子类必须要重写某些方法

                            抽象类的成员：

                               成员变量 

                               成员方法

                               构造方法

                        不能实例化要构造方法有什么用呢？  是为了子类访问父类数据的初始化

                         abstract class Animal{

                                   public Animal(){}

                                  public abstract void eat()

                           }

                       class  Dog extends Animal{

                                    public Dog(){ 

                                            super();

                                          }

                                 public void eat(){}   

                           }

                      public  class  AbstractDemo{

                         public static void main (String[] args){

                                       Dog d= new Dog();

                                             d.eat;

                                }  

                       }

                                        

接口：   

          

                接口的特点：

                         A:定义接口要用关键字interface表示

                格式：interface 接口名 {}

                         B:类实现接口用implements表示

                格式：class 类名 implements 接口名 {}

                         C:接口不能实例化

                那么，接口如何实例化呢?

                                            按照多态的方式，由具体的子类实例化。其实这也是多态的一种，接口多态。

                         D:接口的实现类

                                            要么是抽象类

                                            要么重写接口中的所有抽象方法

     

                接口的成员特点：

                              A:成员变量

                              只能是常量。 

      默认修饰符：public static final

                              B:构造方法

                              没有构造方法

                              C:成员方法

                              只能是抽象方法。

      默认修饰符：public abstract

                      

抽象类和接口的区别

A:成员区别

抽象类：

成员变量：可以是变量，也可以是常量

构造方法：有构造方法

成员方法：可以是抽象方法，也可以是非抽象方法

接口：

成员变量：只能是常量。默认修饰符 public static final

成员方法：只能是抽象方法。默认修饰符 public abstract

B:关系区别

类与类：

继承关系。只能单继承，可以多层 (重)继承。

类与接口：

实现关系。可以单实现，也可以多实现。

还可以在继承一个类的同时实现多个接口。

 

接口与接口：

继承关系。可以单继承，也可以多继承。

C:设计理念区别

抽象类被继承体现的是： "is a"的关系。抽象类定义的是共性功能。

接口被实现体现的是："like a"的关系。接口定义的是扩展功能。