java面向对象编程特性概述

1. 类和对象

2. 封装（Encapsulation）

3. 继承（Inheritance）

4. 多态（Polymorphism）

5. 抽象（Abstraction）

(1). 抽象类（Abstract Class）

(2).接口（Interface）

6. 关联、聚合和组合

总结

Java 是一种面向对象编程（OOP）语言，面向对象编程是一种编程范式，基于“对象”的概念，对象可以包含数据和操作数据的方法。Java 的面向对象特性主要包括以下几个方面：

1. 类和对象

类（Class）：类是对象的蓝图或模板，定义了对象的属性和行为。类包含字段（属性）和方法（行为）。

对象（Object）：对象是类的实例，具有状态和行为。对象的状态由字段的值表示，行为由方法定义。

// 定义一个类
class Dog {// 字段（属性）String name;int age;// 方法（行为）void bark() {System.out.println(name + " is barking!");}
}// 创建对象
public class Main {public static void main(String[] args) {Dog myDog = new Dog();myDog.name = "Buddy";myDog.age = 3;myDog.bark();  // 输出: Buddy is barking!}
}

2. 封装（Encapsulation）

封装是将对象的字段和方法隐藏在类内部，只通过公共接口与外界交互。通过使用访问修饰符（如 private, public, protected），可以控制对类的成员的访问。

class Dog {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) {this.age = age;}
}

3. 继承（Inheritance）

继承允许一个类（子类）继承另一个类（父类）的字段和方法，从而实现代码重用。子类可以扩展或修改父类的行为

