一、包

1. 概念

根據(jù)定義：包是組織類的一種方式

那么為什么要組織類呢？

簡單來講就是保證類的唯一性，就比如在以后的工作中，如果大家一起開發(fā)一個(gè)項(xiàng)目，大家可能在自己的代碼中都寫到了一個(gè) Test 類，而如果出現(xiàn)了兩個(gè)同名的類的話，就會沖突，導(dǎo)致代碼不能編譯通過。

用一份代碼理解下

import java.util.*;
public class TestDemo{
    public static void main(String[] args){
        // 得到一個(gè)毫秒級的時(shí)間戳
        Date date=new Date();
    }
}

上面一份代碼，導(dǎo)入了 util 包，并使用了其中的 Date 類，目的是為了得到一個(gè)毫秒級的時(shí)間戳。而如果我們再導(dǎo)入一個(gè) sql 包

import java.sql.*;
import java.util.*;
public class TestDemo{
    public static void main(String[] args){
        // 得到一個(gè)毫秒級的時(shí)間戳
        Date date=new Date();
    }
}

上述代碼就會編譯錯(cuò)誤，會顯示 Reference to 'Date' is ambiguous, both 'java.sql.Date' and 'java.util.Date' match ，即兩個(gè)包中都有 Date 類，不知道該和哪個(gè)匹配。稍微修改下，確定該 Date 是和誰匹配就行，修改方式如

java.util.Date date=new java.util.Date();

或者修改這里也行

import java.sql.*;
import java.util.Date;

2. 使用方式

Java 中已經(jīng)提供了很多現(xiàn)成的類供我們使用，如上述代碼中的 Date 類，還有我們經(jīng)常使用的 Scanner 類、Arrays 類等等。

而這些類被放置在各個(gè)包中，比如 util 包中就有很多我們常用的類

雖說 Java 有這么多已經(jīng)包裝好的類供我們使用，但是并不是上面有的我們就可以直接使用。

其中 lang 包中的一些類可以直接使用，如 String、Short、Byte、Float 等等（因?yàn)檫@些類會被自動導(dǎo)入），寫一個(gè)代碼理解下

public class TestDemo{
    public static void main(String[] args){
        // 輸出 long 的最大值
        System.out.println(Long.MAX_VALUE); 
    }
}

上述代碼是輸出 long 類型的最大值，其中使用了 Long 類的 Max_VALUE 方法。并且不需要手打?qū)?lang 包

而其它包使用時(shí)都需要手動導(dǎo)入，并且導(dǎo)入一般有以下幾種方法

方法一： 直接在使用時(shí)，類前加包名，如

public class TestDemo{
    public static void main(String[] args){
        // 得到一個(gè)毫秒級的時(shí)間戳
        java.util.Date date=new java.util.Date();
    }
}

這種寫法比較麻煩，不簡潔

方法二： 使用 impot 語句直接導(dǎo)入某包中的某個(gè)類，如

import java.util.Date;
public class TestDemo{
    public static void main(String[] args){
        // 得到一個(gè)毫秒級的時(shí)間戳
        Date date=new Date();
    }
}

注意：

導(dǎo)入包時(shí)也可以直接使用**通配符 *** ，直接導(dǎo)入 util 包中的所有，如

import java.util.*;

但是這個(gè)并不是直接將該包中的所有類全部導(dǎo)入，而是你用到哪個(gè)類就會導(dǎo)入哪個(gè)類。

但是會出現(xiàn)導(dǎo)入的兩個(gè)包都使用通配符，并且兩個(gè)包都包含同名類的話，則在使用時(shí)就會出現(xiàn)錯(cuò)誤，如

import java.sql.*;
import java.util.*;
public class TestDemo{
    public static void main(String[] args){
        // 得到一個(gè)毫秒級的時(shí)間戳
        Date date=new Date();
    }
}

因此更推薦導(dǎo)入某個(gè)指定的類

方法三（下面會講解，不常使用）： 靜態(tài)導(dǎo)入

