Java 面向对象之封装与继承
引言： Java是一种面向对象的编程语言，封装和继承是面向对象编程的两个重要概念。封装通过将数据和方法封装在一个类中，实现了数据的隐藏和保护；继承则允许一个类继承另一个类的属性和方法，实现代码的重用和扩展。我们来聊聊讨Java中的封装和继承，介绍其原理、优势以及在实际开发中的应用。
一、封装
封装是面向对象编程中的一种基本原则，它将数据和相关的方法组合在一个单元中，并对外部隐藏了内部实现细节。这种数据的隐藏和保护确保了数据的安全性和一致性，同时提供了统一的访问接口。在Java中，封装通过访问修饰符（private、protected、public）来实现。
1. 封装的封闭性与信息隐藏
封装的封闭性指的是将类的内部实现细节隐藏起来，只暴露必要的接口给外部使用。这样可以避免外部直接访问和修改内部数据，提高代码的安全性和稳定性。信息隐藏是指将类的内部数据和实现细节对外部隐藏起来，只提供有限的访问接口。这样可以防止外部依赖于类的内部结构，减少了外部对内部实现的依赖，提高了代码的灵活性和可维护性。
示例：
public class Person {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String newName) {
name = newName;
}
public int getAge() {
return age;
}
public void setAge(int newAge) {
if (newAge >= 0) {
age = newAge;
}
}
}
public class Main {
public static void main(String[] args) {
Person person = new Person();
person.setName("John");
person.setAge(25);
System.out.println("Name: " + person.getName());
System.out.println("Age: " + person.getAge());
}
}
在上面的示例中，Person类封装了一个人的属性：name和age。这两个属性被声明为私有的，外部无法直接访问。通过提供公共的getter和setter方法，外部代码可以通过这些方法来访问和修改name和age属性。这样就实现了对数据的封装和保护，外部代码无法直接修改属性的值，必须通过类提供的接口来操作。
2. 封装的数据保护
封装不仅可以隐藏数据的实现细节，还可以通过访问修饰符来限制对数据的访问和修改。私有访问修饰符（private）用于修饰类的成员，表示只能在类的内部访问，外部无法直接访问。通过将数据成员声明为私有的，可以有效保护数据的完整性和安全性，只允许通过类提供的接口进行访问和修改。
示例：
public class BankAccount {
private double balance;
public BankAccount(double initialBalance) {
balance = initialBalance;
}
public double getBalance() {
return balance;
}
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
}
}
public void withdraw(double amount) {
if (amount > 0 && balance >= amount) {
balance -= amount;
}
}
}
public class Main {
public static void main(String[] args) {
BankAccount account = new BankAccount(1000.0);
System.out.println("Initial balance: " + account.getBalance());
account.deposit(Apologies for the incomplete response. Here's the continuation of the example:
account.deposit(500.0);
System.out.println("Balance after deposit: " + account.getBalance());
account.withdraw(200.0);
System.out.println("Balance after withdrawal: " + account.getBalance());
}
}
在上面的示例中，BankAccount类封装了一个银行账户的属性：balance。balance属性被声明为私有的，外部无法直接访问。通过提供公共的getter和setter方法，外部代码可以通过这些方法来访问和修改balance属性。在deposit方法和withdraw方法中，通过对输入值的校验和对balance的修改，确保了对balance的安全操作。
3. 封装的统一访问原则
封装的统一访问原则指的是通过统一的接口来访问数据，而不暴露数据的具体实现细节。这意味着无论数据是存储在类的属性中还是通过计算得到的，外部代码都可以通过同样的方式来访问数据，不需要关心数据的具体存储和计算方式。这样可以在不影响外部代码的前提下，对内部实现进行修改和优化。
示例：
public class Circle {
private double radius;
public Circle(double radius) {
this.radius = radius;
}
public double getRadius() {
return radius;
}
public double getArea() {
return Math.PI * radius * radius;
}
public double getCircumference() {
return 2 * Math.PI * radius;
}
}
public class Main {
public static void main(String[] args) {
Circle circle = new Circle(5.0);
System.out.println("Radius: " + circle.getRadius());
System.out.println("Area: " + circle.getArea());
System.out.println("Circumference: " + circle.getCircumference());
}
}
在上面的示例中，Circle类封装了一个圆的属性：radius。通过提供公共的getter方法来访问radius属性。getArea方法和getCircumference方法通过radius属性的值进行计算，并返回计算结果。外部代码无需知道具体的计算方式，只需要通过这些方法来获得面积和周长的值。
二、继承
继承是面向对象编程中实现代码重用和扩展的机制。它允许一个类（子类）继承另一个类（父类）的属性和方法，并可以在此基础上添加新的属性和方法。在Java中，继承通过关键字"extends"来实现。
1. 继承的基本原理
继承允许子类继承父类的属性和方法，子类可以直接访问和使用父类中的非私有成员。子类可以通过继承来获得父类的行为和特性，并在此基础上进行扩展和修改。子类可以添加新的属性和方法，也可以重写父类的方法来实现自己的逻辑。
示例：
public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void eat() {
System.out.println(name + " is eating.");
}
}
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
public void bark() {
System.out.println(name + " is barking.");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog("Tom");
dog.eat();
dog.bark();
}
}
在上面的示例中，Animal类是一个基类，包含了一个属性name和一个eat方法。Dog类继承了Animal类，通过"extends"关键字声明。Dog类添加了一个新的方法bark。在Main类中，创建了一个Dog对象，并调用了继承自Animal类的eat方法和Dog类自己的bark方法。
继承使得Dog类可以共享Animal类的属性和方法，实现继承使得Dog类可以共享Animal类的属性和方法，实现了代码的重用。子类可以在继承的基础上进行扩展，使得代码具有更高的灵活性和可扩展性。
2. 继承的多层次性
继承还支持多层次性，即一个类可以继承自另一个类的子类。这样就形成了类的层次结构，使得代码的组织更加清晰和有序。
示例：
public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void eat() {
System.out.println(name + " is eating.");
}
}
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
public void bark() {
System.out.println(name + " is barking.");
}
}
public class Labrador extends Dog {
public Labrador(String name) {
super(name);
}
public void swim() {
System.out.println(name + " is swimming.");
}
}
public class Main {
public static void main(String[] args) {
Labrador labrador = new Labrador("Max");
labrador.eat();
labrador.bark();
labrador.swim();
}
}
在上面的示例中，Labrador类继承自Dog类，而Dog类又继承自Animal类，形成了一个继承的多层次结构。Labrador类添加了一个新的方法swim。在Main类中，创建了一个Labrador对象，并调用了继承自Animal类的eat方法、继承自Dog类的bark方法以及Labrador类自己的swim方法。
继承的多层次性允许我们在已有的类的基础上进行扩展和细化，使得代码的设计更加灵活和可扩展。
3. 继承的方法重写
继承允许子类重写父类的方法，即子类可以提供自己的实现逻辑，覆盖父类原有的行为。方法重写通过在子类中定义一个与父类方法具有相同名称、参数列表和返回类型的方法来实现。
示例：
public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
public void eat() {
System.out.println(name + " is eating.");
}
}
public class Dog extends Animal {
public Dog(String name) {
super(name);
}
@Override
public void eat() {
System.out.println(name + " is eating bones.");
}
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog("Tom");
dog.eat();
}
}
在上面的示例中，Dog类重写了Animal类的eat方法，并提供了自己的实现逻辑。在Main类中，创建了一个Dog对象，并调用了重写后的eat方法。运行结果会打印出"Tom is eating bones."，而不是父类Animal中的实现。 通过方法重写，子类可以根据自身的特性和需求，对继承自父类的方法进行定制化的改变，实现不同的行为。
最后： 封装和继承是Java面向对象编程中的重要概念。封装通过隐藏和保护数据，提供统一的访问接口，增强了代码的安全性和可维护性。继承允许子类继承父类的属性和方法，实现了代码的重用和扩展。同时，继承的多层次性和方法重写使得代码的组织更加清晰和灵活。掌握封装和继承的原理和应用，对于我们Java开发人员来说是非常重要的。
金山WPS公司福利 286人发布
