Java全面細(xì)致講解類與對象

更新時間：2022年05月07日 14:52:51 作者：菜菜不恰菜

類和對象是兩種以計算機為載體的計算機語言的合稱。對象是對客觀事物的抽象，類是對對象的抽象。類是一種抽象的數(shù)據(jù)類型；變量就是可以變化的量，存儲在內(nèi)存中—個可以擁有在某個范圍內(nèi)的可變存儲區(qū)域

類和對象的關(guān)系

類就是一類對象的統(tǒng)稱。對象就是這一類具體化的一個實例。（對象是類的實例化）

對象是什么？

此對象非彼對象！?。??說到對象就要提到過程。

面向過程：C語言是面向過程的，關(guān)注的是過程，分析出求解問題的步驟，通過函數(shù)調(diào)用逐步解決問題。面向過程注重的是過程，在整個過程中所涉及的行為，就是功能。

面向?qū)ο螅篔AVA是基于面向?qū)ο蟮?，關(guān)注的是對象，將一件事情拆分成不同的對象，靠對象之間的交互完成。面向?qū)ο笞⒅氐氖菍ο?，也就是參與過程所涉及到的主體。是通過邏輯將一個個功能實現(xiàn)連接起來。

只能說這樣解釋起來很抽象，舉個冰箱的例子。

面向過程：1.把冰箱打開 2. 把水果放入 3. 冰箱關(guān)起來

面向?qū)ο螅罕洹?打開冰箱，儲存，關(guān)閉都是對冰箱的操作，是冰箱的行為。冰箱就是一個對象，所以只要操作冰箱所具備的功能，都要定義在冰箱中。

總結(jié)：面向?qū)ο缶褪怯么a(類)來描述客觀世界的事物的一種方式。一個類主要包含一個事物的屬性和行為。

類和對象的實例化

怎么創(chuàng)建一個類：

// 創(chuàng)建類
class < class_name > {
field ; // 成員屬性
method ; // 成員方法
}
// 實例化對象
< class_name > < 對象名 > = new < class_name > ();
（類名稱采用大駝峰命名方式）

舉個例子：

public class TestModer {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.name = "張三";
        person1.age = 18;
        System.out.println(person1.name);
        System.out.println(person1.age);
        person1.eat();
        Person person2 = new Person();
        person2.name = "李四";
        person2.age = 20;
        System.out.println(person2.name);
        System.out.println(person2.age);
        person2.eat();
    }
}
    class Person {
        public String name;
        public int age;
 
        public void eat() {
            System.out.println("吃飯");
        }
    }

類中定義的變量可稱為“字段”/“屬性”/“成員變量”，類中定義的方法叫成員方法，我們可以知道一個類可以實例化多個對象，每個對象都有一個普通成員變量。

用類類型創(chuàng)建對象的過程，稱為類的實例化

1. 類只是一個模型一樣的東西，限定了類有哪些成員。

2. 一個類可以實例化出多個對象，實例化出的對象占用實際的物理空間，存儲類成員變量。

static關(guān)鍵字

成員變量分為普通成員變量和靜態(tài)成員變量兩種，普通成員變量上面已經(jīng)說過了-->public String name;name就是普通成員變量，而用static修飾之后，就成為了靜態(tài)成員變量。public static String name，name就成為了靜態(tài)成員變量。下面來看個例子：

public class TestModer {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.age ++;
        Person.high++;
        System.out.println(person1.age);
        System.out.println(Person.high);
        Person person2 = new Person();
        person2.age++;
        Person.high++;
        System.out.println(person2.age);
        System.out.println(Person.high);
    }
}
    class Person {
        public int age;
        public static int high;
        public void eat() {
            System.out.println("吃飯");
        }
    }

注意：靜態(tài)成員變量不可以放在其他方法中定義，靜態(tài)變量屬于類，不屬于對象。

默認(rèn)值：

static修飾的成員變量叫靜態(tài)成員變量，static修飾的方法成為靜態(tài)方法。

1、靜態(tài)方法屬于類，而不屬于類的對象。

