• 面向?qū)ο缶幊淌且环N基于對象和類的編程范式，對象是程序中的實體，具有屬性和操作（方法）；
• 程序由一組互相協(xié)作的對象組成，通過彼此交互來完成任務(wù)；
• 將相關(guān)的數(shù)據(jù)和方法組合成一個對象，對象之間通過消息傳遞進(jìn)行通信；
• 強(qiáng)調(diào)數(shù)據(jù)的封裝和隱藏，每個對象僅對外提供有限的接口，以保護(hù)數(shù)據(jù)的完整性和安全性；
• 類是對象的藍(lán)圖，定義了對象的屬性和行為，并可以創(chuàng)建多個具有相同屬性和行為的對象。

例如，使用面向?qū)ο缶幊痰姆绞綄崿F(xiàn)計算兩個數(shù)的和：

# 面向?qū)ο缶幊淌纠?/span>
class Calculator:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def add(self):
        return self.x + self.y

calculator = Calculator(3, 5)
result = calculator.add()

綜上所述，面向過程編程和面向?qū)ο缶幊淘诰帉懘a的思維方式、組織結(jié)構(gòu)和數(shù)據(jù)處理方式上存在著顯著差異。面向過程強(qiáng)調(diào)順序執(zhí)行和直接操作數(shù)據(jù)，而面向?qū)ο髣t強(qiáng)調(diào)對象和類的概念、數(shù)據(jù)封裝和代碼復(fù)用。 具體選擇何種編程范式應(yīng)取決于項目需求、代碼結(jié)構(gòu)和開發(fā)團(tuán)隊的偏好。

4?? 方法重載和方法重寫

?? 方法重載(Method Overloading)是指在同一個類中創(chuàng)建多個具有相同名稱但參數(shù)列表不同的方法。 編譯器會根據(jù)調(diào)用時傳遞的參數(shù)類型和數(shù)量來確定調(diào)用哪個方法。

下面是一個定義了方法重載的代碼：

class Calculation {
    int add(int a, int b) {
        return a + b;
    }
    
    double add(double a, double b) {
        return a + b;
    }
}

public class Main{
    public static void main(String[] args) {
        Calculation calc = new Calculation();
        int result1 = calc.add(3, 4);               // 使用 int 參數(shù)的 add 方法
        double result2 = calc.add(2.5, 3.7);       // 使用 double 參數(shù)的 add 方法
        System.out.println(result1);
        System.out.println(result2);
    }
}

運(yùn)行結(jié)果：

7
6.2

在Calculation類中，我定義了兩個add方法。第一個方法接受兩個整數(shù)類型的參數(shù)a和b，返回這兩個整數(shù)的和。第二個方法接受兩個雙精度浮點數(shù)類型的參數(shù)a和b，返回這兩個浮點數(shù)的和。

在Main類的main方法中，首先創(chuàng)建了一個Calculation對象 calc。然后，通過調(diào)用calc對象的add方法，分別傳入不同的參數(shù)來計算兩個結(jié)果。result1是將整數(shù)3和4作為參數(shù)傳遞給add(int a, int b)方法得到的結(jié)果。result2是將雙精度浮點數(shù)2.5和3.7作為參數(shù)傳遞給add(double a, double b)方法得到的結(jié)果。

?? 方法重寫(Method Overriding)是指在派生類中重新定義繼承自父類的方法。方法重寫要求方法名稱、參數(shù)列表和返回類型完全相同。

下面是一個定義了方法重寫的代碼：

class Animal {
    void makeSound() {
        System.out.println("The animal makes a sound");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("The dog barks");
    }
}

public class OverridingDemo{

    public static void main(String[] args) {
        Animal dog = new Dog();
        dog.makeSound();

        Animal animal = new Animal();
        animal.makeSound();
    }
}

運(yùn)行結(jié)果：

The dog barks
The animal makes a sound

?? 小結(jié)：方法重載與方法重寫的區(qū)別？

• 方法重載是指在一個類中，方法名稱相同而參數(shù)列表（參數(shù)個數(shù)、類型、順序）不同，對權(quán)限符沒有要求；
• 方法重寫是指子類重寫父類的方法，方法的名稱、參數(shù)列表全部相同，重寫方法的權(quán)限符等級必須大于等于被重寫方法的權(quán)限符等級。
  
  

