likes
comments
collection
share

Java 面向对象之封装与继承

作者站长头像
站长
· 阅读数 29

引言: 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开发人员来说是非常重要的。

转载自:https://juejin.cn/post/7267441604620337210
评论
请登录