面向物件

面向物件思想

• 物以類聚，分類的思維模式，思考問題首先會解決問題需要那些分類，然後對這些分類進行單獨思考。最後才對某個分類下的細節進行面向過程的思索。

• 面向物件適合處理複雜的問題，適合處理需要多人協作的問題！

• 對於描述複雜的事物，為了從巨集觀上把握，從整體上合理分析，我們需要使用面向物件的思路來分析整個系統。但是，具體到微觀操作，任然需要向面向過程的思路去處理。

什麼是面向物件

• 面向物件程式設計（OOP，Object-Oriented Programming）

• 面向物件程式設計的本質就是：以類的方式組織程式碼，以物件的方式組織（封裝）資料。

• 抽象

• 三大特性：

  • 封裝

  • 繼承

  • 多型

• 從認識論角度考慮是先有物件後有類。物件，是具體的事物。類是抽象的，是對 物件的抽象

• 從程式碼執行角度考慮是先有類後有物件。類是物件的模板。

Break和Return的區別

• break：用於跳出switch ，跳出迴圈

• return：用於結束方法，返回值要和方法型別相同

值傳遞和引用傳遞

• 值傳遞：在使用變數的過程中，會將變數copy到操作棧中進行運輸

• 引用傳遞：在使用變數的過程中，傳遞的是物件的地址，根據地址指向的記憶體資料進行計算

類與物件的關係

• 類是一種抽象的資料型別，它是對某一類事物整體描述/定義，但是並不代表某一個具體的事物

• 物件是抽象概念的具體例項

構造器

• 一個類即使什麼也不寫，它也會存在一個方法

• 類中的構造器也稱為構造方法，實在進行建立物件的時候必須要呼叫的。並且構造器有以下兩個特點：

  • 方法名必須和類的名字相同

  • 沒有返回值，必須沒有返回型別，也不能寫void

• 作用：

  • new 本質是在呼叫構造方法

  • 初始化物件的值

• 注意點：定義有參構造之後，如果想使用無參構造，需要顯示的定義一個無參的構造

記憶體分析

類與物件

• 類是一個模板，類是抽象的，物件是一個具體的例項

封裝

• 高內聚 ，低耦合 高內聚 就是類的內部資料操作細節自己完成，不允許外部干涉；低耦合 ：僅暴露少量的方法給外部使用

• 封裝（資料的隱藏）

  • 通常，應禁止直接訪問一個物件中資料的實際表示，而應通過操作介面來訪問，稱為資訊隱藏

• 屬性私有 ， get/set

  • 提高程式的安全性，保護資料

  • 隱藏程式碼的實現細節

  • 統一介面

  • 系統可維護性增加了

繼承

• 繼承的本質是對某一批類的抽象

• extends ，子類是父類的擴充套件

• Java中類只有單繼承，沒有多繼承！

• 繼承是類和類之間的一種關係。

• 繼承關係的兩個類，一個為子類，一個為父類。

• 子類繼承了父類，就會擁有父類的全部非私有方法！

• 私有化的東西無法被繼承

• 在Java中所有的類都預設直接或者間接繼承Object類

• 如果一個類被final修飾 則不能被繼承了 final之後斷子絕孫了！

super:

1. super呼叫父類的構造方法，必須在構造方法的第一個

2. super必須只能出現在子類的方法或者構造方法中！

3. super 和 this 不能同時呼叫構造方法，因為都必須在第一行

4. 表示父類物件的應用

• super VS this ：

  • 代表的物件不同

    • this：本身呼叫者這個物件

    • super：代表父類物件的應用

  • 前提：

    • this：沒有繼承也可以使用

    • super：只能在繼承條件下才可以使用

  • 構造方法

    • this（）；本類的構造

    • super（）； 父類的構造

方法重寫：

• 前提： 需要有繼承關係，子類重寫父類方法 是因為父類的方法不足以滿足子類的要求，需要方法進行重寫

• 方法名必須相同

• 引數列表也必須相同

• 訪問修飾符不能夠嚴於父類，注意 private修飾的方法不能被繼承，所以不能被重寫 （public>protected>default>private）

• 丟擲的異常：範圍，可以被縮小，但不能擴大

• 重寫都是方法的重寫 和屬性無關

• 靜態方法的呼叫只和左邊，定義的資料型別有關

• 非靜態的方法才可以重寫

多型

• 即同一個方法可以根據傳送物件的不同而採用多種不同的行為方式

• 有重寫才會存在多型！

• 一個物件的實際型別是確定的，但可以指向物件的引用的型別有很多

• 多型存在的條件

  • 有繼承關係

  • 子類重寫父類的方法

  • 父類引用指向子類的物件：

  • Person person = new Student();

• 注意：多型是方法的多型，屬性沒有多型性

  • 父類和子類存在關係，型別也需要為同類型 Class Cast Exception 型別轉換異常！

  • static 方法不能被重寫 屬於類 不屬於例項

  • final 修飾的方法 也不能被重寫

  • private 修飾的方法 也不能被重寫

• public class Application {
      //一個專案應該只存在一個main方法
      public static void main(String[] args) {
          //一個物件的實際型別是確定的
          // new Person();
          //可以指向的引用型別就不確定了
          //Student 能呼叫的方法都是自己的或者繼承父類的！ 但如果重寫了父類的方法則 執行重寫的那部分
          Student s1 = new Student();
          //父類的引用指向子類 但是不能呼叫子類獨有的方法
          Person s2 = new Student();
          Object s3 = new Student();
  ​
  ​
          s2.run();//子類重寫了父類的方法 執行子類的方法
          s1.run();
          //物件能執行那些方法 主要看物件左邊的型別！
          ((Student)s2).eat();
          s1.eat();
      }
  }

