Java對象與Java類的詳細介紹

本篇內容介紹了“Java對象與Java類的詳細介紹”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

目錄

• 1.面向對象是什么?

• 2.Java類

• 1.什么是類

• 2.Java類

• 類的結構

• Java類的格式

• 3.java對象

• 4.類和對象

• 5.類中的變量，方法

• 1.變量分類

• 成員變量：

• 局部變量：

• 2.方法分類

• 6.方法重載

• 7.對象與引用

• 基本類型和引用類型的區別:

• 值傳遞與引用傳遞

• 8.static關鍵字

• 概念

• static屬性

• static方法

• 代碼塊

• 9.類的加載執行

• 10.包

• 包的概念：

• 包的作用：

• 包（package）的命名規范：

• 訪問權限修飾符

• 11.面向對象語言的三大特征

• 1.封裝

• 2.多態

• 3.繼承

• 12.類于類之間的關系

• 1.關聯關系(has-a)

• 2.依賴關系(uses-a)

• 3.繼承關系（is-a）

1.面向對象是什么?

面向對象：object oriented programming 縮寫 OOP面向對象的編程語言

• 以分類的方式進行思考和解決問題。

• 面向對象先對整體關系作出分類，然后根據不同的類深入細節的處理。

• 面向對象的思想符合人類的認知習慣。

我見過舉的最多的例子就是把大象放進冰箱：

面向對象的思想就是把這件事的三個步驟：打開冰箱，放入大象，關閉冰箱。這三個動作倆個是關于冰箱的，一個是關于操作人的。所以就把打開冰箱，關閉冰箱這倆個操作定義在冰箱這個對象中，把放入大象定義在人這個對象中。于面向過程不同的就是在，面向過程關注的是正在發生什么事，面向對象關注的是發生這件事和誰有關系。

面向對象的程序是由對象組成的，每個對象包含對用戶公開的特定功能部分和隱藏的實現部分。

——Java核心技術 卷1（11版）

注意

面向對象無法取代面向過程，他們是相輔相成的。面向對象關注于從宏觀上把握事物之間的關系，在具體到如何實現某個細節時（在類中定義一個方法），仍然采用面向過程的思維方式。

對于一些規模較小的問題，將它分解為過程的開發方式比較理想，面向對象的設計思想適用于規模較大的項目，把很多個過程轉換為較少的類，這更便于程序員管理，尋找錯誤時與比較方便（假設一個數據出現了錯誤，你只需要找訪問這個數據的方法）。

2.Java類

1.什么是類

類是構造對象的模板或藍圖，我們可以將類想象成制作小甜餅的模具，將對象想象為小甜餅。

——Java核心技術 卷1（11版）

也就是說：

類就是將一類事物的相同的屬性，行為放在一起類是表示一個客觀世界某類群體的一些基本特征抽象

2.Java類

類的結構

變量：事物屬性的描述；

方法:事物的行為；（可以做的事情）

構造方法：用于創建對象；(創建類的時候有一個默認的無參的構造方法)

內部類： 即在類體中聲明的類。

塊：一段沒有名稱的代碼塊

Java類的格式

[訪問權限修飾符]  [修飾符] class Person{
//第一步聲明一個類
  /*訪問修飾符有兩種public，無(默認)
  修飾符：final,abstract
  關鍵字class用來定義一個類
  Java類名的命名規范:
  類名首字母大寫,見名知意,駝峰表示*/
//第二步給類添加屬性
    //成員變量定義
    /*
    [訪問權限修飾符] [修飾符] 屬性類型 屬性名;
    */
    public String name; //名字
    public Integer age; //年齡
//第二步給類添加方法
    /*方法聲明格式為:
    [訪問權限修飾符] [修飾符] 返回值類型  方法名(){
     }*/
     public void eat(){
         System.out.println("吃飯");
     }
}

3.java對象

對象是類的一個實例，是以類為模板在內存中創建的實際存在的實例

上面舉得例子人就是一個類，我們每個人都是一個對象，擁有類中的屬性，行為，可以使用。

對象的創建和使用：

Person person = new Person();

Person person：使用Person類作為類型聲明一個變量person（對象變量）。

new Person()：使用new + Person 類構造方法創建對象.

=：將右邊創建的對象地址 賦給 左邊的person變量

使用person變量可以訪問對象中的成員變量和成員方法.

注意：

1.同一類的每個對象有不同的成員變量存儲空間。

2.同一類的每個對象共享該類的方法。

要想使用對象，必須清楚對象的三個主要特征：

1.對象的行為：可以對對象完成哪些操作，或者可以對對象應用哪些方法。

2.對象的狀態：當調用那些方法時，對象會怎么樣。

