继承和抽象类

java对象的三大特征

0. 面向对象核心思想：解决问题，先考虑对象
1. 封装
   隐藏内部实现细节，对外暴露可访问的方法
2. 继承
   子类继承父类，拥有父类所有的属性和方法（特殊除外）
3. 多态
   父类引用子类对象，父类引用调用方法，执行的是子类重写的方法

一. 封装

  隐藏内部实现细节，对外暴露可访问的方法

1. 类（class）

1. 类是什么？
   一类事务的抽象描述
   2）为什么要有类？
   I .要有对象，必先有类
   II. 对象/实例：一类事物某个实际例子
   3）类中包含什么？
   I. 成员变量
   II. 成员方法
   III. 构造方法
   IV. 代码块
   V. 内部类

2.构造方法和this

 1. 构造方法
   1). 构造的方法名和类名一致
   2）有个隐式声明：如果一个类没有声明任何构造，回有默认public空参构造
 2. 构造方法的主要作用
   1). 创建对象
   2). 通过构造方法对实例的成员属性进行赋值 
 3. this关键字
   1）this：当前对象（谁调用就是谁）
   2）隐式声明
      I. this本身就是隐式内容
      II. 在类中调用本类的成员属性/方法，默认this调用
           （当前方法中存在局部age变量时，隐式的this会被擦除）

3.匿名对象

   1.含义：没有名字的对象
   2.匿名对象：没有给一个变量赋值，而是直接调用
   3.匿名对象的特点
     1) 好处：语法简单
     2) 局限：因为没有变量记住匿名对象的地址，所以只能一次性使用

二.继承

生活中的继承

  父亲有的东西，会被儿女所拥有

java中的继承

 ##  1.概述：子类继承父类，拥有父类所有的属性和方法（除构造/private之外）
 ##  2.语法：
     class A extends B{ //类体}
     1）extends：关键字
     2）B是一个类，叫做A的父类/超类/基类（super class）
       A也是一个类，叫做B的子类
     3) 作用：B中的定义属性/方法，A可以直接使用（除构造/private之外）
 ##  3.继承的作用：
     0) 概括：提高代码的复用性
     1）父类是所有子类的共性抽取
     2）共性内容不需要重复定义，避免代码冗余
 ## 4.子类不能继承的内容
     1.父类的构造不能被继承
           0）父类的构造，在子类是不存在的
           1）构造方法名跟类名相同
           2) 构造的主要作用就是创建对象
           3) 注意：子类可以调用父类的构造
      2. 父类private修饰的内容也认为不能被继承
           1) 父类的private修饰的内容，子类是有的，只是不能直接调用
           2）子类可以通过父类的非private方法进行间接调用    
 ##  5.继承的细节
            0.java运行时的内存
                  ### java代码生命周期（从创建到消失整个过程）
                     .java(源码)  -->  .class(字节码)  --> runtime(运行时)
                                      编译（compile）       运行
                       硬盘（磁盘 disk）  硬盘            内存（memory）
             1. 堆(heap)：存储对象         
             2. 栈(stack)：执行方法
                                1）方法执行的时候，要先入栈（进栈）   
                                2）方法执行结束，会弹栈（出栈）
              3. 方法区(method area)：存储字节码文件
              4. 本地方法栈（native method stack）：执行本地的方法（c/c++）
              5. 程序计数器                           
 ## java运行，为什么在内存中？
        1.集成电路：由电子元件构成的（开关）0 和 1
            cpu  / 内存 / 硬盘
        2. cpu：中央处理器
             计算机的数据管理和运算都在cpu执行
         3. cpu速度最快，内存次之，硬盘最慢       
             （数据先从硬盘加载到内存中，供cpu使用）  

继承中成员变量的特点

 1. 父子类中成员变量不同名的情况
     1）父类的成员变量被子类所拥有（继承，除了private之外）
     2） 子类的成员变量是属于子类的，父类对象不能调用