了解到這里我們就會發(fā)現(xiàn)，Java 中的 import 和 C++ 中的 #include 差別很大，后者必須使用 #include 來引入其他文件內(nèi)容，但是 Java 不需要。

3. 靜態(tài)導(dǎo)入

其實(shí)之前講方法那一章就提到過靜態(tài)方法，而靜態(tài)導(dǎo)入跟靜態(tài)方法一樣，都通過關(guān)鍵字 static 修飾，使用 import static 導(dǎo)入包。

而靜態(tài)導(dǎo)入可以使我們不用寫類名，這在某些時(shí)候會更加方便，例如

import static java.util.lang.Math.*;
public class TestDemo{
    public static void main(String[] args){
        double x=3;
        double ans=pow(x,2);
    }
}

其實(shí) pow 方法就省略了類名 Math

4. 創(chuàng)建包

既然理解了 Java 中的包，那么我們自己可以創(chuàng)建一個(gè)包嗎？因?yàn)檫@樣的話，我們就可以在和別人一起開發(fā)的時(shí)候，使用同一個(gè)類名了！

基本規(guī)則：

• 包中的文件最上方要加上一個(gè) package 語句，來指定該代碼在哪個(gè)包中
• 包名要和代碼路徑相匹配
• 如果一個(gè)類沒有 package 語句，則會被放到一個(gè)默認(rèn)的包中
• 包名需要全部小寫，并盡量指定成唯一的名字（一般取名如下）

1. 個(gè)人項(xiàng)目：pers.發(fā)起者名.項(xiàng)目名.模快名
2. 團(tuán)隊(duì)項(xiàng)目：pers.團(tuán)隊(duì)名.項(xiàng)目名.?？烀?/li>
3. 公司項(xiàng)目：com.公司名.項(xiàng)目名.?？烀?/li>

為了方便上述規(guī)則的理解，接下來讓我來手動創(chuàng)建一個(gè)包吧！

創(chuàng)建及使用步驟：

右鍵 src ，點(diǎn)擊new ，選擇創(chuàng)建一個(gè)package

創(chuàng)建包名，包名全部小寫

創(chuàng)建之后我們就可以看到這些，并且包名和代碼的路徑一致

點(diǎn)擊 demo1，創(chuàng)建一個(gè) Java 文件

大家發(fā)現(xiàn)沒，我創(chuàng)建了一個(gè)叫 TestDemo 的類，而這個(gè)名字在 src 中已經(jīng)有了。這就是包的作用！并且這個(gè)文件上面有 package pers.dmw.demo1; 指定了該代碼的位置

使用創(chuàng)建的類

當(dāng)我們輸入 Test 的時(shí)候，它出現(xiàn)了兩個(gè) TestDemo，下面哪個(gè)就是我們創(chuàng)建的類。按照我們以上所學(xué)的，先導(dǎo)入包，再使用這個(gè)類

完成啦！

5. 包的訪問權(quán)限

之前學(xué)類時(shí)，我們學(xué)過 public 和 private，其中被 public 修飾的成員在整個(gè)工程都可以使用，而被 private 修飾成員的則只能在自己的類中使用

而都不被這兩者修飾的成員，則可以在這個(gè)包的其他類中使用，但是不能在其他包中使用

比如我們個(gè)人創(chuàng)建的包中定義兩個(gè)類 TestDemo1 和 TestDemo2，而 TestDemo 是其他包中的

其中 TestDemo2 代碼如下

package pers.dmw.demo1;
public class TestDemo2 {
    public int a=10;
    private int b=20;
    int c=30;
}

Testdemo1 代碼如下

package pers.dmw.demo1;
public class TestDemo1 {
    public static void main(String[] args) {
        TestDemo2 testDemo2=new TestDemo2();
        System.out.println(testDemo2.a);
        System.out.println(testDemo2.b);
        System.out.println(testDemo2.c);
    }
}

其中 b 不能打印，因?yàn)?b 被 private 修飾，只能在自己的類中使用

TestDemo 代碼如下

