JavaSE 51 面向对象 → 抽象类＜继承＞

8.13 抽象类

---

8.13.1 抽象类理解和使用

• abstract 修饰符可以用来修饰方法也可以用来修饰类，如果修饰方法，那么该方法就是 “抽象方法”（抽象方法自己不能具有主体），如果修饰 类，那么 该类 就是 “抽象类”。
  

• 抽象类中 可以没有抽象的方法！但是有抽象方法的类 一定要声明为 抽象类。（C/C++ 中 就不是这么 严格）
  

• 抽象类，不能使用 new 关键字来创建对象，抽象类只是用来让 子类继承的。（无法 进行 实例化！因为 抽象类 代表着 抽象，是反对 实例化的！）

• 子类继承抽象类，那么就必须要实现 抽象类没有实现的抽象方法，否则该 子类也要声明为抽象类。（反正总要有一个类，去实现这些抽象类没有实现的方法！<工具人>）
  

package 抽象类;

public class Action {

    //约束 ~ 如果有人帮我们实现 这个 方法就好了。
    public void doSomething()
    {

    }
}

怎么办呢？这个时候 如果 将 doSomething() 抽象化，就可以 让 它的子类 去帮它 实现 这个方法了。

package 抽象类;

public abstract class Action {

    //约束 ~ 如果有人帮我们实现 这个 方法就好了。
    /*public void doSomething()
    {

    }*/
    public abstract void doSomething();

}


package 抽象类;

public class A extends Action{
    public void doSomething()
    {
        System.out.println("我正在搞事！");
    }

}

extends 的 局限性：只能实现 单继承，即子类的父类只有一个！这是很不方便的。Java里 有个东西 叫做 “接口”，可以使 “类” 实现多个 接口！这叫 “多接口的实现” 。

所以即使是 “接口” 可以让 类 实现多个接口！我们 也不能说这叫 多继承！在Java里，多继承是不存在的，一个子类只能有一个父类，只不过，一个子类可以有 多个 接口。 但是 “接口” 不是 “类”。它们是有差别的。

接口：只能让类多接口实现！即 假象的 让你认为 子类拥有了 多个 父亲！

1. 抽象类 不能 new 出来！只能靠 子类去实现它，约束！
2. 抽象类中 可以写普通的方法。
3. 抽象方法必须在抽象类中。

抽象 只是个约束！Java 的重写其实也是个约束，保留着 父类的方法，而 只取 子类的方法。

---

8.13.2 抽象类存在构造器吗

答：有！是具有 构造器的！

//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by FernFlower decompiler)
//

package 抽象类;

public abstract class Action {
    public Action() {
    }

    public abstract void doSomething();
}

原因：大家可能 都被 构造器最大的功能，创建 对象 给蒙蔽了双眼。大家想一想，构造器 是不是 还具有 一定的初始化作用？比如说 普通类方法地址的 压栈，变量的初始化 等等。这些 不都是 构造器 的功能吗？ 如果 作为 一个类！被 抽象化后，失去了 构造器！那么 就相当于 它 不再 是一个 类。所以这是不科学的。 构造器 在 抽象化类 里面 也是必须 存在的！

---

8.13.3 抽象类的作用

抽象类 是为了 实现多态中的共同点！也就是说 主要是为 “多态” 而进行服务的。

我个人 把 抽象类的作用，叫做 “方法的助写”，就是帮助 父类 写 方法！而 不被 static 修饰的 方法，同名 情况下，只取 子类的方法，这叫 “方法的重写”。而两种 “写”，都是为 “多态” 进行服务的。

抽象 确实可以提高 开发效率，比如说 基类里面 可以写很多 公共的 方法，供给 子类 使用！ 而 当我们需要 添加一个 新的 功能 时，我们 直接 在 基类里面 写个 抽象方法就可以了。然后 交给 一个 子类 进行 “助写”！

---

8.13.4 多态实现简单的四则运算<重写>

package 多态;

public class Calculator {
    int numA;
    int numB;

    public int getNumA()
    {
        return numA;
    }

    public int getNumB()
    {
        return numB;
    }

