2. 程式人生 > >java語言(7): 深入淺出的 類和物件

java語言(7): 深入淺出的 類和物件

阿新 • • 發佈：2019-01-05

類和物件

一、面向物件簡述

面向過程的操作是以程式的基本功能實現為主，實現之後就完成了，也不考慮修改的可能性，面向物件，更多的是要進行子模組化的設計，每一個模組都需要單獨存在，並且可以被重複利用，所以，面向物件的開發更像是一個具備標準的開發模式。

在面向物件定義之中，也規定了一些基本的特徵： 
（1）封裝：保護內部的操作不被破壞； 
（2）繼承：在原本的基礎之上繼續進行擴充； 
（3）多型：在一個指定的範圍之內進行概念的轉換。

對於面向物件的開發來講也分為三個過程：OOA（面向物件分析）、OOD（面向物件設計）、OOP（面向物件程式設計）。

二、類與物件的基本概念

類與物件時整個面向物件中最基礎的組成單元。

類：是抽象的概念集合，表示的是一個共性的產物，類之中定義的是屬性和行為（方法）； 
物件：物件是一種個性的表示，表示一個獨立的個體，每個物件擁有自己獨立的屬性，依靠屬性來區分不同物件。

可以一句話來總結出類和物件的區別：類是物件的模板，物件是類的例項。類只有通過物件才可以使用，而在開發之中應該先產生類，之後再產生物件。類不能直接使用，物件是可以直接使用的。

三、類與物件的定義和使用

在Java中定義類，使用關鍵字class完成。語法如下：

class 類名稱 {
         屬性 (變數) ;
         行為 (方法) ;
}

定義一個Person類:

class Person {     // 類名稱首字母大寫
    String name ;
    int age ;
    public void tell() {        // 沒有static
          System.out.println("姓名：" + name + "，年齡：" + age) ;
         }
}

類定義完成之後，肯定無法直接使用。如果要使用，必須依靠物件，那麼由於類屬於引用資料型別，所以物件的產生格式（兩種格式）如下：

（1）格式一：宣告並例項化物件

//類名稱 物件名稱 = new 類名稱 () ;

（2）格式二：先宣告物件，然後例項化物件：

/*
類名稱 物件名稱 = null ;
物件名稱 = new 類名稱 () ;
*/

引用資料型別與基本資料型別最大的不同在於：引用資料型別需要記憶體的分配和使用。所以，關鍵字new的主要功能就是分配記憶體空間，也就是說，只要使用引用資料型別，就要使用關鍵字new來分配記憶體空間。

當一個例項化物件產生之後，可以按照如下的方式進行類的操作： 
物件.屬性

：表示呼叫類之中的屬性； 
物件.方法()：表示呼叫類之中的方法。

例1：使用物件操作類

package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年齡：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = new Person() ;// 宣告並例項化物件
            per.name = "張三" ;//操作屬性內容
            per.age = 30 ;//操作屬性內容
            per.get() ;//呼叫類中的get()方法
        }
}

姓名：張三，年齡：30

例2

package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年齡：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = null;//宣告物件
            per = new Person() ;//例項化物件
            per.name = "張三" ;//操作屬性內容
            per.age = 30 ;//操作屬性內容
            per.get() ;//呼叫類中的get()方法
        }
}

姓名：張三，年齡：30

————————————————————————————————————————————————————

對上述2個例子進行分析：

首先，給出兩種記憶體空間的概念： 
（1）堆記憶體：儲存物件的屬性內容。堆記憶體需要用new關鍵字來分配空間； 
（2）棧記憶體：儲存的是堆記憶體的地址（在這裡為了分析方便，可以簡單理解為棧記憶體儲存的是物件的名字）。

1

任何情況下，只要看見關鍵字new，都表示要分配新的堆記憶體空間，一旦堆記憶體空間分配了，裡面就會有類中定義的屬性，並且屬性內容都是其對應資料型別的預設值。

於是，上面兩種物件例項化物件方式記憶體表示如下： 

è¿éåå¾çæè¿°

兩種方式的區別在於①②，第一種宣告並例項化的方式實際就是①②組合在一起，而第二種先宣告然後例項化是把①和②分步驟來。

如果使用了沒有例項化的物件，結果如何？ 如下：

package com.wz.classandobj;

