Java中的類和對象是什么意思

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

目錄

• 認識類和對象

• 1.類、對象是什么？

• 2.什么是面向對象？

• 3.一個對象的產生過程是？

• ?OOP語言的三大特征？

• 類和對象的實例化

• 類的定義：

• 注意：

• 實例化對象：

• ①如何訪問對象中的實例成員變量？

• ②如何訪問靜態的數據成員？

• 注意：

• 方法：

• 實例成員方法：

• 靜態成員方法

• ?構造方法

• ①訪問實例成員方法

• ②訪問靜態成員方法

• static 關鍵字

• 1.修飾屬性：

• 靜態成員變量只有一份：

• 2.修飾方法：

• this 關鍵字

• this 使用方法：

• 舉例1

• 舉例2

• getter 和 setter方法

• 注意事項：

• 封裝

• 封裝的實現步驟：

• 舉例：

• 輸出結果：

• Java中的訪問修飾符：

• 封裝的作用：

• 代碼塊

• 實例代碼塊：

• 注意事項：

• 靜態代碼塊：

• 注意事項：

• 靜態 / 實例代碼塊異同點

認識類和對象

1.類、對象是什么？

類在Java中，也叫做自定義類型。

類就是一類對象的統稱，對象就是這一類具體化的一個個例

可以把類想象成一個模板，把對象想象成實體，比如：建房子，會有圖紙，然后根據圖紙去建房子，一張圖紙可建很多同樣的房子。而圖紙就是"類"，建的房子就是"實體"，通過一個類可以產生多個對象

2.什么是面向對象？

之前在初始Java篇簡單講述了Java的面向對象性，對比了面向對象和面向過程的不同

這里就不多說了 ：https://blog.csdn.net/m0_47988201/article/details/118996045?spm=1001.2014.3001.5501.

面向對象是思考問題的一種方式，是一種思想

總的來說，面向對象就是用代碼(類)，來描述客觀世界事物的一種方式，一個類主要包含一個事物的屬性和行為

面向對象的好處是：將復雜的事情簡單化，只要面對一個對象就行

之后，會從這三點進行深入學習：找對象—創對象—使用對象

3.一個對象的產生過程是？

①給對象分配內存；

②調用合適的構造方法

?OOP語言的三大特征？

OOP：面向對象編程

三大特性：繼承、封裝、多態

類和對象的實例化

類的定義：

在Java中定義類，需要 class 關鍵字

類中包含的內容稱為類的成員；屬性主要是用來描述類的，稱之為類的成員屬性或者類成員變量；方法主要說明類具有哪些功能，稱為類的成員方法

類的成員包括：字段、方法、代碼塊、內部類和接口等，此處只介紹前三個

語法格式：

class ClassName {
field ； …// 字段(成員屬性) / 成員變量
method；// 行為 / 成員方法
}

舉例：

class Person{
    //字段
	String name;
	int age;
    //行為
    public void eat(){
        System.out.println("eat()!");
    }
    public void sleep(){
        System.out.println("sleep()!");
    }
}

注意：

• 類名使用大駝峰命名法

• 字段 / 成員變量定義在方法外面、類的里面

• 實例成員變量存放在對象里

• Java中訪問修飾限定符：
  

• private：私有的；public：共有的；protected：受保護的；什么都不寫：默認權限 / 包訪問權限

• 一般一個文件當中只定義一個類

• main方法所在的類必須要使用public修飾p

• ublic修飾的類必須要和文件名相同

實例化對象：

在Java中，通過關鍵字new，配合類名可以實例化一個對象

用類類型創建對象的過程，稱為類的實例化

//實例化對象
Person person1 = new Person();
Person person2 = new Person();
Person person3 = new Person();
Person person4 = new Person();

①如何訪問對象中的實例成員變量？

通過對象的引用即可訪問：對象的引用 . 成員變量

