IT技术社区_专业开发者平台_最新编程教程与解决方案 -沐辰社区

Java抽象类继承案例如何用

wen java案例 26

本文目录导读：

Java抽象类继承案例如何用

  1. 基础抽象类继承案例
  2. 更复杂的实践案例：图形计算
  3. 实战案例：员工管理系统
  4. 关键要点总结

我来给你展示Java抽象类继承的完整案例,从基础到实践应用。

基础抽象类继承案例

抽象类定义

// 抽象类：动物
public abstract class Animal {
    protected String name;
    protected int age;
    // 构造方法
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    // 抽象方法：子类必须实现
    public abstract void makeSound();
    // 具体方法：子类可以直接继承
    public void sleep() {
        System.out.println(name + "正在睡觉...");
    }
    // 具体方法：提供通用功能
    public void eat() {
        System.out.println(name + "正在吃东西...");
    }
    // Getter方法
    public String getName() {
        return name;
    }
}

子类实现

// 子类1：狗
public class Dog extends Animal {
    private String breed; // 品种
    public Dog(String name, int age, String breed) {
        super(name, age); // 调用父类构造方法
        this.breed = breed;
    }
    @Override
    public void makeSound() {
        System.out.println(name + "发出叫声：汪汪汪！");
    }
    // 子类特有的方法
    public void guard() {
        System.out.println(name + "正在看家护院...");
    }
}
// 子类2：猫
public class Cat extends Animal {
    private String color; // 颜色
    public Cat(String name, int age, String color) {
        super(name, age);
        this.color = color;
    }
    @Override
    public void makeSound() {
        System.out.println(name + "发出叫声：喵喵喵！");
    }
    // 子类特有的方法
    public void catchMouse() {
        System.out.println(name + "正在抓老鼠...");
    }
}

测试类

public class TestAnimal {
    public static void main(String[] args) {
        // 不能直接实例化抽象类
        // Animal animal = new Animal("动物", 1); // 编译错误
        // 创建子类对象
        Dog dog = new Dog("旺财", 3, "金毛");
        Cat cat = new Cat("咪咪", 2, "橘色");
        // 调用重写的方法
        dog.makeSound();  // 输出：旺财发出叫声：汪汪汪！
        cat.makeSound();  // 输出：咪咪发出叫声：喵喵喵！
        // 调用继承的方法
        dog.sleep();  // 输出：旺财正在睡觉...
        cat.eat();    // 输出：咪咪正在吃东西...
        // 调用子类特有方法
        dog.guard();    // 输出：旺财正在看家护院...
        cat.catchMouse(); // 输出：咪咪正在抓老鼠...
        // 多态特性
        Animal animal1 = new Dog("小黑", 2, "拉布拉多");
        Animal animal2 = new Cat("小白", 1, "白色");
        animal1.makeSound(); // 输出：小黑发出叫声：汪汪汪！
        animal2.makeSound(); // 输出：小白发出叫声：喵喵喵！
        // 不能调用子类特有方法（需要通过类型转换）
        if (animal1 instanceof Dog) {
            ((Dog) animal1).guard();
        }
    }
}

更复杂的实践案例：图形计算

// 抽象类：图形
public abstract class Shape {
    private String color;
    public Shape(String color) {
        this.color = color;
    }
    // 抽象方法：计算面积
    public abstract double calculateArea();
    // 抽象方法：计算周长
    public abstract double calculatePerimeter();
    // 具体方法
    public void displayInfo() {
        System.out.println("颜色: " + color);
        System.out.println("面积: " + calculateArea());
        System.out.println("周长: " + calculatePerimeter());
    }
}
// 圆形
public class Circle extends Shape {
    private double radius;
    public Circle(String color, double radius) {
        super(color);
        this.radius = radius;
    }
    @Override
    public double calculateArea() {
        return Math.PI * radius * radius;
    }
    @Override
    public double calculatePerimeter() {
        return 2 * Math.PI * radius;
    }
}
// 矩形
public class Rectangle extends Shape {
    private double width;
    private double height;
    public Rectangle(String color, double width, double height) {
        super(color);
        this.width = width;
        this.height = height;
    }
    @Override
    public double calculateArea() {
        return width * height;
    }
    @Override
    public double calculatePerimeter() {
        return 2 * (width + height);
    }
}

实战案例：员工管理系统

// 抽象类：员工
public abstract class Employee {
    private String id;
    private String name;
    private double baseSalary;
    public Employee(String id, String name, double baseSalary) {
        this.id = id;
        this.name = name;
        this.baseSalary = baseSalary;
    }
    // 抽象方法：计算工资（不同岗位计算方式不同）
    public abstract double calculateSalary();
    // 抽象方法：获取职位
    public abstract String getPosition();
    // 具体方法
    public void work() {
        System.out.println(name + "正在工作...");
    }
    public void displayInfo() {
        System.out.println("员工编号: " + id);
        System.out.println("姓名: " + name);
        System.out.println("职位: " + getPosition());
        System.out.println("工资: " + calculateSalary());
    }
}
// 程序员
public class Programmer extends Employee {
    private int bugFixCount; // 修复bug数量
    private double bonusPerBug = 500; // 每个bug的奖金
    public Programmer(String id, String name, double baseSalary, int bugFixCount) {
        super(id, name, baseSalary);
        this.bugFixCount = bugFixCount;
    }
    @Override
    public double calculateSalary() {
        return super.baseSalary + bugFixCount * bonusPerBug;
    }
    @Override
    public String getPosition() {
        return "程序员";
    }
    public void fixBug() {
        System.out.println(name + "正在修复bug...");
        bugFixCount++;
    }
}
// 经理
public class Manager extends Employee {
    private double performanceBonus; // 绩效奖金
    public Manager(String id, String name, double baseSalary, double performanceBonus) {
        super(id, name, baseSalary);
        this.performanceBonus = performanceBonus;
    }
    @Override
    public double calculateSalary() {
        return super.baseSalary + performanceBonus;
    }
    @Override
    public String getPosition() {
        return "经理";
    }
    public void manage() {
        System.out.println(name + "正在管理团队...");
    }
}

关键要点总结

抽象类规则

public abstract class AbstractClass {
    // 1. 可以包含抽象方法和具体方法
    public abstract void abstractMethod();
    public void concreteMethod() { }
    // 2. 可以包含构造方法
    public AbstractClass() { }
    // 3. 可以包含成员变量
    private int id;
    // 4. 可以有静态方法
    public static void staticMethod() { }
}

继承注意事项

// 1. 子类必须实现所有抽象方法（除非也是抽象类）
abstract class AbstractParent {
    public abstract void method1();
    public abstract void method2();
}
abstract class AbstractChild extends AbstractParent {
    // 只实现一个抽象方法
    public void method1() { }
    // method2() 仍未实现
}
class ConcreteChild extends AbstractChild {
    // 必须实现剩余的抽象方法
    public void method2() { }
}
// 2. 使用super关键字调用父类构造方法和方法
class Child extends Parent {
    public Child() {
        super(); // 调用父类构造方法
    }
    public void someMethod() {
        super.someMethod(); // 调用父类方法
    }
}

使用抽象类的场景

  1. 定义通用行为：多个子类有共同的属性和方法
  2. 强制子类实现特定方法：确保子类都有某些功能
  3. 代码复用：将公共代码放在抽象类中
  4. 提供模板方法：定义算法的骨架

这个案例展示了Java抽象类继承的核心用法,你可以根据实际需求进行调整和扩展。

上一篇Java接口案例如何基础编写

下一篇Java抽象方法案例怎么实现

相关文章

抱歉，评论功能暂时关闭!