class Person { 
    String name ;
    int age ;
    public void get() {
        System.out.println("姓名：" + name + "，年齡：" + age);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Person per = null;//宣告物件
            //per = new Person() ;//例項化物件
            per.name = "張三" ;//操作屬性內容
            per.age = 30 ;//操作屬性內容
            per.get() ;//呼叫類中的get()方法
        }
}

/*執行結果
Exception in thread "main" java.lang.NullPointerException
    at com.wz.classandobj.TestDemo.main(TestDemo.java:15)
*/

此時，程式只聲明瞭Person物件，但並沒有例項化Person物件（只有了棧記憶體，並沒有對應的堆記憶體空間），則程式在編譯的時候不會出現任何的錯誤，但是在執行的時候出現了上面的錯誤資訊。這個錯誤資訊表示的是“NullPointerException（空指向異常）”，這種異常只要是應用資料型別都有可能出現。

四、物件引用傳遞初步分析

引用傳遞的精髓：同一塊堆記憶體空間，可以同時被多個棧記憶體所指向，不同的棧可以修改同一塊堆記憶體的內容。

下面通過若干個程式，以及程式的記憶體分配圖，來進行程式碼的講解。

範例1：

class Person {     
         String name ;
         int age ;
         public void tell() {        
                   System.out.println("姓名：" + name + "，年齡：" + age) ;
         }
}
public class TestDemo {
         public static void main(String args[]) {
                   Person per1 = new Person() ;         // 宣告並例項化物件
                   per1.name = "張三" ;
                   per1.age = 20 ;
                   Person per2 = per1 ;  // 引用傳遞
                   per2.name = "李四" ;
                   per1.tell() ;
         }
}

記憶體分配圖如下：

11

範例2：

class Person {
         String name ;
         int age ;
         public void tell() {
                   System.out.println("姓名：" + name + "，年齡：" + age) ;
         }
}
public class TestDemo {
         public static void main(String args[]) {
                   Person per1 = new Person() ;         // 宣告並例項化物件
                   Person per2 = new Person() ;
                   per1.name = "張三" ;
                   per1.age = 20 ;
                   per2.name = "李四" ;
                   per2.age = 30 ;
                   per2 = per1 ;// 引用傳遞
                   per2.name = "王五" ;
                   per1.tell() ;
         }
}

12

垃圾：指的是在程式開發之中沒有任何物件所指向的一塊堆記憶體空間，這塊空間就成為垃圾，所有的垃圾將等待GC（垃圾收集器）不定期的進行回收與空間的釋放。

五、面向物件的封裝性

封裝(encapsulation)又叫隱藏實現(Hiding the implementation)。就是隻公開程式碼單元的對外介面，而隱藏其具體實現。比如手機，手機的鍵盤，螢幕，聽筒等，就是其對外介面。你只需要知道如何按鍵就可以使用手機，而不需要了解手機內部的電路是如何工作的。封裝機制就像手機一樣只將對外介面暴露，而不需要使用者去了解其內部實現。

舉例1:

package com.wz.classandobj;

class Book{

    String title;
    double price;

    public void getInfo(){
        System.out.println("圖書的名稱："+title+" 圖書的價格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book = new Book();
            book.title = "Java開發";
            book.price = -89.9;
            book.getInfo();
        }
}

輸出結果：

圖書的名稱：Java開發 圖書的價格：-89.9

以上程式碼沒有任何語法錯誤，卻存在一個業務邏輯的錯誤，因為圖書的價格不能為負數。造成這種情況的的原因在於：物件可以在一個類的外部直接訪問屬性。 
如何解決？我們需要將Book類中的屬性設定為對外不可見（只能是本類訪問），可以使用private關鍵字來定義屬性。

修改程式碼如下：

package com.wz.classandobj;

class Book{

    private String title;
    private double price;

    public void getInfo(){
        System.out.println("圖書的名稱："+title+" 圖書的價格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book = new Book();
            book.title = "Java開發";
            book.price = -89.9;
            book.getInfo();
        }
}

輸出結果：

Exception in thread "main" java.lang.Error: Unresolved compilation problems: 
    The field Book.title is not visible
    The field Book.price is not visible