3.對象的標識：如何區分具有相同行為與狀態的不同對象。

4.類和對象

類是一類事物的抽象概念，是一個模型

對象是由這個模型所創造的一個個具體存在的，實實在在存在的實例。

所以創建對象的過程也叫實例化對象。

編程中現有類后有對象。

現實生活中先有對象后有類（相當于根據對象，總結出來的類）。

5.類中的變量，方法

1.變量分類

按照位置分

成員變量：

• 成員變量是定義在類中，方法體之外的變量。

• 成員變量可以使用Java語言中任何一種數據類型（包括基本類型和引用類型）。

• 在定義成員變量時可以對其初始化，如果不對其初始化，Java使用默認的值對其初始化。

• 成員變量在創建對象的時候會從類中復制一份到對象中。

• 成員變量可以被類中方法、構造方法和特定類的語句塊訪問。

• 成員變量的作用范圍為整個類體。

局部變量：

• 在方法、構造方法或者語句塊中定義的變量被稱為局部變量。

• 局部變量可以使用Java語言中任何一種數據類型（包括基本類型和引用類型）。

• 局部變量在使用前必須初始化賦值。

• 變量聲明和初始化都是在方法中，方法結束后，變量就會自動銷毀。

2.方法分類

成員方法：成員方法是定義在類中。這種方法在創建對象的時候創建。

語法格式：

修飾符 返回值類型 方法名(參數列表) {
    方法體語句；
    [return 返回值]
}

構造方法：用來創建對象的方法

構造方法名與類名相同,且沒有返回值，且不需要使用void修飾。

構造方法是定義在 Java 類中的一個用來創建對象的方法。

使用 new + 構造方法 創建一個新的對象。在創建一個對象的時候，至少要調用一個構造方法。

每個類都有構造方法。如果沒有顯式地為類定義構造方法，Java將會為該類提供一個默認構造方法，但是只要在一個Java類中定義了一個顯示的構造方法后，默認的無參構造方法即失效。

一個類可以有多個構造方法。

public class Person{ 
  public Person(){ 
  } 
  public Person(String name){ 
      // 這個構造方法有一個參數：name 
  } 
}

例：創建Person類的對象

Person person= new Person();
Person person = new Person("張三")；

6.方法重載

方法的重載是指同一個類中具有相同的名字，但參數不同的幾個方法。

參數不同（可以有三方面的不同）

• 數量不同

• 類型不同

• 順序不同

調用時，會根據不同的參數表選擇對應的方法。

注意：方法重載跟方法的返回值類型沒有任何關系

7.對象與引用

Java 語言中除基本類型之外的變量類型都稱之為引用類型。

Java中的對象是通過引用對其操作的。

 class Person{    
    String name;
    String age;
}
Person person= new Person();

創建一個對象包含三個動作:

• 右邊的“new Person()”，是以Person類為模板,調用Person類的構造方法,在堆空間里創建一個Person類對象。

• 左邊的“Person person”創建了一個Person類型引用變量。所謂Person類的引用，就是以后可以用來指向Person對象的對象引用。

• ”=”操作符使對象引用指向剛創建的那個Person對象。

Person person;//對象引用變量
person= new Person();//對象本身

new Person(); 這個語句在堆空間里創建了實體，盡管它們也是確確實實存在的實體，但是，我們看不見，也摸不著。

對象沒有名字，也就沒法直接訪問它。我們需要通過對象引用來間接訪問對象。

對象好比是一只很大的氣球，但是我們抓不住它。引用變量是一根繩，可以用來系汽球。

Person  person1; //創建一根繩子，一根還沒有系上任何一個氣球的繩；
Person  person2;//又做了一根繩，還沒系上氣球，
person1 = new Person();//給person1系上氣球；
person2 = person1；//這里，發生了復制行為。要說明的是，對象本身并沒有被復制，被復制的只是對象引用。

結果是，person2也指向了person1所指向的對象。兩根繩系的是同一只氣球。

基本類型和引用類型的區別:

基本類型

byte,short,int,long,float,double,char,boolean

它的值就是一個數字，一個字符或一個布爾值.

引用數據類型

類,接口,數組

它的值是對象在內存空間中的地址,

值傳遞與引用傳遞

Java中進行方法調用中傳遞參數時，參數傳遞有兩種：

1.值傳遞：(形式參數類型是基本數據類型)：方法調用時，實際參數把它的值傳遞給對應的形式參數，形式參數只是用實際參數的值初始化自己的存儲單元內容，是兩個不同的存儲單元，所以方法執行中形式參數值的改變不影響實際參數的值。

