網路層協議介紹

阿新 • • 發佈：2021-11-25

物件

概述

Java是一種面向物件的高階程式語言。

三大特徵：封裝，繼承，多型

面向物件最重要的兩個概念：類和物件

類：相同事物共同特徵的描述。類只是學術上的一個概念並非真實存在的，只能描述一類事物
物件：是真實存在的例項，例項==物件，物件是類的例項化
結論：有了類和物件就可以描述萬千世界所有的事物。必須先有類才能有物件

類

定義

定義格式

修飾符 class 類名{
}

類名的首字母建議大寫，滿足駝峰模式，比如 StudentNameCode
一個 Java 程式碼中可以定義多個類，按照規範一個 Java 檔案一個類
一個 Java 程式碼檔案中，只能有一個類是 public 修飾，public修飾的類名必須成為當前Java程式碼的檔名稱

類中的成分:有且僅有五大成分
修飾符 class 類名{
		1.成員變數(Field):  	描述類或者物件的屬性資訊的。
        2.成員方法(Method):		描述類或者物件的行為資訊的。
		3.構造器(Constructor):	 初始化一個物件返回。
		4.程式碼塊
		5.內部類
	  }
類中有且僅有這五種成分，否則程式碼報錯！
public class ClassDemo {
    System.out.println(1);//報錯
}

構造器

構造器格式：

修飾符 類名(形參列表){

}

作用：初始化類的一個物件返回

分類：無引數構造器，有引數構造器

注意：一個類預設自帶一個無引數構造器，寫了有引數構造器預設的無引數構造器就消失，還需要用無引數構造器就要重新寫

構造器初始化物件的格式：類名物件名稱 = new 構造器

無引數構造器的作用：初始化一個類的物件（使用物件的預設值初始化）返回
有引數構造器的作用：初始化一個類的物件（可以在初始化物件的時候為物件賦值）返回

包

包：分門別類的管理各種不同的技術，便於管理技術，擴充套件技術，閱讀技術

定義包的格式：package 包名，必須放在類名的最上面

導包格式：import 包名.類名

相同包下的類可以直接訪問；不同包下的類必須導包才可以使用

封裝

封裝的哲學思維：合理隱藏，合理暴露
封裝最初的目的：提高程式碼的安全性和複用性，元件化

封裝的步驟：

成員變數應該私有，用 private 修飾，只能在本類中直接訪問
提供成套的 getter 和 setter 方法暴露成員變數的取值和賦值

使用 private 修飾成員變數的原因：實現資料封裝，不想讓別人使用修改你的資料，比較安全

this

this 關鍵字的作用：

this 關鍵字代表了當前物件的引用
this 出現在方法中：哪個物件呼叫這個方法 this 就代表誰
this 可以出現在構造器中：代表構造器正在初始化的那個物件
this 可以區分變數是訪問的成員變數還是區域性變數

static

基本介紹

Java 是通過成員變數是否有 static 修飾來區分是類的還是屬於物件的。

static 靜態修飾的成員（方法和成員變數）屬於類本身的。

按照有無 static 修飾，成員變數和方法可以分為：

成員變數：
- 靜態成員變數（類變數）：static 修飾的成員變數，屬於類本身，與類一起載入一次，只有一個，直接用類名訪問即可
- 例項成員變數：無 static 修飾的成員變數，屬於類的每個物件的，與類的物件一起載入，物件有多少個，例項成員變數就載入多少個，必須用類的物件來訪問
成員方法：
- 靜態方法：有 static 修飾的成員方法稱為靜態方法也叫類方法，屬於類本身的，直接用類名訪問即可
- 例項方法：無 static 修飾的成員方法稱為例項方法，屬於類的每個物件的，必須用類的物件來訪問

static用法

成員變數的訪問語法：

靜態成員變數：只有一份可以被類和類的物件共享訪問
- 類名.靜態成員變數（同一個類中訪問靜態成員變數可以省略類名不寫）
- 物件.靜態成員變數（不推薦）
例項成員變數：
- 物件.例項成員變數（先建立物件）

成員方法的訪問語法：

靜態方法：有 static 修飾，屬於類
- 類名.靜態方法（同一個類中訪問靜態成員可以省略類名不寫）
- 物件.靜態方法（不推薦，參考 JVM → 執行機制 → 方法呼叫）

例項方法：無 static 修飾，屬於物件

物件.例項方法

public class Student {
    // 1.靜態方法：有static修飾，屬於類，直接用類名訪問即可！
    public static void inAddr(){ }
    // 2.例項方法：無static修飾，屬於物件，必須用物件訪問！
    public void eat(){}
    