    at com.wz.classandobj.TestDemo.main(TestDemo.java:16)

在訪問屬性的時候，外部的物件無法再直接呼叫類中的屬性了，此時就相當於Book類的屬性對外部不可見。

但是，要想讓程式可以正常執行，那麼必須讓外部可以操作Book類的屬性。在Java開發中，針對屬性有這樣的定義，在類中定義的屬性都要求使用private宣告，如果屬性需要被外部所使用，那麼按照要求，定義屬性相應的setter和getter方法。

以Book類中的String title 為例： 

（1）setter方法是設定屬性內容：public void setTitle(String t)

主要：有引數。

（2）getter方法是取得屬性內容： public String getTitle()

注意：無引數。

舉例2:

package com.wz.classandobj;

class Book{

    private String title;
    private double price;

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return price;
    }


    public void setPrice(double price) {
        this.price = price;
    }

    public void getInfo(){
        System.out.println("圖書的名稱："+title+" 圖書的價格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book = new Book();
            book.setTitle("Java開發"); 
            book.setPrice(-89.9);
            book.getInfo();
        }
}

輸出結果：

圖書的名稱：Java開發 圖書的價格：-89.9

發現，圖書的價格是負數，需要加入檢查業務邏輯錯誤的程式碼，可以在setter中增加驗證，如果值為正，賦值，否則為預設值0.0：

public void setPrice(double price) {
        if(price > 0.0){
            this.price = price;
        }
    }

對於資料驗證，在Java標準開發中應該由輔助程式碼完成。在實際開發中，setter往往只是簡單的設定屬性內容，getter只是簡單的取得屬性內容。

開發建議：以後在定義類的時候，所有的屬性都要編寫private封裝，封裝之後的屬性如果需要被外部操作，則編寫setter、getter。

六、類中的構造方法

物件格式如下：

/*
①類名稱 ②物件名稱 = ③new ④類名稱（）；

①類名稱：規定了物件的型別。即：物件可以使用哪些屬性和方法都是由類定義的； 
②物件名稱：如果需要使用物件，需要有一個名稱，這是一個唯一的標記； 
③new：分配新的堆記憶體空間； 
④類名稱()：呼叫了名稱和類名稱相同的方法，這就是構造方法。

*/

實際上，構造方法一直在被我們呼叫，但我們並沒有去定義它，為什麼能夠使用呢？這是因為在整個Java開發中，為了保證程式可以正常執行，即便使用者沒有定義任何構造方法，也會在程式編譯後自動為類增加一個沒有引數，方法名稱與類名稱相同，沒有返回值的構造方法。

構造方法的定義：方法名稱和類名稱相同，沒有返回值宣告。

//無參，無返回值的構造方法
    public Book() {

    }

如果在Book類中沒有定義以上的構造方法，那麼也會自動生成一個無參，無返回值的構造方法。

範例1：

package com.wz.classandobj;

class Book{

    //無參，無返回值的構造方法
    public Book() {
        System.out.println("無參構造方法");
    }

}

public class TestDemo {
        public static void main(String args[]) {
            Book book = null;//宣告物件
        }
}

執行輸出結果為空。 


在主方法中加入例項化物件的程式碼：

public class TestDemo {
        public static void main(String args[]) {
            Book book = null;//宣告物件
            book = new Book();//例項化物件
        }
}

執行輸出結果：

無參構造方法

以上說明，構造方法是在物件使用關鍵字new例項化的時候被呼叫。

構造方法與普通方法最大的區別是： 
1）、構造方法在例項化物件（new）的時候只調用一次，而普通方法是在例項化物件之後可以隨意呼叫多次。

2）、在實際開發中，構造方法的作用是在類物件例項化的時候設定屬性的初始化內容。

範例2如下：

package com.wz.classandobj;

class Book{

    private String title;
    private double price;

    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public double getPrice() {
        return price;
    }


    public void setPrice(double price) {
        this.price = price;
    }

    public void getInfo(){
        System.out.println("圖書的名稱："+title+" 圖書的價格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book = new Book("Java開發",89.9);//設定屬性的初始化內容
            book.getInfo();

        }
}

執行結果：

//圖書的名稱：Java開發 圖書的價格：89.9

如果一個類中已經明確定義了一個構造方法，則無參構造方法將不會自動生成。而且，一個類之中至少存在一個構造方法。另外，既然構造方法也屬於方法，那麼構造方法也可以過載，但是由於構造方法的特殊性，所以在構造方法過載時注意其引數的型別及引數的個數即可。

範例3：

package com.wz.classandobj;

class Book{

    private String title;
    private double price;


    public Book() {
        System.out.println("無參的構造方法");
    }


    public Book(String title) {
        this.title = title;
        System.out.println("有一個引數的構造方法");
    }


