掌握 Java 面向对象编程：综合指南 ☕♨

面向对象编程

面向对象编程（OOP）是一种将现实世界实体建模为对象的编程范例。这些对象具有属性（属性）和行为（方法）。 OOP 基于封装、继承、多态性和抽象的概念。

Java 是一种并发、基于类和面向对象的计算机编程语言。面向对象的优点
软件开发如下图：

• 模块化开发：这使得代码更容易维护和修改。
• 代码可重用性：这减少了多次编写相同代码的需要。
• 提高了代码可靠性和灵活性：这使得创建健壮且适应性强的软件变得更加容易。
• 增强代码理解：这提高了代码的可读性和可维护性。

封装

Java 中的封装是一个基本的面向对象编程概念，涉及在对象内捆绑数据（属性）和方法（行为）。它提供数据隐藏和访问控制，确保数据受到保护并且只能通过定义的方法访问。

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

public class Main {
    public static void main(String[] args) {
        Person p = new Person("Sam", 21);
        System.out.println("Person Name: "+ p.getName());
        System.out.println("Person Name: "+ p.getAge());
        /* 
         *  p.name = "Anderson";  -> We couldn't modify the varibale value directly. It's Error ❗.
         *  p.age = 20;
        */
    }
}

想象一个盒子。盒子里面是您的个人物品。你可以看到盒子并知道里面有什么，但不打开盒子你不能直接触摸或改变里面的物品。这类似于Java中的封装。

多态性

多态性，在Java中，是指不同类的对象以不同方式响应相同方法调用的能力。这是面向对象编程中的一个基本概念，它允许灵活性和代码可重用性。多态有编译时多态和运行时多态两种。

例子

想象你有一个遥控器。您可以按“播放”按钮，它会播放一些内容。但它播放的内容取决于它控制的设备：电视、DVD 播放器或音乐播放器。

这就像Java中的多态性。 “播放”按钮是相同的方法，但行为（播放内容）根据对象（电视、DVD 播放器、音乐播放器）而不同。

因此，多态性意味着同一事物（方法）可以根据调用它的对象而具有不同的行为。

interface Playable {
    void play();
}

class TV implements Playable {
    public void play() {
        System.out.println("Playing TV show");
    }
}

class DVDPlayer implements Playable {
    public void play() {
        System.out.println("Playing DVD");
    }
}

class MusicPlayer implements Playable {
    public void play() {
        System.out.println("Playing music");
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Playable[] devices = {new TV(), new DVDPlayer(), new MusicPlayer()};
        for (Playable device : devices) {
            device.play();
        }
    }
}

遗产

继承概念允许类从父类继承属性、属性和方法。这促进了代码的可重用性、模块化以及类之间层次关系的创建。

Java 中的继承就像一棵家谱。子类可以继承父类的特征。有几种不同的方法可以做到这一点：

• 单一继承：一个孩子，一个父母。
• 多级继承：子级继承父级，而父级也是子级。
• 分层继承：来自一个父级的多个子级。

Java不直接支持多重继承，但你可以使用接口来获得类似的结果。

class Animal {
    void makeSound() {
        System.out.println("Generic animal sound");
    }

    void makeSound(int numberOfTimes) {
        for (int i = 0; i < numberOfTimes; i++) {
            System.out.println("Generic animal sound");
        }
    }
}

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

    @Override
    void makeSound(int numberOfTimes) {
        for (int i = 0; i < numberOfTimes; i++) {
            System.out.println("Woof!");
        }
    }
}

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

    @Override
    void makeSound(int numberOfTimes) {
        for (int i = 0; i < numberOfTimes; i++) {
            System.out.println("Meow!");
        }
    }
}

public class PolymorphismExample {
    public static void main(String[] args) {
        Animal[] animals = {new Dog(), new Cat()};

        // Method overloading:
        animals[0].makeSound();
        animals[1].makeSound(3);

        // Method overriding:
        for (Animal animal : animals) {
            animal.makeSound();
        }
    }
}

抽象

抽象是将想法与特定实例分离的过程，因此根据类自身的功能而不是其实现细节来开发类。 Java 支持公开接口的抽象类的创建和存在，而不包括所有方法的实际实现。抽象技术旨在将类的实现细节与其行为分开。

abstract class Shape {
    abstract double getArea();
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double length;
    private double width;

    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    @Override
    public double getArea() {
        return length * width;
    }
}

public class ShapeExample {
    public static void main(String[] args) {
        Shape circle = new Circle(5.0);
        Shape rectangle = new Rectangle(4.0, 3.0);

        System.out.println("Circle area: " + circle.getArea());
        System.out.println("Rectangle area: " + rectangle.getArea());
    }
}

想象一下您有一个汽车、自行车和飞机的遥控器。您可以使用遥控器上的相同按钮来启动、停止和移动每辆车，即使它们非常不同。这就像编程中的抽象。

抽象和封装之间的区别

抽象

• 焦点：隐藏对象的潜在复杂性，仅揭示基本特征。
• 目的：通过关注对象的作用而不是它如何做来简化代码。
• 机制：通过抽象类和接口实现。
• 示例： 定义 start()、stop() 和 move() 等方法的车辆接口，但不透露每种车辆类型（汽车、自行车等）的具体实现。

封装

• 重点： 保护对象的数据免遭未经授权的访问或修改。
• 目的：增强代码安全性、模块化和可维护性。
• 机制：通过将数据成员设为私有并提供访问或修改它们的公共方法来实现。
• 示例： 一个 Person 类，具有姓名和年龄等私有字段，以及用于访问或修改这些字段的公共方法（例如 getName() 和 setAge()）。

主要区别

Feature	Abstraction	Encapsulation
Focus	Essential features	Data protection
Purpose	Simplification	Security, modularity
Mechanism	Abstract classes, interfaces	Private fields, public methods
Example	Vehicle interface	Person class with private fields and public methods

本质上：

• 抽象是关于对象的作用。
• 封装是关于对象如何实现它的。

将 OOP 想象成用乐高积木建造。每块砖都是一个具有自己形状和属性的物体。您可以组合砖块来创建更大、更复杂的结构。通过理解这些概念，您可以创建更有组织、灵活且高效的代码。

以上是掌握 Java 面向对象编程：综合指南 ☕♨的详细内容。更多信息请关注PHP中文网其他相关文章！