面向对象三大特征封

最新推荐文章于 2024-09-27 00:45:01 发布

墨子白

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量822

点赞数 12

分类专栏： java 文章标签： java 前端开发语言

本文链接：https://blog.csdn.net/tszc95/article/details/136820278

版权

java 专栏收录该内容

44 篇文章 0 订阅

订阅专栏

面向对象编程的三大特征是封装、继承和多态。

封装（Encapsulation）

封装定义：

封装是指将数据和操作数据的方法（即行为）捆绑在一起，形成一个独立的、对外部隐藏内部细节的单元。通过封装，可以限制对数据的访问，并确保数据的完整性和安全性。

封装特点：

数据隐藏：封装允许我们将对象的状态信息（属性）隐藏起来，只允许通过对象的公有方法来访问和修改这些信息。这种数据隐藏可以防止外部代码直接访问和修改对象的内部状态，从而确保了数据的安全性和完整性。
信息隐藏与简化：封装可以隐藏对象的具体实现细节，使得外部代码只需关注对象提供的公有接口，而不需要关心内部的具体实现。这样可以降低外部代码对对象的耦合性，同时也简化了外部代码的使用和维护。
代码复用：封装可以通过提供公有方法来实现对对象的访问和操作，从而实现了代码的复用。其他类和模块可以通过调用对象的公有方法来实现对对象的操作，而不需要了解对象内部的具体实现方式。
灵活性和可维护性：封装可以在不影响外部代码的情况下修改对象的内部实现，从而提高了代码的灵活性和可维护性。对象内部的改变不会影响外部代码的调用，只要对象的公有接口保持不变，外部代码就不需要进行修改。

封装代码示例

public class Animal {
    private String name;

    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public class EncapsulationExample {
    public static void main(String[] args) {
        Animal animal = new Animal("Buddy");
        System.out.println(animal.getName()); // 输出：Buddy

        animal.setName("Max");
        System.out.println(animal.getName()); // 输出：Max
    }
}

在这个示例中，将属性 name 封装在 Animal 类中，并通过公有的 getter 和 setter 方法来访问和修改该属性。

继承（Inheritance）

继承定义：

继承是指一个新类（子类）可以继承一个已有类（父类）的属性和方法，从而实现代码的重用和扩展。子类可以通过继承获取父类的特性，并且可以根据需要添加新的属性和方法或者修改已有的属性和方法。

继承特点：

代码复用： 继承允许子类继承父类的属性和方法，从而实现了代码的复用。子类可以直接使用父类已有的属性和方法，无需重新编写相同的代码。
派生性： 子类可以通过继承父类，拥有父类的属性和方法，同时还可以添加新的属性和方法，实现对父类功能的扩展。
多态性： 继承是实现多态性的基础之一。子类对象可以当做父类类型来对待，这样就可以实现父类引用指向子类对象的特性，从而实现多态的效果。
单继承： Java中只支持单继承，即一个子类只能继承一个父类。这样可以避免出现多继承带来的复杂性和歧义性。
继承链： 通过继承，可以构建出类的继承层次结构，形成一个继承链。子类可以继承祖先类的属性和方法，形成类的层级关系。
覆盖（Override）与重载（Overload）： 子类可以覆盖（Override）父类的方法，以实现子类特定的行为；同时，子类也可以重载（Overload）继承自父类的方法，提供不同的参数列表或返回类型。
访问控制： 子类可以访问父类中的非私有成员（属性和方法），但不能访问父类中私有的成员。通过继承，可以实现对父类成员的访问控制。

继承代码示例

public class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.sound(); // 输出：Dog barks
    }
}

在这个示例中，Dog 类继承自 Animal 类，并重写了父类的 sound 方法，实现了狗的特定叫声。

多态（Polymorphism）

多态定义：

多态是指同样的消息作用于不同的对象上会产生不同的结果。通过多态，可以用统一的接口来操作不同的对象，从而提高代码的灵活性和可扩展性。在面向对象编程中，多态可以通过方法重载、方法重写和接口实现来实现。

多态特点：

方法重写（Override）： 子类可以对继承自父类的方法进行重写，即子类可以提供与父类方法签名相同但实现内容不同的方法。这样，当使用父类引用指向子类对象时，通过父类引用调用被子类重写的方法时，将执行子类中的方法实现。
动态绑定（Dynamic Binding）： 在运行时，系统能够自动地选择调用对象的方法，这就是动态绑定。当使用父类引用指向子类对象，并调用被子类重写的方法时，实际执行的是子类中的方法，而不是父类中的方法，这种绑定是动态的，也称为运行时绑定。
方法重载（Overload）： 多态性还包括方法重载，即在一个类中可以存在多个方法名相同但参数列表不同的方法。在调用这些方法时，根据传入的参数类型和数量的不同，系统会选择匹配的方法进行调用，这也是一种多态性的表现。
父类引用指向子类对象： 在Java中，可以使用父类的引用来指向子类的对象，这样可以实现对子类对象的多态性访问。这种特性可以带来更灵活的程序设计和组织，同时也支持接口的统一调用。
接口与多态： Java中的接口也可以实现多态性，即一个接口的引用可以指向其实现类的对象，从而实现对不同实现类的统一访问。

多态代码示例

public class Animal {
    public void sound() {
        System.out.println("Animal makes a sound");
    }
}

public class Dog extends Animal {
    @Override
    public void sound() {
        System.out.println("Dog barks");
    }
}

public class Cat extends Animal {
    @Override
    public void sound() {
        System.out.println("Cat meows");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.sound(); // 输出：Dog barks
        animal2.sound(); // 输出：Cat meows
    }
}

在这个示例中，创建了 Animal、Dog 和 Cat 类，其中 Dog 和 Cat 都是 Animal 的子类。通过将 Dog 和 Cat 对象赋值给 Animal 类型的变量，实现了多态性，即相同的方法调用但根据对象的类型会产生不同的行为。

更多消息资讯，请访问昂焱数据（https://www.ayshuju.com）