5?? 接口和抽象類

?? 接口(Interface)

接口(Interface)是一種規(guī)范，定義了一組方法但沒有實現(xiàn)。一個類可以實現(xiàn)一個或多個接口，強(qiáng)制其提供接口中定義的方法的實現(xiàn)。

下面是一個定義了接口及其實現(xiàn)類的代碼：

interface Drawable {
    void draw();
}

class Rectangle implements Drawable {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle");
    }
}

public class interfaceDemo{
    public static void main(String[] args) {
        Drawable drawable = new Rectangle();
        drawable.draw(); // 輸出: "Drawing a rectangle"
    }
}

運(yùn)行結(jié)果：

Drawing a rectangle

上面代碼定義了一個接口 Drawable，該接口包含一個抽象方法 draw()。接口中的方法聲明只有方法名和簽名，沒有方法體。

接著，代碼定義了一個實現(xiàn)了接口 Drawable 的類 Rectangle。在該類中，使用 @Override 注解來表示該方法重寫了接口中的 draw() 方法。具體實現(xiàn)是打印出字符串 “Drawing a rectangle”。

接下來，在 interfaceDemo 類中，我在 main 方法中創(chuàng)建了一個 Drawable 接口的引用 drawable 并將其賦值為一個 Rectangle 對象。通過這種方式，我們可以使用 drawable 引用調(diào)用 draw() 方法。

最后，在調(diào)用 drawable.draw() 時，將會執(zhí)行 Rectangle 類中的實現(xiàn)。

?? 抽象類(Abstract Class)

抽象類(Abstract Class)是一個不能被實例化的類，可以包含抽象方法和具體方法。抽象方法是沒有實現(xiàn)的方法，需要在派生類中進(jìn)行實現(xiàn)。

下面是一個定義了抽象類及其實現(xiàn)類的代碼：

abstract class Shape {
    abstract double area();

    void display() {
        System.out.println("Displaying shape");
    }
}

class Circle extends Shape {
    double radius;

    @Override
    double area() {
        return Math.PI * radius * radius;
    }
}

public class AbstractDemo{
    public static void main(String[] args) {
        Shape shape = new Circle();
        shape.display(); // 輸出: "Displaying shape"
        double area = shape.area(); // 調(diào)用 Circle 中的 area 方法
        System.out.println(area);
    }
}

運(yùn)行結(jié)果：

Displaying shape
12.566370614359172

這段代碼定義了一個抽象類 Shape 和一個繼承自 Shape 的子類 Circle。

抽象類 Shape 中包含兩部分內(nèi)容：

1. abstract double area();：這是一個抽象方法，沒有具體的實現(xiàn)，子類必須提供實現(xiàn)。該方法的目的是計算圖形的面積，并返回一個 double 類型的值。
2. void display()：這是一個普通方法，它有具體的實現(xiàn)。

子類 Circle 繼承自 Shape，它具有一個 radius 屬性和一個重寫了父類抽象方法 area() 的具體實現(xiàn)。在 Circle 類中，area() 方法使用圓的半徑計算并返回其面積。

在 main 方法中，首先創(chuàng)建了一個 Circle 對象賦值給父類 Shape 類型的引用變量 shape。然后調(diào)用了 shape 的 display() 方法，輸出字符串 “Displaying shape”。接著，通過 shape 調(diào)用 area() 方法，實際上將調(diào)用到 Circle 類中重寫的 area() 方法，計算并返回了圓的面積。

?? 小結(jié)：接口和抽象類的區(qū)別？

在Java中，接口和抽象類都可以用來定義對象的公共行為，但它們之間存在一些重要的區(qū)別。
具體區(qū)別說明如下：