public static void main(String[] args) {
	//實例化一個對象
	Person person = new Person();
	//訪問對象中的實例成員變量
	//通過對象的引用
	System.out.println(person.age);
	System.out.println(person.name);
}

②如何訪問靜態的數據成員？

類名 . 靜態成員變量

public static void main(String[] args) {
	Person per = new Person();
	System.out.println(Person.size);
}

注意：

• 同一個類可以創建多個實例

• new關鍵字用于創建一個對象的實例實例

• 成員變量，沒有初始化，默認值為對應的 0 值
  

• 引用類型默認為null，簡單類型默認為 0

• 特殊：char類型—"\u0000"；boolean類型—false

• 使用 . 來訪問對象中的屬性和方法

• 靜態成員變量不屬于對象，屬于類，且只有一份

方法：

實例成員方法：

public void eat(){
    System.out.println("eat()!");
}
public void sleep(){
    System.out.println("sleep()!");
}

靜態成員方法

靜態成員方法
public static func(){
	System.out.println("static::func()!");
}

?構造方法

構造方法的方法名和類名相同，且沒有返回值

構造方法作用： 實例化一個對象

class Person{
    private String name;
    private int age;
    public  Person(){
        System.out.println("Person!");
    }
	public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person<String,int>");
    }
public class Test {
    public static void main(String[] args) {
        //寫這行代碼的時候，就會調用構造方法
        Person person1 = new Person();
        Person person2 = new Person("Huahua",18);
	 }
}

注意：

• 當沒有提供構造方法的時候，編譯器會自動提供一個沒有參數的構造方法

• 若類中定義了構造方法，則默認的無參構造不再產生

• 什么時候調用構造方法取決于new對象時是否給參數

• 構造方法支持重載，規則和普通方法一致

①訪問實例成員方法

通過對象的引用進行訪問：對象的引用 . 實例成員方法

public static void main(String[] args) {
	Person per = new Person();
	per.eat();
	per.sleep();
}

②訪問靜態成員方法

類名 . 靜態成員方法

public static void main(String[] args) {
	Person.func();
}

static 關鍵字

1.修飾屬性：

Java靜態屬性和類相似，和具體的實例無關

即：同一個類的不同實例共用同一個靜態屬性

class Test{
    public int a = 0;
    public static int count;
}

靜態成員變量只有一份：

public static void main(String[] args) {
    Test T = new Test();
    T.a++;
    Test.count++;
    System.out.println(T.a+" "+Test.count);
}

輸出結果：

分析原因：

2.修飾方法：

在方法前應用 ststic 關鍵字，就把該方法稱為靜態方法

靜態成員方法
public static func(){
	System.out.println("static::func()!");
}

注意：

• 靜態方法內部不能訪問非靜態成員

• 靜態方法屬于類，不屬于類的對象

• 可以直接調用靜態方法，而無需創建類的實例

• 靜態方法可以更改靜態數據成員的值

• 靜態方法中不能調用任何非靜態方法

this 關鍵字

this 表示當前對象的引用

this 使用方法：

1、this . 屬性名稱 訪問屬性，指的是訪問類中的成員變量，用來區分成員變量和局部變量

2、this . 方法名稱 用來訪問本類的成員方法

3、this()；訪問本類的構造方法，()中可以有參數的 如果有參數 就是調用指定的有參構造

舉例1

訪問屬性 和 訪問方法

class  Person{
    private String name;
    private int age;
    //調用屬性
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //調用方法
    public void eat{
    	System.out.println(this.getName());
    }
    public String getName{
    	return name;
    }
}

舉例2

訪問構造方法

class Person{
    private String name;
    private int age;
    public  Person(){
    	// 訪問構造方法
        this("Huahua",3);
        System.out.println("Person!");
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
        System.out.println("Person<String,int>");
    }
}

注意事項：

• this() 不能使用在普通方法中 只能寫在構造方法中

• this() 必須是構造方法中的第一條語句

getter 和 setter方法

當我們使用 private 來修飾字段的時候，就無法直接使用這個字段了，這就需要使用 getter 和 setter 方法

