Java面向对象

java面向对象

Java 是一门面向对象的编程语言，这意味着它的设计和编程范式是基于面向对象的思想。面向对象编程（Object-Oriented Programming，简称 OOP）是一种以对象为核心的编程风格，通过封装、继承和多态等概念来组织和管理代码。

以下是面向对象编程的主要概念：

1. 封装（Encapsulation）： 封装是指将对象的状态（数据）和行为（方法）捆绑在一起，并对外部隐藏对象的内部实现细节。通过封装，可以控制对对象的访问，提高代码的可维护性和安全性。

   public 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 void setName(String name) {
           this.name = name;
       }
       
       public void setAge(int age) {
           this.age = age;
       }
       
       // 其他方法
       public void displayInfo() {
           System.out.println("Name: " + name + ", Age: " + age);
       }
   ​
   }

2. 继承（Inheritance）： 继承是一种机制，允许一个类（子类）继承另一个类（父类）的属性和方法。子类可以重用父类的代码，并且可以在其基础上进行扩展或修改。继承有助于代码的重用和层次结构的建立。

   public class Student extends Person { //继承的上面的Person
       private String studentId;
   ​
       // 构造方法
       public Student(String name, int age, String studentId) {
           super(name, age); // 调用父类的构造方法
           this.studentId = studentId;
       }
   ​
       // 新的方法
       public String getStudentId() {
           return studentId;
       }
   ​
       // 重写父类的方法
       @Override
       public void displayInfo() {
           super.displayInfo(); // 调用父类的方法
           System.out.println("Student ID: " + studentId);
       }
   }
   ​

3. 多态（Polymorphism）： 多态允许一个类的实例在运行时表现出多种形态。通过多态，可以以一致的方式处理不同类的对象，提高代码的灵活性和可扩展性。多态包括编译时多态性（方法重载、运算符重载等）和运行时多态性（方法重写）。

   public class Main {
       public static void main(String[] args) {
           Person person = new Person("Alice", 25);
           Student student = new Student("Bob", 20, "S12345");
   ​
           displayPersonInfo(person);
           displayPersonInfo(student);
       }
   ​
       // 通用的方法，接受 Person 类型的参数
       public static void displayPersonInfo(Person p) {
           p.displayInfo(); // 调用多态方法
       }
   }

   ​

4. 抽象（Abstraction）： 抽象是一种对现实世界实体的简化和建模过程。在面向对象编程中，通过抽象可以定义抽象类和接口，提供了一种机制来隐藏对象的复杂性，使得系统更易于理解和维护。

   // 抽象类
   

   abstract class Shape {
       // 抽象方法，没有具体实现
       abstract double calculateArea();
   ​
       // 具体方法
       void display() {
           System.out.println("This is a shape.");
       }
   }
   ​
   // 子类继承抽象类并提供具体实现
   class Circle extends Shape {
       private double radius;
   ​
       // 构造方法
       public Circle(double radius) {
           this.radius = radius;
       }
   ​
       // 实现抽象方法
       @Override
       double calculateArea() {
           return Math.PI * radius * radius;
       }
   }

总结：其中抽象是Java面向对象的一种重要思想，需要我们通过实际操作不断练习，分析实物行为，最后体现在我们的代码上；继承、多态 则是让面向对象变得更加有逻辑，代码写起来变得更加灵活，封装则是提高了代码的安全性。