java枚举成员 map 多个db链接 java 枚举 接口

目录

1.枚举

1.1枚举的概述

1.2定义枚举类的格式：

1.3枚举的特征

2抽象类

2.1抽象类概述

2.2抽象的使用总结与注意事项

2.3抽象类的案例

2.4抽象类的特征，注意事项小结

2.5final和abstract是什么关系？

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

2.7模块案例

2.8模块方法为什么建议使用final修饰？

3接口

3.1接口概述，特点

3.2接口的基本使用：被实现

2.4JDK8开始接口新增方法

2.5使用接口的注意事项

---

1.枚举

1.1枚举的概述

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

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

1.2定义枚举类的格式：

修饰符 enum 枚举名称{
            第一行都是罗列枚举类实例的名称。
}

1.3枚举的特征

1.枚举类都是继承枚举类型：java.lang.Enum；

2.枚举都是最终类，不可以被继承；

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

4.枚举的第一行默认都是罗列枚举对象的名称的；

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

2抽象类

2.1抽象类概述

在Java中abstract是抽象的意思，如果一个类中的某个方法的具体实现不能确定，就可以申明成abstract修饰的抽象方法（不能写方法体了），这个类必须用abstract修饰，被称为抽象类。

2.2抽象的使用总结与注意事项

1.抽象类可以理解成类的不完整设计图，是用来被子类继承的。

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

public abstract class Animal {
    private String name;

    public abstract void run();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class Dog extends Animal{
    @Override
    public void run() {
        System.out.println("狗跑的也很快~~~");
    }
}

2.3抽象类的案例

系统需求：某加油站推出了2种支付卡，一种是预存10000的金卡，后续加油享受8折优惠，另一种是预存5000的银卡 ,后续加油享受8.5折优惠。请分别实现2种卡片进入收银系统后的逻辑，卡片需要包含主人名称，余额，支付功能。

分析实现：

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

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

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

//创建抽象父类
public abstract class Card {
    private String name;
    private double money;
    public abstract void pay(double money);

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

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

//创建白金卡子类，重写抽象的支付方法
public class GoldCard extends Card{

    @Override
    public void pay(double money) {
        double rs = money * 0.8;
        double lastMoney = getMoney() - rs;
        System.out.println(getMoney() + "当前账户总金额：" + getMoney() + "，当前消费了：" + rs + "还剩余：" + lastMoney);
        setMoney(lastMoney);
    }
}

//银卡
public class SilverCard extends Card{

    @Override
    public void pay(double money) {
        double rs = money * 0.85;
        double lastMoney = getMoney() - rs;
        System.out.println(getMoney() + "当前账户总金额：" + getMoney() + "，当前消费了：" + rs + "还剩余：" + lastMoney);
        setMoney(lastMoney);
    }
}

public class Test {
    public static void main(String[] args) {
        GoldCard c = new GoldCard();
        c.setMoney(10000);
        c.setName("san");
        c.pay(300);
        System.out.println("余额：" + c.getMoney());

        SilverCard d = new SilverCard();
        d.setMoney(10000);
        d.setName("san");
        d.pay(300);
        System.out.println("余额：" + d.getMoney());
    }
}

2.4抽象类的特征，注意事项小结

有得有失: 得到了抽象方法，失去了创建对象的能力。

抽象类为什么不能创建对象？

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

2.抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类；

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

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

2.5final和abstract是什么关系？

1.互斥关系；

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

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

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

什么时候使用模板方法模式

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

模块方法模式实现步骤

1.把功能定义成一个所谓的模板方法，放在抽象类中，模板方法中只定义通用且能确定的代码。

2.模板方法中不能决定的功能定义成抽象方法让具体子类去实现。

2.7模块案例

需求：

某软件公司要为某银行的业务支撑系统开发一个利息结算系统，账户有活期和定期账户两种，
活期是0.35%，定期是 1.75%，定期如果满10万额外给予3%的收益，
结算利息要先进行用户名、密码验证，验证失败直接提示，登录成功进行结算。

分析：

1.创建一个抽象的账户类Account作为父类模板，提供属性（卡号，余额）
2.在父类Account中提供一个模板方法实现登录验证，利息结算、利息输出。
3.具体的利息结算定义成抽象方法，交给子类实现。
4.定义活期账户类，让子类重写实现具体的结算方法
5.定义定期账户类，让子类重写实现具体的结算方法
6.创建账户对象，完成相关功能。

public abstract class Account {
    private String cardId;
    private double money;

    public Account() {
    }

    public Account(String cardId, double money) {
        this.cardId = cardId;
        this.money = money;
    }

    /**
      模板方法
     */
    public final void handle(String loginName , String passWord ){
        // a.判断登录是否成功
        if("li".equals(loginName) && "123456".equals(passWord)){
            System.out.println("登录成功。。");
            // b.正式结算利息
            // 当前模板方法知道所有子类账户都要结算利息，但是具体怎么结算，模板不清楚，交给具体的子类来计算
            double result = calc();
            // c.输出利息详情
            System.out.println("本账户利息是："+ result);
        }else{
            System.out.println("用户名或者密码错误了");
        }
    }

