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

珍惜时间，勤奋学习！今天给大家带来《掌握 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()）。

主要区别

本质上：

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

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

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《掌握 Java 面向对象编程：综合指南 ☕♨》文章吧，也可关注golang学习网公众号了解相关技术文章。