Java 全方位講解物件導向特點與使用

2022-04-14 19:00:06

程式導向和物件導向的區別

程式導向：當事件比較簡單的時候，利用程式導向，注重的是事件的具體步驟和過程，注重的是過程中的具體行為，以函數為最小單位，考慮怎麼做。

物件導向：注重找“參與者”，將功能封裝進物件中，強調具備了功能的物件，以類/物件為最小單位，考慮誰來做。

案例：小明從冰箱裡拿東西

程式導向：

物件導向:

程式導向 —> 物件導向 , 其實就是由執行者 —> 指揮者的一個過渡

類和物件的關係

萬物皆物件

物件：具體的事物，具體的實體，具體的範例，模板下具體的產品

類：對物件向上抽取出像的部分，公佈部分，形成類，類是抽象的，是一個模板，一般在寫程式碼的時候先寫類，然後再根據類建立對應的物件

類是物件的抽象，物件是類的範例化

類和物件的建立

類的建立

1.屬性（field 成員變數）

屬性用於定義該類或該類物件包含的資料或者說靜態特徵。屬性作用範圍是整個類體。

屬性定義格式：

[修飾符] 屬性型別屬性名 = [預設值]；

2.方法

方法用於定義該類或該類範例的行為特徵和功能實現。方法是類和物件行為特徵的抽象。方法很類似於程式導向中的函數。程式導向中，函數是最基本單位，整個程式由一個個函數呼叫組成。物件導向中，整個程式的基本單位是類，方法是從屬於類和物件的。

方法定義格式：

[修飾符] 方法返回型別方法名（形參列表）{

//Java語句

}

我們以上面王者榮耀英雄類建立為例：

//建立英雄類
public class Hero {
    //屬性
    String Name;//英雄姓名
    int Survive;//生存能力
    int Attack;//攻擊傷害
    int Skill;//技能效果
    int Difficulty;//上手難度

    //技能
    public void Kill(int number){
        //根據輸入的數位釋放幾技能
        System.out.println(Name+"釋放"+number+"技能！！！");
    }
    //輸出該英雄的屬性
    public void print(){
        System.out.println("英雄："+Name);
        System.out.println("生存能力："+Survive);
        System.out.println("攻擊傷害："+Attack);
        System.out.println("技能效果："+Skill);
        System.out.println("上手難度："+Difficulty);
    }

}

物件的建立

接下來我們對我們建立好的類來建立物件

public class TestCode01 {
    //main方法，程式的入口
    public static void main(String[] args) {
        //建立一個物件(英雄)-->馬克波羅
        Hero make = new Hero();
        make.Name = "馬克波羅";
        make.Survive = 4;
        make.Attack = 6;
        make.Skill = 6;
        make.Difficulty = 5;
        //再建立一個英雄-->瀾
        Hero lan = new Hero();
        lan.Name = "瀾";
        lan.Survive = 3;
        lan.Attack = 5;
        lan.Skill = 4;
        lan.Difficulty = 6;
        lan.Kill(1);
        //輸出兩個英雄的屬性
        make.print();
        System.out.println("-------------");
        lan.print();
        //釋放技能
        make.Kill(3);
        System.out.println("-------------");
        lan.Kill(2);
    }
}

結果: 每個英雄都有相同的屬性，每個屬性又有不同的值，通過類我們可以建立很多個物件，每個物件又有不同的屬性值。

比如：王者裡的一百多個英雄，每個都有不同的特點。

建立物件的過程：

（1）在第一次遇到一個類的時候，對這個類要進行載入，只載入一次。

（2）建立物件，在堆中開闢空間

（3）對物件進行初始化操作，屬性賦值都是預設的初始值。

（4）new關鍵字呼叫構造器，執行構造方法，在構造器中對屬性重新進行賦值

構造器

物件都是new出來的，new關鍵字實際上在呼叫一個方法，這個方法叫做構造方法（構造器）

呼叫構造器的時候，如果你的類中沒有寫構造器，那麼系統會預設給你分配一個構造器（空構造器）

構造方法格式：

[修飾符] 構造器名字（）{

}

構造器和方法的區別：

沒有方法的返回值
方法體內部不能有return語句
構造器的名字很特殊，必須跟類名一致

構造器的作用：不是為了建立物件，因為在呼叫構造器之前，這個物件就已經建立好了，並且屬性有預設的初始化的值。

呼叫構造器的目的是給屬性進行賦值操作的。

注意：我們一般不會在空構造器中進行初始化操作，因為那樣的話每個物件的屬性就一樣了。

下面例子：

class Hero{
    //屬性
    String Name;//英雄姓名
    int Survive;//生存能力
    int Attack;//攻擊傷害
    int Skill;//技能效果
    int Difficulty;//上手難度

    public Hero(){
        Survive=4;
        Attack=5;
        Skill=6;
        Difficulty=7;
    }
    public void print(){
        System.out.println("英雄："+Name);
        System.out.println("生存能力："+Survive);
        System.out.println("攻擊傷害："+Attack);
        System.out.println("技能效果："+Skill);
        System.out.println("上手難度："+Difficulty);
    }
}
public class TestCode01 {
    public static void main(String[] args) {
        //建立兩個英雄物件
        Hero make = new Hero();
        make.Name="馬克";
        Hero lan=new Hero();
        lan.Name="瀾";
        //輸出兩個屬性
        make.print();
        lan.print();
    }
}

