JAVA面向对象的四大特征是什么？

西瓜本瓜@

于 2024-10-10 14:38:53 发布

阅读量411

点赞数 7

文章标签： java 开发语言面向对象

本文链接：https://blog.csdn.net/LLZjiayou/article/details/142821301

版权

Java 面向对象编程（OOP）的四大特征是 封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism） 和 抽象（Abstraction）。这些特征是面向对象编程的核心，帮助开发者构建灵活且可扩展的系统。

1. 封装（Encapsulation）

封装是将对象的状态（属性）和行为（方法）组合在一起，并隐藏对象的内部实现细节，只允许通过公共的接口（getter 和 setter 方法等）来访问这些属性。这种做法增强了数据的安全性和代码的可维护性。

特点：

通过使用 private 修饰符隐藏类的属性，只允许通过 public 方法访问。
用户不需要了解对象内部的具体实现，只需要知道如何与对象交互即可。

代码示例：

public class Person {
    // 私有属性
    private String name;
    private int 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;
        } else {
            System.out.println("年龄必须为正数！");
        }
    }
}

解释：

通过 private 关键字将 name 和 age 属性封装起来，只有通过 getName() 和 setName() 等公共方法才能访问和修改这些属性，确保数据安全。

2. 继承（Inheritance）

继承是面向对象编程中允许一个类（子类）从另一个类（父类）继承属性和方法的机制。通过继承，子类可以复用父类的代码，并且可以扩展或修改父类的行为。

特点：

使用 extends 关键字实现类的继承。
子类可以重用父类的属性和方法，也可以增加新的属性和方法。
子类可以通过 方法重写（Override） 修改父类的行为。

代码示例：

// 父类
public class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

// 子类继承自 Animal 类
public class Dog extends Animal {
    // 子类可以重写父类的方法
    @Override
    public void makeSound() {
        System.out.println("狗叫：汪汪");
    }
}

解释：

Dog 类继承了 Animal 类，重写了 makeSound() 方法，实现了狗发出自己的声音。同时，Dog 类还可以使用 Animal 类中的其他属性和方法。

3. 多态（Polymorphism）

多态是指同一个方法在不同对象上有不同的表现形式。多态可以通过 方法重载（Overloading） 和 方法重写（Overriding） 来实现。多态让程序在执行时能够根据对象的实际类型来调用对应的方法，实现灵活性和可扩展性。

特点：

编译时多态（静态绑定）：通过方法重载实现，编译时确定调用哪个方法。
运行时多态（动态绑定）：通过方法重写实现，运行时根据对象的实际类型决定调用哪个方法。

代码示例：

// 父类
public class Animal {
    public void makeSound() {
        System.out.println("动物发出声音");
    }
}

// 子类
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗叫：汪汪");
    }
}

// 子类
public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("猫叫：喵喵");
    }
}

public class TestPolymorphism {
    public static void main(String[] args) {
        Animal myDog = new Dog(); // 动态绑定
        Animal myCat = new Cat(); // 动态绑定

        myDog.makeSound();  // 输出：狗叫：汪汪
        myCat.makeSound();  // 输出：猫叫：喵喵
    }
}

解释：

在这个例子中，Animal 是父类，而 Dog 和 Cat 是子类。即使 myDog 和 myCat 的引用类型是 Animal，但在运行时，它们根据实际的对象类型调用了对应的 makeSound() 方法，这就是多态的体现。

4. 抽象（Abstraction）

抽象是指将对象的复杂实现细节隐藏起来，只向外界暴露必要的接口。这可以通过 抽象类 和接口来实现。抽象类是不能实例化的类，通常包含一个或多个抽象方法，这些方法必须由子类实现。

特点：

使用 abstract 关键字定义抽象类和抽象方法。
抽象类不能实例化，只能被继承。
子类必须实现所有抽象方法。

代码示例：

// 抽象类
public abstract class Animal {
    // 抽象方法，没有方法体，子类必须实现
    public abstract void makeSound();

    // 普通方法
    public void sleep() {
        System.out.println("动物在睡觉");
    }
}

// 子类必须实现抽象方法
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("狗叫：汪汪");
    }
}