java从入门到起飞（七）——面向对象

最新推荐文章于 2024-08-24 17:09:16 发布

杨思默

最新推荐文章于 2024-08-24 17:09:16 发布

阅读量5.1k

点赞数 1

分类专栏： ✿✿Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/yangsimo/article/details/132630600

版权

✿✿Java 专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一、什么是面向对象

1.1 定义

面向对象编程（Object-Oriented Programming，简称OOP）是一种软件开发方法，它将程序设计看作是一组对象的集合，每个对象都有自己的状态和行为。面向对象的编程思想是以对象为中心，通过封装、继承和多态等特性来实现代码的复用、灵活性和可扩展性。

1.2 特点

封装：将数据和方法封装在一个对象中，对象对外提供公共接口进行访问。
继承：通过继承机制，子类可以继承父类的属性和方法，并可以在此基础上进行扩展和重写。
多态：同一类型的对象在不同的情况下可以表现出不同的行为，提高了代码的灵活性和可扩展性。

二、面向对象的基础

2.1 面向对象的基础是抽象

抽象是面向对象编程中的一个重要概念，它指的是将具体的事物抽象成一种更一般、更通用的概念或模型。在面向对象的编程语言中，抽象是通过类和对象来实现的。

2.2 抽象的作用

抽象的作用是隐藏内部实现细节，只对外提供公共接口。通过抽象，我们可以将复杂的问题简化成一些更容易理解和处理的概念。抽象提高了代码的可维护性和可复用性，使得代码更加灵活和易于扩展。

2.3 类和对象

类：类是对一类具有相同属性和行为的对象的抽象，是创建对象的模板。
对象：对象是类的实例，具有自己的状态和行为。

// 定义一个类
public class Person {
    // 属性
    private String name;
    private int age;

    // 构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I'm " + age + " years old.");
    }
}

// 创建对象
Person person = new Person("Alice", 20);
person.sayHello(); // 输出：Hello, my name is Alice, I'm 20 years old.

2.4 属性和方法

属性：类中定义的变量，用于描述对象的状态。
方法：类中定义的函数，用于描述对象的行为。

public class Circle {
    // 属性
    private double radius;

    // 构造方法
    public Circle(double radius) {
        this.radius = radius;
    }

    // 方法
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

// 创建对象
Circle circle = new Circle(5);
double area = circle.getArea();
System.out.println("The area of the circle is: " + area); // 输出：The area of the circle is: 78.53981633974483

2.5 构造方法

构造方法：用于创建对象并初始化对象的属性。

public class Student {
    // 属性
    private String name;
    private int age;

    // 构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 方法
    public void displayInfo() {
        System.out.println("Name: " + name);
        System.out.println("Age: " + age);
    }
}

// 创建对象
Student student = new Student("Bob", 18);
student.displayInfo(); // 输出：Name: Bob, Age: 18

三、面向对象的三大特征

3.1 封装

3.1.1 封装的意义

隐藏内部实现细节，只对外提供公共接口。
提高代码的可维护性和可复用性。

3.1.2 封装的实现

使用访问修饰符（public、private、protected）控制属性和方法的访问权限。
提供公共方法（getter和setter）来访问和修改属性。

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) {
        this.age = age;
    }
}

Person person = new Person();
person.setName("Alice");
person.setAge(20);
System.out.println("Name: " + person.getName()); // 输出：Name: Alice
System.out.println("Age: " + person.getAge()); // 输出：Age: 20

3.2 继承

3.2.1 继承的意义

代码复用：子类可以继承父类的属性和方法。
类的层次结构：通过继承可以建立类之间的层次关系。

3.2.2 继承的实现

使用关键字extends来实现继承。
子类通过继承父类，可以直接使用父类的属性和方法。

public class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

public class Dog extends Animal {
    public void bark() {
        System.out.println("Dog is barking.");
    }
}

Dog dog = new Dog();
dog.eat(); // 输出：Animal is eating.
dog.bark(); // 输出：Dog is barking.

3.3 多态

3.3.1 多态的意义

提高代码的灵活性和可扩展性。
实现方法的重写和重载。

3.3.2 多态的实现

方法重写：子类可以重写父类的方法，实现方法的多态性。
方法重载：在同一个类中，可以定义多个同名方法，但参数类型或个数不同。

public class Shape {
    public void draw() {
        System.out.println("Drawing shape...");
    }
}

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

public class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("Drawing rectangle...");
    }
}

Shape shape1 = new Circle();
Shape shape2 = new Rectangle();
shape1.draw(); // 输出：Drawing circle...
shape2.draw(); // 输出：Drawing rectangle...

四、使用面向对象编程有哪些优点和缺点

使用面向对象编程的优点

面向对象编程（Object-Oriented Programming，OOP）具有以下几个优点：

可重用性：面向对象的编程思想通过封装、继承和多态等特性，可以将代码组织成可重用的模块。这意味着可以在不同的项目中重复使用已经编写好的类和对象，减少了代码的重复编写，提高了开发效率。
灵活性：面向对象的编程思想使得代码更加灵活和可扩展。通过继承和多态，可以在不修改原有代码的情况下，对已有的类进行扩展和修改。这样可以更好地应对需求的变化，提高了代码的可维护性和可扩展性。
可维护性：面向对象的编程思想通过封装和隐藏内部实现细节，使得代码更加模块化和易于理解。这样可以降低代码的复杂性，减少了代码的维护成本，提高了代码的可维护性。
安全性：面向对象的编程思想通过封装和访问控制，可以保护对象的数据不被外部访问和修改。这样可以提高代码的安全性，防止数据被误用或破坏。
可扩展性：面向对象的编程思想通过继承和多态，可以很容易地扩展已有的代码。新的类可以继承已有的类，并可以重写父类的方法或添加新的方法，从而实现对已有功能的扩展。这样可以降低了系统的耦合度，提高了代码的可扩展性。

总的来说，面向对象的编程思想可以使代码更加模块化、可维护和可复用，提高了开发效率和代码质量。它是现代软件开发中非常重要的一种编程范式。

使用面向对象编程的缺点

虽然面向对象编程（Object-Oriented Programming，OOP）有许多优点，但也存在一些缺点：

代码冗余性：面向对象编程的代码通常比较复杂，涉及到许多类和对象之间的关系。这使得代码的阅读和理解变得更加困难，也增加了程序的冗余性。在设计和实现过程中，需要花费更多的时间和精力来规划和组织代码结构。
性能开销：面向对象编程为了解决类与类之间的耦合，会做一层抽象和封装，会带来一定的性能开销。由于需要通过方法调用和对象间的消息传递来实现功能，相对于面向过程的编程方式，面向对象的程序可能会运行得更慢。
尽管面向对象编程存在一些缺点，但通过良好的设计和编码实践，可以最大限度地发挥其优点，减少其缺点的影响。同时，现代编程语言和开发工具也提供了许多支持面向对象编程的功能和特性，使得开发者能够更加高效地使用面向对象编程思想。