因為我們在構造器裡面賦值了，所以我們建立物件的時候屬性就一樣了

實際上，我們只要保證空構造器的存在就可以了，裡面的東西不用寫，我們要用構造器賦值就要對構造器過載

構造器過載

一般保證空構造器的存在，空構造器中一般不會進行屬性的賦值操作

一般我們會過載構造器，在過載的構造器中進行屬性賦值操作

在過載構造器以後，假如空構造器忘寫了，系統也不會給你分配預設的空構造器了，那麼你要呼叫的話就會出錯了。所以我們過載構造器時，一般要保留預設構造器

當形參名字和屬性名字重名的時候，會出現就近原則：在要表示物件的屬性前加上this.來修飾，因為this代表的就是你建立的那個物件

this的使用

this就是指當前的物件

this可以修飾屬性

當屬性名字和形參發生重名的時候，或者屬性名字和區域性變數重名的時候，都會發生就近原則，所以如果我要是直接使用變數名字的話就指的是離的近的那個形參或者區域性變數，這時候如果我想要表示屬性的話，在前面要加上：this.修飾（如果不發生重名問題的話，實際上你要是存取屬性也可以省略this.）

this修飾方法

在同一個類中，方法可以互相呼叫，this.可以省略不寫。

this可以修飾構造器

同一個類中的構造器可以相互用this呼叫，注意：this修飾構造器必須放在第一行

static修飾

static可以修飾：屬性、方法、程式碼塊、內部類

static修飾屬性

在類載入的時候，會將靜態內容也載入到方法區的靜態域中，靜態的內容先於物件存在，並且這個靜態內容被所有該類的物件共用。

在類載入的時候一起載入入方法區中的靜態域中
先於物件存在
存取方式：物件名.屬性名類名.屬性名（推薦）

static修飾屬性的應用場景：某些特定的資料想要在記憶體中共用，只有一塊 -->這個情況下，就可以用static修飾的屬性。

static修飾方法：

static和public都是修飾符，並列的沒有先後順序，先寫誰後寫誰都行
在靜態方法中不能使用this關鍵字
在靜態方法中不能存取非靜態的方法
在靜態方法中不能存取非靜態的屬性
靜態的方法可以用物件名.方法名去呼叫也可以用類名.方法名（推薦）
在同一個類中可以直接呼叫靜態方法

程式碼塊

程式碼塊的分類：普通塊、構造塊、靜態塊、同步塊（多執行緒）

程式碼塊執行順序：最先執行靜態塊–>再執行構造塊，（不常用）–>再執行構造器–>再執行方法中的普通塊

public class Test {
    //屬性
    int a;
    static int sa;
    //方法
    public void a(){
        System.out.println("-----a");
        {
            //普通塊限制了區域性變數的作用範圍
            System.out.println("這是普通塊");
            System.out.println("----000000");
            int num = 10;
            System.out.println(num);
        }

    }
    public static void b(){
        System.out.println("------b");
    }
    //構造塊
    {
        System.out.println("------這是構造塊");
    }
    //靜態塊
    static{
        System.out.println("-----這是靜態塊");
        //在靜態塊中只能方法：靜態屬性，靜態方法
        System.out.println(sa);
        b();
    }
    //構造器
    public Test(){
        System.out.println("這是空構造器");
    }
    public Test(int a){
        this.a = a;
    }
    //這是一個main方法，是程式的入口：
    public static void main(String[] args) {
        Test t = new Test();
        t.a();
        Test t2 = new Test();
        t2.a();
    }
}

包（import）

包的作用：為了解決重名的作用，解決許可權問題

包名的定義：

名字全部小寫
中間用.隔開
一般都是公司域名倒著寫：com.jd 、com.taobao
加上模組名字：com.taobao.login
不能使用系統中的關鍵字：null
包宣告的位置一般都在非註釋程式碼的第一行

導包：

（1）使用不同包下的類要需要導包，例如：import java.util.Date;

（2）在導包以後，還想用其他包下同名的類，就必須要手動自己寫所在的包。

（3）同一個包下的類想使用不需要導包，可以直接使用。

（4）在java.lang包下的類，可以直接使用無需導包

（5）可以直接匯入*：

靜態匯入：

//靜態匯入：
import static java.lang.Math.*;
//匯入：java.lang下的Math類中的所有靜態的內容

public class Test {
    //這是一個main方法，是程式的入口：
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
        System.out.println(round(5.6));
    }
    //在靜態匯入後，同一個類中有相同的方法的時候，會優先走自己定義的方法。
    public static int round(double a){
        return 1000;
    }
}

到此這篇關於Java 全方位講解物件導向特點與使用的文章就介紹到這了,更多相關Java 物件導向內容請搜尋it145.com以前的文章或繼續瀏覽下面的相關文章希望大家以後多多支援it145.com！