记录java基础学习中有关常量、枚举类、抽象类和多态的内容。
public class Constant {
public static final String SCHOOL_NAME = “清华校园";
public static final String LOGIN_NAME = “admin";
public static final String PASS_WORD = “123456";
}
枚举(enum)是一种特殊的类(class),它用于盛放一组有限且确定的常量集合。
修饰符 enum 枚举名称{
第一行都是罗列枚举类实例的名称。每个实例实际是构造方法调用而来。
}
在这个例子中,每个枚举常量都是枚举类型的唯一实例,并且在编译时就被默认调用无参构造创建了。
类型安全:枚举类型确保只能使用预定义的值,从而避免了拼写错误或意外地使用非法值的情况。
单例性:枚举中的每个元素都是一个单例对象,这意味着无论何时何地创建枚举实例,同一枚举常量的引用始终指向相同的内存地址。
继承自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接口,可以被序列化和反序列化。
线程安全:枚举类的实例创建过程天然具有线程安全性。
枚举在实际开发中广泛应用,例如:
abstract
关键字修饰修饰的类或方法就是抽象类或抽象方法。详解见abstract关键字
当编程中遇到暂不明确实现的类或方法时,可以声明为抽象类/方法,在之后以继承的方式实现。
// 抽象卡片类:定义基本属性和支付功能接口
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
// 更多支付操作...
}
}
当系统中出现同一个功能多处在开发,而该功能中大部分代码是一样的,只有其中部分可能不同的时候。
实现步骤:
1、定义一个抽象类。
2、定义2个方法,把相同代码放模板方法中,建议定义为final让子类不可修改,不同代码定义成抽象方法。
3、子类继承抽象类,重写抽象方法。
多态,指对象可以有多种形态。
同类型的对象,执行统一行为,可以表现出不同的特征。如动物类下的猫和狗对象,发出叫声,声音不同。
多态实现了在同一个父类中使用不同子类的对象,对同一消息做出不同的响应。
多态的常见形式
父类类型 对象名称 = 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)实现,即在同一个类中可以有多个同名的方法,但参数列表不同(参数数量、类型或顺序不同)。编译器根据调用方法时提供的参数自动选择对应的方法执行。
动态多态(运行时多态):通过继承和接口实现,具体表现为:
多态示例:
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对象
}
}
注意事项:
多态的好处:
多态的劣势:
// 定义一个父类 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类特有的方法,输出 "小狗汪汪叫"
}
}
}