// 父类
class Animal {void eat() {System.out.println("This animal eats food.");}
}// 子类
class Dog extends Animal {void bark() {System.out.println("The dog barks.");}
}public class Main {public static void main(String[] args) {Dog myDog = new Dog();myDog.eat();  // 继承自 Animal 类myDog.bark(); // Dog 类自己的方法}
}

4. 多态（Polymorphism）

多态是指同一个方法在不同对象中有不同的实现。多态可以通过方法重载（Overloading）和方法重写（Overriding）来实现。

方法重载：在同一个类中，方法名相同但参数列表不同。

方法重写：子类重写父类的方法，提供不同的实现。

class Animal {void sound() {System.out.println("Animal makes a sound");}
}class Dog extends Animal {@Overridevoid sound() {System.out.println("Dog barks");}
}class Cat extends Animal {@Overridevoid sound() {System.out.println("Cat meows");}
}public class Main {public static void main(String[] args) {Animal myAnimal = new Animal();  // Animal 对象Animal myDog = new Dog();        // Dog 对象Animal myCat = new Cat();        // Cat 对象myAnimal.sound();  // 输出: Animal makes a soundmyDog.sound();     // 输出: Dog barksmyCat.sound();     // 输出: Cat meows}
}

5. 抽象（Abstraction）

什么是抽象？

抽象是面向对象编程的核心概念之一，它的目的是隐藏复杂的实现细节，只暴露必要的部分。通过抽象，我们可以定义一个通用的模板，让子类去实现具体的细节。

在 Java 中，抽象可以通过以下两种方式实现：

（1）.抽象类（Abstract Class）（2).接口（Interface）

(1). 抽象类（Abstract Class）

特点

•抽象类用 abstract 关键字修饰。

•抽象类不能直接实例化，即不能创建抽象类的对象。

•抽象类可以包含：

抽象方法：没有方法体的方法，必须由子类实现。

具体方法：有方法体的方法，子类可以直接继承或重写。

字段：可以是普通字段或静态字段。

•子类必须实现抽象类中的所有抽象方法，除非子类也是抽象类。示例

// 抽象类
abstract class Animal {// 抽象方法：没有方法体，子类必须实现abstract void sound();// 具体方法：有方法体，子类可以直接继承void sleep() {System.out.println("This animal is sleeping.");}
}// 子类继承抽象类
class Dog extends Animal {// 实现抽象方法@Overridevoid sound() {System.out.println("Dog barks.");}
}class Cat extends Animal {// 实现抽象方法@Overridevoid sound() {System.out.println("Cat meows.");}
}public class Main {public static void main(String[] args) {// Animal myAnimal = new Animal(); // 错误！抽象类不能实例化Dog myDog = new Dog();myDog.sound(); // 输出：Dog barks.myDog.sleep(); // 输出：This animal is sleeping.Cat myCat = new Cat();myCat.sound(); // 输出：Cat meows.myCat.sleep(); // 输出：This animal is sleeping.}
}

抽象类的使用场景

当多个类有共同的行为，但具体实现不同时，可以使用抽象类。

抽象类适合作为基类，定义通用的方法和字段，子类在此基础上扩展。

(2).接口（Interface）

特点

接口用 interface 关键字定义。

接口中的方法默认是 public abstract 的（即抽象方法），没有方法体。

接口中的字段默认是 public static final 的（即常量）。

类通过 implements 关键字实现接口，必须实现接口中的所有方法。

一个类可以实现多个接口（Java 支持多接口继承）。

示例:

// 定义接口
interface Drawable {// 抽象方法void draw();
}interface Soundable {// 抽象方法void makeSound();
}// 类实现接口
class Circle implements Drawable {@Overridepublic void draw() {System.out.println("Drawing a circle.");}
}class Dog implements Soundable {@Overridepublic void makeSound() {System.out.println("Dog barks.");}
}// 类实现多个接口
class Cat implements Drawable, Soundable {@Overridepublic void draw() {System.out.println("Drawing a cat.");}@Overridepublic void makeSound() {System.out.println("Cat meows.");}
}public class Main {public static void main(String[] args) {Circle myCircle = new Circle();myCircle.draw(); // 输出：Drawing a circle.Dog myDog = new Dog();myDog.makeSound(); // 输出：Dog barks.Cat myCat = new Cat();myCat.draw();      // 输出：Drawing a cat.myCat.makeSound(); // 输出：Cat meows.}
}

接口的使用场景

当需要定义一组行为规范，而不关心具体实现时，可以使用接口。

接口适合实现多继承（一个类可以实现多个接口）。

抽象类 vs 接口
特性	抽象类（Abstract Class）	接口（Interface）
关键字	abstract	interface
实例化	不能直接实例化	不能直接实例化
方法	可以包含抽象方法和具体方法	只能包含抽象方法（Java 8 后可以有默认方法）
字段	可以包含普通字段和静态字段	只能包含常量（public static final）
继承	单继承（一个类只能继承一个抽象类）	多继承（一个类可以实现多个接口）
设计目的	提供通用的基类，定义部分实现	定义行为规范，不关心具体实现

默认方法和静态方法（Java 8 新增）
从 Java 8 开始，接口可以包含默认方法（Default Method）和静态方法（Static Method）。

默认方法
用 default 关键字修饰。

提供默认实现，子类可以选择重写或直接使用。

静态方法
用 static 关键字修饰。

可以直接通过接口名调用。

示例:

interface Vehicle {// 抽象方法void start();// 默认方法default void stop() {System.out.println("Vehicle stopped.");}// 静态方法static void honk() {System.out.println("Honk honk!");}
}class Car implements Vehicle {@Overridepublic void start() {System.out.println("Car started.");}
}public class Main {public static void main(String[] args) {Car myCar = new Car();myCar.start(); // 输出：Car started.myCar.stop();  // 输出：Vehicle stopped.Vehicle.honk(); // 输出：Honk honk!}
}

总结

抽象类：适合定义通用的基类，包含部分实现。

接口：适合定义行为规范，支持多继承。

抽象类和接口的选择：

如果需要定义通用的字段和方法，使用抽象类。

如果需要定义行为规范，或者需要多继承，使用接口。

6. 关联、聚合和组合

这些是类之间的关系，用于描述对象之间的交互方式。

关联（Association）：表示两个类之间的简单关系，可以是单向或双向的。

聚合（Aggregation）：表示“整体-部分”关系，部分可以独立于整体存在。

组合（Composition）：表示更强的“整体-部分”关系，部分不能独立于整体存在。

// 关联
class Teacher {String name;Teacher(String name) {this.name = name;}
}class Student {String name;Teacher teacher;Student(String name, Teacher teacher) {this.name = name;this.teacher = teacher;}
}// 聚合
class Department {String name;List<Teacher> teachers;Department(String name, List<Teacher> teachers) {this.name = name;this.teachers = teachers;}
}// 组合
class Car {Engine engine;Car() {engine = new Engine();}
}class Engine {void start() {System.out.println("Engine starts");}
}