2. 父子类中成员变量同名的情况
     1）为什么父类和子类可以拥有同名的成员变量？
            因为在子类对象中，父类的属性和子类的属性是分开存放的
      2）this和super
             I this：谁调用就是谁
                        先调用子类的属性，后调用父类的属性
             II super：this的父类区域
                             是this的子集

方法重写

       1.子类拥有跟父类完全一样的方法，称之为方法重写
             1）方法名相同
             2）参数列表相同
             3）返回值相同
         2.方法重写的作用
             1）父类的方法不适用于子类，子类需要重新定义
              2）父类的方法过于简单，子类需要增强
                           super.父类的方法
                            子类增强的内容

方法重载和方法重写

 1. 方法重载（overload）
     1）发生在同一个类中
     2）方法名相同，参数列表不同的方法
             参数个数
              参数顺序
              参数类型
   2. 方法重写（override）
     1) 发生在由继承关系的两个类中
     2）在子类中定义与父类完全一致的方法
             方法名
             参数列表
             返回值

继承中构造方法的特点

         # 原则：子类必须调用到父类的构造方法
               1.构造方法不可被继承
               2.子类调用父类的构造方法的语法：
                        super(参数列表)
                        子类调用父类的构造，必须在子类的构造中
                 3. 子类为什么要调用父类的构造方法：
                        1）在通过子类构造创建对象的时候，子类构造会调用父类的构造
                        2）父类的属性由父类构造自己赋值，子类的属性由子类自己赋值，更符合面向对象的封装

三. this和super关键字

    # this和super的含义
      1. this：当前对象（谁调用就是谁）
      2. super：this的父类区域
    # this和super在继承关系中使用
    1. 属性
        this.属性：调用当前对象的属性
        super.属性：调用当前对象的父类属性
     2. 方法
         this.方法：调用当前对象的方法
                   如果子类有，先调用子类，没有调用父类
          super.方法：调用当前对象的父类方法
     3. 构造
               this(参数列表)：调用本类的构造
               super (参数列表)：调用父类的构造
           规定：以上两个语法都必须在构造方法中使用，而且必须在有效代码第一行

四. 抽象类

         ## 抽象方法
         1.当我们定义一个类的时候，知道这个类有某方法，但是不知道具体的实现:就有了抽象方法
         2.抽象方法是没有方法体的方法，在方法声明中，需要关键字abstract
         3.拥有抽象方法的类，必须是抽象类，用abstract修饰
        ## 抽象类
         1.抽象类不能实例化（不能创建对象）
         2.抽象类的主要作用是被其他类所继承
         3. 一个类B继承抽象类A，也会拥有A的抽象方法
             1）要么B声明为抽象类
             2) 要么B重写这些抽象方法
         4.拥有抽象方法的类一定是抽象类，抽象类可以没有抽象方法
         ## 抽象类存在的意义之一：模板设计模式
          1.设计模式：解决一类问题的固定套路，就是前任总结的最优方法
          2.模板设计模式的案例：
              类：司机
              方法：开车
                         1.启动：踩离合，点火，挂挡起步
                         2.开车中 style（因为不同的老司机开车的风格不同，所以抽象）
                         3.停火：踩刹车，熄火
              子类：A老司机  B 老司机
                         继承老司机，只要重写style方法即可
             3.模板设计模式的好处：
                         固定的内容抽取到父类中，形成一个模板
                         不固定内容抽象化，交给子类去实现                                          

public abstract class Driver{
 //模板
    public void driver(){
      System.out.println("启动：踩离合，点火，挂挡起步")；
      this.style();
      System.out.println("停车：踩刹车，熄火")
    }
    //开车风格
    public abstract void style();
}

class ADriver extends Driver{
    @Override
    public void style() {
        System.out.println("单手漂移");
    }
}
class BDriver extends Driver{
    @Override
    public void style() {
        System.out.println("一路狂飙");
    }
}