2.引用傳遞：(形參數類型是引用數據類型參數)：也稱為傳地址。方法調用時，實際參數是對象，這時實際參數與形式參數指向同一個地址，在方法執行中，對形式參數的操作實際上就是對實際參數的操作，這個結果在方法結束后被保留了下來，所以方法執行中形式參數的改變將會影響實際參數。

基本類型傳遞的是該數據值本身。引用類型傳遞的是對對象的引用，而不是對象本身 。

8.static關鍵字

概念

• static被稱為靜態，可以用來修飾類的屬性,方法,代碼塊,內部類。

• 隨著類的加載而加載

• 優先于對象存在

• 修飾的成員，被所有對象所共享

• 可不創建對象，直接被類調用

static屬性

靜態屬性是類的所有對象共享的，不管創建了多少個對象，靜態屬性在內存中只有一個。

static方法

可以使用對象調用，也可以直接用類名調用，建議用類名直接調用

在static方法內部只能訪問類的static屬性，不能訪問類的非static屬性，因為static屬性先加載。

因為在類加載的時候加載方法，非static屬性還沒有加載，如果在靜態方法中訪問非static屬性，該屬性找不到。

代碼塊

代碼塊在類中聲明，類似一個沒有名稱的方法體(代碼塊)，代碼分實例塊和靜態塊

//實例塊：每次創建對象時自動調用
{
   //任何符合語法的Java代碼
}
//靜態塊：類加載時自動調用，僅一次，與是否創建對象無關。  
static {
    //任何符合語法的Java代碼
}

9.類的加載執行

創建對象時，先執行靜態代碼塊，在執行實例代碼塊，然后執行構造方法。

10.包

包的概念：

包就相當于一個文件夾

包的作用：

避免類重名

按照不同功能管理類

控制訪問權限

包（package）的命名規范：

在包名中，可以使用 . 號來區分包的級別；包名一般情況下是小寫

• 第一級 指該項目的類型，如com等，

• 第二級 指項目所開發或者運行的公司名稱，如：oracle,sun,huawei等

• 第三級 指項目的名稱。

• 第四級 指項目模塊的名稱。如：filter等表明這個包下類的功能

包可以更好得管理邏輯相關的類，可以控制不同包之間的訪問權限

導入外部包的類，關鍵字import

訪問權限修飾符

Java語言有四個權限訪問修飾符，權限從大到小依次為：

• public ：公共權限 修飾類、屬性、方法。可以被任意類訪問

• protected：受保護的權限 修飾屬性、方法。可以被同包類訪問，如果不是同包類，必須是該類的子類才可以訪問。

• default：同包權限 修飾類、屬性、方法。只能被同包的類訪問

• private：私有權限 修飾屬性、方法。 只能在本類中訪問

11.面向對象語言的三大特征

1.封裝

封裝：有時稱之為數據隱藏，將類的某些信息隱藏在類內部，不允許外部程序直接訪問，而是通過該類提供的方法來實現對隱藏信息的操作和訪問

好處：隱藏類的實現細節，方便加入控制語句，方便修改實現

具體表現是

1.屬性使用private權限 （私有的）

2.方法使用public權限

例子：

public class Person {    
    private String name;    
    private String age;    
    public String getName() {        
        return name;    
    }    
    public void setName(String name) {        
        this.name = name;   
    }   
    public String getAge() {        
        return age;    
    }    
    public void setAge(String age) {        
        this.age = age;    
    }
}

我們可以發現上述代碼用到了this關鍵字，那么什么是this關鍵字呢？

this關鍵字代表自身類的對象

功能：

1.使用this關鍵字引用成員變量

2.使用this關鍵字引用成員方法

注意：

this關鍵字必須放在非靜態方法里面

在一個類的方法或構造方法內部，可以使用“this.成員變量名”這樣的格式來引用成員變量名，常常用來區分同名的成員變量和局部變量。

例如上面的：

 this.name = name;   //把局部變量賦值給自己類的成員變量

2.多態

多態是同一個行為具有多個不同表現形式或形態的能力

多態的優點

• 消除類型之間的耦合關系

• 可替換性

• 可擴充性

• 接口性

• 靈活性

• 簡化性

多態存在的三個必要條件

• 繼承

• 重寫

• 父類引用指向子類對象：Parent p = new Child();（Child類繼承了Parent 類）

當使用多態方式調用方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，再去調用子類的同名方法。

多態的好處：可以使程序有良好的擴展，并可以對所有類的對象進行通用處理。

public class Test {
    public static void main(String[] args) {
        show(new Cat());  
        show(new Dog());  
    }  
    public static void show(Animal a)  {
        a.eat();  
        // 類型判斷
        if (a instanceof Cat)  {  
            Cat c = (Cat)a;  //向下轉型
            c.work();  
        } else if (a instanceof Dog) { 
            Dog c = (Dog)a;  
            c.work();  
        }  
	}  
}
public abstract class Animal {  
    abstract void eat();  
}  
public class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃魚");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}
public class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨頭");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

Test中的main方法輸出：

同一個方法在不同情況下的表現不同，就是多態的體現。

3.繼承

繼承：繼承是面向對象程序設計不可缺少的設計思想，是實現代碼可重用的根基，是提高代碼可擴展性的主要途徑。

繼承是從已有的類中派生出新的類，新的類能吸收已有類的屬性和行為，并能擴展新的能力。

• 在JAVA中使用extends關鍵字來表示繼承關系。

• JAVA不支持多繼承，單繼承使JAVA的繼承關系很簡單，一個類只能有一個直接父類。

• 繼承之后子類可以調用父類的所有非私有屬性和非私有方法。

什么時候使用繼承呢？

當你想用一些非本類的方法或屬性時，可以使用繼承，繼承想使用的那個類，就可以將那個類中的屬性方法拿過來用，可以讓你少寫一些代碼。所以繼承是代碼重用的一種方式

public class Animal{
  public static void eat(){
            System.out.println("動物吃");
        }
}
public class Dog  extends Animal{
 public static   void main(String[] args) {
        Dog dog = new Dog();
        dog.eat();
    }
}

專業術語：

Dog類是 Animal類的子類, Animal類是Dog類的父類（或者是） Dog類是 Animal類的派生類, Animal類是Dog類的基類。

繼承的傳遞性

C類從B類繼承,B類又從A類繼承

那么C類就具有B類和A類的所有非私有的屬性和方法

當一個沒有繼承任何一個類時，jvm（java虛擬機）會默認讓類繼承Object類

Object是 java為所有類提供的基類

繼承中的構造方法

子類構造方法總是先調用父類構造方法，默認情況下，調用父類無參構造方法

可以在子類構造方法的第一行，使用super關鍵字調用父類任意一個構造方法

如果用super，必須寫在方法的第一行

如果子類的構造方法中沒有顯式地（使用super）調用基類構造方法，則系統默認調用基類無參數的構造方法。

為什么要先創建父類：子類創建后需要調用父類的方法,所以在創建子類對象是父類也需要同時被創建.

我們又提到了一個新的關鍵字——super

super關鍵字用途

• super關鍵字代表父類的引用，在程序中主要的用途

• 在子類構造方法中要調用父類的構造方法，需要注意：super語句只能出現在子類構造方法體的第一行。

• 用“super.成員變量名”來引用父類成員變量。

• 用“super.方法名（參數列表）”的方式訪問父類的方法。

• 與this的區別，this通常指代當前對象，super通常指代父類。

方法的重寫(OverRide)

在子類中可以根據需要對從基類中繼承來的方法進行重寫。

方法重寫規則

• 方法名相同、參數列表相同；

• 返回值類型相同；

• 訪問權限等于或大于父類中方法權限;

只有方法體不同（大括弧內的代碼不同）

注意：構造方法不能重寫

應用場景： 當父類的方法實現不能滿足子類需求時,可以對方法進行重寫( override)

12.類于類之間的關系

1.關聯關系(has-a)

對象和對象之間的連接。在Java中，關聯關系的代碼表現形式為一個類做為另一個類的屬性類型存在。

就是相當于我們在我們的類中定義了一個String類型的屬性，那么，我們這個類和String類就是關聯關系。

即“有”的關系：”has-a”。

關聯關系分為單向關聯和雙向關聯

• 單向關聯： A類關聯B類。

• 雙向關聯：A類關聯B類,B類關聯A類;

public class Phone {
     private  Person per;//手機有主人
}
public  class Person {
     private Phone phone;//人擁有手機
}

關聯關系的多重性

一對一關聯：一個手機只能有一個主人

一對多關聯：一個人，可以擁有多個手機。

解決一對多的關聯的方案：集合或者數組

public List<Phone> phoneList;//集合
public Phone[] phones;//數組

2.依賴關系(uses-a)

依賴關系是指一個類A使用到了另一個類B，也就是說一個類的方法使用或者操作另一個類的對象

依賴關系的特性：

這種關系是具有偶然性的、臨時性的、非常弱的，但是類B的變化會影響到類A。

依賴具體表現

在代碼層面，依賴關系表現為類B作為參數被類A在某個方法中使用

例：

public  class Person {
      public void travel(Bus bus){}
}

注意：

應該盡量減少類與類之間有這種關系

3.繼承關系（is-a）

這種關系在上文中有過解釋，在這就不贅述了，寫在這只是表明類與類還有這種關系。

“Java對象與Java類的詳細介紹”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！