package pers.dmw.demo1;
public class TestDemo {
    public static void main(String[] args) {
        TestDemo2 testDemo2=new TestDemo2();
        System.out.println(testDemo2.a);
        System.out.println(testDemo2.b);
        System.out.println(testDemo2.c);
    }
}

其中 b 和 c 都不能打印，b 是被 private 修飾的類，而 c 沒有被修飾，只能在自己的包中使用

6. 常見的系統(tǒng)包

包大概的知識已經(jīng)介紹完了，最后讓我們來了解下那些常見的系統(tǒng)包吧！

1. java.lang：系統(tǒng)常用基礎(chǔ)類（String、Object），此包從 JDK1.1 后自動導(dǎo)入。
2. java.lang.reflflect：java 反射編程包
3. java.net：進(jìn)行網(wǎng)絡(luò)編程開發(fā)包
4. java.sql：進(jìn)行數(shù)據(jù)庫開發(fā)的支持包
5. java.util：是 Java 提供的工具程序包
6. java.io：I/O 編程開發(fā)包

二、繼承

我們知道面向?qū)ο蟮幕咎卣骶褪牵豪^承、封裝、多態(tài)

我們已經(jīng)了解過封裝了，接下來就開始學(xué)習(xí)繼承

學(xué)習(xí)繼承之前我們首先回憶一下類與對象，之前我舉了一個(gè)洗衣服的例子，不記得的朋友可以去看看之前的文字Java 基礎(chǔ)語法讓你弄懂類和對象

而今天我再用一個(gè)謎語更好的幫大家去理解類和對象

謎語：

年紀(jì)不大，胡子一把?？腿藖砝玻秃皨寢專ù蛞粍游铮?/p>

謎底：

誒?。肯炔?，謎底我已經(jīng)放到本章的最后了，猜完的小伙伴可以到下面去驗(yàn)證哈

我們可以發(fā)現(xiàn)

• 謎語就是一種抽象
• 謎底就是一個(gè)具體
• 類就是一個(gè)事物的抽象
• 對象就是一個(gè)抽象的具體
  

回顧了類與對象之后，我們開始學(xué)習(xí)繼承，那么繼承是什么呢？

1. 概念

其實(shí)這里的繼承和我們生活中的繼承很類似，比如誰繼承了長輩的產(chǎn)業(yè)。我們也可以用這樣的比喻去寫一個(gè)代碼。

首先我們看一幅圖

圖片里有一只羊和一只狼，然后它們都屬于動物對吧，那我們可以根據(jù)動物去寫一個(gè)類

class Animal{
    public String name;
    public int age;
    public void eat(){
        System.out.println("我要睡覺啦！");
    }
    public void bark(){
        System.out.println("我要叫啦！");
    }
}

該類中，定義了動物的名字、年齡屬性以及睡覺、叫的行為。我們再繼續(xù)對狼和羊定義一個(gè)類

狼

class Wolf{
    public String name;
    public int age;
    public void eat(){
        System.out.println("我要睡覺啦！");
    }
    public void bark(){
        System.out.println("我要叫啦！");
    }
    public void hunt(){
        System.out.println("我要獵食啦！");
    }
}

羊

class Sheep{
    public String name;
    public int age;
    public int cleatNum;
    public void eat(){
        System.out.println("我要睡覺啦！");
    }
    public void bark(){
        System.out.println("我要叫啦！");
    }
}

我們發(fā)現(xiàn)，在羊和狼的類的定義時(shí)，由于它們都屬于動物，所以動物的一些屬性和行為它們都有，所以我們可以通過繼承，將羊和狼的類的代碼變得更加簡介

狼

class Wolf extends Animal{
    public void hunt(){
        System.out.println("我要獵食啦！");
    }
}

羊

class Sheep extends Animal{
    public int cleatNum;
}

如上述代碼中的 A extends B 就是繼承。其中

A：叫做子類或者派生類
B：叫做父類、基類或者超類

當(dāng)子類繼承了父類之后，子類就擁有了父類的方法和屬性

因此繼承的意義就是

為了代碼的重復(fù)使用

