目录
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、一个接口继承多个接口，是没有问题的，如果多个接口中存在规范冲突则不能多继承。
588
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