    public Book(String title, double price) {
        this.title = title;
        this.price = price;
        System.out.println("有倆個引數的構造方法");
    }

    public void getInfo(){
        System.out.println("圖書的名稱："+title+" 圖書的價格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book1 = new Book();
            book1.getInfo();

            Book book2 = new Book("Java開發");
            book2.getInfo();

            Book book3 = new Book("Java開發",89.9);
            book3.getInfo();

        }
}

執行結果：

/*無參的構造方法
圖書的名稱：null 圖書的價格：0.0
有一個引數的構造方法
圖書的名稱：Java開發 圖書的價格：0.0
有倆個引數的構造方法
圖書的名稱：Java開發 圖書的價格：89.9
*/

在進行構造方法過載時有一個編寫建議：所有過載的構造方法按照引數的個數由多到少，或者是由少到多排列。

如果在類中為屬性直接設定預設值，結果會怎樣？

範例4：

ackage com.wz.classandobj;

class Book{

    private String title = "Android開發";
    private double price = 199.9;


    public Book() {
        System.out.println("無參的構造方法");
    }


    public Book(String title) {
        this.title = title;
        System.out.println("有一個引數的構造方法");
    }


    public Book(String title, double price) {
        this.title = title;
        this.price = price;
        System.out.println("有倆個引數的構造方法");
    }

    public void getInfo(){
        System.out.println("圖書的名稱："+title+" 圖書的價格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            Book book1 = new Book();
            book1.getInfo();

            Book book2 = new Book("Java開發");
            book2.getInfo();

            Book book3 = new Book("Java開發",89.9);
            book3.getInfo();

        }
}

執行結果：

無參的構造方法
圖書的名稱：Android開發 圖書的價格：199.9
有一個引數的構造方法
圖書的名稱：Java開發 圖書的價格：199.9
有倆個引數的構造方法
圖書的名稱：Java開發 圖書的價格：89.9

從上面可以發現：如果在類中為屬性直接設定預設值，而且這個預設值是在構造方法執行完後才會設定的，且屬性內容為對應資料型別的預設值時才設定類中定義的這個預設值。但是，要注意的是在構造方法沒有執行之前，屬性內容都是其對應資料型別的預設值。

七、類中的匿名物件

沒名字的物件稱為匿名物件，物件的名字按照之前的記憶體關係來講，在棧記憶體之中，而物件的具體內容在堆記憶體之中儲存，這樣，沒有棧記憶體指向堆記憶體空間，就是一個匿名物件。

package com.wz.classandobj;

class Book{

    private String title;
    private double price;

    public Book(String title, double price) {
        this.title = title;
        this.price = price;
        System.out.println("有倆個引數的構造方法");
    }

    public void getInfo(){
        System.out.println("圖書的名稱："+title+" 圖書的價格："+price);
    }
}

public class TestDemo {
        public static void main(String args[]) {
            //匿名物件
            new Book("Java開發",89.9).getInfo();

        }
}

執行結果：

有倆個引數的構造方法
圖書的名稱：Java開發 圖書的價格：89.9

匿名物件由於沒有對應的棧記憶體指向，所以只能使用一次，一次之後就將成為垃圾，並且等待被GC回收釋放。

————————————————————————————————————————————

抽象類

一、基本概念

普通類是一個完善的功能類，可以直接產生例項化物件，並且在普通類中可以包含有構造方法、普通方法、static方法、常量和變數等內容。而抽象類是指在普通類的結構裡面增加抽象方法的組成部分。

那麼什麼叫抽象方法呢？在所有的普通方法上面都會有一個“{}”，這個表示方法體，有方法體的方法一定可以被物件直接使用。而抽象方法，是指沒有方法體的方法，同時抽象方法還必須使用關鍵字abstract做修飾。

而擁有抽象方法的類就是抽象類，抽象類要使用abstract關鍵字宣告。

範例：定義一個抽象類

abstract class A{//定義一個抽象類

    public void fun(){//普通方法
        System.out.println("存在方法體的方法");
    }

    public abstract void print();//抽象方法，沒有方法體，有abstract關鍵字做修飾

}

範例1：直接例項化抽象類的物件

package com.wz.abstractdemo;

abstract class A{//定義一個抽象類

    public void fun(){//普通方法
        System.out.println("存在方法體的方法");
    }

