java如何封装继承类

Java封装继承类的核心观点包括：使用访问修饰符来保护数据、通过getter和setter方法访问私有属性、在子类中使用super关键字调用父类构造函数、通过方法重写实现多态。

在Java中，封装是通过将类的属性私有化，并提供公共的getter和setter方法来访问这些属性，从而实现对数据的保护。继承则是通过子类继承父类的属性和方法，实现代码的重用和扩展。使用封装和继承可以提高代码的可维护性和可扩展性。例如，在子类中可以通过super关键字调用父类的构造函数，从而初始化父类的属性，这样既保留了父类的功能，又可以在子类中进行扩展。

一、封装的实现

1、使用访问修饰符保护数据

在Java中，访问修饰符有四种：public、protected、default和private。通过将类的属性设置为private，可以防止外部类直接访问这些属性，从而保护数据的完整性。

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

在上面的例子中，name和age属性被设置为private，因此不能直接从类外部访问。

2、通过getter和setter方法访问私有属性

为了允许外部类访问或修改私有属性，可以提供公共的getter和setter方法。这些方法可以包含数据验证逻辑，从而确保数据的有效性。

public class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

在上面的例子中，setAge方法包含了一个简单的验证逻辑，确保年龄是一个正数。

二、继承的实现

1、继承父类的属性和方法

通过使用关键字extends，子类可以继承父类的属性和方法，从而实现代码的重用。

public class Employee extends Person {
    private String employeeId;
    public Employee(String name, int age, String employeeId) {
        super(name, age);
        this.employeeId = employeeId;
    }
    public String getEmployeeId() {
        return employeeId;
    }
    public void setEmployeeId(String employeeId) {
        this.employeeId = employeeId;
    }
}

在上面的例子中，Employee类继承了Person类，并增加了一个新的属性employeeId。

2、使用super关键字调用父类构造函数

在子类的构造函数中，可以使用super关键字调用父类的构造函数，从而初始化父类的属性。

public class Employee extends Person {
    private String employeeId;
    public Employee(String name, int age, String employeeId) {
        super(name, age);
        this.employeeId = employeeId;
    }
}

在上面的例子中，Employee类的构造函数通过super(name, age)调用了Person类的构造函数，从而初始化了name和age属性。

三、方法重写与多态

1、方法重写

方法重写是指子类重新定义父类的某个方法，从而实现不同的行为。重写的方法必须具有相同的参数列表和返回类型。

public class Employee extends Person {
    private String employeeId;
    public Employee(String name, int age, String employeeId) {
        super(name, age);
        this.employeeId = employeeId;
    }
    @Override
    public String getName() {
        return "Employee Name: " + super.getName();
    }
}

在上面的例子中，Employee类重写了Person类的getName方法，增加了额外的描述信息。

2、多态的实现

多态是指在运行时决定调用哪种方法。通过使用父类引用指向子类对象，可以实现多态。

public class Main {
    public static void main(String[] args) {
        Person person = new Employee("John", 30, "E123");
        System.out.println(person.getName());  // 输出: Employee Name: John
    }
}

在上面的例子中，虽然person的类型是Person，但由于它实际引用的是Employee对象，因此调用的是Employee类的getName方法。

四、封装与继承的结合

1、代码重用与扩展

通过将公共的属性和方法封装在父类中，子类可以继承这些属性和方法，从而实现代码的重用。同时，子类可以添加新的属性和方法，或者重写父类的方法，从而实现功能的扩展。

public class Manager extends Employee {
    private String department;
    public Manager(String name, int age, String employeeId, String department) {
        super(name, age, employeeId);
        this.department = department;
    }
    public String getDepartment() {
        return department;
    }
    public void setDepartment(String department) {
        this.department = department;
    }
    @Override
    public String getName() {
        return "Manager Name: " + super.getName();
    }
}

在上面的例子中，Manager类继承了Employee类，并增加了一个新的属性department。同时，重写了getName方法，增加了额外的描述信息。

2、提高代码的可维护性

通过封装和继承，可以将不同的功能模块化，从而提高代码的可维护性。例如，可以将与员工相关的公共属性和方法封装在Employee类中，将与经理相关的特定属性和方法封装在Manager类中。

public class Main {
    public static void main(String[] args) {
        Employee employee = new Employee("Alice", 28, "E456");
        Manager manager = new Manager("Bob", 35, "M789", "HR");
        System.out.println(employee.getName());  // 输出: Employee Name: Alice
        System.out.println(manager.getName());   // 输出: Manager Name: Employee Name: Bob
        System.out.println(manager.getDepartment());  // 输出: HR
    }
}

在上面的例子中，Employee类和Manager类各自封装了不同的功能，从而提高了代码的可维护性。

五、封装与继承的最佳实践

1、合理使用访问修饰符

在实现封装时，应合理使用访问修饰符。对于需要保护的数据，应设置为private，并提供必要的getter和setter方法。对于需要在子类中访问的属性和方法，可以设置为protected。

public class Person {
    private String name;
    protected int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

在上面的例子中，name属性被设置为private，而age属性被设置为protected，从而允许子类访问。

2、避免过度使用继承

虽然继承是实现代码重用的重要手段，但过度使用继承可能导致代码的复杂性增加。因此，应避免将所有功能都放在一个基类中，而应根据实际需求进行合理的设计。

public class Person {
    private String name;
    public Person(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}
public class Employee extends Person {
    private String employeeId;
    public Employee(String name, String employeeId) {
        super(name);
        this.employeeId = employeeId;
    }
    public String getEmployeeId() {
        return employeeId;
    }
    public void setEmployeeId(String employeeId) {
        this.employeeId = employeeId;
    }
}

在上面的例子中，Person类只包含与人相关的属性和方法，而Employee类只包含与员工相关的属性和方法，从而避免了过度使用继承。

通过合理使用封装和继承，可以提高代码的可维护性和可扩展性，从而编写出更加健壮和高效的Java程序。