面向对象编程（二）

修饰符	同一个类中	同一个包中其他类	不同包下的子类	不同包下的无关类
private	√
缺省	√	√
protected	√	√	√
public	√	√	√	√

三、final

1、final的作用

final 关键字是最终的意思，可以修饰（类、方法、变量）

修饰类：表明该类是最终类，不能被继承。

修饰方法：表明该方法是最终方法，不能被重写。

修饰变量：表示该变量第一次赋值后，不能再次被赋值(有且仅能被赋值一次)。

2、final修饰变量的注意

final修饰的变量是基本类型：那么变量存储的数据值不能发生改变。

final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的。

四、常量

1、常量概述和基本作用

1）、常量

常量是使用了public static final修饰的成员变量，必须有初始化值，而且执行的过程中其值不能被改变。

常量名的命名规范：英文单词全部大写，多个单词下划线连接起来。

常量的作用：通常用来记录系统的配置数据。

2）、常量做信息配置的原理、优势

在编译阶段会进行“宏替换”：把使用常量的地方全部替换成真实的字面量。

维护系统容易，可读性更好。

2、常量做信息标志和分类的优点

代码可读性好，实现了软编码形式。

五、枚举

1、枚举的概述

枚举是Java中的一种特殊类型。

枚举的作用："是为了做信息的标志和信息的分类"。

2、定义枚举类的格式

3、反编译后观察枚举的特征

4、枚举的特征

枚举类都是继承了枚举类型：java.lang.

Enum 枚举都是最终类，不可以被继承。

构造器都是私有的，枚举对外不能创建对象。

枚举类的第一行默认都是罗列枚举对象的名称的。

枚举类相当于是多例模式。

六、抽象类

1、抽象类

1）、抽象类

在Java中abstract是抽象的意思，可以修饰类、成员方法。

abstract修饰类，这个类就是抽象类；修饰方法，这个方法就是抽象方法。

2）、注意事项

抽象方法只有方法签名，不能声明方法体。

一个类中如果定义了抽象方法，这个类必须声明成抽象类，否则报错。

3)、抽象的使用场景

抽象类可以理解成不完整的设计图，一般作为父类，让子类来继承。

当父类知道子类一定要完成某些行为，但是每个子类该行为的实现又不同，于是该父类就把该行为定义成抽象方法的形式，具

体实现交给子类去完成。此时这个类就可以声明成抽象类。

2、抽象类的应用案例

1）、系统需求

某加油站推出了2种支付卡，一种是预存10000的金卡，后续加油享受8折优惠，另一种是预存5000的银卡 ,后续加油享受8.5折

优惠。

请分别实现2种卡片进入收银系统后的逻辑，卡片需要包含主人名称，余额，支付功能。

2）、分析实现

创建一张卡片父类：定义属性包括主人名称、余额、支付功能（具体实现交给子类）

创建一张白金卡类：重写支付功能，按照原价的8折计算输出。

创建一张银卡类：重写支付功能，按照原价的8.5折计算输出。

3）、代码展示

1、创建父卡

public abstract class Card {
    public static final double preferentialPrice = 0.8;
    private String userName;
    private double money;

    /**
        定义一个支付方法：表示卡片可以支付。
        抽象方法
     */
    public abstract void pay(double money2);

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }
}

2、创建金卡

public class GoldCard extends Card{
    @Override
    public void pay(double money2) {
        System.out.println("您当前消费："+money2);
        System.out.println("您卡片的当前余额为：" + getMoney());
        //优惠价
        double rs = money2 * preferentialPrice;
        System.out.println(getUserName()+"：您实际支付了："+rs);
        //更新账户余额
        setMoney(getMoney() - rs);
    }
}

3、测试类

public class Test {
    public static void main(String[] args) {
        //目标： 学习一下抽象类的基本使用：做父类，被继承，重写抽象方法
        GoldCard g = new GoldCard();
        g.setUserName("小王");
        g.setMoney(10000);
        g.pay(600);
        System.out.println(g.getMoney());
    }
}

4）、结果展示

3、抽象类的特征、注意事项

1）、特征和注意事项

类有的成员（成员变量、方法、构造器）抽象类都具备。

抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。

一个类继承了抽象类必须重写完抽象类的全部抽象方法，否则这个类也必须定义成抽象类。

不能用abstract修饰变量、代码块、构造器。

最重要的特征：得到了抽象方法，失去了创建对象的能力（有得有失）。

2）、final和abstract的关系

互斥关系

abstract定义的抽象类作为模板让子类继承，final定义的类不能被继承。

抽象方法定义通用功能让子类重写，final定义的方法子类不能重写。

4、抽象类的应用知识：模板方法模式

1）、使用场景说明

使用场景说明：当系统中出现同一个功能多处在开发，而该功能中大部分代码是一样的，只有其中部分可能不同的时候。

2）、模板方法模式实现步骤

1、定义一个抽象类。

2、定义2个方法，一个是模板方法：把相同代码放里面去，不同代码定义成抽象方法

3、子类继承抽象类，重写抽象方法。

3）、案例需求

现在有两类学生，一类是中学生，一类是小学生，他们都要写《我的爸爸》这篇作文。

要求每种类型的学生，标题第一段和最后一段，内容必须一样。

正文部分自己发挥。请选择最优的面向对象方案进行设计。

4）、分析

5）、代码

1、父类

public abstract class Student {
    public final void write(){
        System.out.println("\t\t\t\t\t《我的爸爸》");
        //正文部分（每个子类都要写的，每个子类写的情况不一样
        // 因此。模板方法把正文部分定义成抽象方法，交给
        // 具体的子类来完成）
        System.out.println(writeMain());

        System.out.println("我的爸爸简直太好了~~");
    }
    public abstract String writeMain();
}

2、小学生子类

public class StudentChild extends Student{
    @Override
    public String writeMain() {
        return "我的爸爸是最棒的！~！";
    }
}

3、中学生子类

public class StudentMiddle extends Student{


    @Override
    public String writeMain() {
        return "我的爸爸也很牛";
    }
}

4、测试类

public class Test {
    public static void main(String[] args) {
        //目标： 理解模板方法模式的思想和使用
        StudentChild s1 = new StudentChild();
        s1.write();

        StudentMiddle s2 = new StudentMiddle();
        s2.write();
    }
}