文章目錄

1、初識面向物件
- 1.1、面向程序、面向物件
- - 1.1.1、面向程序
  - 1.1.2、面向物件思想
- 1.2、什么是面向物件
- 1.3、類與物件的關系
2、創建與初始化物件
- 2.1、構造器
- 2.2、記憶體分析
3、封裝
4、繼承
- 4.1、super 、this
- 4.2、方法的重寫
5、多型
- 5.1、instanceof和型別轉換
6、Static
7、抽象類(abstract)
8、介面(interface)
9、內部類

1、初識面向物件

1.1、面向程序、面向物件

1.1.1、面向程序

步驟清晰簡單，第一步做什么，第二部做什么…
面向程序適合處理一些較為簡單的問題

1.1.2、面向物件思想

物以類聚，分類的思維模式，思考問題首先會解決問題需要哪些分類，然后對這些分類進行單獨思考，最后，才對某個分類下的細節進行面向程序的思索，
面向物件適合處理復雜的問題，適合處理需要多人協作的問題！
對于描述復雜的事物，為了從宏觀上把握、從整體上合理分析，我們需要使用面向物件來分析整個系統，但是，具體到微觀操作，仍然需要面向程序的思路去處理，

1.2、什么是面向物件

面向物件編程（Object-Oriented Programming, OOP）
本質：以類的方式組織代碼，以物件的組織(封裝)資料，
抽象
三大特性
- 封裝
- 繼承
- 多型
從認識論的角度考慮是先有物件后有類，物件是具體的事物，類是物件的抽象，
從代碼運行角度考慮是先有類后有物件，類是物件的模板，

1.3、類與物件的關系

類是一種抽象的資料型別，它是對某一類事物整體描述/定義，但并不能代表某一個具體的事物，
- 動物、植物、手機、電腦…
- Person類、Pet類、Cat類等，都是用來描述/定義某一具體的事物應該具備的特點和行為，
物件是抽象概念的具體實體，如張三是人的一個具體實體、張三家里的狗旺財就是狗的一個具體實體，

2、創建與初始化物件

使用new來創建物件，
使用new關鍵字創建的時候，除了分配記憶體之外，還會給創建好的物件進行默認的初始化，以及對類中構造器的呼叫，
類中的構造器也被稱為構造方法，創建物件時必須要呼叫，有以下特點：
- 必須和類的名字相同
- 沒有回傳型別，也不能寫void
一個類即使什么都不寫，也會存在一個默認的構造方法

2.1、構造器

public class Person {
    //一個類即使什么都不寫，也會存在一個默認的無參構造方法
    //顯示地定義構造器
    String name;
    
    //作用：1. 使用new關鍵字，本質是在呼叫構造器
    //2. 用來初始化物件的值
    public Person(){} //無參構造
    
    //有參構造 3.一旦定義了有參構造，無參就必須顯示定義
    public Person(String name){
        this.name=name;
    }
	//Alt+insert 快捷鍵插入構造方法
}

2.2、記憶體分析

//定義一個寵物類
public class Pet {
    public String name; //默認 null
    public int age; 	//默認 0
    //無參構造

    public void shout(){
        System.out.println("叫了一聲");
    }
}

//應用類，創建呼叫物件
public class Application {
    public static void main(String[] args) {
        
        Pet dog = new Pet();

        dog.name = "旺財";
        dog.age = 3;
        dog.shout();
    }
}

物件通過參考型別來操作：堆疊 - - ->堆

3、封裝

該露的露，該藏的藏
- 我們程式設計要追求“高內聚，低耦合”，高內聚就是類的內部資料細節由自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用，
封裝（資料的隱藏）
- 通常，應禁止直接訪問一個物件中資料的實際表示，而應通過操作介面來訪問，稱為資訊隱藏，
作用
- 提高程式的安全性，保護資料
- 隱藏代碼的實作細節
- 統一介面
- 系統可維護性增加了

在這里插入圖片描述

4、繼承

