Java語言之包和繼承詳解

一、包

包名

在講包名前,我們先來瞭解一下,包是用來幹什麼的?

Java中允許使用包(package),包將類組織在一個集合中。借助包可以方便管理組織自己的代碼,並將自己的代碼與別人的提供的代碼庫分開管理。

包是組織類的一種方式。使用包的主要目的就是保證類的唯一性。

在Windows操作系統中,我們都知道,同一個文件夾下,不能同時出現兩個一樣的文件名的文件。而我們的java類,對應的就是一個.class文件,所以產生瞭包,而包其實就可以理解為路徑中所存放的文件夾,為瞭出現重命的類名,所以將各個類分佈在不同的包(文件夾)中。

而包名的命名:包名必須全部是小寫字母,且一般包的命名方式是所在公司的官網(域名)的逆序寫,假如www.xxxx.com,一般包名就是com.xxxx.——等等。

從編譯器的角度來看,嵌套的包之間沒有任何關系。例如:java.util包和java.util.jar包毫無關系。每一個包都是獨立的類集合。

image-20210909190637262

類的導入與靜態導入

一個類可以使用所屬包中的所有類,以及其他包下的公共類(public class)。

訪問另一個包的類有兩種方式:

1.使用完全限定名,也就是說在包名後面跟著類名。

java.util.Scanner scan = new java.util.Scanner(); //類名前面,直接跟包名

2.使用import關鍵字

import語句應該位於源文件的頂部,且位於package語句的後面。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new scanner();
    }
}

對於導包,我們還有一種比較簡單的方式,如下

import java.util.*;

*,就是通配符。也就是在當前類中,可以直接使用util包的所有類,從而不需要再次導包瞭。值得註意的是,這裡的導入,並不是導入util包下的所有類,這裡跟C語言的include,不一樣。C語言中的include,是導入頭文件下的所有內容;而這裡的import導入,隻會在需要使用這個包下的類的時候,才會導入進來

當然,對於import導入包時,還需要特別註意一個問題,如下:

import java.util.*;
import java.sql.*;
public class Main {
    public static void main(String[] args) {
        Date date = new Date(); //error, java.util.Date 還是 java.sql.Date?
    }
}

此時進行編譯,就會產生一個如上面代碼的註釋部分的錯誤。此時的編譯器無法確定你想使用的是哪一個包下的Date類。現在就可以添加一個特定的import來解決這個問題。

import java.util.*;
import java.sql.*;
import java.util.Date; //特別指出是使用這個包下的Date類
public class Main {
    public static void main(String[] args) {
        Date date = new Date();
    }
}

如果此時,兩個包中的Date都需要使用,那就隻能使用完全限定名瞭。如下:

import java.util.*;
import java.sql.*;
public class Main {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();
        java.sql.Date  date2 = new java.util.Date();
    }
}

靜態導入

我們還可以使用靜態導入包的方式,進行代碼的縮寫。使用import static 可以導入包中的靜態方法和靜態字段。這樣就可以不必再加類名前綴。

import static java.lang.System.*;
public class Main {
    public static void main(String[] args) {
        out.println("hello world");
    }
}

隻是有這樣一種機制,可以進行代碼的縮寫,但在現實中,這樣的代碼,可能更不容易讀懂。所以大傢使用時,酌情考慮。

在包中添加類

如果要想將類放入包中,就必須將包的名字放在源文件的開頭,即就是放在定義這個包中各個類的代碼之前。如下:

image-20210909194719866

如果沒有在這個源文件的開頭,寫package語句,則這個源文件中類就屬於無名包(unnamed package)。無名包沒有包名。

基本規則:

  • 在源文件的最上方加一個package語句,可以指定該代碼在哪個包
  • 包名盡量指定成唯一的名字,通常會使用公司的域名逆序形成
  • 包名要和代碼路徑相匹配。例如:package com.xxxx.demo,那麼所對應的文件路徑就是com/xxxx/demo
  • 如果一個源文件沒有package語句,則該類會被放到無名包(默認包)中

IDEA建包過程:

