深入探讨Java面向对象编程（OOP）

原创

g201909 2024-06-14 07:23:43 ©著作权

文章标签 java 开发语言 System Java 封装 文章分类 HarmonyOS 后端开发

©著作权归作者所有：来自51CTO博客作者g201909的原创作品，请联系作者获取转载授权，否则将追究法律责任

引言

在上一篇文章中，我们介绍了Java的基础语法和概念，包括数据类型、条件语句、循环语句和基本的类与对象。在本篇文章中，我们将深入探讨Java的面向对象编程（OOP）特性。这些特性包括继承、封装、多态和抽象，它们是OOP的四大支柱。通过理解和应用这些概念，你将能够编写更具结构性和可维护性的Java程序。

继承（Inheritance）

继承是面向对象编程中的一个重要概念，它允许我们基于现有类创建新类，从而实现代码的重用。新类称为子类（或派生类），现有类称为父类（或基类）。

示例

// 父类
class Animal {
    String name;

    void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类
class Dog extends Animal {
    void bark() {
        System.out.println(name + " is barking.");
    }
}

public class InheritanceExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.name = "Buddy";
        dog.eat();
        dog.bark();
    }
}

在这个例子中，Dog 类继承自 Animal 类，因此 Dog 类可以访问 Animal 类的属性和方法。

方法重写

子类可以重写父类的方法，以便提供特定的实现。

class Animal {
    void makeSound() {
        System.out.println("Animal is making a sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog is barking");
    }
}

public class MethodOverrideExample {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound();  // 输出 "Dog is barking"
    }
}

封装（Encapsulation）

封装是将对象的状态（属性）和行为（方法）封装在一个类中，并提供受控的访问。通过使用访问修饰符（如 private、public 和 protected），我们可以控制哪些属性和方法是对外可见的。

示例

class Person {
    private String name;
    private int age;

    // Getter 方法
    public String getName() {
        return name;
    }

    // Setter 方法
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

public class EncapsulationExample {
    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 类的属性被声明为 private，只能通过公共的 getter 和 setter 方法访问，从而实现了封装。

多态（Polymorphism）

多态性允许我们使用相同的接口来调用不同的实际方法。这可以通过方法重载（编译时多态）和方法重写（运行时多态）实现。

方法重载

方法重载是指在同一个类中定义多个方法，它们具有相同的名字但参数不同。

class MathUtils {
    // 两个参数的 add 方法
    int add(int a, int b) {
        return a + b;
    }

    // 三个参数的 add 方法
    int add(int a, int b, int c) {
        return a + b + c;
    }
}

public class MethodOverloadExample {
    public static void main(String[] args) {
        MathUtils math = new MathUtils();
        System.out.println("Sum of 2 numbers: " + math.add(10, 20));
        System.out.println("Sum of 3 numbers: " + math.add(10, 20, 30));
    }
}

方法重写

方法重写允许子类提供其自己的实现版本，而不是使用父类的方法。

class Animal {
    void makeSound() {
        System.out.println("Animal is making a sound");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("Cat is meowing");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal myCat = new Cat();
        myCat.makeSound();  // 输出 "Cat is meowing"
    }
}

抽象（Abstraction）

抽象是指将对象的复杂实现隐藏起来，只对外暴露必要的接口。Java 使用抽象类和接口来实现抽象。

抽象类

抽象类不能实例化，可以包含抽象方法（没有实现的方法）和具体方法。

abstract class Animal {
    abstract void makeSound();

    void sleep() {
        System.out.println("Animal is sleeping");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Dog is barking");
    }
}

public class AbstractClassExample {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.makeSound();
        dog.sleep();
    }
}

接口

接口是一个纯粹的抽象类，只能包含抽象方法（Java 8 以后可以包含默认方法和静态方法）。

interface Animal {
    void makeSound();
}

class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat is meowing");
    }
}

public class InterfaceExample {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.makeSound();
    }
}