繼承的本質是對某一批類的抽象，從而實作對世界更好地建模，
extends的意思是”擴展“，子類是父類的擴展，使用關鍵字extends來表示，
Java中類只有單繼承，沒有多繼承！一個類只能繼承一個父類，
繼承是類與類之間的一種關系，此外還有依賴、組合、聚合等，
繼承關系的兩個類，一個為子類（派生類），一個為父類（基類），子類繼承父類，
子類和父類之間，從意義上講應該具有”is a“的關系，

//學生類(子類)繼承 人類(父類)
public class Student extends Person{ /*Person extends Object*/
    ...
}

子類繼承了父類，就會擁有父類的全部方法，而private私有屬性及方法無法繼承，
在Java中，所有類，都默認直接或間接繼承Object類 (Ctrl+H 可以查看類關系)
被final修飾的類，無法被繼承（斷子絕孫），

4.1、super 、this

1、super()呼叫父類的構造方法，必須在構造方法的第一個
2、super必須只能出現在子類的方法或構造方法中
3、super()和this()不能同時呼叫構造方法，因為this也必須寫在第一行

super與this的區別：super代表父類物件的參考，只能在繼承條件下使用；this呼叫自身物件，沒有繼承也可以使用，

super(); //隱藏代碼，默認呼叫了父類的無參構造，要寫只能寫第一行

在這里插入圖片描述

4.2、方法的重寫

1、重寫：子類的方法必須與父類方法必須一致，方法體不同，
2、重寫是方法的重寫，與屬性無關
3、重寫方法只與非靜態方法有關，與靜態方法無關（靜態方法不能被重寫）

public class B {
    public static void test(){ //靜態方法
        System.out.println("B==>test()");
    }
}

public class A extends B{ //繼承
    public static void test(){
        System.out.println("A==>test()");
    }
}

public class Application {
    public static void main(String[] args) {
        //方法的呼叫之和左邊定義的型別有關
        A a = new A();
        a.test(); //列印 A==>test()

        //父類的參考指向了子類，但靜態方法沒有被重寫
        B b = new A();
        b.test(); //列印 B==>test()
    }
}

修改A.java, B.java

public class B {
    public void test(){ //非靜態方法
        System.out.println("B==>test()");
    }
}
public class A extends B{
    @Override //重寫了B的方法
    public void test() {
        System.out.println("A==>test()");
    }
}

//父類的參考指向了子類
B b = new A(); //子類重寫了父類的方法，執行子類的方法
b.test(); //列印變成了 A==>test()
/* 
靜態方法是類的方法，非靜態方法是物件的方法
有static時，b呼叫了B類的方法，因為b是b類定義的
沒有static時，b呼叫的是物件的方法，而b是A類new出來的物件，呼叫A的方法
*/

靜態方法屬于類，非靜態方法屬于物件
注意點：
1. 方法名、引數串列必須相同
2. 修飾符范圍可以擴大，不能縮小
3. 拋出的例外范圍可以被縮小，不能擴大
4. 被static(屬于類，不屬于實體)，final(常量方法)，private(私有)修飾的方法不能重寫

5、多型

動態編譯：型別
即同一方法可以根據發送物件的不同而采用不同的行為方式
一個物件的實際型別是確定的，但可以指向物件的參考可以有很多
多型存在條件
- 有繼承關系
- 子類重寫父類方法
- 父類參考指向子類物件

在這里插入圖片描述

注意點：

多型是方法的多型，沒有屬性的多型
父類和子類，有聯系型別轉換例外: ClassCastException
存在條件：繼承關系，方法需要重寫，父類參考指向子類物件！

5.1、instanceof和型別轉換

instanceof 參考型別比較，判斷一個物件是什么型別

public static void main(String[] args) {

    // Object > String
    // Objest > Person > Student
    // Objest > Person > Teacher
    Object object = new Student();
	// X instanceof Y，X參考指向的物件是不是Y的子類
    System.out.println(object instanceof Student); //true
    System.out.println(object instanceof Person); //true
    System.out.println(object instanceof Teacher); //false
    System.out.println(object instanceof Object); //true
    System.out.println(object instanceof String); //false
	
    //型別之間的轉化：父-子（高-低）,低可以轉換為高
    Person obj = new Syudent(); //只能用Person方法（重寫了用子類重寫過的方法）
    (Syudent)obj.go(); //強轉之后可以用Student方法(Student->go())
}