2、可以直接調(diào)用靜態(tài)方法，而無需創(chuàng)建類的實例。

3、靜態(tài)方法可以訪問靜態(tài)數(shù)據(jù)成員，并可以更改靜態(tài)數(shù)據(jù)成員的值

4、靜態(tài)方法內(nèi)部不可以調(diào)用其他方法，但是其他方法內(nèi)部可以調(diào)用靜態(tài)方法。

看個例子：

    public static void main(String[] args) {
        Test.change();//無需創(chuàng)建實例對象 就可以調(diào)用
        System.out.println(Test.count);
    }
}
class Test{
    public int a;
    public static int count;
 
    public static void change() {
        count = 100;
        //a = 10; error 不可以訪問非靜態(tài)數(shù)據(jù)成員
    }
}

//結(jié)果為100

private實現(xiàn)的封裝

什么叫封裝：

<< 代碼大全 >> 開篇就在討論一個問題 : 軟件開發(fā)的本質(zhì)就是對程序復(fù)雜程度的管理 . 如果一個軟件代碼復(fù)雜程度太高 , 那么就無法繼續(xù)維護(hù) 。如何管理復(fù)雜程度 ? 封裝就是最基本的方法。在我們寫代碼的時候經(jīng)常會涉及兩種角色 : 類的實現(xiàn)者和類的調(diào)用者 . 封裝的本質(zhì)就是讓類的調(diào)用者不必太多的了解類的實現(xiàn)者是如何實現(xiàn)類的 , 只要知道如何使用類就行了 .這樣就降低了類使用者的學(xué)習(xí)和使用成本 , 從而降低了復(fù)雜程度。

private實現(xiàn)的封裝：

private/ public 這兩個關(guān)鍵字表示 " 訪問權(quán)限控制 " .

被 public 修飾的成員變量或者成員方法 , 可以直接被類的調(diào)用者使用 .

被 private 修飾的成員變量或者成員方法 , 不能被類的調(diào)用者使用 .

換句話說 , 類的使用者根本不需要知道 , 也不需要關(guān)注一個類都有哪些 private 的成員。從而讓類調(diào)用者以更低的成本來使用類。

看個例子：

public class TestModer {
    public static void main(String[] args) {
        Person person = new Person();
        person.show();
    }
}
class Person{
    private String name = "張三";
    private int age = 18;
    public void show() {
        System.out.println("我叫" + name + ", 今年" + age + "歲");
    }
}

此時字段已經(jīng)使用 private 來修飾 . 類的調(diào)用者 (main 方法中 ) 不能直接使用 . 而需要借助 show 方法。此時類的使用者就不必了解 Person 類的實現(xiàn)細(xì)節(jié)。同時如果類的實現(xiàn)者修改了字段的名字 , 類的調(diào)用者不需要做出任何修改 ( 類的調(diào)用者根本訪問不到 name, age 這樣的字段 )。

注意：

1、private 不光能修飾字段 , 也能修飾方法

2、通常情況下我們會把字段設(shè)為 private 屬性 , 但是方法是否需要設(shè)為 public, 就需要視具體情形而定。一般我們希望一個類只提供 " 必要的 " public 方法 , 而不應(yīng)該是把所有的方法都無腦設(shè)為 public。

現(xiàn)在有一個問題類的實現(xiàn)者萬一修改了 public 方法 show 的名字 , 豈不是類的調(diào)用者仍然需要大量修改代碼嘛 ?

這個時候我們就來看看 getter 和 setter 方法。

getter 和 setter 方法的使用：

public class TestModer {
    public static void main(String[] args) {
        Person person = new Person();
        person.setName("張三");
        String name = person.getName();
        System.out.println(name);
        person.show();
    }
}
class Person{
    private String name;//實例成員變量
    private int age;
    public void setName(String name){
        //name = name;//不能這樣寫
        this.name = name;//this引用，表示調(diào)用該方法的對象
    }
    public String getName(){
        return name;
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age);
    }
}