• 定義的關(guān)鍵字不同：接口使用 interface 來定義，抽象類使用 abstract class來定義；
• 子類繼承或?qū)崿F(xiàn)關(guān)鍵字不同：接口實現(xiàn)使用 implements，抽象類繼承使用 extends ；
• 擴(kuò)展限制不同：抽象類有單繼承局限，而接口是多繼承，這也使得接口更加靈活；
• 方法權(quán)限修飾符：抽象類無限制，只是不能被 private 修飾；而接口默認(rèn)且只能是 public 修飾；
• 屬性權(quán)限修飾符：抽象類無限制，而接口默認(rèn)且只能是 public 修飾；
• 結(jié)構(gòu)不同：抽象類中可以有構(gòu)造方法、成員變量（變量及常量）、普通方法、抽象方法；而接口中只能有常量（默認(rèn) public static final 修飾）、抽象方法，在 JDK 8 加入了 static 修飾的靜態(tài)方法和 default 修飾的普通方法；
• 靜態(tài)代碼塊的使用不同：抽象類可以有靜態(tài)代碼塊，而接口不能有；
• 設(shè)計目的不同：抽象類主要是用于代碼復(fù)用和簡化設(shè)計，用于表示某個類的通用行為；而接口是一組規(guī)范，用于指導(dǎo)類的行為，以便多個類可以遵循同樣的規(guī)范進(jìn)行操作。
  
  

6?? 包和訪問修飾符

Java中的包(Package)是將相關(guān)類和接口組織在一起的方式。它們提供了命名空間管理、可見性控制和代碼結(jié)構(gòu)組織的好處。

訪問修飾符(Access Modifier)用于控制對類、方法和變量的訪問權(quán)限。

• public：可以從任何地方訪問；
• protected：同一包內(nèi)和子類中可訪問；
• default(默認(rèn)，無修飾符)：同一包內(nèi)可訪問；
• private：僅在當(dāng)前類中可訪問。

下面這段代碼展示了Java中的訪問修飾符（access modifiers）的概念。
我分別定義了在本類、同包下的其他類、不同包的子類、不同包的其他類四種類，對于一個類中各種權(quán)限修飾符修飾的屬性的訪問權(quán)限。

以下是每個類和方法的詳細(xì)代碼及解釋：

package com.xiaoshan.accessmodifier.onepack;

import com.xiaoshan.accessmodifier.anotherpack.AnotherPackClass;
import com.xiaoshan.accessmodifier.anotherpack.AnotherPackSonClass;

public class OneClass {
    public String publicVariable = "Public Variable";
    protected String protectedVariable = "Protected Variable";
    String defaultVariable = "Default Variable";
    private String privateVariable = "Private Variable";

    public void method(){

        String variable = this.publicVariable;
        System.out.println("本類可以訪問到：" + variable);

        variable = this.protectedVariable;
        System.out.println(variable);

        variable = this.defaultVariable;
        System.out.println(variable);

        variable = this.privateVariable;
        System.out.println(variable);
    }

    public static void main(String[] args) {
        OneClass clazz = new OneClass();
        clazz.method();

        SamePackClass samePackClass = new SamePackClass();
        samePackClass.method();

        AnotherPackSonClass anotherPackSonClass = new AnotherPackSonClass();
        anotherPackSonClass.method();

        AnotherPackClass anotherPackClass = new AnotherPackClass();
        anotherPackClass.method();
    }
}

以上，我定義了一個OneClass 公開類。其中，定義了一個公開（public）變量 publicVariable、一個受保護(hù)（protected）變量 protectedVariable、一個默認(rèn)訪問修飾符（沒有訪問修飾符）的變量 defaultVariable、一個私有（private）變量 privateVariable。

然后定義了一個方法 method()，用于演示不同訪問修飾符下的變量可見性。可以發(fā)現(xiàn)在本類方法內(nèi)部可以訪問到任何權(quán)限的變量和方法： variable 可以訪問到 publicVariable、protectedVariable、defaultVariable以及 privateVariable。

package com.xiaoshan.accessmodifier.onepack;

public class SamePackClass {

    public void method() {
        OneClass oneClass = new OneClass();

        String variable = oneClass.publicVariable;
        System.out.println("\n同包的類可以訪問到：" + variable);

        variable = oneClass.protectedVariable;
        System.out.println(variable);

        variable = oneClass.defaultVariable;
        System.out.println(variable);

        // 編譯不通過，訪問不到
        // oneClass.privateVariable;
    }
}

以上，我定義了一個 SamePackClass 的和oneClass同包下的類。在method()方法內(nèi)部創(chuàng)建了 OneClass 的實例，可以發(fā)現(xiàn)能訪問到 publicVariable、protectedVariable以及defaultVariable，但無法訪問 privateVariable，因為它是 OneClass 中的私有變量。

