了解面向对象编程 (OOP)

面向对象编程（oop）是 java 其中一个基本概念使创建模块化、可重用和可扩展的代码更容易。本文将讨论 oop 类、对象、继承、包装、多态性、抽象等核心原则。

oop 它是一个基于“对象”概念的编程示例，可以包含数据和操作数据的方法。通过组织代码作为对象，您可以创建一个更容易管理和理解的程序。

oop 四个关键原则是：

• 封装
• 传承
• 多态性
• 抽象

让我们在 java 探索上下文中的每一个概念。

点击下载“修复打印机驱动工具”；

2.1 什么是类？

java中的类是创建对象的蓝图。它定义了从类创建的对象的属性(字段)和行为(方法)。将类视为概述对象结构和功能的模板。

班级示例：

public class car {
    // fields (attributes)
    string mark;
    string model;
    int year;

    // method (behavior)
    void startengine() {
        system.out.println("engine started.");
    }
}

在本例中，car类有三个字段：mark、model、year，以及startengine()的一种方法。

2.2 对象是什么？

对象是类别的例子。定义类别后，您可以创建多个对象，每个对象都有自己唯一的字段值。

创建对象的例子：

public class main {
    public static void main(string[] args) {
        // creating an object of the car class
        car mycar = new car();

        // setting field values
        mycar.mark = "toyota";
        mycar.model = "corolla";
        mycar.year = 2021;

        // calling a method
        mycar.startengine();  // outputs: engine started.
    }
}

在这个例子中，mycar 是 car 对象类，并为其字段分配特定值。

挑战1： 创建一个名字 book 类，包括标题，作者和页码字段。创建。 book 对象类，设置其字段，并打印书籍的详细信息。

包装是将数据（字段）和数据操作方法绑定到单个单元或类别中，并限制对某些对象组件的访问。这是通过使用访问修改符（私有、公共和受保护的）来实现的。

包装有助于保护对象的内部状态免受意外干扰和误用。

封装示例：

public class person {
    // private fields
    private string name;
    private int age;

    // public methods to access private fields
    public string getname() {
        return name;
    }

    public void setname(string newname) {
        name = newname;
    }

    public int getage() {
        return age;
    }

    public void setage(int newage) {
        if (newage > 0) {
            age = newage;
        }
    }
}

在这个例子中，person 该类通过将其字段设置为私有来包装其字段，并提供公共方法（getname、setname、getage、setage）访问和修改这些字段。

挑战2： 通过将字段设置为私有，并为每个字段创建公共 getter 和 setter 方法，为 book 类别添加包装。

继承是一种允许一个类继承另一个类的属性和方法的机制。继承的类称为“子类”或“子类”，继承的类称为“超级类”或“父类”。

继承提高了代码的可重用性，并在类之间建立了自然的层次结构。

继承示例：

// superclass
public class animal {
    void eat() {
        system.out.println("this animal is eating.");
    }
}

// subclass
public class dog extends animal {
    void bark() {
        system.out.println("the dog is barking.");
    }
}

public class main {
    public static void main(string[] args) {
        dog mydog = new dog();
        mydog.eat();  // inherited method from animal class
        mydog.bark(); // method from dog class
    }
}

在这个例子中，dog类继承了animal类的eat方法，并且有自己的bark方法。

挑战3： 创造一个继承自 book 类的子类 ebook。添加新字段 filesize 和方法 download() 到 ebook 类。

多态允许不同类别的对象被视为公共超级对象。可以通过方法重写和界面来实现。

5.1 方法重写

方法重写允许子类提供其超类中定义的方法的具体实现。

多态性示例：

public class animal {
    void sound() {
        system.out.println("this animal makes a sound.");
    }
}

public class cat extends animal {
    @override
    void sound() {
        system.out.println("the cat meows.");
    }
}

public class main {
    public static void main(string[] args) {
        animal myanimal = new cat(); // polymorphism
        myanimal.sound();  // outputs: the cat meows.
    }
}

尽管如此 myanimal 是 animal 但它引用的是类型 cat 类型对象，并调用 cat 重写的 sound 方法。

挑战4： 重写 book 类中的 tostring 该方法以字符串的形式返回书籍的详细信息。

抽象涉及到实现隐藏系统的复杂细节，并且只披露必要的部分。抽象类和接口可用于实现。

6.1 抽象类

抽象类不能实例化，可能包含子类必须实现的抽象方法(没有主体的方法)。

抽象示例：

abstract class Shape {
    abstract void draw();  // Abstract method
}

public class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("Drawing a circle.");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape myShape = new Circle();
        myShape.draw();  // Outputs: Drawing a circle.
    }
}

在这种情况下，shape是一种抽象类，有一种抽象方法draw，它是由circle类实现的。

挑战5： 采用抽象方法 poweron 创建抽象类 device。创造一个实现 poweron 方法的 smartphone 子类。

在这篇文章中，我们进行了讨论 java 中面向对象编程的关键概念：类别、对象、继承、包装、多态性和抽象性。理解这些原则是为了构建复杂而高效的原则 java 应用程序非常重要。

请随意尝试提供的示例和挑战。如果您有任何问题或需要进一步解释，请在下面发表评论！

以上是对面向对象编程的理解 (OOP)详情请关注图灵教育的其他相关文章！