面向对象编程（Object Oriented Programming）简称为OOP，是一种基于对象和类的编程范式，通过将程序的功能组织为多个对象，每个对象包含数据和操作数据的方法。
基本概念和特性
类：
类是对象的模板或蓝图，定义了一组具有相同属性和行为的对象。类描述了对象的属性（成员变量）和行为（成员函数），通过实例化类来创建对象。
以下代码定义了一个简单的Cat类，包含两个属性：name（名字）和 age（年龄）
```
public class Cat {
// 属性 name和age
private String name;
private int age;
// 构造方法 （又称构造器，构造函数）
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
// getter 方法，用于获取名字
public String getName() {
return name;
}
// setter 方法，用于设置名字
public void setName(String name) {
this.name = name;
}
// getter 方法，用于获取年龄
public int getAge() {
return age;
}
// setter 方法，用于设置年龄
public void setAge(int age) {
if (age >= 0) { // 通常年龄应该是非负数
this.age = age;
}
}
// 重写 toString() 方法，用于输出对象的字符串表示形式
@Override
public String toString() {
return "Cat{name='" + name + "', age=" + age + "}";
}
对象：
对象是类的实例，每个对象具有独立的属性和方法
对象的属性和方法可以绑定在一起，并限制外部对属性的直接访问，这种特性叫封装，封装通过访问修饰符（如public、protected）实现，提供数据隐藏和保护的机制。封装有助于提高代码的可维护性和安全性。
```
public class Today {
private String weather;
private int date;
// 构造方法
public Today(String weather, int date) {
this.weather = weather;
this.date = date;
}
//方法：说明天气及日期
public void introduce(){
System.out.println("今天的天气为"+weather+" 今日是本月的"+date+" 号");
}
}
//创建对象并调用方法
public class THIS {
public static void main(String[] args) {
//创建对象Today
Today today=new Today("晴",21);
//调用方法
today.introduce();
}
}
多态：
多态是指同一个操作在不同对象上表现出不同行为的能力。多态可以通过方法重载（同名不同参数的方法）和方法重写（子类重写父类的方法）实现。
以下是一个子类重写父类方法的例子
```
//创建一个父类Animal
public class Animal {
public void sound() {
System.out.println("Animal makes a sound");
}
}
创建第一个子类Cat
public class Cat extends Animal {
@Override
public void sound() {
System.out.println("喵喵喵");
}
}
创建第二个子类Dog
public class Dog extends Animal {
@Override
public void sound() {
System.out.println("汪汪汪！");
}
}
public class Main {
public static void main(String[] args) {
// 创建 Animal 类的引用，指向 Dog 和 Cat 对象，表现出多态性
Animal myDog = new Dog();
Animal myCat = new Cat();
// 调用 sound 方法
myDog.sound(); // 输出显示: 汪汪汪！
myCat.sound(); // 输出显示: 喵喵喵
}
}
多态允许同一个方法有不同的实现方式，使得代码更加灵活和可扩展。当需要添加新的功能时，只需添加新的子类或覆盖现有方法，而不需要修改现有代码。
继承:
继承是指一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码重用和层次化组织。通过继承，子类可以扩展或修改父类的行为。继承可以是单继承（一个子类继承一个父类）或多继承（一个子类继承多个父类(部分语言支持))增加代码的可重用性，拓展，修改。在想要拓展功能时不必重写整个对象，只需继承再写新的属性，方法即可。
```
// 父类 Animal
public class Animal {
// 属性
protected String name;
// 构造方法
public Animal(String name) {
this.name = name;
}
// 方法
public void makeSound() {
System.out.println(name + " makes a sound");
}
}
// 子类 Dog 继承自 Animal
public class Dog extends Animal {
// 构造方法，调用父类的构造方法
public Dog(String name) {
super(name); // 调用父类的构造方法，设置 name 属性
}
// 重写 makeSound 方法
@Override
public void makeSound() {
System.out.println(name + " whoops: No! No!");
}
}
// 主类 Main
public class Main {
public static void main(String[] args) {
// 创建 Dog 对象
Dog myDog = new Dog("Leon"); s
// 调用 makeSound 方法
myDog.makeSound(); // 输出: Leon whoops: No! No!
}
}