package com.xiaoshan.accessmodifier.anotherpack;

import com.xiaoshan.accessmodifier.onepack.OneClass;

public class AnotherPackSonClass extends OneClass {

    public void method() {
        String variable = super.publicVariable;
        System.out.println("\n不同包的子類可以訪問到：" + variable);

        variable = super.protectedVariable;
        System.out.println(variable);

        // 編譯不通過，訪問不到
        // variable = super.defaultVariable;
        // variable = super.privateVariable;
    }
}

以上，我定義了一個 AnotherPackSonClass 的類，它繼承自 OneClass 類。
可以發(fā)現(xiàn)，在method()方法內(nèi)部能通過super訪問到 父類中的 publicVariable、protectedVariable。
但無法訪問 defaultVariable 和 privateVariable，它們分別是 OneClass 中的默認(rèn)變量和私有變量。

package com.xiaoshan.accessmodifier.anotherpack;

import com.xiaoshan.accessmodifier.onepack.OneClass;

public class AnotherPackClass {
    public void method() {
        OneClass oneClass = new OneClass();

        String variable = oneClass.publicVariable;
        System.out.println("\n不同包的無關(guān)類可以訪問到：" + variable);

        // 編譯不通過，訪問不到
        // oneClass.protectedVariable;
        // oneClass.defaultVariable;
        // oneClass.privateVariable;
    }
}

以上，我定義了一個 AnotherPackClass 的和 OneClass 不同包且無繼承關(guān)系的類。
可以發(fā)現(xiàn)，在method()方法內(nèi)部通過創(chuàng)建的 OneClass 的實例只能訪問到 publicVariable，因為它是公開變量。
而無法訪問 protectedVariable、defaultVariable 和 privateVariable，它們分別是 OneClass 中的受保護(hù)、默認(rèn)和私有變量。

最后，運(yùn)行結(jié)果：

本類可以訪問到：Public Variable
Protected Variable
Default Variable
Private Variable

同包的類可以訪問到：Public Variable
Protected Variable
Default Variable

不同包的子類可以訪問到：Public Variable
Protected Variable

不同包的無關(guān)類可以訪問到：Public Variable

7?? 構(gòu)造函數(shù)和析構(gòu)函數(shù)

構(gòu)造函數(shù)(Constructor)是用于初始化對象的特殊方法。它們與類具有相同的名稱，并且沒有返回類型。當(dāng)創(chuàng)建對象時，構(gòu)造函數(shù)會被自動調(diào)用。如果不提供構(gòu)造函數(shù)，則編譯器會生成一個默認(rèn)的無參構(gòu)造函數(shù)。

析構(gòu)函數(shù)(Destructor)是在對象被銷毀之前調(diào)用的方法。Java沒有顯式的析構(gòu)函數(shù)，而是通過垃圾回收器(Garbage Collector)自動處理內(nèi)存的釋放。

public class Person {
    String name;
    int age;

    // 構(gòu)造函數(shù)
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // ...
}

以上就是Java面向?qū)ο蟮娜恐R的詳細(xì)介紹。通過理解和應(yīng)用這些核心概念，您將能夠更好地進(jìn)行面向?qū)ο蟮木幊?，在Java中開發(fā)出高質(zhì)量的應(yīng)用程序。

8?? 成員變量和局部變量

成員變量（Instance Variables）和局部變量（Local Variables）是編程語言中兩種不同作用域的變量。

?? 成員變量
成員變量屬于一個類或?qū)ο?，并且在類的聲明中定義。它們存在于整個類的生存周期內(nèi)，即使沒有被初始化，也會有默認(rèn)值。每個類的實例都擁有一組獨立的成員變量。特點：

• 成員變量的作用域為整個類，在類內(nèi)部的方法、構(gòu)造函數(shù)里都可以使用；
• 成員變量可以被所有該類的對象訪問和修改；
• 成員變量不需要顯式地進(jìn)行初始化，如果沒有賦初值，會有一個默認(rèn)值；
• 每個實例都有獨立的一套成員變量。

示例：

class Car {
    String color;     // 成員變量
    int speed;        // 成員變量
    
    void drive() {
        System.out.println("正在駕駛" + color + "顏色的車，時速為" + speed + "km/h");
    }
}

