记录java基础学习中有关常量、枚举类、抽象类和多态的内容。
1 常量
- 什么是常量?
- 常量是使用了public static final修饰的成员变量,必须有初始化值,而且执行的过程中其值不能被改变。
- 常量名的命名规范:英文单词全部大写,多个单词下划线连接起来。
public class Constant {
public static final String SCHOOL_NAME = “清华校园";
public static final String LOGIN_NAME = “admin";
public static final String PASS_WORD = “123456";
}
- 常量的作用:通常用来记录系统的配置数据。
2 枚举
枚举(enum)是一种特殊的类(class),它用于盛放一组有限且确定的常量集合。
2.1 枚举的声明
修饰符 enum 枚举名称{
第一行都是罗列枚举类实例的名称。每个实例实际是构造方法调用而来。
}
在这个例子中,每个枚举常量都是枚举类型的唯一实例,并且在编译时就被默认调用无参构造创建了。
2.2 枚举的特点:
-
类型安全:枚举类型确保只能使用预定义的值,从而避免了拼写错误或意外地使用非法值的情况。
-
单例性:枚举中的每个元素都是一个单例对象,这意味着无论何时何地创建枚举实例,同一枚举常量的引用始终指向相同的内存地址。
-
继承自Enum类:所有的枚举都隐式地继承自
java.lang.Enum
类,因此可以访问到Enum
类提供的方法,如name()
(返回枚举常量的名称)、ordinal()
(返回枚举常量在其枚举类型中的位置索引)等。 -
可定制化:枚举不仅可以包含预定义的常量,还可以定义自己的方法、属性以及实现接口:
public enum Color { //相当于调用了构造方法 //public static final Color RED = new Color("红色"); RED("红色"), GREEN("绿色"), BLUE("蓝色"); private String chineseName; // 有参构造器 Color(String chineseName) { this.chineseName = chineseName; } // 自定义方法 public String getChineseName() { return this.chineseName; } }
-
switch支持:Java的switch语句可以直接支持枚举类型作为判断条件。
-
序列化与反序列化支持:Java枚举类型自动实现了Serializable接口,可以被序列化和反序列化。
-
线程安全:枚举类的实例创建过程天然具有线程安全性。
2.3 使用场景
枚举在实际开发中广泛应用,例如:
- 表示状态机的状态,如订单状态(PENDING、COMPLETED、CANCELLED)。
- 星期几、月份、颜色、方向等固定数量且预先知道所有可能值的场合。
- 在设计模式中,例如策略模式或者工厂模式,用以替代传统的基于字符串标识符的选择逻辑。
3 抽象类
abstract
关键字修饰修饰的类或方法就是抽象类或抽象方法。详解见abstract关键字
当编程中遇到暂不明确实现的类或方法时,可以声明为抽象类/方法,在之后以继承的方式实现。
- 抽象的使用场景
- 抽象类可以理解成不完整的设计图,一般作为父类,让子类来继承。
- 当父类知道子类一定要完成某些行为,但是每个子类该行为的实现又不同,于是该父类就把该行为定义成抽象方法的形式,具体实现交给子类去完成。此时这个类就可以声明成抽象类。
3.1 抽象类案例
- 系统需求
- 某加油站推出了2种支付卡,一种是预存10000的金卡,后续加油享受8折优惠,另一种是预存5000的银卡 ,后续加油享受8.5折优惠。
- 请分别实现2种卡片进入收银系统后的逻辑,卡片需要包含主人名称,余额,支付功能。
- 分析实现
- 创建一张卡片父类:定义属性包括主人名称、余额、支付功能(具体实现交给子类)
- 创建一张白金卡类:重写支付功能,按照原价的8折计算输出。
- 创建一张银卡类:重写支付功能,按照原价的8.5折计算输出。
// 抽象卡片类:定义基本属性和支付功能接口
public abstract class Card {
private String ownerName;
private double balance;
public Card(String ownerName, double initialBalance) {
this.ownerName = ownerName;
this.balance = initialBalance;
}
// 获取主人名称
public String getOwnerName() {
return ownerName;
}
// 获取余额
public double getBalance() {
return balance;
}
// 抽象的支付方法,由子类具体实现
public abstract void pay(double originalPrice);
// 充值方法
public void recharge(double amount) {
if (amount > 0) {
balance += amount;
}
}
}
// 金卡子类:实现8折优惠支付功能
public class PlatinumCard extends Card {
public PlatinumCard(String ownerName, double initialBalance) {
super(ownerName, initialBalance);
}
@Override
public void pay(double originalPrice) {
double discountedPrice = originalPrice * 0.8;
if (discountedPrice <= balance) {
System.out.println("金卡用户" + ownerName + "成功支付:" + discountedPrice);
balance -= discountedPrice;
} else {
System.out.println("金卡用户" + ownerName + "余额不足,无法完成支付!");
}
}
}
// 银卡子类:实现8.5折优惠支付功能
public class SilverCard extends Card {
public SilverCard(String ownerName, double initialBalance) {
super(ownerName, initialBalance);
}
@Override
public void pay(double originalPrice) {
double discountedPrice = originalPrice * 0.85;
if (discountedPrice <= balance) {
System.out.println("银卡用户" + ownerName + "成功支付:" + discountedPrice);
balance -= discountedPrice;
} else {
System.out.println("银卡用户" + ownerName + "余额不足,无法完成支付!");
}
}
}
现在可以在收银系统中实例化不同类型的卡片,并调用其支付方法进行支付操作。例如:
public class CashierSystem {
public static void main(String[] args) {
Card platinumCard = new PlatinumCard("张三", 10000);
Card silverCard = new SilverCard("李四", 5000);
platinumCard.pay(200); // 金卡用户张三成功支付:160.0
silverCard.pay(150); // 银卡用户李四成功支付:127.5
// 更多支付操作...
}
}
3.2 final和abstract是什么关系?
- 互斥关系。
- abstract定义的抽象类作为模板让子类继承,final定义的类不能被继承。
- 抽象方法定义通用功能让子类重写,final定义的方法子类不能重写。
3.3 设计模式之模板方法模式
当系统中出现同一个功能多处在开发,而该功能中大部分代码是一样的,只有其中部分可能不同的时候。
实现步骤:
1、定义一个抽象类。
2、定义2个方法,把相同代码放模板方法中,建议定义为final让子类不可修改,不同代码定义成抽象方法。
3、子类继承抽象类,重写抽象方法。
4 多态
4.1 什么是多态?
多态,指对象可以有多种形态。
同类型的对象,执行统一行为,可以表现出不同的特征。如动物类下的猫和狗对象,发出叫声,声音不同。
多态实现了在同一个父类中使用不同子类的对象,对同一消息做出不同的响应。
多态的常见形式
父类类型 对象名称 = new 子类构造器();
创建子类对象,并将其引用赋值给父类类型的变量
class Animal {
// ...
}
class Dog extends Animal {
public Dog() {
// 这里是Dog类的构造方法
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Dog(); // 创建Dog对象,并将Dog对象的引用赋值给Animal类型的变量
}
}
多态中成员访问特点
方法调用:编译看左边确认是哪个父类,运行看右边确认是哪个子类。
变量调用:编译和运行都看左边确认是哪个父类。
Java中的多态(Polymorphism)是面向对象编程的三大特性之一,另外两个特性是封装和继承。多态允许不同类的对象对同一消息做出不同的响应,它增强了代码的灵活性、可扩展性和重用性。
多态的概念:
-
静态多态(编译时多态):通过方法重载(Overloading)实现,即在同一个类中可以有多个同名的方法,但参数列表不同(参数数量、类型或顺序不同)。编译器根据调用方法时提供的参数自动选择对应的方法执行。
-
动态多态(运行时多态):通过继承和接口实现,具体表现为:
- 方法重写(Override):子类继承父类并覆盖其非私有的实例方法。
- 父类引用指向子类对象:声明为父类类型的变量可以引用子类对象,在程序运行期间调用实际对象的方法时,会调用该对象的实际类型所重写的方法。
多态示例:
class Animal {
void sound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override
void sound() {
System.out.println("Dog barks");
}
}
public class PolymorphismExample {
public static void main(String[] args) {
Animal animal = new Animal(); // 动物对象
Animal dog = new Dog(); // 动物引用指向狗对象
animal.sound(); // 输出 "Animal makes a sound"
dog.sound(); // 输出 "Dog barks",由于dog实际上是Dog对象,因此调用的是Dog类重写的sound方法
// 这里体现了运行时多态,尽管animal变量被声明为Animal类型,但它实际绑定的是Dog对象
}
}
注意事项:
- 调用方法时遵循“动态绑定”,即在运行时决定调用哪个方法。但对于静态方法、final方法以及private方法,不存在多态,它们是在编译时期就确定了要调用的方法。
- 当父类引用指向子类对象时,只能访问父类中定义的属性和方法,不能直接访问子类新增加的属性和方法,除非进行显式向下转型操作。
4.2 多态的优势与劣势
多态的好处:
- 提高代码通用性,可以使用父类类型作为方法的参数或者返回值类型,使得方法能够处理多种子类对象。
- 增强可扩展性,当添加新的子类时,无需修改父类的代码就能与新子类协同工作。
- 遵循里氏替换原则,定义方法的时候,使用父类型作为参数,任何基类出现的地方都可以用子类替代,而不会影响程序的正确性。
多态的劣势:
- 多态下不能使用子类的独有功能。
4.3 父类如何实现调用子类独有功能
将对象类型由父类转换为子类即可。
// 定义一个父类 Animal
class Animal {
public void makeSound() {
System.out.println("动物发出声音");
}
}
// 定义一个子类 Dog 继承自 Animal,并添加自己特有的方法
class Dog extends Animal {
public void bark() {
System.out.println("小狗汪汪叫");
}
@Override
public void makeSound() {
System.out.println("狗发出声音");
}
}
public class Main {
public static void main(String[] args) {
// 创建一个 Dog 对象,但使用 Animal 类型的引用指向它
Animal animal = new Dog();
// 只能调用 Animal 接口中的方法
animal.makeSound(); // 输出 "狗发出声音",多态的表现
// 虽然animal实际上是Dog对象,但由于类型是Animal,所以无法直接调用bark()
// 若要调用Dog类特有的bark()方法,必须进行强制类型转换
if (animal instanceof Dog) { // 检查是否可以安全转换
Dog dog = (Dog) animal; // 强制类型转换
dog.bark(); // 现在可以调用Dog类特有的方法,输出 "小狗汪汪叫"
}
}
}