class Person{
    private String name;
    //setter方法給設施變量的值
    public String getName{
       	return name;
    }
    public void setName(String name){
        this.name = name;
    }
}

注意事項：

• getName 即為 getter 方法，表示獲取這個成員的值

• setName 即為 setter 方法，表示設置這個成員的值

• 不是所有的字段都一定要提供 setter / getter 方法，而是要根據實際情況決定提供哪種方法

• 當 setter 方法的形參名字和類中的成員屬性的名字一樣時，如果不適用 this，相當于自賦值，this表示當前實例的引用

• 在IDEA中，可以使用Alt+F12，快速生成 setter / getter 方法

封裝

封裝：用private 來修飾屬性 / 方法

類和對象階段，主要研究的就是封裝特性

class Student{
    private String name;
    public int age;
    public void func1(){
        System.out.println("func1()");
    }
}

如果一個屬性 / 方法被 private 修飾之后，限定只能在類當中來使用

封裝的實現步驟：

1、修改屬性的可見性——設為private

2、創建getter / setter方法——用于屬性的讀寫

3、在getter / setter方法中加入屬性控制語句——對屬性值的合法性進行判斷

舉例：

class Student{
    //成員變量私有化
    private int age;
    //setter方法給設施變量的值
    public void setAge(int age){
        if(age < 0){
            System.out.println("年齡無效！");
        }
        else{
            this.age = age;
        }
    }
    //提供一個公開的接口
    //使用getter方法獲取賦值
    public int getAge(){
        return age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        //檢驗
        student.setAge(-10);
        System.out.println(student.getAge());
    }
}

輸出結果：

Java中的訪問修飾符：

封裝的作用：

• 對象的數據封裝特性，提高了程序的可復用性和可維護性，降低了程序員保持數據與操作內容的負擔

• 對象的數據封裝特性還可以把對象的私有數據和公共數據分離開，保護了私有數據，減少了可能的模塊間干擾，達到降低程序復雜性、提高可控性的目的

建議：以后在設計類的時候，無特殊要求，所有的屬性雖好都設置為私有的private ，一定要體現封裝

代碼塊

使用 { } 定義的一段代碼稱為代碼塊

重點掌握代碼塊執行的先后順序

分為四種：

普通代碼塊：在方法或語句中出現的{ }就稱為普通代碼塊
實例代碼塊 (構造代碼塊)
靜態代碼塊
同步代碼塊

實例代碼塊：

定義在類中且沒有加static關鍵字的代碼塊

如果存在多個構造代碼塊，執行順序由他們在代碼中出現的次序決定，先出現先執行

特性：

{
 System.out.println("實例代碼塊......");
}

注意事項：

• 實例代碼塊優先于構造方法執行，因為編譯完成后，編譯器會將實例代碼塊中的代碼拷貝到每個構造方法第一條語句前

• 實例代碼塊只有在創建對象時才會執行

靜態代碼塊：

static {
 System.out.println("靜態代碼塊......");
}

注意事項：

• 靜態代碼塊不能存在于任何方法體內

• 靜態代碼塊不能直接訪問實例變量和實例方法，需要通過類的實例對象來訪問

• 靜態代碼塊不管生成多少個對象，其只會執行一次

• 靜態成員變量是類的屬性，因此是在JVM加載類時開辟空間并初始化的

• 如果一個類中包含多個靜態代碼塊，在編譯代碼時，編譯器會按照定義的先后次序依次合并，最終放在生成的<>方法中，該方法在類加載時調用，并且只調用一次

靜態 / 實例代碼塊異同點

相同點： 都是JVM加載類后且在構造函數執行之前執行，在類中可定義多個，一般在代碼塊中對一些static變量進行賦值

不同點：靜態代碼塊在非靜態代碼塊之前執行，靜態代碼塊只在第一次 new 時執行一次，之后不在執行。而非靜態代碼塊每new一次就執行一次

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