Java面向对象编程（OOP）是现代编程的核心范式，通过类和对象、封装、继承、多态等特性实现代码的模块化和复用。以下是核心概念的详细解析：
一、类与对象
类（Class） 类是对象的模板，定义了对象的属性（数据成员）和行为（方法）。例如：
```java
public class Cat {
String name; // 属性
int age;// 属性
void meow() { System.out.println(name + " 喵喵叫!"); } // 方法
}
```
类相当于蓝图，描述了具有相同属性和行为的对象集合。
对象（Object）
对象是类的实例，是实际存在的实体。通过`new`关键字创建：
```java
Cat myCat = new Cat();
myCat.name = "咪咪";
myCat.age = 2;
myCat.meow(); // 输出: 咪咪 喵喵叫!
```
每个对象都有自己独立的属性值，但共享类的结构。
二、封装
封装是将对象的状态（属性）和行为（方法）捆绑在一起，并隐藏内部实现细节，只暴露必要接口。例如：
```java
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 void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) { this.age = age; }
public void introduce() {
System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
}
}
```
通过`private`修饰属性，外部无法直接访问，只能通过`public`方法操作，保障数据安全。
三、继承
继承允许一个类（子类）继承另一个类（父类）的属性和方法，实现代码复用。例如：
```java
public class Animal {
String name;
int age;
void eat() { System.out.println(name + " is eating."); }
public void introduce() {
System.out.println("Hello, I am a " + name + " who is " + age + " years old.");
}
}
public class Cat extends Animal {
void meow() { System.out.println(name + " meows!"); }
@Override
public void introduce() {
super.introduce();
System.out.println("I am also a cat.");
}
}
```
`Cat`类继承了`Animal`的属性和方法，并重写了`introduce（）`方法，实现了多态性。
四、多态
多态允许不同类的对象通过相同的接口调用不同实现。例如：
```java
public class Animal {
void makeSound() {
System.out.println("Some sound");
}
}
public class Cat extends Animal {
@Override
void makeSound() {
System.out.println(name + " says meow!");
}
}
public class Dog extends Animal {
@Override
void makeSound() {
System.out.println(name + " barks!");
}
}
public class Main {
public static void main(String[] args) {
Animal cat = new Cat();
Animal dog = new Dog();
cat.makeSound(); // 输出: 猫 says meow!
dog.makeSound(); // 输出: 狗 barks!
}
}
```
通过父类引用指向子类对象，调用相同方法时执行不同实现，实现动态绑定。
五、抽象类与接口
抽象类： 不能直接实例化，必须被继承。适用于定义共同行为和部分实现。 接口
总结
Java面向对象编程通过类与对象、封装、继承、多态等特性，帮助开发者构建模块化、可维护的代码。理解这些核心概念是掌握Java编程的基础。