    public abstract double calc();


    public String getCardId() {
        return cardId;
    }

    public void setCardId(String cardId) {
        this.cardId = cardId;
    }

    public double getMoney() {
        return money;
    }

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

重写利息结算功能：

public class CurrentAccount extends Account {

    public CurrentAccount(String cardId,  double money) {
        super(cardId, money);
    }

    @Override
    public double calc() {
        // b.正式结算利息
        double result =  getMoney() * 0.0175; // 结算利息了
        return result;
    }

}

public class Test {
    public static void main(String[] args) {
        CurrentAccount acc = new CurrentAccount("ICBC-111", 100000);
        acc.handle("li", "123456");
    }
}

2.8模块方法为什么建议使用final修饰？

模块方法是给子类直接使用的，不是让子类重写的，一旦子类重写了模板方法就失效了。

3接口

3.1接口概述，特点

接口是一种规范。

 接口的定义与特点：

1.接口的格式如下

2. JDK8之前接口中只能是抽象方法和常量，没有其他成分了。

3.接口不能实例化。

4.接口中的成员都是public修饰的，写不写都是，因为规范的目的是为了公开化。

public interface SportManInterface {
    // 接口中的成员：JDK 1.8之前只有常量 和 抽象方法
    // public static final 可以省略不写，接口默认会为你加上！
    // public static final String SCHOOL_NAME = "黑马";
    String SCHOOL_NAME = "li";

    // 2、抽象方法
    //  public abstract 可以省略不写，接口默认会为你加上！
    // public abstract void run();
    void run();

    // public abstract void eat();
    void eat();
}

public class Test {
    public static void main(String[] args) {
        // 接口不能创建对象！
        // SportManInterface s = new SportManInterface();
    }

3.2接口的基本使用：被实现

接口的用法：

1.接口是用来被类实现（implements）的，实现接口的类称为实现类。实现类可以理解成所谓的子类。

2.从上面可以看出，接口可以被类单实现，也可以被类多实现。

接口实现的注意事项：

一个类实现接口，必须重写完全部接口的全部抽象方法，否则这个类需要定义成抽象类。

2.3接口与接口的关系：多继承

基本小结：

1.类和类的关系：单继承。

2.类和接口的关系：多实现。

3.接口和接口的关系：多继承，一个接口可以同时继承多个接口。

接口多继承的作用：

规范合并，整合多个接口为同一个接口，便于子类实现。

public interface Law {
    void rule(); // 遵章守法
    void eat();
}

public interface People {
    void eat();
}

public interface SportMan extends Law, People {
    void run();
    void competition();
}

public class BasketballMan implements SportMan{

    @Override
    public void rule() {

    }

    @Override
    public void eat() {

    }


    @Override
    public void run() {

    }

    @Override
    public void competition() {

    }
}

首先SportMan接口继承了Law和People两个接口，故在BasketballMan类中只需要继承SportMan接口，但必须重写所有方法。

2.4JDK8开始接口新增方法

接口新增方法的原因？

在丰富接口功能的同时又不对子类代码进行更改。

第一种：默认方法

1.类似之前写的普通实例方法：必须用default修饰；

2.默认会public修饰。需要用接口的实现类的对象来调用。

 第二种：静态方法

1.默认会public修饰，必须static修饰。

2.注意：接口的静态方法必须用本身的接口名来调用。

 第三种：私有方法

1.就是私有的实例方法:，必须使用private修饰，从JDK 1.9才开始有的；

2.只能在本类中被其他的默认方法或者私有方法访问。

public interface SportManInter {
    /**
       1、JDK 8开始 ：默认方法(实例方法)
       -- 必须default修饰，默认用public修饰
       -- 默认方法，接口不能创建对象，这个方法只能过继给了实现类，由实现类的对象调用。
     */
    default void run(){
        go();
        System.out.println("跑的很快~~~");
    }

    /**
      2、静态方法
        必须使用static修饰，默认用public修饰
        -- 接口的静态方法，必须接口名自己调用。
     */
    static void inAddr(){
        System.out.println("我们都在学习Java新增方法的语法，它是Java源码自己会用到的~~~");
    }

    /**
       3、私有方法（实例方法）
         -- JDK 1.9开始才支持的。
         -- 必须在接口内部才能被访问
     */
    private void go(){
        System.out.println("开始跑~~~");
    }

}

class PingPongMan implements SportManInter{
}

class Test{
    public static void main(String[] args) {
        PingPongMan p = new PingPongMan();
        p.run();


        SportManInter.inAddr();
        // PingPongMan.inAddr();
    }
}

2.5使用接口的注意事项

1、接口不能创建对象
2、一个类实现多个接口，多个接口中有同样的静态方法不冲突。
3、一个类继承了父类，同时又实现了接口，父类中和接口中有同名方法，默认用父类的。
4、一个类实现了多个接口，多个接口中存在同名的默认方法，不冲突，这个类重写该方法即可。
5、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。