在上述示例中，color和speed是Car類的成員變量，可以被類中的所有方法訪問和修改。

?? 局部變量
局部變量僅在定義它的代碼塊（方法、循環(huán)等）內(nèi)有效，超出該范圍后將無法訪問。局部變量必須顯式地聲明和初始化，否則編譯器會報錯。特點：

• 局部變量的作用域僅限于聲明它的代碼塊內(nèi)部；
• 只有在聲明期間和初始化后才能使用；
• 每次代碼塊執(zhí)行時都會創(chuàng)建一個新的局部變量，該變量只在當(dāng)前代碼塊中有效。

示例：

void calculateSum() {
    int a = 5;     // 局部變量
    int b = 10;    // 局部變量
    int sum = a + b;
    System.out.println("兩個數(shù)的和為：" + sum);
}

在上述示例中，a和b是calculateSum方法中的局部變量，只能在該方法內(nèi)部訪問和使用，在方法執(zhí)行完畢后將無法訪問。

總之，成員變量是屬于類的實例的，存在整個類的生命周期中，而局部變量只在定義它的代碼塊內(nèi)有效，其作用范圍更加有限。

?? 成員變量和局部變量的區(qū)別？

變量定義時，根據(jù)變量所在的代碼塊范圍分為成員變量（也叫實例變量或?qū)ο笞兞浚┖途植孔兞績煞N。
成員變量指定義在類中方法外的變量，局部變量則是定義在方法體或代碼塊內(nèi)部的變量。

成員變量和局部變量的主要區(qū)別在于作用域和生命周期不同。成員變量擁有更長的生命周期和更廣泛的作用域，而局部變量的生命周期和作用域均限定在其聲明的代碼塊內(nèi)或方法調(diào)用過程中。

具體區(qū)別細(xì)節(jié)如下：

• 從語法形式上看，成員變量是屬于類或?qū)ο蟮?，而局部變量是在方法中定義的變量或方法參數(shù)；
• 從修飾符上看，成員變量可以被 權(quán)限修飾符等其他關(guān)鍵字所修飾，而局部變量不能被權(quán)限修飾符及static所修飾，但二者都能被final所修飾；
• 從變量在內(nèi)存中的存儲方式及生命周期來看，成員變量是對象的一部分：被static修飾的成員變量也叫類變量，存儲于方法區(qū)當(dāng)中，生命周期與當(dāng)前類相同；未被static修飾的成員變量也叫實例變量，存儲于對象所在的堆內(nèi)存當(dāng)中，生命周期與對象相同。而局部變量存儲于棧內(nèi)存中，其生命周期隨方法的調(diào)用結(jié)束而結(jié)束，變量空間會自動的釋放；
• 從初始值上看，成員變量若未被賦初值，則會自動以對應(yīng)數(shù)據(jù)類型的默認(rèn)值來賦值（一種情況例外：被final修飾但沒有被static修飾的成員變量，必須顯式地賦值）。而局部變量則不會自動賦初值；
• 從使用范圍上看， 局部變量只能在聲明它的方法或代碼塊內(nèi)使用，不能被其他方法或代碼塊訪問。
  
  

?? 總結(jié)

本文主要總結(jié)介紹了面向?qū)ο缶幊蹋∣OP）和面向過程編程（PP）各自的編程思想范式特征，面向?qū)ο笾蓄惡蛯ο蟮母拍铌P(guān)系，面向?qū)ο缶幊痰娜筇匦裕悍庋b、繼承和多態(tài)。

以及類中一些相關(guān)概念及其區(qū)別：方法重載和方法重寫、接口和抽象類、包和訪問修飾符。此外，還包括類中成員的大致介紹：構(gòu)造函數(shù)和析構(gòu)函數(shù)、成員變量和局部變量。

?? 本文源碼下載地址

src.zip Java的面向?qū)ο缶幊獭ぶv解代碼

文章來源地址http://www.zghlxwxcb.cn/news/detail-585096.html

到了這里，關(guān)于【Java基礎(chǔ)教程】特別篇：面向?qū)ο蠛陷嫛崎_Java 的面向?qū)ο笊w章時代，一起來發(fā)現(xiàn)OOP的編程秘密！~的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！