    public static void main(String[] args) {
        // a.類名.靜態方法
        Student.inAddr();
        inAddr();
        // b.物件.例項方法
        // Student.eat(); // 報錯了！
        Student zbj = new Student();
        zbj.eat();
    }
}

兩個問題

記憶體問題：

棧記憶體存放 main 方法和地址
堆記憶體存放物件和變數
方法區存放 class 和靜態變數（jdk8 以後移入堆）

訪問問題：

例項方法是否可以直接訪問例項成員變數？可以的，因為它們都屬於物件
例項方法是否可以直接訪問靜態成員變數？可以的，靜態成員變數可以被共享訪問
例項方法是否可以直接訪問例項方法? 可以的，例項方法和例項方法都屬於物件
例項方法是否可以直接訪問靜態方法？可以的，靜態方法可以被共享訪問
靜態方法是否可以直接訪問例項變數？不可以的，例項變數必須用物件訪問！！
靜態方法是否可以直接訪問靜態變數？可以的，靜態成員變數可以被共享訪問。
靜態方法是否可以直接訪問例項方法? 不可以的，例項方法必須用物件訪問！！
靜態方法是否可以直接訪問靜態方法？可以的，靜態方法可以被共享訪問！！

繼承

基本介紹

繼承是 Java 中一般到特殊的關係，是一種子類到父類的關係

被繼承的類稱為：父類/超類。
繼承父類的類稱為：子類。

繼承的作用：

提高程式碼的複用，相同程式碼可以定義在父類中
子類繼承父類，可以直接使用父類這些程式碼（相同程式碼重複利用）
子類得到父類的屬性（成員變數）和行為（方法），還可以定義自己的功能，子類更強大

繼承的特點：

子類的全部構造器預設先訪問父類的無引數構造器，再執行自己的構造器
單繼承：一個類只能繼承一個直接父類
多層繼承：一個類可以間接繼承多個父類（家譜）
一個類可以有多個子類
一個類要麼預設繼承了 Object 類，要麼間接繼承了 Object 類，Object 類是 Java 中的祖宗類

繼承的格式：

子類 extends 父類{

}

子類不能繼承父類的東西：

子類不能繼承父類的構造器，子類有自己的構造器
子類是不能可以繼承父類的私有成員的，可以反射暴力去訪問繼承自父類的私有成員
子類是不能繼承父類的靜態成員的，子類只是可以訪問父類的靜態成員，父類靜態成員只有一份可以被子類共享訪問，共享並非繼承

public class ExtendsDemo {
    public static void main(String[] args) {
        Cat c = new Cat();
        // c.run();
        Cat.test();
        System.out.println(Cat.schoolName);
    }
}
class Cat extends Animal{
}
class Animal{
    public static String schoolName ="seazean";
    public static void test(){}
    private void run(){}
}

變數訪問

繼承後成員變數的訪問特點：就近原則，子類有找子類，子類沒有找父類，父類沒有就報錯

如果要申明訪問父類的成員變數可以使用：super.父類成員變數，super指父類引用

public class ExtendsDemo {
    public static void wmain(String[] args) {
        Wolf w = new Wolf();w
        w.showName();
    }
}
class Wolf extends Animal{
    private String name = "子類狼";
    public void showName(){
        String name = "區域性名稱";
        System.out.println(name); // 區域性name
        System.out.println(this.name); // 子類物件的name
        System.out.println(super.name); // 父類的
        System.out.println(name1); // 父類的
        //System.out.println(name2); // 報錯。子類父類都沒有
    }
}

class Animal{
    public String name = "父類動物名稱";
    public String name1 = "父類";
}

方法訪問

子類繼承了父類就得到了父類的方法，可以直接呼叫，受許可權修飾符的限制，也可以重寫方法

方法重寫：子類重寫一個與父類申明一樣的方法來覆蓋父類的該方法

方法重寫的校驗註解：@Override

方法加了這個註解，那就必須是成功重寫父類的方法，否則報錯
@Override 優勢：可讀性好，安全，優雅

子類可以擴充套件父類的功能，但不能改變父類原有的功能，重寫有以下三個限制：

子類方法的訪問許可權必須大於等於父類方法
子類方法的返回型別必須是父類方法返回型別或為其子型別
子類方法丟擲的異常型別必須是父類丟擲異常型別或為其子型別

繼承中的隱藏問題：

子類和父類方法都是靜態的，那麼子類中的方法會隱藏父類中的方法
在子類中可以定義和父類成員變數同名的成員變數，此時子類的成員變數隱藏了父類的成員變數，在建立物件為物件分配記憶體的過程中，隱藏變數依然會被分配記憶體

public class ExtendsDemo {
    public static void main(String[] args) {
        Wolf w = new Wolf();
        w.run();
    }
}
class Wolf extends Animal{
    @Override
    public void run(){}//
}
class Animal{
    public void run(){}
}

