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

Java抽象类继承案例如何用

wen java案例 298

本文目录导读：

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抽象类继承的核心用法,你可以根据实际需求进行调整和扩展。

版权声明：足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播 足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播 足球直播 足球直播 足球直播 足球直播 足球直播 中超直播 中超直播 中超直播 中超直播 中超直播 英超直播 英超直播 英超直播 英超直播 英超直播 德甲直播 德甲直播 德甲直播 德甲直播 德甲直播 西甲直播 西甲直播 西甲直播 西甲直播 西甲直播 意甲直播 意甲直播 意甲直播 意甲直播 意甲直播 NBA直播 NBA直播 NBA直播 NBA直播 NBA直播 篮球直播 篮球直播 篮球直播 篮球直播 篮球直播

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

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

相关文章

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

友情链接攻略窝 · 礼包窝 · 配置窝 · 换算窝 · 算法窝 · 查文窝 · 手册窝 · 问答窝 · 全文搜 · 手册库
相关站点礼包窝 · 查文窝