字段已經(jīng)使用 private 來修飾. 類的調(diào)用者(main方法中)不能直接使用，這時候我們可以借助getter和setter來使用，getName 即為 getter 方法, 表示獲取這個成員的值。setName 即為 setter 方法, 表示設(shè)置這個成員的值。getter和setter可以不用手動輸入，可以在類中點擊右鍵按下圖操作：

在這里我們是調(diào)用了show這個方法來實現(xiàn)打印，如果不調(diào)用方法，可以自帶的to String進(jìn)行打印。

to String用法：

public class TestModer {
        public static void main(String[] args) {
            Person person = new Person();
            person.setName("張三");
            String name = person.getName();
            System.out.println(name);
            //person.show();
            System.out.println(person);
        }
    }
    class Person{
        private String name;//實例成員變量
        private int age;
 
        public void setName(String name){
            //name = name;//不能這樣寫
            this.name = name;//this引用，表示調(diào)用該方法的對象
        }
        public String getName(){
            return name;
        }
        //public void show(){
            //System.out.println("name: "+name+" age: "+age);
        //}
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

toString 方法會在 println 的時候被自動調(diào)用，將對象轉(zhuǎn)成字符串這樣的操作我們稱為序列化 . toString 是 Object 類提供的方法 , 我們自己創(chuàng)建的 Person 類默認(rèn)繼承自 Object 類 , 可以重寫 toString 方法實現(xiàn)我們自己版本的轉(zhuǎn)換字符串方法。快速生成toString的方法：在類中點擊鼠標(biāo)右鍵，按下圖操作：

構(gòu)造方法

構(gòu)造方法是一種特殊方法 , 使用關(guān)鍵字 new 實例化新對象時會被自動調(diào)用 , 用于完成初始化操作。

new 執(zhí)行過程

為對象分配內(nèi)存空間
調(diào)用對象的構(gòu)造方法

語法規(guī)則

1.方法名稱必須與類名稱相同

2.構(gòu)造方法沒有返回值類型聲明

3. 每一個類中一定至少存在一個構(gòu)造方法（沒有明確定義，則系統(tǒng)自動生成一個無參構(gòu)造）

舉個例子：

public class TestModer {
    public static void main(String[] args) {
            Person p1 = new Person();//調(diào)用不帶參數(shù)的構(gòu)造函數(shù) 如果程序沒有提供會調(diào)用不帶參數(shù)的構(gòu)造函數(shù)
            p1.show();
            Person p2 = new Person("張三",80,"男");//調(diào)用帶有3個參數(shù)的構(gòu)造函數(shù)
            p2.show();
    }
}
class Person {
    private String name;//實例成員變量
    private int age;
    private String sex;
    //默認(rèn)構(gòu)造函數(shù) 構(gòu)造對象
    public Person() {
        this.name = "王五";
        this.age = 10;
        this.sex = "男";
    }
    public Person(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }
    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}

注意事項：

如果類中沒有提供任何的構(gòu)造函數(shù)，那么編譯器會默認(rèn)生成一個不帶有參數(shù)的構(gòu)造函數(shù) 。

若類中定義了構(gòu)造方法，則默認(rèn)的無參構(gòu)造將不再生成。

構(gòu)造方法支持重載，規(guī)則和普通方法的重載一致。

this關(guān)鍵字

this 表示當(dāng)前對象引用 ( 注意不是當(dāng)前對象 ). 可以借助 this 來訪問對象的字段和方法

this有三種用法：

1、this.date-->調(diào)用當(dāng)前對象的屬性。

2、this.func()-->調(diào)用當(dāng)前對象的方法。

3、this（）-->調(diào)用當(dāng)前對象的其他構(gòu)造方法。

前面兩種方法我們之前都用過了，接下來我們來看看第三種用法。

class Person { 
 private String name;//實例成員變量
 private int age; 
 private String sex; 
 //默認(rèn)構(gòu)造方法 構(gòu)造對象
 public Person() { 
 //this調(diào)用構(gòu)造函數(shù)
 this("bit", 12, "man");//必須放在第一行進(jìn)行顯示
 } 
 //這兩個構(gòu)造方法之間的關(guān)系為重載。
 public Person(String name,int age,String sex) { 
 this.name = name; 
 this.age = age; 
 this.sex = sex; 
 } 
 public void show() { 
 System.out.println("name: "+name+" age: "+age+" sex: "+sex); 
 } 
} 
public class Main{ 
 public static void main(String[] args) { 
 Person person = new Person();//調(diào)用不帶參數(shù)的構(gòu)造方法
 person.show(); 
 }

運行結(jié)果：

注意：this（）必須放在第一行?。?！否則會報錯。

代碼塊

字段的初始化方式有：

1. 就地初始化

2. 使用構(gòu)造方法初始化

3. 使用代碼塊初始化

前兩種方式前面已經(jīng)看過了 , 接下來我們介紹第三種方式 , 使用代碼塊初始化。

代碼塊可以分為四種：

1、普通代碼塊（也稱本地代碼塊）

2、構(gòu)造代碼塊（也稱實例化代碼塊）

3、靜態(tài)代碼塊

4、同步代碼塊

我們在這里主要認(rèn)識第二種和第三種。

1、普通代碼塊

定義在方法中

  public static void main(String[] args) {
        { //直接使用{}定義，普通方法塊
            int x = 10;
            System.out.println("x1 = " + x);
        }
    }
}

2、構(gòu)造代碼塊

構(gòu)造塊：定義在類中的代碼塊 ( 不加修飾符 ) 。也叫：實例代碼塊。構(gòu)造代碼塊一般用于初始化實例成員變量。

class Person {
    private String name;
    private int age=19;
    public static int count;
  //構(gòu)造代碼塊
    {
        this.age = 99;
        System.out.println("構(gòu)造代碼塊！");
    }

3、靜態(tài)代碼塊

使用 static 定義的代碼塊。一般用于初始化靜態(tài)成員屬性。

class Person {
    private String name;
    private int age = 19;
    public static int count;//0
   //靜態(tài)代碼塊
    static {
        count = 99;
        System.out.println("靜態(tài)代碼塊！");
    }
}

注意：

1、靜態(tài)代碼塊不管生成多少個對象，其只會執(zhí)行一次，且是最先執(zhí)行的。

2、靜態(tài)代碼塊執(zhí)行完畢后 , 實例代碼塊（構(gòu)造塊）執(zhí)行，再然后是構(gòu)造函數(shù)執(zhí)行。

匿名對象

1、匿名只是表示沒有名字的對象 .

2、沒有引用的對象稱為匿名對象 .

3、匿名對象只能在創(chuàng)建對象時使用 .

4、如果一個對象只是用一次 , 后面不需要用了 , 可以考慮使用匿名對象。

來看個例子：

class Person { 
 private String name; 
 private int age; 
 public Person(String name,int age) { 
 this.age = age; 
 this.name = name; 
 } 
 public void show() { 
 System.out.println("name:"+name+" " + "age:"+age); 
 } 
} 
public class Main { 
 public static void main(String[] args) { 
 new Person("caocao",19).show();//通過匿名對象調(diào)用方法
//Person person=new Person();//非匿名對象
 } 
}

小結(jié)

以上就是類和對象的使用，一個類可以產(chǎn)生無數(shù)的對象，類就是模板，對象就是具體的實例。類中定義的屬性，大概分為幾類：類屬性，對象屬性。其中被static所修飾的數(shù)據(jù)屬性稱為類屬性, static修飾的方法稱為類方法，特點是不依賴于對象，我們只需要通過類名就可以調(diào)用其屬性或者方法。靜態(tài)代碼塊優(yōu)先實例代碼塊執(zhí)行，實例代碼塊優(yōu)先構(gòu)造函數(shù)執(zhí)行。 this關(guān)鍵字代表的是當(dāng)前對象的引用。并不是當(dāng)前對象。如果有什么不正確的地方大家盡管說哦！

到此這篇關(guān)于Java全面細(xì)致講解類與對象的文章就介紹到這了,更多相關(guān)Java類與對象內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

您可能感興趣的文章: