91超碰碰碰碰久久久久久综合_超碰av人澡人澡人澡人澡人掠_国产黄大片在线观看画质优化_txt小说免费全本

溫馨提示×

溫馨提示×

您好,登錄后才能下訂單哦!

密碼登錄×
登錄注冊×
其他方式登錄
點擊 登錄注冊 即表示同意《億速云用戶服務條款》

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

發布時間:2021-08-19 17:44:33 來源:億速云 閱讀:128 作者:chen 欄目:開發技術

本篇內容介紹了“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();

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

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

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

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

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

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

                              類名 . 靜態成員變量

                              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);
                              }

                              輸出結果:

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

                              分析原因:

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

                              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中的類和對象是什么意思

                              Java中的訪問修飾符:

                              訪問修飾符本類同包子類其他
                              private


                              public
                              protected
                              默認

                              封裝的作用:

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

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

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

                              代碼塊

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

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

                              分為四種:

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

                              實例代碼塊:

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

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

                              特性:

                              {
                               System.out.println("實例代碼塊......");
                              }
                              注意事項:
                              • 實例代碼塊優先于構造方法執行,因為編譯完成后,編譯器會將實例代碼塊中的代碼拷貝到每個構造方法第一條語句前

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

                              靜態代碼塊:

                              static {
                               System.out.println("靜態代碼塊......");
                              }
                              注意事項:
                              • 靜態代碼塊不能存在于任何方法體內

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

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

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

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

                              靜態 / 實例代碼塊異同點

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

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

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

                              向AI問一下細節

                              免責聲明:本站發布的內容(圖片、視頻和文字)以原創、轉載和分享為主,文章觀點不代表本網站立場,如果涉及侵權請聯系站長郵箱:is@yisu.com進行舉報,并提供相關證據,一經查實,將立刻刪除涉嫌侵權內容。

                              AI

                              碌曲县| 景宁| 靖安县| 建平县| 鄂托克旗| 永定县| 新巴尔虎左旗| 凤凰县| 固镇县| 双辽市| 台南县| 武功县| 三亚市| 汉寿县| 乌兰浩特市| 石河子市| 德格县| 栖霞市| 彭州市| 长春市| 龙里县| 阿巴嘎旗| 襄城县| 仁怀市| 革吉县| 山丹县| 吴桥县| 定州市| 辽中县| 枣强县| 望都县| 绥滨县| 彩票| 通辽市| 刚察县| 新竹县| 钦州市| 瑞昌市| 贺兰县| 邹城市| 南皮县|