    public abstract void print();//抽象方法，沒有方法體，有abstract關鍵字做修飾

}

public class TestDemo {

    public static void main(String[] args) {
        A a = new A();
    }
}

//執行結果
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Cannot instantiate the type A

    at com.wz.abstractdemo.TestDemo.main(TestDemo.java:15)

從上可知，A是抽象的，無法直接進行例項化操作。為什麼不能直接例項化呢？當一個類例項化之後，就意味著這個物件可以呼叫類中的屬性或者放過了，但在抽象類裡存在抽象方法，而抽象方法沒有方法體，沒有方法體就無法進行呼叫。既然無法進行方法呼叫的話，又怎麼去產生例項化物件呢。

抽象類的使用原則如下： 
（1）抽象方法必須為public或者protected（因為如果為private，則不能被子類繼承，子類便無法實現該方法），預設情況下預設為public； 
（2）抽象類不能直接例項化，需要依靠子類採用向上轉型的方式處理； 
（3）抽象類必須有子類，使用extends繼承，一個子類只能繼承一個抽象類； 
（4）子類（如果不是抽象類）則必須覆寫抽象類之中的全部抽象方法（如果子類沒有實現父類的抽象方法，則必須將子類也定義為為abstract類。）；

範例2：

package com.wz.abstractdemo;

abstract class A{//定義一個抽象類

    public void fun(){//普通方法
        System.out.println("存在方法體的方法");
    }

    public abstract void print();//抽象方法，沒有方法體，有abstract關鍵字做修飾

}
//單繼承
class B extends A{//B類是抽象類的子類，是一個普通類

    @Override
    public void print() {//強制要求覆寫
        System.out.println("Hello World !");
    }

}
public class TestDemo {

    public static void main(String[] args) {
        A a = new B();//向上轉型

        a.fun();//被子類所覆寫的過的方法
    }
}

//執行結果
Hello World !

現在就可以清楚的發現： 
（1）抽象類繼承子類裡面有明確的方法覆寫要求，而普通類可以有選擇性的來決定是否需要覆寫； 
（2）抽象類實際上就比普通類多了一些抽象方法而已，其他組成部分和普通類完全一樣； 
（3）普通類物件可以直接例項化，但抽象類的物件必須經過向上轉型之後才可以得到。

雖然一個類的子類可以去繼承任意的一個普通類，可是從開發的實際要求來講，普通類儘量不要去繼承另外一個普通類，而是去繼承抽象類。

三、抽象類的使用限制

（1）抽象類中有構造方法麼？ 
由於抽象類裡會存在一些屬性，那麼抽象類中一定存在構造方法，其存在目的是為了屬性的初始化。 
並且子類物件例項化的時候，依然滿足先執行父類構造，再執行子類構造的順序。

範例3：

package com.wz.abstractdemo;

abstract class A{//定義一個抽象類

    public A(){
        System.out.println("*****A類構造方法*****");
    }

    public abstract void print();//抽象方法，沒有方法體，有abstract關鍵字做修飾

}
//單繼承
class B extends A{//B類是抽象類的子類，是一個普通類

    public B(){
        System.out.println("*****B類構造方法*****");
    }

    @Override
    public void print() {//強制要求覆寫
        System.out.println("Hello World !");
    }

}
public class TestDemo {

    public static void main(String[] args) {
        A a = new B();//向上轉型
    }

}

/*執行結果：

*****A類構造方法*****
*****B類構造方法*****

*/

（2）抽象類可以用final宣告麼？ 
不能，因為抽象類必須有子類，而final定義的類不能有子類；

（3）抽象類能否使用static宣告？ 
範例4：外部抽象類

package com.wz.abstractdemo;

static abstract class A{//定義一個抽象類

    public abstract void print();

}

class B extends A{

    public void print(){
        System.out.println("**********");
    }
}
public class TestDemo {

    public static void main(String[] args) {
        A a = new B();//向上轉型
        a.print();
    }

}

//執行結果
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
    Illegal modifier for the class A; only public, abstract & final are permitted

    at com.wz.abstractdemo.A.<init>(TestDemo.java:3)
    at com.wz.abstractdemo.B.<init>(TestDemo.java:9)
    at com.wz.abstractdemo.TestDemo.main(TestDemo.java:18)

範例5：內部抽象類

package com.wz.abstractdemo;

abstract class A{//定義一個抽象類

    static abstract class B{//static定義的內部類屬於外部類
        public abstract void print();
    }

}

class C extends A.B{

    public void print(){
        System.out.println("**********");
    }
}
public class TestDemo {

    public static void main(String[] args) {
        A.B ab = new C();//向上轉型
        ab.print();
    }

}

//執行結果
**********

由此可見，外部抽象類不允許使用static宣告，而內部的抽象類執行使用static宣告。使用static宣告的內部抽象類相當於一個外部抽象類，繼承的時候使用“外部類.內部類”的形式表示類名稱。

（4）可以直接呼叫抽象類中用static宣告的方法麼？ 
任何時候，如果要執行類中的static方法的時候，都可以在沒有物件的情況下直接呼叫，對於抽象類也一樣。 
範:6：

package com.wz.abstractdemo;

abstract class A{//定義一個抽象類

    public static void print(){
        System.out.println("Hello World !");
    }

}

public class TestDemo {

    public static void main(String[] args) {
        A.print();
    }

}

//執行結果
Hello World !

（5）有時候由於抽象類中只需要一個特定的系統子類操作，所以可以忽略掉外部子類。這樣的設計在系統類庫中會比較常見，目的是對使用者隱藏不需要知道的子類。 
範例7：

package com.wz.abstractdemo;

abstract class A{//定義一個抽象類
    public abstract void print();

    private static class B extends A{//內部抽象類子類

        public void print(){//覆寫抽象類的方法
            System.out.println("Hello World !");
        }
    }

    //這個方法不受例項化物件的控制
    public static A getInstance(){
        return new B();
    }

}

public class TestDemo {

    public static void main(String[] args) {

        //此時取得抽象類物件的時候完全不需要知道B類這個子類的存在
        A a = A.getInstance();
        a.print();
    }
}

//執行結果
Hello World !

相關推薦

java語言(7): 深入淺出的 類和物件

類和物件 一、面向物件簡述 面向過程的操作是以程式的基本功能實現為主，實現之後就完成了，也不考慮修改的可能性，面向物件，更多的是要進行子模組化的設計，每一個模組都需要單獨存在，並且可以被重複利用，所以，面向物件的開發更像是一個具備標準的開發模式。 在面向物件定義之中，也

Java 7：類和物件（域、引數、初始化）

面向物件程式設計：每個物件包含對使用者公開的特定功能部分和隱藏的實現部分，在OOP中不必關心物件的具體實現,OOP更看重資料（結構），而不是具體演算法。 封裝（資料隱藏）：將資料和行為組合在一個包裡，並對物件的使用者隱藏資料的實現方式，封裝的關鍵是絕不能讓其他類直接訪問例項

java基礎複習（類和物件）

建構函式（構造器） 1、this() super()都必須是建構函式裡的第一句宣告 若同時出現，那麼原則是： 引數少的構造器用this呼叫引數多的，在引數最多的建構函式裡呼叫 super 靜態變數、靜態方法、常量 static: 被所有的例項共享

JAVA基礎總結5——類和物件的一些總結

什麼是類，什麼是物件？ 物件等價於事物的話，那類就相當於同一類事物的統稱 類中定義方法的語法格式 修飾符 返回值 方法名（引數）{ …方法體 返回值； } 這個引數可以是物件也可以說基本的變數，若此方法需要返回值用return返回 許可權修飾符是幹嘛的呢？ 顧名思義它就是用來設定許可權的

Java 實驗案例（類和物件篇）

實驗任務     任務一：手機類的封裝     任務二：基於控制檯的購書系統     任務三：簡單的投票程式 實驗內容 任務一：手機類的封裝     任務目的     理解和掌握面向物件的設計過程     掌握類的結構和定義過程     掌握構造方法及其過載    

Python基礎教程（第3版）中文版 第7章 類和物件（筆記）

