拉勾教育 Java就业急训营 学习笔记——抽象类

学习资源：拉勾教育

---

抽象方法与抽象类的概念

• 抽象方法主要指不能具体实现的方法并且使用abstract关键字修饰，也就是没有方法体。具体格式为：访问权限 abstract 返回值类型 方法名(形参列表);
• 抽象类主要指不能具体实例化的类并且使用abstract关键字修饰，也就是不能创建对象。

抽象类和抽象方法的关系

• 抽象类中可以有成员变量、构造方法、成员方法；
• 抽象类中可以没有抽象方法，也可以有抽象方法；
• 拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是具有抽象方法并且使用abstract关键字修饰的类。

抽象类的实际意义

• 抽象类的实际意义不在于创建对象而在于被继承。
• 当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也就是抽象类对子类具有强制性和规范性，因此叫做模板设计模式。

开发经验分享

• 在以后的开发中推荐使用多态的格式，此时父类类型引用直接调用的所有方法一定是父类中拥有的方法，若以后更换子类时，只需要将new关键字后面的子类类型修改而其它地方无需改变就可以立即生效，从而提高了代码的可维护性和可扩展性。
• 该方式的缺点就是：父类引用不能直接调用子类独有的方法，若调用则需要强制类型转换。

讲解使用的代码

public abstract class AbstractTest {

    private int cnt;

    public AbstractTest() {
    }

    public AbstractTest(int cnt) {
        setCnt(cnt);
    }

    public int getCnt() {
        return cnt;
    }

    public void setCnt(int cnt) {
        this.cnt = cnt;
    }

    // 自定义抽象方法
    public abstract void show();
    
}

public class SubAbstractTest2 extends AbstractTest{

    @Override
    public void show() {
        System.out.println("使用多态方式可以提高代码的可维护性！");
    }

    public void test() {
        System.out.println("第二个子类中独有的方法！");
    }
}

public class SubAbstractTest extends AbstractTest{

    @Override
    public void show() {
        System.out.println("其实我是被迫重写的，否则我也得变成抽象的！");
    }

    public static void main(String[] args) {

        // 1.声明本类类型的引用指向本类类型的对象
        SubAbstractTest sat = new SubAbstractTest();
        sat.show();

        System.out.println("-----------------------------");
        // 2.声明AbstractTest类型的引用指向子类的对象，形成了多态   多态的使用场合之二
        // 多态的使用场合之二：直接在方法体中使用抽象类的引用指向子类类型的对象
        AbstractTest at = new SubAbstractTest2();
        // 编译阶段调用父类版本，运行阶段调用子类版本
        at.show();
        // 调用子类中独有的方法时需要强制转换
        ((SubAbstractTest2) at).test();

        System.out.println("-----------------------------");
        SubAbstractTest2 sat2 = new SubAbstractTest2();
        sat2.test();
    }
}

案例题目——银行的定期账户和活期账户

• 银行有 定期账户和活期账户。继承自 账户类。账户类中：

public class Account{
	private double money;
	public double getLixi(){}
}

代码实现：

public abstract class Account {

    private int money;

    public Account() {
    }

    public Account(int money) {
        setMoney(money);
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        if(money >= 0) {
            this.money = money;
        } else {
            System.out.println("金额不合理！");
        }
    }

    // 自定义抽象方法实现计算利息并返回的功能描述
    public abstract double getLixi();
    // private 和 abstract 关键字不能共同修饰一个方法
    //private abstract double getLixi();
    // final 和 abstract 关键字不能共同修饰一个方法
    //public final abstract double getLix();
    // static 和 abstract 关键字不能共同修饰一个方法
    //public static abstract double getLixi();
}

public class FixedAccount extends Account{

    public FixedAccount() {
    }

    public FixedAccount(int i) {
        super(i);   // 表示调用父类的有参构造方法
    }

    @Override
    public double getLixi() {
        // 利息 = 本金 * 利率 * 时间
        return getMoney() * 0.03 * 1;
    }

    public static void main(String[] args) {

        // 1.声明一个Account类型的引用指向子类类型的对象，c形成了多态
        //Account acc = new FixedAccount(1000);
        Account acc = new FixedAccount();
        acc.setMoney(1000);
        double res = acc.getLixi();
        System.out.println("计算的利息是：" + res);
    }
}