繼承的思想就是

1. 抽取共性，放到基類當(dāng)中
2. extends

2. 語法規(guī)則（含 super 使用）

這里我們再更加詳細(xì)的介紹繼承的語法規(guī)則，以便于解決一些疑惑的地方

語法：

class 子類 extends 父類{
    
}

規(guī)則：

• Java 中一個(gè)子類只能繼承一個(gè)父類（C++/python 等語言支持多繼承）
• 子類會繼承父類的所有 public 的字段和方法
• 對于父類的 private 的字段和方法，子類無法訪問（可以繼承）
• 子類的實(shí)例中，也包含著父類的實(shí)例，可以使用 super 關(guān)鍵字得到父類實(shí)例的引用
  

注意：

由于 Java 當(dāng)中只能單繼承，為了解決這個(gè)問題，后面可以通過接口來實(shí)現(xiàn)類似于“多繼承”的關(guān)系

那么上述關(guān)鍵字 super 是什么意思呢？首先我們看這樣一段代碼

class Animal{
    public String name;
    public void eat(){
        System.out.println(this.name + "要睡覺啦！");
    }
    public void bark(){
        System.out.println(this.name + "要叫啦！");
    }
}
class Wolf extends Animal{
    public void hunt(){
        System.out.println(this.name + "要獵食啦！");
    }
}
public class TestDemo{
    public static void main(String[] args){
        Wolf wolf=new Wolf();
        wolf.name="灰太狼";
        wolf.eat();
        wolf.bark();
        wolf.hunt();
    }
}

這就是一個(gè)簡單的子類繼承父類的使用。

我們知道創(chuàng)建一個(gè)對象分為兩步：為對象分配內(nèi)存和調(diào)用構(gòu)造類。當(dāng)我們沒有定義構(gòu)造方法時(shí)，系統(tǒng)會自動為我們構(gòu)造一個(gè)無參的構(gòu)造方法。

那如果我們在父類中主動的創(chuàng)建一個(gè)構(gòu)造方法

class Animal{
    public String name;
    public Animal(Stirng name){
        this.name=name;
    }
    public void eat(){
        System.out.println(this.name + "要睡覺啦！");
    }
    public void bark(){
        System.out.println(this.name + "要叫啦！");
    }
}

那么我們要記?。鹤宇惱^承父類，需要先幫父類構(gòu)造。那么怎么構(gòu)造呢，就要用到 super

class Wolf extends Animal{
    public Wolf(String name){
        super(name); // 顯示的調(diào)用父類的構(gòu)造方法
    }
    public void hunt(){
        System.out.println(this.name + "我要獵食啦！");
    }
}

其中 super 就是調(diào)用父類的構(gòu)造方法，這就滿足子類繼承父類之前，要先構(gòu)造父類的構(gòu)造方法

再具體理解下 super：

• super：表示當(dāng)前對象的父類的引用（但這個(gè)說法不嚴(yán)謹(jǐn)，這是和 this 類比的結(jié)論）
• super()：調(diào)用父類的構(gòu)造方法
• super.父類屬性：調(diào)用父類的屬性
• super.父類方法：調(diào)用父類的方法

注意：

• 當(dāng)我們不主動創(chuàng)建構(gòu)造方法時(shí)，但不是也有系統(tǒng)主動創(chuàng)建的構(gòu)造方法嗎？因?yàn)楫?dāng)我們不主動創(chuàng)建時(shí)，系統(tǒng)也主動使用了 super
• super 不能和 this 一起使用，因?yàn)樗鼈兌家旁诘谝恍?/li>
• super 不能放在被 static 修飾的方法中使用，因?yàn)樗蕾囉趯ο?/li>
• super 只會指向最直接的父類，不會指向父類的父類
  

3. protected 關(guān)鍵字

我們對之前學(xué)的關(guān)鍵字 public、private、默認(rèn)以及即將要學(xué)的關(guān)鍵字 protected 做一個(gè)比較，就可以得到下面的表格

我們發(fā)現(xiàn)在上述代碼中，我使用的繼承時(shí)，父類代碼的屬性都是用 public 修飾的。這樣子類就可以正常使用這些屬性，但是這就違背了“封裝”的思想。但是如果用 private 修飾，不同包的子類又不能訪問

因此出現(xiàn)了一個(gè)關(guān)鍵字 protected，使用它的話

• 對于不同包的非子類： protected 修飾的字段和方法是不能訪問的
• 對于不同包的子類和同一包的其他類：protected 修飾的字段和方法是能訪問的
  

學(xué)到這里，我們可以開始解決之前一些未提及的問題了：如果父類和子類都含有同一個(gè)參數(shù)，那調(diào)用時(shí)是使用哪個(gè)呢？我們來看下面的代碼

class Base{
    public int a=1;
}
class Derieve extends Base{
    public int a=3;
    public void func(){
        System.out.println(a);
    }
}
public class TestDemo{
    public static void main(String[] args){
        Derieve derieve=new Derieve();
        derieve.func();
    }
}
// 結(jié)果為：3

也就是說，調(diào)用時(shí)也是依靠了一個(gè)就近原則，默認(rèn)為子類中的。那么調(diào)用時(shí)想調(diào)用父類該怎么辦呢？這時(shí)我們就可以使用 super 來調(diào)用父類的屬性。將 Derieve 類 改成這樣即可

class Derieve extends Base{
    public int a=3;
    public void func(){
        System.out.println(super.a);
    }
}
// 結(jié)果為：1

至于方法同名的問題下章將講解！

4. 更復(fù)雜的繼承關(guān)系

以上的繼承關(guān)系都比較簡單，如果關(guān)系變得更復(fù)雜時(shí)，如這個(gè)樣子，我們該怎么辦呢？

emmm，其實(shí)一般建議是不希望超過三層的繼承關(guān)系的，如果繼承層次太多了，就需要考慮重構(gòu)代碼。

而有時(shí)我們不知不覺就寫了很多的繼承關(guān)系，所以為了在語法上進(jìn)行限制繼承，就可以使用關(guān)鍵字 final

5. final 關(guān)鍵字

之前我們了解過 final，它可以修飾一個(gè)變量或者字段，使其變成常量，不可以被修改，如

final int a=10;
// a 為常量不可以被修改

而在這里，final 也能修飾類，此時(shí)被修飾的類就不能被繼承了，被叫做密封類，如

final class A{
    
}

此時(shí) A 就不能被繼承了

final 也可以修飾方法，被修飾的方法叫做密封方法，至于此時(shí) final 有什么作用，下章將會講解！

三、組合

上述重點(diǎn)講解了繼承相關(guān)的內(nèi)容，而繼承的意義就是：使代碼可以重復(fù)使用

而組合也是一種表達(dá)類之間關(guān)系的方式，也能夠達(dá)到代碼重用的效果

顧名思義，組合就是將各種東西組合成一個(gè)東西。比如學(xué)習(xí)，學(xué)校就是由老師、學(xué)生、教學(xué)樓等等組合而成的，我們可以寫一個(gè)代碼

class Teacher{
    // ...
}
class Student{
    // ...
}
public class School{
    public Teacher[] teachers;
    public Student[] students;
}

上述代碼就是將老師和學(xué)生的類封裝成了對象，并且作為了另一個(gè)類的字段

四、總結(jié)（含謎底）

今天這章重點(diǎn)講解了包和繼承相關(guān)的內(nèi)容，概念比較多，自己的理解也可能很不到位，所以寫的不好，希望大家可以理解吧！最后來揭曉我們的謎底吧！

我是謎底：

其實(shí)我自己在猜的時(shí)候一直搞不懂羊?yàn)樯督袐寢?，羊不都?miemie~ 的叫嘛，直到我想到了 giegie~

到此這篇關(guān)于Java 基礎(chǔ)語法之解析 Java 的包和繼承的文章就介紹到這了,更多相關(guān) Java 的包和繼承內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

nal 有什么作用，下章將會講解！

最新評論