一、包
1. 概念
根據(jù)定義：包是組織類的一種方式
那么為什么要組織類呢？
簡單來講就是保證類的唯一性，就比如在以后的工作中，如果大家一起開發(fā)一個項目，大家可能在自己的代碼中都寫到了一個 Test 類，而如果出現(xiàn)了兩個同名的類的話，就會沖突，導(dǎo)致代碼不能編譯通過。
用一份代碼理解下
import java.util.*;
public class TestDemo{
public static void main(String[] args){
// 得到一個毫秒級的時間戳
Date date=new Date();
}
}
上面一份代碼，導(dǎo)入了 util 包，并使用了其中的 Date 類，目的是為了得到一個毫秒級的時間戳。而如果我們再導(dǎo)入一個 sql 包
import java.sql.*;
import java.util.*;
public class TestDemo{
public static void main(String[] args){
// 得到一個毫秒級的時間戳
Date date=new Date();
}
}
上述代碼就會編譯錯誤，會顯示 Reference to "Date" is ambiguous, both "java.sql.Date" and "java.util.Date" match ，即兩個包中都有 Date 類，不知道該和哪個匹配。稍微修改下，確定該 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 類等等。
而這些類被放置在各個包中，比如 util 包中就有很多我們常用的類
雖說 Java 有這么多已經(jīng)包裝好的類供我們使用，但是并不是上面有的我們就可以直接使用。
其中 lang 包中的一些類可以直接使用，如 String、Short、Byte、Float 等等（因為這些類會被自動導(dǎo)入），寫一個代碼理解下
public class TestDemo{
public static void main(String[] args){
// 輸出 long 的最大值
System.out.println(Long.MAX_VALUE);
}
}
上述代碼是輸出 long 類型的最大值，其中使用了 Long 類的 Max_VALUE 方法。并且不需要手打?qū)?lang 包
而其它包使用時都需要手動導(dǎo)入，并且導(dǎo)入一般有以下幾種方法
方法一： 直接在使用時，類前加包名，如
public class TestDemo{
public static void main(String[] args){
// 得到一個毫秒級的時間戳
java.util.Date date=new java.util.Date();
}
}
這種寫法比較麻煩，不簡潔
方法二： 使用 impot 語句直接導(dǎo)入某包中的某個類，如
import java.util.Date;
public class TestDemo{
public static void main(String[] args){
// 得到一個毫秒級的時間戳
Date date=new Date();
}
}
注意：
導(dǎo)入包時也可以直接使用**通配符 *** ，直接導(dǎo)入 util 包中的所有，如
import java.util.*;
但是這個并不是直接將該包中的所有類全部導(dǎo)入，而是你用到哪個類就會導(dǎo)入哪個類。
但是會出現(xiàn)導(dǎo)入的兩個包都使用通配符，并且兩個包都包含同名類的話，則在使用時就會出現(xiàn)錯誤，如
import java.sql.*;
import java.util.*;
public class TestDemo{
public static void main(String[] args){
// 得到一個毫秒級的時間戳
Date date=new Date();
}
}
因此更推薦導(dǎo)入某個指定的類
方法三（下面會講解，不常使用）： 靜態(tài)導(dǎo)入
了解到這里我們就會發(fā)現(xiàn)，Java 中的 import 和 C++ 中的 #include 差別很大，后者必須使用 #include 來引入其他文件內(nèi)容，但是 Java 不需要。
3. 靜態(tài)導(dǎo)入
其實之前講方法那一章就提到過靜態(tài)方法，而靜態(tài)導(dǎo)入跟靜態(tài)方法一樣，都通過關(guān)鍵字 static 修飾，使用 import static 導(dǎo)入包。
而靜態(tài)導(dǎo)入可以使我們不用寫類名，這在某些時候會更加方便，例如
import static java.util.lang.Math.*;
public class TestDemo{
public static void main(String[] args){
double x=3;
double ans=pow(x,2);
}
}
其實 pow 方法就省略了類名 Math
4. 創(chuàng)建包
既然理解了 Java 中的包，那么我們自己可以創(chuàng)建一個包嗎？因為這樣的話，我們就可以在和別人一起開發(fā)的時候，使用同一個類名了！
基本規(guī)則：
-
包中的文件最上方要加上一個
package語句，來指定該代碼在哪個包中 - 包名要和代碼路徑相匹配
-
如果一個類沒有
package語句，則會被放到一個默認(rèn)的包中 - 包名需要全部小寫，并盡量指定成唯一的名字（一般取名如下）
- 個人項目：pers.發(fā)起者名.項目名.模快名
- 團隊項目：pers.團隊名.項目名.模快名
- 公司項目：com.公司名.項目名.模快名
為了方便上述規(guī)則的理解，接下來讓我來手動創(chuàng)建一個包吧！
創(chuàng)建及使用步驟：
右鍵 src ，點擊new ，選擇創(chuàng)建一個package
創(chuàng)建包名，包名全部小寫
創(chuàng)建之后我們就可以看到這些，并且包名和代碼的路徑一致
點擊 demo1，創(chuàng)建一個 Java 文件
大家發(fā)現(xiàn)沒，我創(chuàng)建了一個叫 TestDemo 的類，而這個名字在 src 中已經(jīng)有了。這就是包的作用！并且這個文件上面有 package pers.dmw.demo1; 指定了該代碼的位置
使用創(chuàng)建的類
當(dāng)我們輸入 Test 的時候，它出現(xiàn)了兩個 TestDemo，下面哪個就是我們創(chuàng)建的類。按照我們以上所學(xué)的，先導(dǎo)入包，再使用這個類
完成啦！
5. 包的訪問權(quán)限
之前學(xué)類時，我們學(xué)過 public 和 private，其中被 public 修飾的成員在整個工程都可以使用，而被 private 修飾成員的則只能在自己的類中使用
而都不被這兩者修飾的成員，則可以在這個包的其他類中使用，但是不能在其他包中使用
比如我們個人創(chuàng)建的包中定義兩個類 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 不能打印，因為 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)包吧！
-
java.lang：系統(tǒng)常用基礎(chǔ)類（String、Object），此包從 JDK1.1 后自動導(dǎo)入。 -
java.lang.reflflect：java 反射編程包 -
java.net：進行網(wǎng)絡(luò)編程開發(fā)包 -
java.sql：進行數(shù)據(jù)庫開發(fā)的支持包 -
java.util：是 Java 提供的工具程序包 -
java.io：I/O 編程開發(fā)包
二、繼承
我們知道面向?qū)ο蟮幕咎卣骶褪牵豪^承、封裝、多態(tài)
我們已經(jīng)了解過封裝了，接下來就開始學(xué)習(xí)繼承
學(xué)習(xí)繼承之前我們首先回憶一下類與對象，之前我舉了一個洗衣服的例子，不記得的朋友可以去看看之前的文字Java 基礎(chǔ)語法讓你弄懂類和對象
而今天我再用一個謎語更好的幫大家去理解類和對象
謎語：
年紀(jì)不大，胡子一把。客人來啦，就喊媽媽（打一動物）
謎底：
誒！？先猜，謎底我已經(jīng)放到本章的最后了，猜完的小伙伴可以到下面去驗證哈
我們可以發(fā)現(xiàn)
- 謎語就是一種抽象
- 謎底就是一個具體
- 類就是一個事物的抽象
- 對象就是一個抽象的具體
回顧了類與對象之后，我們開始學(xué)習(xí)繼承，那么繼承是什么呢？
1. 概念
其實這里的繼承和我們生活中的繼承很類似，比如誰繼承了長輩的產(chǎn)業(yè)。我們也可以用這樣的比喻去寫一個代碼。
首先我們看一幅圖
圖片里有一只羊和一只狼，然后它們都屬于動物對吧，那我們可以根據(jù)動物去寫一個類
class Animal{
public String name;
public int age;
public void eat(){
System.out.println("我要睡覺啦！");
}
public void bark(){
System.out.println("我要叫啦！");
}
}
該類中，定義了動物的名字、年齡屬性以及睡覺、叫的行為。我們再繼續(xù)對狼和羊定義一個類
狼
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)，在羊和狼的類的定義時，由于它們都屬于動物，所以動物的一些屬性和行為它們都有，所以我們可以通過繼承，將羊和狼的類的代碼變得更加簡介
狼
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ù)使用
繼承的思想就是
- 抽取共性，放到基類當(dāng)中
- extends
2. 語法規(guī)則（含 super 使用）
這里我們再更加詳細(xì)的介紹繼承的語法規(guī)則，以便于解決一些疑惑的地方
語法：
class 子類 extends 父類{
}
規(guī)則：
-
Java中一個子類只能繼承一個父類（C++/python等語言支持多繼承） -
子類會繼承父類的所有
public的字段和方法 -
對于父類的
private的字段和方法，子類無法訪問（可以繼承） -
子類的實例中，也包含著父類的實例，可以使用
super關(guān)鍵字得到父類實例的引用
注意：
由于 Java 當(dāng)中只能單繼承，為了解決這個問題，后面可以通過接口來實現(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();
}
}
這就是一個簡單的子類繼承父類的使用。
我們知道創(chuàng)建一個對象分為兩步：為對象分配內(nèi)存和調(diào)用構(gòu)造類。當(dāng)我們沒有定義構(gòu)造方法時，系統(tǒng)會自動為我們構(gòu)造一個無參的構(gòu)造方法。
那如果我們在父類中主動的創(chuàng)建一個構(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)前對象的父類的引用（但這個說法不嚴(yán)謹(jǐn)，這是和 this 類比的結(jié)論）
- super()：調(diào)用父類的構(gòu)造方法
- super.父類屬性：調(diào)用父類的屬性
- super.父類方法：調(diào)用父類的方法
注意：
-
當(dāng)我們不主動創(chuàng)建構(gòu)造方法時，但不是也有系統(tǒng)主動創(chuàng)建的構(gòu)造方法嗎？因為當(dāng)我們不主動創(chuàng)建時，系統(tǒng)也主動使用了
super -
super不能和this一起使用，因為它們都要放在第一行 -
super不能放在被static修飾的方法中使用，因為它依賴于對象 -
super只會指向最直接的父類，不會指向父類的父類
3. protected 關(guān)鍵字
我們對之前學(xué)的關(guān)鍵字 public、private、默認(rèn)以及即將要學(xué)的關(guān)鍵字 protected 做一個比較，就可以得到下面的表格
| num | 范圍 | private | 默認(rèn)（包訪問權(quán)限） | protected | public |
|---|---|---|---|---|---|
| 1 | 同一包中的同一類 | ? | ? | ? | ? |
| 2 | 同一包中的不同類 | ? | ? | ? | |
| 3 | 不同包中的子類 | ? | ? | ||
| 4 | 不同包中的非子類 | ? |
我們發(fā)現(xiàn)在上述代碼中，我使用的繼承時，父類代碼的屬性都是用 public 修飾的。這樣子類就可以正常使用這些屬性，但是這就違背了“封裝”的思想。但是如果用 private 修飾，不同包的子類又不能訪問
因此出現(xiàn)了一個關(guān)鍵字 protected，使用它的話
-
對于不同包的非子類：
protected修飾的字段和方法是不能訪問的 -
對于不同包的子類和同一包的其他類：
protected修飾的字段和方法是能訪問的
學(xué)到這里，我們可以開始解決之前一些未提及的問題了：如果父類和子類都含有同一個參數(shù)，那調(diào)用時是使用哪個呢？我們來看下面的代碼
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)用時也是依靠了一個就近原則，默認(rèn)為子類中的。那么調(diào)用時想調(diào)用父類該怎么辦呢？這時我們就可以使用 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ù)雜時，如這個樣子，我們該怎么辦呢？
emmm，其實一般建議是不希望超過三層的繼承關(guān)系的，如果繼承層次太多了，就需要考慮重構(gòu)代碼。
而有時我們不知不覺就寫了很多的繼承關(guān)系，所以為了在語法上進行限制繼承，就可以使用關(guān)鍵字 final
5. final 關(guān)鍵字
之前我們了解過 final，它可以修飾一個變量或者字段，使其變成常量，不可以被修改，如
final int a=10; // a 為常量不可以被修改
而在這里，final 也能修飾類，此時被修飾的類就不能被繼承了，被叫做密封類，如
final class A{
}
此時 A 就不能被繼承了
final 也可以修飾方法，被修飾的方法叫做密封方法，至于此時 final 有什么作用，下章將會講解！
三、組合
上述重點講解了繼承相關(guān)的內(nèi)容，而繼承的意義就是：使代碼可以重復(fù)使用
而組合也是一種表達(dá)類之間關(guān)系的方式，也能夠達(dá)到代碼重用的效果
顧名思義，組合就是將各種東西組合成一個東西。比如學(xué)習(xí)，學(xué)校就是由老師、學(xué)生、教學(xué)樓等等組合而成的，我們可以寫一個代碼
class Teacher{
// ...
}
class Student{
// ...
}
public class School{
public Teacher[] teachers;
public Student[] students;
}
上述代碼就是將老師和學(xué)生的類封裝成了對象，并且作為了另一個類的字段
四、總結(jié)（含謎底）
今天這章重點講解了包和繼承相關(guān)的內(nèi)容，概念比較多，自己的理解也可能很不到位，所以寫的不好，希望大家可以理解吧！最后來揭曉我們的謎底吧！
我是謎底：
其實我自己在猜的時候一直搞不懂羊為啥叫媽媽，羊不都是 miemie~ 的叫嘛，直到我想到了 giegie~
到此這篇關(guān)于Java 基礎(chǔ)語法之解析 Java 的包和繼承的文章就介紹到這了,更多相關(guān) Java 的包和繼承內(nèi)容請搜索服務(wù)器之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持服務(wù)器之家！
nal 有什么作用，下章將會講解！
原文鏈接：https://blog.csdn.net/weixin_51367845/article/details/120244811
