Java基础语法之面向对象编程

在上一篇文章中，我们介绍了Java基础语法之方法（Java基础语法之方法），面向对象编程（Object-Oriented Programming，简称OOP）是Java的核心编程范式。OOP通过将数据和行为封装在对象中，使代码更加模块化、易维护和重用。本文将详细介绍Java中面向对象编程的基础，包括类和对象、封装、继承、多态以及相关注意事项。

1. 类和对象

类是对象的模板，定义了对象的属性和行为。对象是类的实例，通过类创建对象。

• 类的定义

  public class Person {
      // 属性
      String name;
      int age;
  
      // 方法
      public void speak() {
          System.out.println("Hello, my name is " + name);
      }
  }
  

• 对象的创建和使用

  public class Main {
      public static void main(String[] args) {
          // 创建对象
          Person person = new Person();
          
          // 设置属性
          person.name = "Alice";
          person.age = 30;
          
          // 调用方法
          person.speak();
      }
  }
  

2. 封装

封装是将对象的属性私有化，通过公共方法（getter和setter）访问和修改属性。封装提高了代码的安全性和可维护性。

• 封装示例

  public class Person {
      // 私有属性
      private String name;
      private int age;
  
      // getter 方法
      public String getName() {
          return name;
      }
  
      public int getAge() {
          return age;
      }
  
      // setter 方法
      public void setName(String name) {
          this.name = name;
      }
  
      public void setAge(int age) {
          if (age > 0) {
              this.age = age;
          }
      }
  
      // 公共方法
      public void speak() {
          System.out.println("Hello, my name is " + name);
      }
  }
  

• 注意事项：

  • 私有属性只能通过公共方法访问和修改。
  • 使用setter方法可以增加对属性值的验证。

3. 继承

继承是创建新类的方式，新类继承已有类的属性和方法。继承提高了代码的复用性和扩展性。

• 继承示例

  // 父类
  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) {
          if (age > 0) {
              this.age = age;
          }
      }
  
      public void speak() {
          System.out.println("Hello, my name is " + name);
      }
  }
  
  // 子类
  public class Student extends Person {
      private String studentId;
  
      public String getStudentId() {
          return studentId;
      }
  
      public void setStudentId(String studentId) {
          this.studentId = studentId;
      }
  }
  

• 使用继承的子类

  public class Main {
      public static void main(String[] args) {
          Student student = new Student();
          student.setName("Bob");
          student.setAge(20);
          student.setStudentId("S12345");
          student.speak();
          System.out.println("Student ID: " + student.getStudentId());
      }
  }
  

• 注意事项：

  • 子类可以继承父类的所有非私有属性和方法。
  • 子类可以添加新的属性和方法，也可以重写父类的方法。

4. 多态

多态是指同一个方法在不同对象中具有不同实现方式。通过继承和方法重写实现多态。

• 多态示例

  public class Animal {
      public void makeSound() {
          System.out.println("Some sound");
      }
  }
  
  public class Dog extends Animal {
      @Override
      public void makeSound() {
          System.out.println("Bark");
      }
  }
  
  public class Cat extends Animal {
      @Override
      public void makeSound() {
          System.out.println("Meow");
      }
  }
  

• 使用多态

  public class Main {
      public static void main(String[] args) {
          Animal myDog = new Dog();
          Animal myCat = new Cat();
          
          myDog.makeSound(); // 输出 "Bark"
          myCat.makeSound(); // 输出 "Meow"
      }
  }
  

• 注意事项：

  • 多态通过方法重写实现，子类重写父类的方法。
  • 父类引用可以指向子类对象，但只能调用父类定义的方法。

5. 知识结构图解

6. 示例代码整合

以下示例代码展示了面向对象编程的基础概念，包括类和对象、封装、继承和多态的各种使用方法：

public class OOPExamples {
    public static void main(String[] args) {
        // 类和对象示例
        Person person = new Person();
        person.setName("Alice");
        person.setAge(30);
        person.speak();

        // 继承示例
        Student student = new Student();
        student.setName("Bob");
        student.setAge(20);
        student.setStudentId("S12345");
        student.speak();
        System.out.println("Student ID: " + student.getStudentId());

        // 多态示例
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        myDog.makeSound(); // 输出 "Bark"
        myCat.makeSound(); // 输出 "Meow"
    }
}

// 类和对象示例
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) {
        if (age > 0) {
            this.age = age;
        }
    }

    public void speak() {
        System.out.println("Hello, my name is " + name);
    }
}

// 继承示例
class Student extends Person {
    private String studentId;

    public String getStudentId() {
        return studentId;
    }

    public void setStudentId(String studentId) {
        this.studentId = studentId;
    }
}

// 多态示例
class Animal {
    public void makeSound() {
        System.out.println("Some sound");
    }
}

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

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

注意事项总结

• 类是对象的模板，定义了对象的属性和行为。
• 封装通过私有属性和公共方法提高了代码的安全性和可维护性。
• 继承通过复用已有类的属性和方法提高了代码的复用性和扩展性。
• 多态通过方法重写实现，同一个方法在不同对象中具有不同实现方式。

结语

面向对象编程是Java中重要的编程范式，通过掌握类和对象、封装、继承和多态，可以编写出模块化、可维护和可扩展的代码。在接下来的文章中，我们将继续探讨Java的封装这一关键概念以及更多Java编程的基础知识，敬请期待！