image-20210909200854540

包訪問權限

在之前的文章中,我們介紹過publicprivate。而private修飾的方法或成員變量,隻能在當前這個類中訪問。

如果有個類,既沒有寫public,也沒有寫private訪問修飾限定符,則此時這個(類、方法或成員變量)可以在包內部(當前文件夾下)的其他類中使用,但是不能在包外部(其他文件夾下)的類中使用。如下代碼:

import com.xxxx.demo1;
//demo1 包
public class Main {
    public static void main(String[] args) {
        Test test = new Test(); //會報錯,訪問權限不夠。
    }
}
//=====假設下面是第二個文件夾下的文件=====
import com.xxxx.demo2;
class Test { //訪問修飾限定符:沒寫,我們就稱為 默認
    public int number;
}
public class Demo2 {
    public int val;
}

訪問修飾限定符權限:

范圍 private 默認(default) protected public
同包同類 Y Y Y Y
同包不同類 Y Y Y
不同包,子類 Y Y
不同包,不同類 Y

其中,protected會在繼承中講到,我們繼續往下看!!!

二、繼承

繼承的基本思想就是:在已有類的基礎之上,創建新的類。繼承已存在的類得到就是復用瞭(繼承)這些類的方法,而且可以增加一些新的方法和成員變量。

類、超類與子類

我們先來舉個例子,比如一隻貓和一隻狗。它們瞭分別有自己的名字、性別、還是吃東西等等的一些性質。如下圖:

image-20210910141954783

他們分別都有自己的這些特征,我們也可以很容易的發現,他們都有自己一些共有的特征:比如姓名,性別。所以如果我們分別在新建貓和狗的類,還得寫專屬於它們自己的成員變量,這樣的話,就顯得代碼重復累贅,如下圖這樣:

image-20210910143026606

我們可以很清晰的看到,紅色框代碼部分,就是一模一樣的,所以出現瞭重復的代碼。而且這兩個類都是動物,所以說引出瞭一個繼承中的一個概念:“is -a”關系。

也就是說,什麼是一個什麼這樣的概念。就可能會用到繼承。

那該怎麼實現繼承關系呢?我們來看下圖:

image-20210910143839666

我們可以使用extends關鍵字來實現繼承關系,這樣的話,貓和狗兩個類,就能夠同時實現name和sex字段。這就是繼承。

此時貓和狗類,我們稱為子類或者派生類。而Animal類我們稱為父類基類超類

總結:

  • 使用extends指定父類
  • Java中一個子類隻能繼承一個父類。(而C++中可以實現多繼承)
  • 子類會繼承父類所有的public的字段和方法
  • 對於父類的private的字段和方法,子類是無法進行訪問的
  • 子類的實例中,也包含這父類的實例。可以使用super關鍵字得到父類實例的引用。

重寫方法(override)

image-20210910150713255

像上圖,子類和父類中,方法名和參數列表是一模一樣的。我們就稱為方法重寫(override)。可能有人就會問,我該怎麼調用相應的方法呢?

我們想調用Animal的eat方法,我們隻需要new出一個Animal的對象,就能進行調用,當然,Cat類的實例對象也是如此。如果我們想在Cat類的實例對象調用父類的方法,則我們可以使用super關鍵字進行調用。如下圖:

image-20210910151641612

切記:

  • super關鍵字,在使用的時候,隻能調用他的直接父類的方法或字段。比如:Animal類還繼承瞭一個類,此時Cat類中,使用super,則隻會調用Animal中的方法或字段。
  • 在子類中重寫的方法,這個方法的訪問修飾限定符的等級,應高於或等於父類的方法的訪問修飾限定符。比如:父類中的eat方法是public修飾,而子類中的eat方法也應該是public,或者是更高的。(當然隻是舉個例子,public就是最高的訪問修飾限定符瞭)
  • 被重寫的方法,不能是被static修飾的

this與super的區別:

image-20210910152820374

子類構造器

在上面說瞭,super關鍵字來調用父類的構造方法,那具體是如何進行調用的,我們來看一下具體的代碼實現:

