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");}
}