    public void setNumA(int a)
    {
        this.numA = a;
    }

    public void setNumB(int b)
    {
        this.numB = b;
    }

    public int operate()
    {
        System.out.println("父类的基本运算！");
        return 0;
    }

}
---------------------------------------
package 多态;

public class Add extends Calculator{

    public Add()
    {

    };

    public Add(int a,int b)
    {
        super.setNumA(a);
        super.setNumB(b);
    };

    public int operate()
    {
        int a = super.numA;
        int b = super.numB;

        return a+b;
    }

}
---------------------------------------
package 多态;

public class Subtract extends Calculator {

    public Subtract()
    {

    };

    public Subtract(int a,int b)
    {
        super.setNumA(a);
        super.setNumB(b);
    };
    public int operate()
    {
        int a = super.numA;
        int b = super.numB;
        return a - b;
    };
}
-------------------------------------------------
package 多态;

public class Multiply extends Calculator {
    public Multiply()
    {

    };

    public Multiply(int a,int b)
    {
        super.setNumA(a);
        super.setNumB(b);
    };
    public int operate()
    {
        int a = super.numA;
        int b = super.numB;
        return a * b;
    };
}

-------------------------------------------------
package 多态;

public class Divide extends Calculator {
    public Divide()
    {

    };

    public Divide(int a,int b)
    {
        super.setNumA(a);
        super.setNumB(b);
    };
    public int operate()
    {
        int a = super.numA;
        int b = super.numB;
        if(b == 0)
        {
            System.out.println("分母不能为0");
            return 0;
        }
        return a / b;
    };
}
-----------------------------------------------
package 多态;

public class Item {
    public static void main(String[] args) {
        Calculator a = new Add();
        Calculator s = new Subtract(20,10);
        Calculator m = new Multiply(222,10);
        Calculator d = new Divide(50,0);

        a.setNumA(20);
        a.setNumB(2);

        System.out.println(a.operate());
        System.out.println(s.operate());
        System.out.println(m.operate());
        System.out.println(d.operate());



    }
}

---

8.13.5 多态实现简单的四则运算<助写>

package 抽象类;

public abstract class Calculatior {
    int numA;
    int numB;

    public int getNumA()
    {
        return numA;
    }

    public int getNumB()
    {
        return numB;
    }

    public void setNumA(int a)
    {
        this.numA = a;
    }

    public void setNumB(int b)
    {
        this.numB = b;
    }

    public abstract int operate();

}
----------------------------------------------
package 抽象类;

public class Add extends Calculatior {

    Add(){};
    Add(int a,int b){
        super.numA = a;
        super.numB = b;
    }

    public int operate()
    {

        return super.numA +  super.numB;
    }


}
-----------------------------------------------
package 抽象类;

public class Subtract extends Calculatior {
    Subtract(){};
    Subtract(int a,int b){
        super.numA = a;
        super.numB = b;
    }

    public int operate()
    {
        return super.numA -  super.numB;
    }

}
------------------------------------------
package 抽象类;

public class Multiply extends Calculatior {
    Multiply(){};
    Multiply(int a,int b){
        super.numA = a;
        super.numB = b;
    }

    public int operate()
    {
        return super.numA *  super.numB;
    }
}
---------------------------------------------
package 抽象类;

public class Divide extends Calculatior{
    Divide(){};
    Divide(int a,int b){
        super.numA = a;
        super.numB = b;
    }

    public int operate()
    {
        if(super.numB == 0) {
            System.out.println("分母不能为0");
            return -1;
        }
        return super.numA /  super.numB;
    }

}
-----------------------------------------------
package 抽象类;

import javax.security.auth.Subject;
import java.util.Date;

public class Item {
    public static void main(String[] args) {
        Calculatior a = new Add();
        Calculatior s = new Subtract(10,2);
        Calculatior m = new Multiply(20,50);
        Calculatior d = new Divide(30,20);
        a.setNumA(10);
        a.setNumB(10);
        System.out.println(a.operate());
        System.out.println(s.operate());
        System.out.println(m.operate());
        System.out.println(d.operate());
    }
}