public class Cat extends Animal{
    public Cat(String name, String sex) {
        super(name, sex); //調用父類的構造方法,super語句必須在子類構造器的第一行
        System.out.println("Cat的構造方法"); 
    }
    public void eat() {
        System.out.println("吃魚");
    }
}
public class Animal {
    public String name;
    public String sex;
    public Animal(String name, String sex) { //父類的構造方法
        this.name = name;
        this.sex = sex;
    }
    public void eat() {
        System.out.println("吃肉");
    }
}

總結:

  • 使用super構造方法的語句必須放在子類構造方法中的第一行。
  • 如果子類中,沒有顯示地調用父類的構造方法,將自動地調用超類的無參構造方法。
  • 在進行子類的實例化時,會調用子類的構造方法,而在調用子類構造方法時,將會先調用父類的構造方法。也就是說:new Cat ,實際上將先會新建出父類,在父類新建完成後,才會回到子類的構造方法,進行新建子類。

下面是一道有趣的題:請問下列代碼的輸出結果是什麼。

class X {
    Y y=new Y();
    public X() {
        System.out.print("X");
    }
}
class Y {
    public Y() { 
        System.out.print("Y");
    }
}
public class Z extends X {
    Y y=new Y();
    public Z() {
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Z();
    }
}

上面的代碼的輸出結果是:YXYZ。

分析:

  • 如果調用的是子類,那麼在進入子類構造方法後,將先執行super語句(若沒寫,編譯器自帶),先構造父類。
  • 在父類構造完成後,再次回到子類的構造方法。此時將先初始化當前類的成員變量。
  • 在成員變量初始化之後,才會執行構造方法裡面的語句。

上訴代碼執行流程圖:

image-20210910163739247

protected關鍵字

在上文中,我寫瞭一個訪問修飾限定符的表,表中第3個protected關鍵字。

前面我們學瞭public和private訪問修飾限定符,public的權限有大瞭,對於public來說,整個工程都可以進行使用;而對於private來說,隻能在當前的類中進行使用。二者之前,一個權限過大,一個權限過小。所以在Java的繼承中,還引入瞭這個關鍵字:protected;

對於protected來說,protected修飾的內容,在這個包下,可以直接使用。而在不同的包下,隻有繼承瞭這個類,才能在不同的包下使用該類被protected修飾內容。

阻止繼承:final關鍵字

在前面的文章中,我們介紹過final關鍵字,final修飾的變量,在初始化之後,將不能被修改。

final int a = 10;
a = 20; //編譯出錯,此時的a被final修飾,存儲在方法區,且不能被修改

final也能修飾類,,表示不能再被繼承,稱為密封類。

final還能修飾方法,表示此時的方法不能被重寫,稱為密封方法。

切記:如果一個類被final修飾,那麼其中的方法將自動地稱為final,但是不包括字段。如果一個方法沒有被重寫並且還很短,編譯器將會對此進行優化處理,這個過程稱為內聯

組合

和繼承類似的,還有一個叫組合的概念,也是用於表達類之間的關系,也能夠達到代碼的重復使用。

例如:一個公司由很多人組合而成,有當經理的、職員的、保潔員的等等……

class Person {
    public String name;
    public String sex;
}
class Manager extends Person { //繼承 人
    //經理的薪水
    public double getSalary() {
    }
}
class Staff extends Person { //繼承 人
    //普通職員的薪水
    public double getSalary() {
    }
}
//組合
public class Company {
    public Manager[] manager; //經理
    public Staff[] staff; //普通職員
}

組合並沒有涉及到特殊的語法,僅僅隻是將一個類的實例作為另一個類的字段,這也是我們設計類的一種常用的方式或思想。

組合表示has- a 的語義:意為:一個事物 由 什麼組合而成,也就是包含的意思。

繼承表示is-a的語義:意為:一個事物 是 一個什麼事物的概念。

總結

本篇文章就到這裡瞭,希望能夠給你帶來幫助,也希望您能夠多多關註WalkonNet的更多內容!

推薦閱讀: