Java 中的面向对象编程：类和对象的使用方法

原创

老年程序员 2023-03-18 09:52:51 博主文章分类：Java入门文章 ©著作权

文章标签 父类子类多态 文章分类 Java 后端开发 yyds干货盘点

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

一、介绍

什么是面向对象编程

面向对象编程（Object-Oriented Programming, OOP）是一种编程范式，它将现实世界中的事物抽象成对象，通过对象之间的交互来完成程序的设计与实现。面向对象编程的主要特点包括：封装、继承、多态。

Java 中的面向对象编程优势

代码复用性高：面向对象编程支持类的继承和对象的多态等特性，这些特性使得代码的复用性大大提高。
代码可维护性高：面向对象编程的封装性和抽象性使得代码结构清晰，易于维护。
开发效率高：面向对象编程的封装性、抽象性和多态性等特性，使得代码编写更为简洁、易于理解。
程序设计更为灵活：面向对象编程的多态性使得程序设计更为灵活，能够适应不同的需求变化。
可扩展性高：面向对象编程的继承和多态性使得程序更为可扩展，能够方便地增加新的功能模块。
代码重用性高：面向对象编程支持封装、抽象、继承和多态等特性，这些特性使得代码的重用性大大提高。

二、类的定义和使用

定义类

Java 中定义一个类需要使用关键字 class，类的名称一般采用首字母大写的驼峰命名法，类的定义包含在一对花括号 {} 中。

例如：

public class Person {
    // 类的成员变量
    String name;
    int age;
    
    // 类的成员方法
    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I'm " + age + " years old.");
    }
}

类的构造方法

类的构造方法（Constructor）是一种特殊的方法，用于创建对象时进行初始化操作。构造方法的名称必须与类名相同，并且不能有返回类型，可以有参数也可以没有参数。

例如，我们可以在 Person 类中添加一个构造方法，用于初始化成员变量 name 和 age，代码如下：

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(String name, int age)，用于初始化成员变量 name 和 age。在构造方法中，我们使用了 this 关键字来引用当前对象的成员变量，从而完成初始化操作。

类的成员变量和成员方法

类的成员变量和成员方法是类的重要组成部分，用于描述对象的状态和行为。成员变量可以是基本类型或引用类型，成员方法可以是普通方法或静态方法。

例如，我们在 Person 类中定义了两个成员变量 name 和 age，以及一个成员方法 sayHello()，代码如下：

public class Person {
    private String name;
    private int age;
    
    public void sayHello() {
        System.out.println("Hello, my name is " + name + ", I'm " + age + " years old.");
    }
    
    // 省略其他代码
}

在上述代码中，成员变量 name 和 age 用于描述一个人的姓名和年龄，成员方法 sayHello() 用于输出该人的信息。

访问控制修饰符

访问控制修饰符包括以下四种：

public：表示该成员变量或成员方法对所有类可见，可以在任何地方访问。
private：表示该成员变量或成员方法仅对当前类可见，其他类无法访问。
protected：表示该成员变量或成员方法对当前类及其子类可见，其他类无法访问。
默认访问修饰符（即不写访问控制修饰符）：表示该成员变量或成员方法仅对当前包内的类可见，其他包的类无法访问。

三、对象的创建和使用

创建对象

在 Java 中，通过 new 关键字可以创建一个对象，语法如下：

类名 对象名 = new 类名();

其中，类名 是要创建对象的类名，对象名 是指定对象的名字，可以根据需要自行命名。

例如，我们在 Main 类中创建一个 Person 对象，代码如下：

public class Main {
    public static void main(String[] args) {
        // 创建一个 Person 对象
        Person person = new Person();
    }
}

对象的属性和方法访问

在 Java 中，通过对象名和点运算符 . 可以访问对象的属性和方法。

例如，我们在 Main 类中创建一个 Person 对象 person，并访问它的属性 name 和方法 sayHello()，代码如下：

public class Main {
    public static void main(String[] args) {
        // 创建一个 Person 对象
        Person person = new Person();
        
        // 访问对象的属性 name
        person.name = "张三";
        
        // 访问对象的方法 sayHello()
        person.sayHello();
    }
}

对象的方法调用

在 Java 中，通过对象名和点运算符 . 可以调用对象的方法。

例如，我们在 Main 类中创建一个 Person 对象 person，并调用它的方法 eat()，代码如下：

public class Main {
    public static void main(String[] args) {
        // 创建一个 Person 对象
        Person person = new Person();
        
        // 调用对象的方法 eat()
        person.eat();
    }
}

四、继承

定义子类和父类

在 Java 中，可以使用 extends 关键字来定义子类和父类。子类继承父类的属性和方法，并且可以扩展或重写父类的方法。

下面是定义一个子类的语法：

class 子类名 extends 父类名 {
    // 子类的属性和方法
}

例如，我们定义一个 Student 子类继承 Person 父类，代码如下：

class Student extends Person {
    // 学号属性
    int studentId;
    
    // 构造方法
    public Student(String name, int age, int studentId) {
        super(name, age);  // 调用父类的构造方法
        this.studentId = studentId;
    }
    
    // 子类的方法
    public void study() {
        System.out.println("我在学习");
    }
}

继承关系的实现

在 Java 中，子类可以访问父类的 public 和 protected 属性和方法。但是，子类不能访问父类的 private 属性和方法。

例如，在 Student 子类中可以访问 Person 父类的 name 和 age 属性，以及 sayHello() 方法，但不能访问 private 访问控制修饰符修饰的 id 属性，代码如下：

class Student extends Person {
    // 学号属性
    int studentId;
    
    // 构造方法
    public Student(String name, int age, int studentId) {
        super(name, age);  // 调用父类的构造方法
        this.studentId = studentId;
    }
    
    // 子类的方法
    public void study() {
        System.out.println("我在学习");
        System.out.println("我的名字是：" + name);  // 访问父类的属性 name
        System.out.println("我的年龄是：" + age);  // 访问父类的属性 age
        sayHello();  // 调用父类的方法 sayHello()
        //System.out.println("我的 ID 是：" + id);  // 编译错误，不能访问父类的 private 属性 id
    }
}

方法的重写和重载

方法的重写是指在子类中定义与父类中名称、参数列表、返回类型相同的方法，但实现内容不同，可以覆盖父类中的方法。方法的重写使用 @Override 注解来标识。

五、多态

定义多态

在面向对象编程中，多态是指同一个方法调用可以有不同的表现形式。多态实现了面向对象编程的另一个重要特性——接口。

多态的实现方式有两种：继承和接口。

通过继承实现多态时，子类可以重写（override）父类的方法，从而实现不同的行为，但是方法名、参数列表和返回值类型必须与父类一致。

通过接口实现多态时，一个类可以实现多个接口，从而具有多种形态。

多态的实现

在 Java 中，多态的实现需要使用到抽象类和接口。抽象类和接口都是一种规范，用来定义子类需要实现的方法。

下面是一个接口的定义：

interface Shape {
    public void draw();
}

下面是一个实现了 Shape 接口的类：

class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("画一个圆形");
    }
}

在上述代码中，Circle 类实现了 Shape 接口，因此必须实现 draw() 方法。

下面是一个实现多态的示例：

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle();  // 向上转型
        Shape shape2 = new Rectangle();  // 向上转型
        shape1.draw();
        shape2.draw();
    }
}

在上述代码中，Circle 类和 Rectangle 类都实现了 Shape 接口，因此可以向上转型为 Shape 类型。在 Main 类中，我们创建了两个 Shape 对象，并分别调用了它们的 draw() 方法，输出了不同的内容。

多态的优势

提高了代码的复用性和扩展性，因为子类可以通过继承和实现接口来重用父类的代码。
降低了耦合度，因为客户端只需要知道父类或接口的方法名和参数类型，而不需要知道具体的子类实现，从而降低了代码的依赖性。
提高了灵活性和可维护性，因为可以随时修改、添加或删除子类，而不影响客户端代码的正常运行。

六、接口

定义接口

在 Java 中，接口是一种特殊的抽象类，它只定义了方法的规范，而没有提供方法的实现。接口中的方法默认是公共和抽象的，因此可以被任何类实现。

下面是一个接口的定义：

public interface MyInterface {
    public void myMethod();
}

实现接口

要实现一个接口，必须使用关键字 implements，并重写接口中的所有方法。下面是一个实现接口的示例：

public class MyClass implements MyInterface {
    @Override
    public void myMethod() {
        System.out.println("实现 MyInterface 接口的 myMethod() 方法");
    }
}

在上述代码中，我们定义了一个名为 MyClass 的类，它实现了 MyInterface 接口，并重写了 myMethod() 方法。

接口的优势

定义了一组公共的方法，可以让不同的类实现相同的接口，从而具有相同的行为和特征，提高了代码的可重用性和可维护性。
降低了耦合度，因为客户端只需要知道接口的方法名和参数类型，而不需要知道具体的实现，从而降低了代码的依赖性。
提高了灵活性和扩展性，因为可以随时增加或修改接口的方法，而不需要改变已经实现了接口的类的代码。

七、封装和抽象

封装的定义和实现

封装是一种面向对象编程的重要特性，它将数据和行为封装在一个类中，并对外提供公共的接口，以保护数据不被不当访问或修改。封装可以通过以下两种方式实现：

使用访问控制修饰符，如 private、public、protected，控制变量的访问范围。
提供公共的 get 和 set 方法，用于获取和设置变量的值。

下面是一个封装的示例：

public class MyClass {
    private int myVar;

    public int getMyVar() {
        return myVar;
    }

    public void setMyVar(int myVar) {
        this.myVar = myVar;
    }
}

在上述代码中，我们定义了一个名为 MyClass 的类，它有一个私有的变量 myVar，并提供了公共的 getMyVar() 和 setMyVar() 方法，用于获取和设置变量的值。

抽象类和抽象方法的定义和实现

抽象类是一种特殊的类，它不能被实例化，只能被继承，用于表示一类具有相似特征和行为的对象。抽象类可以包含抽象方法，抽象方法只有方法头，没有方法体，需要在子类中实现。

下面是一个抽象类和抽象方法的示例：

public abstract class MyAbstractClass {
    public abstract void myAbstractMethod();
}

在上述代码中，我们定义了一个名为 MyAbstractClass 的抽象类，它有一个抽象方法 myAbstractMethod()，需要在子类中实现。

封装和抽象的优势

提高了代码的可维护性和可扩展性，因为封装和抽象使得代码更加模块化，各个模块之间的关系更加清晰，修改和扩展更加方便。
隐藏了实现细节，使得客户端无需关心内部实现细节，只需要关心提供的接口，从而降低了代码的依赖性和耦合度。
提高了代码的安全性和可靠性，封装保护了数据的完整性和一致性，抽象规范了接口的行为和特征，使得代码更加健壮和可靠。

上一篇：spring的面向切面编程

下一篇：在 Java 中使用数组存储和操作数据

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