                                  7 類和物件 1.物件魔法  1.多型  2.多型和方法   3.封裝  4.繼承 2.類  1.類是什麼 類 型別 2.建立自定義類  class Person:      def set_

Java基礎學習 三 (類和物件、類和成員修飾符、this關鍵字、成員的初始化、構造器初始化)

面向物件的基本概念 類和物件   1.類的宣告 [修飾符關鍵字] class 類名 [extends 父類名] [implements 介面1,介面2]{ //類的主體內容 } public class tt extends Test implements Te

重溫Java經典教程(The Java™ Tutorials)第三篇-Java語言-第二章-2.1類和物件

巢狀類 巢狀類幾種型別 The Java programming language allows you to define a class within another class. Such a class is called a nested class and

java中的類和物件

類 類在客觀世界裡是不存在的，是描寫物件的資訊 類是模子，確定物件將會擁有的特徵（屬性）和行為（方法）  類的特點 類是物件的型別 具有相同屬性和方法的一組物件的集合 屬性（特徵） int cpu  = 5.5； int screen 

java作業 類和物件

第二題風扇： 我的程式碼： package pack1; public class Fan { final int SLOW=1; final int MEDIUM=2; final int FAST=3; private int speed=SLOW; private bo

Java基礎 實驗二：類和物件

1．實驗目的 掌握類的宣告、物件的建立、方法的定義和呼叫、建構函式的使用。 2．實驗內容 1）定義一個表示學生資訊的類Student，要求如下： ① 類Student的成員變數：       sNO　表示學號；      

Java練習 SDUT-3339_計算長方形的周長和麵積（類和物件）

計算長方形的周長和麵積（類和物件） Time Limit: 1000 ms Memory Limit: 65536 KiB Problem Description 設計一個長方形類Rect，計算長方形的周長與面積。 成員變數：整型、私有的資料成員length(長)、width(寬)； 構造方法如下： （

Java入門系列-14-深入類和物件

這篇文章用大量的程式碼幫你搞懂：值傳遞和引用傳遞、構造方法、方法過載、static關鍵字的使用 方法引數傳遞-值傳遞和引用傳遞 1.值傳遞 敲一敲： /** * 使用方法交換兩個變數的值 * @author Jack * */ public class Swap {

java基礎篇---------類和物件(OOP)

JAVA 的是完全面向物件程式設計的！！！ 面向物件程式設計的三大特性：封裝、繼承、多型 1.類 類是構造物件的模板或者藍圖，由類構造物件的過程就是建立類的例項； 類裡面存放類的成員變數，成員方法， class student { private int age; //

[Java]Java類和物件記憶體分配詳解

描述 程式碼說明： 一.當Person p1 = new Person();第一次被呼叫時需要做兩件事： 1.先判斷類載入器是否載入過Person類，如果沒有則載入到Person型別到方法區 2.在堆中開闢記憶體空間，在棧中物件名引用（指向）堆的相應記憶體空間 二. p1.name = '皓皓'： 將堆中n

Java類和物件（四）

抽象類和抽象方法 1. 抽象類 在 Java 面向物件當中，所有的物件都是用過類進行描繪的，但是並不是所有的類都是用來描繪物件的，如果一個類中沒有包含足夠的資訊來描繪一個具體的物件，我們把這種類定義為抽象類。 抽象類的特徵： 抽象類不能用來例項化物件，所以抽象類必須被

JAVA程式設計基礎——類和物件（繼承、多型）

一、單利模式 （1）單例類只能有一個例項； （2）單例類必須自己建立自己的唯一例項； （3）單例類必須給所有其他物件提供這個例項。 場景：一個類可以定義無數個物件，但是隻有一個例項。 1、餓漢式單利模式 package practise.test1030; //餓漢式單利模式

Java筆記：類和物件

Java類和物件 類是在程式設計中經過編寫的，擁有成員變數和一些方法的一種資料型別，可以由自己通過聯絡現實中的事物進行編寫，關鍵字是class，一個Java原始檔只能含有一個public類，且該類名稱與檔名相同。類是對現實中具體事物的一種表示，並且需藉由類建立

java類和物件及python中的類似實現

一：java類和物件 首先，我們簡單說一下類和物件的理解：所有男的這相當於一個“類”，而某個具體的人就是一個“物件” 類：當做物件的模板 物件：根據類建立，在java中，使用關鍵詞new建立新物件 java中定義一個類： public class Dog { String

1.面向過程程式設計 2.面向物件程式設計 3.類和物件 4.python 建立類和物件 如何使用物件 5.屬性的查詢順序 6.初始化函式 7.繫結方法 與非繫結方法

1.面向過程程式設計 面向過程:一種程式設計思想在編寫程式碼時 要時刻想著過程這個兩個字過程指的是什麼? 解決問題的步驟 流程,即第一步幹什麼 第二步幹什麼,其目的是將一個複雜的問題,拆分為若干的小的問題,按照步驟一一解決,也可以說 將一個複雜的問題,流程化(為其制定一個固定的實現流程),從而變得簡單化例如