黑马程序员--面向对象(继承，多态，抽象类)

------- android培训、java培训、期待与您交流！ ----------

1.如何使用API。
      A:找到文档，打开文档。
      B:点击左上角的显示变成隐藏，然后点击索引
      C:你应该知道你要找谁?Math
            所以，你就在那个输入框里面输入Math，然后回车，再回车。
      D:看这个类的结构
            java.lang 
            类 Math

            java.util 
            类 Scanner
            如果是java.lang包下的类，是可以直接使用的。(Math)
            否则，就需要导包才能使用。(Scanner)
      E:看看对这个类的说明。
      F:看构造方法
            名称：字段 -- 成员变量 -- 属性。

            a:有构造方法，那么，就通过构造方法创建对象使用。
            b:没有构造方法，那么，这个类的成员一般都是静态。
             通过类名调用。
      G:按照正常的操作使用方法。
       左边：
        是否静态：如果静态修饰，那么可以通过类名调用。否则，就必须创建对象调用。
        是否有明确返回值：如果是void类型，就直接调用即可。否则，就可以输出或者赋值。
       右边：
        看方法名：不要写错了。
        看参数：看参数类型及个数。

      例：
       Scanner：解决键盘录入的问题。
             1、导包:放在文件的最前边
              import java.util.Scanner
             2、创建对象：
              Scanner s = new Scanner(System.in);
             3、调用方法：
              int nextInt()   
              s.nextInt();
              猜数字问题
   

import java.util.Scanner;/*随机给定1~100的一个数猜这个数是多少，如果我们猜的数大于这个数，就输出“大了”，小于输出“小了”，直到等于*/class  GuessNumber{public static void main(String[] args) {//随机获取1~100的获取int myRandom = (int)(Math.random()*100)+1;Scanner s = new Scanner(System.in);int temp = 0;//一直判断，直到猜对为止while((temp=s.nextInt())!=myRandom){if(temp>myRandom){System.out.println("大了");}else{System.out.println("小了");}}System.out.println("你猜的太对了");}}

2.继承
     (1)把多个类中的相同的属性和行为进行抽取，封装到一个类中，
         然后再建立新类的时候，不需要从头做起，继承刚才定义的那个类即可。
     (2)好处：
         A:提高代码的复用性。
         B:让类与类之间产生了一个关系，是多态的前提。
     (3)什么时候使用继承?
        A:如果类之间存在着:
        is a 的关系，就可以考虑使用继承。
        B:不要为了继承部分功能，而去使用继承。
     (4)继承的特点：
        A:Java只支持单继承，不支持多继承。
        为什么?如果支持多继承，就会有调用不明确的问题。
        B:Java支持多层(重)继承。
     (5)super和this的区别?
       A:super是一个关键字，代表父类的存储空间标识。(可以理解为父亲的引用)
       B:它和this的用法相似
          a:成员变量
          this.变量 -- 本类的
          super.变量 -- 父类的
          b:构造方法
          this(...) -- 本类的
          super(...) -- 父类的
          c:成员方法
          this.方法名() -- 本类的 
          super.方法名() -- 父类的
    (6)子父类中成员变量的用法：
       A:名称不同，这个太简单了。
       B:名称相同，子类对象的在使用的时候：
   
        先找子类局部范围
        再找子类成员范围
        最后找父类成员范围
        父类的父类成员范围
    (7)子父类中成员方法的用法：
       A:名称不同，这个太简单了。
       B:名称相同，子类对象的在使用的时候：
          先找子类的
          再找父类的
       C:方法重写
          在子类中，方法声明(修饰符,返回值,方法名,参数列表)相同的情况。

         注意事项：
            a:父类中私有方法是不能被重写
            b:子类方法的访问权限一定要大于等于父类的访问权限
            c:静态只能重写静态。(这个不能算，因为静态跟类相关)
            d:
               基本数据类型+void   子类与父类返回值类型必须相同
               引用数据类型   子类重写方法的返回值类型必须为父类这个方法的返回值类型的子类

    (8)子父类中构造方法的用法：
        A:子类的初始化过程中，首先回去执行父类的初始化动作。
            因为子类的构造方法中默认有一个super()。
            为什么?子类要使用父类的成员变量，这个初始化，必须在子类初始化之前完成。
            所以，子类的初始化过程中，会先执行父类的初始化。
        B:如果父类没有无参构造方法
        A:使用super调用父类的带参构造。推荐方式。
        B:使用this调用本身的其他构造。
3.代码块
    (1)执行顺序：
       静态代码块 --> 构造代码块 --> 构造方法
    (2)注意事项：
       静态代码块只执行一次
 
      例：分析如下代码的结果

class X{Y b = new Y();X(){super();System.out.print("X");}}class Y {int a = 19;Y() {System.out.print("Y");}}public class Z extends X {Y y = new Y();Z() {super();//代表先构建父类，不是从这里开始System.out.print("Z");}public static void main(String[] args) {new Z(); }}

     提示：
       一个类的初始化
       A:把class文件加载到内存
       B:在栈内存开辟p变量空间
       C:在堆内存开辟new Person()空间
       D:对成员变量默认初始化
       E:对成员变量显示初始化
       F:走构造方法对成员变量初始化(如果有构造代码块，走构造代码块)
       G:构造完毕，把地址赋值给p变量。

       如果有继承关系，则无论父类还是子类，构造顺序如上

4.final
     (1)是一个关键字，可以用于修饰类，成员变量，成员方法。
     (2)特点：
      它修饰的类不能被继承。
      它修饰的成员变量是一个常量。
      它修饰的成员方法是不能被子类重写的。
5.多态
     (1)同一个对象在不同时刻表现出来的不同状态。
        另外的表达方式：针对同一个对象，编译期类型和运行期类型不一致。
        举例：
        狗(狗是狗,狗是动物)
        水(水，水蒸气，冰)
     (2)前提：
        A:有继承或者实现关系。
        B:有方法重写。
        C:有父类或者父接口引用指向子类对象。
     (3)好处和弊端：
        A:好处
        扩展性和维护性(是由继承保证)。
        B:弊端
        不能使用子类的特有功能。
    (4)向上转型和向下转型
      A:向上转型
      把子类对象赋值给父类或者父接口引用
      B:向下转型
      把父类或者父接口引用强制转换为子类
    (5)多态中的使用成员特点
     A:成员变量
     编译运行都看左边
     B:成员方法
     编译看左边，运行看右边。
  
  
    (6)多态的体现形式
    A:具体类多态(几乎不用)
    B:抽象类多态
    C:接口多态

6.抽象类
    (1)多个具体的事物具备相同的方法声明，而方法体不同，我们就只抽取方法声明，然后定义到一个类中。
       而一个没有方法体的方法是一个抽象方法，一个类中有抽象方法，该类必须定义为抽象类。
    (2)抽象类的特点：
     A:抽象类或者抽象方法用abstract修饰。
     B:抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
     C:抽象类不能被实例化。
     D:子类继承抽象类，要么是抽象类，要么重写所有父类抽象方法。
    (3)抽象类的几个小问题
     A:不能被实例化，要构造方法干啥?
     B:一个类中没有抽象方法，居然定义抽象类，有什么意义?
     C:抽象关键字不能和哪些关键字共存
        a:private
        b:final
        c:static
    (4)抽象类的成员：
       A:成员变量 有变量，也有常量
       B:构造方法 有构造方法，用于子类访问父类数据的初始化
       C:成员方法 有抽象方法，也有非抽象的方法
    (5)抽象类的案例
       A:老师案例
       B:学生案例
       C:员工案例