java入门－＞基础知识5 继承，常量，抽象，接口，多态，内部类

一.继承 ：

  1.方法的重写

    1.1）发生在父子类中，方法名称相同，参数列表相同，方法体不同；

    1.2）重写方法调用时，看对象的类型；

    1.3）作用：避免代码的重复，有利于代码的重用；

    1.4）通过entends实现继承；

    1.5）父类：所有子类所共有的属性和行为；   子类：子类所特有的属性和行为；

    1.6）子类继承父类后，  子类具有=子类+父类；

    1.7）一个父类可以有多个子类，一个子类只能有一个父类——》单一继承；

    1.8）继承具有传递性；

    1.9）java规定构造子类之前必须先构造父类。  子类构造中若自己不调用父类构造，则默认为super()调用父类的无参构造，若              自己写了，则不在默认提供，super()调父类构造必须位于子类构造第一句；

  2    super():指代当前对象的父类对象

      super().成员名——访问父类的成员变量

      super().方法名——调用父类的方法

      super(). ——调用父类的构造方法

 3 向上造型

     3.1）父类型的引用指向子类的对象；

     3.2）能点出来什么，看引用的类型；

     3.3）造型成的类：父类，接口；

 4.重写与重载的区别

    4.1）重写：父子类中，方法名相同，参数列表相同，方法体不同； 遵循运行期绑定，根据对象的类型；

    4.2）重载：同一个类中，方法名相同，参数列表不同； 遵循编译期绑定，根据参数引用的类型；

 5.重写遵循两同两小一大原则、

    5.1）两同：方法名称相同，

                       参数列表相同

    5.2）两小：子类的返回值类型小于或等于父类；

                        返回值类型为void时，必须相等；

                        返回值类型为基础类型时，必须相等；

                        返回值类型为引用类型时，可以小于或等于；

    5.3）一大：子类的访问权限大于或者等于父类；

二：package:

    1) 避免类的命名冲突；

    2）包名可以有层次结构；

    3）建议：包名所有字母都小写；

    4）完全限定名，包名，类名； 

三：import:

    1）同包中的类可以互相访问；

         不同包中的类想访问：

          1）import先申明引入类后再使用；

          2）完全限定名——不建议

          3）语法：import 包名.类名

四：访问控制修饰符

    1）public：公共的，任何类；

    2）protected：受保护的，本类，子类，同包类；

    3）默认的：什么也不写，本类，同包类；

    4）private：私有的，本类；

五：static：静态的

    1）静态变量

         1.1）由static修饰；

         1.2）属于类，存在公共区中，只有一份；

         1.3）常常通过类名. 访问；

         1.4）何时用：当所有对象数据都一样时使用；

    2）静态方法

         2.1）由static修饰；

         2.2）属于类，存在方法区中只有一份；

         2.3）常常通过类名. 访问；

         2.4）静态方法没有隐式的this传递，所以静态方法中不能直接访问实例成员；

         2.5）何时用：方法的操作仅与参数相关而与对象无关的时候；

    3）静态块

         3.1） 由static修饰；

         3.2）在类被加载时自动执行，因此只被加载一次，所以静态块也只执行一次；

         3.3）何时用：常常用于加载静态资源（图片，音频，视频等）

六：final

    1）修饰变量，变量不可被改变；

    2）修饰方法，方法不可被重写；

    3）修饰类，类不可被继承；

    final修饰成员变量，两种初始化方式：

          1）声明时初始化；

          2）构造方法中初始化；

    final修饰局部变量

           1）使用之前初始化即可；    

七：常量

    7.1）由static final修饰，必须声明时同时初始化；

    7.2）不能改变，通过类名来访问；

    7.3）建议：常量名所有字母大写（多个单词用下划线_分割）；

    7.4）编译器在编译时被直接替换为具体的数，所以效率高；

八：抽象方法

    8.1）由abstract修饰；

    8.2）只有方法的定义，没有方法的实现 {}都没有；

九：抽象类

    9.1）由abstract修饰；

    9.2）包含抽象方法的类必须是抽象类，不包含抽象方法的类也可以声明为抽象类；

    9.3）抽象类不能被实例化；

    9.4）抽象类是要被继承的；

        子类：9.4.1）重写父类的所有抽象方法；

                   9.4.2）也可申明为抽象类——一般不这么用；

    9.5）抽象类的意义：

          父类的意义；9.5.1）封装子类公有的属性和行为，被子类公用；

                                9.5.2）为所有子类提供一种统一的类型——>向上造型；

           可以包含抽象方法，为所有子类提供了一个统一的入口，每个子类具体的实现不同；

十：接口 ：引用数据类型

    10.1）是一个标准规范，由interface定义；

    10.2）接口中只能包含常量(默认)和抽象方法(默认)；

    10.3）接口不能被实例化；

    10.4）接口是要被实现的，实现类；必须重写接口中的所有方法；

    10.5）一个类可以实现多个接口，又继承又实现，必须先继承后实现；

    10.6）接口可以继承接口；

十一：多态:多种形态

    11.1）多态的意义：

        11.1.1）同一类型的引用指向不同的对象时，有不同的实现； eg:行为的多态：cut();run();

        11.1.2）同一个对象被造型为不同的类型时，有不同的功能；eg:对象的多态：水，冰；

    11.2）向上造型：

        11.2.1）父类型的引用指向子类的对象；

        11.2.2）能造型成的类型为：父类实现的接口；

        11.2.3）能点出来什么，看引用的类型；

    11.3）强制类型的转换：成功条件

        11.3.1）引用所指向的对象，就是该类型；

        11.3.2）应用所指向的对象，实现了该接口；

    11.4）若违背如上两个条件，则发生类型转换异常

        11.4.1）建议强转之前通过 instanceof来判断是否是该类型，instanceof为true的条件就是强转成功的条件；

十二：成员内部类

    12.1）类中套类，里面的叫内部类，外面的叫外部类；

    12.2）内部类通常只服务与外部类，对外不具备可见性；

    12.3）内部类对象通常只在外部类创建；

    12.4）内部类中可以直接访问外部内成员（包括私有的），内部类中有个隐式的引用指向创建它的外部类对象，

               外部类名.class 成员变量；

十三：匿名内部类

    13.1）想创建一个类的对象，对象创建后，类的意义就不存在了，此时该类不必命名，称之为匿名内部类；

    13.2）匿名内部类若想访问外部的变量，变量必须是final的；

 

总结：面向对象的三大特点

    1）封装

       1.1）类：封装的对象的属性和行为；

       1.2）方法：封装的功能的具体实现；

       1.3）访问修饰符：封装的是访问的权限；

   2） 继承

       2.1）减少代码的重复，有利于代码的重用；

       2.2）父类：所有子类所共有的，子类：子类所特有的；

       2.3）一旦子类继承了父类，子类具有：父+子；

    3）多态

       3.1）意义：行为的多态，对象的多态；

       3.2）向上造型：强制类型装换 instanceof；

       3.3）多态后，代码扩展性，维护性好；

       3.4）多态的表现形式：重写和重载；