面向对象编程

面向对象编程的主要目标是通过对象和类来组织代码，使得程序更加模块化和可维护。

2. 面向对象编程

2.1 类与对象

类是对象的蓝图或模板。类定义了对象的属性和行为。对象是类的实例，通过类创建，并可以使用类定义的方法和属性。

创建类和对象的基本示例：

public class Dog {
    // 属性（字段）
    String name;
    int age;

    // 方法
    void bark() {
        System.out.println("Woof! Woof!");
    }

    void displayInfo() {
        System.out.println("Name: " + name + ", Age: " + age);
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建对象
        Dog myDog = new Dog();
        // 设置属性
        myDog.name = "Buddy";
        myDog.age = 3;
        // 调用方法
        myDog.bark();
        myDog.displayInfo();
    }
}

在这个示例中，Dog 是一个类，具有 name 和 age 这两个属性，以及 bark 和 displayInfo 这两个方法。Main 类中的 main 方法创建了一个 Dog 对象，并对其属性进行了赋值，调用了其方法。

2.2 继承

继承允许我们创建一个新的类，该类基于现有类，并且可以复用、扩展或修改现有类的功能。被继承的类称为父类（或基类），继承的类称为子类（或派生类）。

继承的基本示例：

// 父类
public class Animal {
    void eat() {
        System.out.println("This animal eats food.");
    }
}

// 子类
public class Cat extends Animal {
    void meow() {
        System.out.println("Meow! Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat myCat = new Cat();
        myCat.eat(); // 从父类继承的方法
        myCat.meow(); // 子类自己的方法
    }
}

在这个示例中，Animal 类是父类，Cat 类是子类。Cat 类继承了 Animal 类的 eat 方法，并添加了自己的 meow 方法。

2.3 多态

多态是指同一个方法或操作在不同的对象中具有不同的表现。主要有两种形式：方法重载和方法重写。

• 方法重载（Overloading）：同一个类中，方法名称相同但参数不同。

  方法重载示例：

  public class Display {
      void show(int num) {
          System.out.println("Number: " + num);
      }
  
      void show(String message) {
          System.out.println("Message: " + message);
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Display display = new Display();
          display.show(10); // 调用 show(int)
          display.show("Hello"); // 调用 show(String)
      }
  }
  

• 方法重写（Overriding）：子类中定义一个与父类中方法相同的方法，用于修改或扩展父类的行为。

  方法重写示例：

  // 父类
  public class Animal {
      void sound() {
          System.out.println("Some sound...");
      }
  }
  
  // 子类
  public class Dog extends Animal {
      @Override
      void sound() {
          System.out.println("Woof! Woof!");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Animal myDog = new Dog();
          myDog.sound(); // 调用 Dog 类中的 sound 方法
      }
  }
  

2.4 封装

封装是将数据（属性）和操作数据的方法（行为）封装在一个类中，并隐藏实现细节。封装的好处是可以控制数据访问，保护数据不被随意修改。

封装的基本示例：

public class Person {
    // 私有属性
    private String name;
    private int age;

    // 公共的 getter 和 setter 方法
    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 class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("John");
        person.setAge(30);
        System.out.println("Name: " + person.getName());
        System.out.println("Age: " + person.getAge());
    }
}

在这个示例中，Person 类的 name 和 age 属性是私有的，通过公共的 getter 和 setter 方法进行访问和修改。setAge 方法还包含了数据验证逻辑，确保年龄是正数。

2.5 抽象与接口

• 抽象类：抽象类是不能实例化的类，主要用于被其他类继承。它可以包含抽象方法（没有实现的方法）和具体方法（有实现的方法）。

  抽象类示例：

  abstract class Animal {
      abstract void makeSound(); // 抽象方法
  
      void sleep() { // 具体方法
          System.out.println("This animal sleeps.");
      }
  }
  
  public class Dog extends Animal {
      @Override
      void makeSound() {
          System.out.println("Woof! Woof!");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Animal myDog = new Dog();
          myDog.makeSound(); // 调用 Dog 类中的 makeSound 方法
          myDog.sleep(); // 调用 Animal 类中的 sleep 方法
      }
  }
  

• 接口：接口是一种特殊的抽象类，包含抽象方法的集合。类通过实现接口来承诺实现接口中的所有方法。

  接口示例：

  interface Animal {
      void makeSound();
  }
  
  class Cat implements Animal {
      @Override
      public void makeSound() {
          System.out.println("Meow! Meow!");
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          Animal myCat = new Cat();
          myCat.makeSound(); // 调用 Cat 类中的 makeSound 方法
      }
  }
  

  接口与抽象类的区别：

  • 接口不能包含具体的方法实现，而抽象类可以。
  • 一个类可以实现多个接口，但只能继承一个抽象类。

以上就是面向对象编程的基本概念和示例。在 Java 编程中，掌握这些面向对象的原则对于编写清晰、可维护和可扩展的代码非常重要。