型別轉換

父類參考指向子類的物件
把子類轉換為父類，向上轉型，會丟失自己原來的一些方法
把父類轉換為子類，向下轉型，強制轉換，才呼叫子類方法
方便方法的呼叫(轉型)，減少重復的代碼，簡潔，

6、Static

靜態變數可以直接用類名訪問，也稱類變數，
靜態變數(或方法)對于類，所有物件（實體）所共享，
靜態區代碼加載類時一起被初始化，最早執行且只執行一次（第一次new），
Math->亂數:

//靜態匯入包
import static java.lang.Math.random;

public class Application {
    public static void main(String[] args) {

        //第一種亂數，不用導包
        System.out.println(Math.random()); //0.7562202902634543

        //第二種亂數，靜態匯入包
        System.out.println(random()); //0.5391606223844663
    }
}

7、抽象類(abstract)

abstract修飾的類就是抽象類，修飾的方法就是抽象方法，
抽象類中可以沒有抽象方法，但有抽象方法的類一定要宣告為抽象類，
抽象類不能使用new來創建物件，它是用來讓子類繼承的，
抽象方法只有方法的宣告，沒有實作，讓其子類實作，
子類繼承抽象類，必須實作抽象類的所有方法，否則該子類也要宣告為抽象類，

//abstract 抽象類 類只能單繼承（介面可以多繼承）
public abstract class Action {

    //約束~有人幫我們實作~
    //抽象方法只有方法名，沒有方法的實作
    public abstract void doSth();

    //1.不能new抽象類，只能靠子類去實作它，僅作為一個約束
    //2.抽象方法只能出現在抽象類中，抽象類可以有普通方法
    //3.抽象類有構造器，可以派生子類
    //4.抽象類的意義：約束，提高開發效率，但是類只能單繼承，所以有局限 用的不多
}

8、介面(interface)

普通類：只有具體實作
抽象類：具體實作和規范(抽象方法)都有
介面：只有規范，沒有方法實作，專業的約束！約束與實作分離：面向介面編程~
介面就是規范，定義的是一組規則，"你是什么…必須做什么…"的思想，
介面的本質是約束，就像人間法律一樣，制定好大家都遵守，

//interface介面,介面都要有繼承類
//實作類（implements 可以繼承多個介面）
//多繼承，利用介面實作多繼承
public interface UserService {
    //定義的屬性都是常量,默認修飾 public static final
    public static final int AGE = 99; //一般不用
    //所有的定義的方法都是抽象的 默認public abstract
    public abstract void run();
    void add();
    void query();
    void delete();
}

注意點

加粗樣式介面沒有構造方法，不能被實體化
實作類必須要重寫介面中的方法
實作類（implements）可以實作多個介面

9、內部類

內部類就是在一個類的內部再定義一個類，比如A類中定義了一個B類，那么B就是A的內部類，而A相對B來說就是外部類

成員內部類：可以操作外部類的私有屬性及方法
靜態內部類：static修飾，不能訪問外部類私有屬性
區域內部類：外部類的方法里定義的類
匿名內部類：沒有名字初始化類

在這里插入圖片描述

視頻學習地址：https://www.bilibili.com/video/BV12J41137hu?p=60

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/298352.html

標籤：java

上一篇：大一總結錄

下一篇：瀘職院一年學習總結

java基礎-面向物件（回顧）

文章目錄

1、初識面向物件

1.1、面向程序、面向物件

1.1.1、面向程序

1.1.2、面向物件思想

1.2、什么是面向物件

1.3、類與物件的關系

2、創建與初始化物件

2.1、構造器

2.2、記憶體分析

3、封裝

4、繼承

4.1、super 、this

4.2、方法的重寫

5、多型

5.1、instanceof和型別轉換

6、Static

7、抽象類(abstract)

8、介面(interface)

9、內部類