• public class Person {
      public void run(){
          System.out.println("run");
      }
  }
  ​

• public class Student extends Person {
      @Override
      public void run() {
          System.out.println("son");
      }
      public void eat(){
          System.out.println("eat=>Student");
      }
  }

•  

instance of 和型別轉換

• instanof：用來判斷兩個類之間是否存在父子關係

• public class Application {
      //一個專案應該只存在一個main方法
      public static void main(String[] args) {
          //Object>Person>Student
          Object object = new Student();
          System.out.println(object instanceof Student);//true
          System.out.println(object instanceof Person);//true
          System.out.println(object instanceof Object);//true
          System.out.println(object instanceof Teacher);//false
          System.out.println(object instanceof String);//false
          System.out.println("================");
          //Object>Person>Student
          //Object>Person>Teacher
          //Object>String
          Person person = new Student();
          System.out.println(person instanceof Student);//true
          System.out.println(person instanceof Person);//true
          System.out.println(person instanceof Object);//true
          System.out.println(person instanceof Teacher);//false
          //System.out.println(person instanceof String);//編譯報錯
          System.out.println("================");
          Student student = new Student();
          System.out.println(student instanceof Student);//true
          System.out.println(student instanceof Person);//true
          System.out.println(student instanceof Object);//true
          //System.out.println(student instanceof Teacher);//編譯報錯
          //System.out.println(student instanceof String);//編譯報錯
      }
  }

• 型別轉換：

  • 子類轉換為父類，可能丟失自己本來的一些方法！

  • 把子類轉換為父類，向上轉型 自動轉換

  • 把父類轉為子類，向下轉型 需要強制轉換

static關鍵字

• 可以用來修飾方法和屬性

• public class Student {
      private static int age;//靜態變數
      private double score ;//非靜態變數
  ​
      public void run(){
          go();
      }
      public static void go(){
          System.out.println("static go");
      }
      public static void main(String[] args) {
          Student s1 = new Student();
          System.out.println(Student.age);
          System.out.println(s1.score);
          System.out.println(s1.age);
          s1.run();
          Student.go();
      }
  }

• package com.zhou.oop.Demo07;
  //靜態匯入包
  import static java.lang.Math.random;
  import static java.lang.Math.PI;
  public class Test {
      public static void main(String[] args) {
          System.out.println(random());
          System.out.println(PI);
      }
  }

抽象類

• abstract :

  • 用來修飾類的時候 就是抽象類

  • 用來修飾方法的時候就是 抽象方法 抽象方法只有方法名字，沒有具體實現。需要靠其他類繼承通過重寫去實現。

  • 抽象類不能被new 只能靠子類繼承來實現

  • 一個類只要有抽象方法 那麼這個類就必須被宣告為抽象類 但抽象類裡可以寫普通方法

  • 子類必須實現所有的父類抽象方法，否則也要註明abstract

• 抽象類存在的意義：

  • 更利於程式碼的維護和重用，因為抽象類不能例項化物件，所以必須要有子類來實現它之後才能使用。這樣就可以把相同的屬性和方法的元件進行抽象，這樣更利於程式碼和程式的維護，也是Java面向物件的一個重要體現。

介面

• 自己無法寫方法體，只能定義方法，讓實現了介面的類去實現，約束和實現分離，面向介面程式設計。

• 介面的本質是契約。

• 介面是面向物件的精髓，是對物件的抽象，最能體現這一點的就是介面。

• 介面宣告的關鍵字 interface

• 介面中所有的定義方法其實都是抽象的 public abstract

• 所有在介面中定義的屬性都是 public static final 修飾的靜態常量

• 介面不能被例項化，因為介面中沒有構造方法

• 介面都需要有實現類

• 類可以實現介面 通過implements 利用介面可以實現偽多繼承

• 實現了介面中的類，就必須重寫介面中的所有方法

• 只有一個方法的介面叫做函式式介面，可以使用lambda表示式

內部類

• 內部類就是在一個類的內部在定義一個類，比如，A類中定義一個B類，那麼B類相對A類來說就稱為內部類，而A類相對於B類來說就是外部類了。

  • 成員內部類

  • public class Outer {
        private int id = 10;
        public void out(){
            System.out.println("這是外部類的方法");
        }
        public class Inner{
            public void in(){
                System.out.println("這是內部類的方法");
            }
            //獲得外部類的私有屬性
            public void getID(){
                System.out.println(id);
            }
        }
    }
    ​
    public class Application {
        //一個專案應該只存在一個main方法
        public static void main(String[] args) {
            Outer outer = new Outer();
            //通過這個外部類來例項化內部類
            Outer.Inner inner = outer.new Inner();
            inner.getID();
        }
    }

  • 靜態內部類

  • 區域性內部類

  • 匿名內部類

  • public class Test {
        public static void main(String[] args) {
            //沒有名字初始化類,不用將例項儲存到變數中 就是匿名內部類
            new Apple().eat();
            UserService userService = new UserService(){
    ​
                @Override
                public void hello() {
                    
                }
            };
        }
    }
    class Apple{
        public void eat(){
            System.out.println("apple");
        }
    }
    interface UserService{
        void hello();
    }

  •