面試問題

為什麼子類構造器會先呼叫父類構造器？

子類的構造器的第一行預設 super() 呼叫父類的無引數構造器，寫不寫都存在
子類繼承父類，子類就得到了父類的屬性和行為。呼叫子類構造器初始化子類物件資料時，必須先呼叫父類構造器初始化繼承自父類的屬性和行為
參考 JVM → 類載入 → 物件建立

class Animal{
    public Animal(){
        System.out.println("==父類Animal的無引數構造器==");
    }
}
class Tiger extends Animal{
    public Tiger(){
        super(); // 預設存在的，根據引數去匹配呼叫父類的構造器。
        System.out.println("==子類Tiger的無引數構造器==");
    }
    public Tiger(String name){
        //super();  預設存在的，根據引數去匹配呼叫父類的構造器。
        System.out.println("==子類Tiger的有引數構造器==");
    }
}

為什麼 Java 是單繼承的？

答：反證法，假如 Java 可以多繼承，請看如下程式碼：

class A{
	public void test(){
		System.out.println("A");
	}
}
class B{
	public void test(){
		System.out.println("B");
	}
}
class C extends A , B {
	public static void main(String[] args){
		C c = new C();
        c.test(); 
        // 出現了類的二義性！所以Java不能多繼承！！
	}
}

super

繼承後 super 呼叫父類構造器，父類構造器初始化繼承自父類的資料。

總結與拓展：

this 代表了當前物件的引用（繼承中指代子類物件）：this.子類成員變數、this.子類成員方法、this(...)可以根據引數匹配訪問本類其他構造器。
super 代表了父類物件的引用（繼承中指代了父類物件空間）：super.父類成員變數、super.父類的成員方法、super(...)可以根據引數匹配訪問父類的構造器

注意：

this(...) 借用本類其他構造器，super(...) 呼叫父類的構造器。
this(...) 或 super(...) 必須放在構造器的第一行，否則報錯!
this(...) 和 super(...) 不能同時出現在構造器中，因為建構函式必須出現在第一行上，只能選擇一個。

public class ThisDemo {
    public static void main(String[] args) {
        // 需求：希望如果不寫學校預設就是”張三“！
        Student s1 = new Student("天蓬元帥", 1000 );
        Student s2 = new Student("齊天大聖", 2000, "清華大學" );
    }
}
class Study extends Student {
   public Study(String name, int age, String schoolName) {
        super(name , age , schoolName) ; 
       // 根據引數匹配呼叫父類構造器
   }
}

class Student{
    private String name ;
    private int age ;
    private String schoolName ;

    public Student() {
    }
    public Student(String name , int age){
        // 借用兄弟構造器的功能！
        this(name , age , "張三");
    }
	public Student(String name, int age, String schoolName) {
        this.name = name;
        this.age = age;
        this.schoolName = schoolName;
    }
// .......get + set
}

final

基本介紹

final 用於修飾：類，方法，變數

final 修飾類，類不能被繼承了，類中的方法和變數可以使用
final 可以修飾方法，方法就不能被重寫
final 修飾變數總規則：變數有且僅能被賦值一次

面試題：final 和 abstract 的關係是互斥關係，不能同時修飾類或者同時修飾方法！

修飾變數

靜態變數

final 修飾靜態成員變數，變數變成了常量

常量：有 public static final 修飾，名稱字母全部大寫，多個單詞用下劃線連線。

final 修飾靜態成員變數可以在哪些地方賦值：

定義的時候賦值一次
可以在靜態程式碼塊中賦值一次

public class FinalDemo {
//常量：public static final修飾，名稱字母全部大寫，下劃線連線。
    public static final String SCHOOL_NAME = "張三" ;
    public static final String SCHOOL_NAME1;

    static{
        //SCHOOL_NAME = "java";//報錯
        SCHOOL_NAME1 = "張三1";
        //SCHOOL_NAME1 = "張三2"; // 報錯，第二次賦值！
    }
}

例項變數

final 修飾變數的總規則：有且僅能被賦值一次

final 修飾例項成員變數可以在哪些地方賦值 1 次：

定義的時候賦值一次
可以在例項程式碼塊中賦值一次
可以在每個構造器中賦值一次

public class FinalDemo {
    private final String name = "張三" ;
    private final String name1;
    private final String name2;
    {
        // 可以在例項程式碼塊中賦值一次。
        name1 = "張三1";
    }
	//構造器賦值一次
    public FinalDemo(){
        name2 = "張三2";
    }
    public FinalDemo(String a){
        name2 = "張三2";
    }

    public static void main(String[] args) {
        FinalDemo f1 = new FinalDemo();
        //f1.name = "張三1"; // 第二次賦值 報錯！
    }
}