〖JAVA養成計劃〗4. JAVA面向對象基礎之一！

4. JAVA面向對象基礎之一！

聲明以下內容主要參考尚學堂Java大型300集，表示感謝！

一. 面向過程和麪向對象

面向過程(Procedure Oriented)和面向對象(Object Oriented,OO)：都是對軟件分析、設計和開發的一種思想,它指導着人們以不同的方式去分析、設計和開發軟件。早期先有面向過程思想，隨着軟件規模的擴大，問題複雜性的提高，面向過程的弊端越來越明顯的顯示出來，出現了面向對象思想併成爲目前主流的方式。兩者都貫穿於軟件分析、設計和開發各個階段，對應面向對象就分別稱爲面向對象分析(OOA)、面向對象設計(OOD)和麪向對象編程(OOP)。C語言是一種典型的面向過程語言，Java是一種典型的面嚮對象語言。

面向過程思想思考問題時，我們首先思考“怎麼按步驟實現?”並將步驟對應成方法，一步一步，最終完成。這個適合簡單任務，不需要過多協作的情況下。比如，如何開車? 我們很容易就列出實現步驟：1. 發動車 2. 掛擋 3.踩油門 4. 走你

面向過程適合簡單、不需要協作的事務。 但是當我們思考比較複雜的問題，比如“如何造車?”，就會發現列出1234這樣的步驟，是不可能的。那是因爲，造車太複雜，需要很多協作才能完成。此時面向對象思想就應運而生了。

面向對象(Object)思想更契合人的思維模式。我們首先思考的是 “怎麼設計這個事物?” 比如思考造車，我們就會先思考“車怎麼設計?”，而不是“怎麼按步驟造車的問題”。這就是思維方式的轉變。

一、面向對象思想思考造車，發現車由如下對象組成：1. 輪胎，2. 發動機，3. 車殼，4. 座椅，5. 擋風玻璃。

爲了便於協作，我們找輪胎廠完成製造輪胎的步驟，發動機廠完成製造發動機的步驟;這樣，發現大家可以同時進行車的製造，最終進行組裝，大大提高了效率。但是，具體到輪胎廠的一個流水線操作，仍然是有步驟的，還是離不開面向過程思想!

們千萬不要把面向過程和麪向對象對立起來。他們是相輔相成的。面向對象離不開面向過程!

面向對象和麪向過程的總結：

都是解決問題的思維方式，都是代碼組織的方式。

解決簡單問題可以使用面向過程

解決複雜問題：宏觀上使用面向對象把握，微觀處理上仍然是面向過程。

面向對象思考方式：

遇到複雜問題，先從問題中找名詞，然後確立這些名詞哪些可以作爲類，再根據問題需求確定的類的屬性和方法，確定類之間的關係。

建議：

面向對象具有三大特徵：封裝性、繼承性和多態性，而面向過程沒有繼承性和多態性，並且面向過程的封裝只是封裝功能，而面向對象可以封裝數據和功能。所以面向對象優勢更明顯。

一個經典的比喻：面向對象是蓋澆飯、面向過程是蛋炒飯。蓋澆飯的好處就是“菜”“飯”分離，從而提高了製作蓋澆飯的靈活性。飯不滿意就換飯，菜不滿意換菜。用軟件工程的專業術語就是“可維護性”比較好，“飯” 和“菜”的耦合度比較低。

二. 對象和類的概念

我們人認識世界，其實就是面向對象的(此對象可不是男女談對象的彼對象呀)。比如現在讓大家認識一下“天使”這個新事物，天使大家沒見過吧，怎麼樣認識呢?最好的辦法就是，給你們面前擺4個天使，帶翅膀的美女，讓大家看，看完以後，即使我不說，大家下一次是不是就都認識天使了。

但是，看完10個天使後，我們總要總結一下，什麼樣的東東纔算天使?天使是無數的，總有沒見過的!所以必須總結抽象，便於認識未知事物!總結的過程就是抽象的過程。小時候，我們學自然數時怎麼定義的?像1，2，3，4…這樣的數就叫做自然數。通過抽象，我們發現天使有這樣一下特徵：

1. 帶翅膀(帶翅膀不一定是天使，還可能是鳥人)

2. 女孩(天使掉下來臉着地，也是天使!)

3. 善良

4. 頭上有光環

那麼通過這4個具體的天使，我們進行抽象，抽象出了天使的特徵，我們也可以歸納一個天使類。通過這個過程，類就是對象的抽象。

類可以看做是一個模版，或者圖紙，系統根據類的定義來造出對象。我們要造一個汽車，怎麼樣造?類就是這個圖紙，規定了汽車的詳細信息，然後根據圖紙將汽車造出來。

類：我們叫做class。對象：我們叫做Object,instance(實例)。以後我們說某個類的對象，某個類的實例。是一樣的意思。

總結：

1.對象是具體的事物;類是對對象的抽象;

2.類可以看成一類對象的模板，對象可以看成該類的一個具體實例。

3.類是用於描述同一類型的對象的一個抽象概念，類中定義了這一類對象所應具有的共同的屬性、方法。

2.1. 類的定義

類的定義方式：

//每一個源文件必須有且只有一個public class，並且類名和文件名保持一致！
public class Car {
}

class Dog{// 一個Java文件可以同時定義多個class	
}

class Seat{	
}

上面的類定義好後，沒有任何的其他信息，就跟我們拿到一張張圖紙，但是紙上沒有任何信息，這是一個空類，沒有任何實際意義。所以，我們需要定義類的具體信息。對於一個類來說，一般有三種常見的成員：屬性field、方法method、構造器constructor。這三種成員都可以定義零個或多個。如下簡單的學生類編寫

public class Student {
	//屬性(成員變量)
	int id;
	String name;
	int age;
	//方法
	void study(){
		System.out.println("正在學習！");
	}
	//構造方法
	Student(){
		
	}
}

2.2. 類的屬性和方法

屬性：用於定義該類或該類對象包含的數據或者說靜態特徵。屬性作用範圍是整個類體。在定義成員變量時可以對其初始化，如果不對其初始化，Java使用默認的值對其初始化。

屬性定義格式：[修飾符] 屬性類型屬性名 = [默認值] ;

方法：用於定義該類或該類實例的行爲特徵和功能實現。方法是類和對象行爲特徵的抽象。方法很類似於面向過程中的函數。面向過程中，函數是最基本單位，整個程序由一個個函數調用組成。面向對象中，整個程序的基本單位是類，方法是從屬於類和對象的。

屬性定義格式：

[修飾符]  方法返回值類型  方法名(形參列表) {
    // n條語句
}

2.3. 一個典型類的定義和UML圖

模擬學生使用電腦學習：

/**
 * 模型學生使用電腦，學生有自己的學好，姓名，年齡，而且使用電腦進行學習！
 * @author devinzhang
 */
class Computer {
	String brand;// 品牌
}

public class Student1 {
	// 屬性
	int id;
	String sname;
	int age;
	Computer comp;

	// 方法
	void study() {
		System.out.println(sname+"正在學習，使用"+comp.brand+"電腦！");
	}

	// 構造器
	Student1() {
	}

	public static void main(String[] args) {
		Student1 stu = new Student1();
		stu.sname = "devin zhang";
		Computer comp1 = new Computer();
		comp1.brand = "Dell";

		stu.comp = comp1;
		stu.study();
	}
}

三. 面向對象的內存分析(堆棧角度)重要

Java虛擬機的內存可以分爲三個區域：棧stack、堆heap、方法區method area。

棧的特點如下：

1. 棧描述的是方法執行的內存模型。每個方法被調用都會創建一個棧幀(存儲 局部變量、操作數、方法出口 等)

2. JVM爲每個線程創建一個棧，用於存放該線程執行方法的信息(實際參數、局部變量等)

3. 棧屬於線程私有，不能實現線程間的共享!

4. 棧的存儲特性是 “先進後出，後進先出”

5. 棧是由系統 自動分配，速度快! 棧是一個連續的內存空間!

堆的特點如下：

1. 堆用於存儲創建好的對象和數組(數組也是對象)

2. JVM只有一個堆，被所有線程共享

3. 堆是一個 不連續的內存空間，分配靈活，速度慢!

方法區(又叫靜態區)特點如下：：

1. JVM只有一個方法區，被所有線程共享!

2. 方法區實際也是堆，只是用於存儲類、常量相關的信息!

3. 用來存放程序中永遠是不變或唯一的內容。(類信息【Class對象】、靜態變量、字符串常量等)

這裏以上一節中的程序進行分析程序的執行過程：用習慣eclipse可能忘記程序是怎麼執行的，先是javac Student1.java編譯成字節碼文件，然後java Student1解釋執行。在Eclipse中調用虛擬機從java Student1開始執行。

調用java Student1命令來啓用虛擬機，畫出堆棧空間，內存圖就是下面的。

執行Student1這個類的話，首先要在內存中尋找這個類的代碼信息，這時候需要把這個代碼加載到方法區空間中。此時下圖相當於java Student1執行完了。

然後找到類裏的main入口方法(static方法)，當開始調用main方法的時候，這個時候開闢一個所謂的棧幀。main方法裏定義了stu變量，引用類型變量，目前初始是空。

執行new …，當調用new的時候，構造方法Student1()，這個時候回開闢一個新的棧幀。

開闢完之後，就開始執行這個Student1()方法，通過這個方法創建這個類的一個對象，因爲內存中已經有這個類的代碼信息了。構造器執行完之後，會在堆中新建一個對象了(釋放這個棧幀)。

下一步執行： stu.id=1001;，一次執行完這個樣子。

最後執行stu.comp = comp1;，這裏需要comp1的值賦值給comp(都是地址)。執行之後內存全部關閉！

四. 構造方法和其重載

構造器也叫構造方法(constructor)：用於對象的初始化。構造器是一個創建對象時被自動調用的特殊方法，目的是對象的初始化。構造器的名稱應與類的名稱一致。Java通過new關鍵字來調用構造器，從而返回該類的實例，是一種特殊的方法。

聲明格式：

[修飾符] 類名(形參列表){
    //n條語句
}

構造器注意一下幾點：

通過new關鍵字調用!!

構造器雖然有返回值，但是不能定義返回值類型(返回值的類型肯定是本類)，不能在構造器裏使用return返回某個值。

如果我們沒有定義構造器，則編譯器會自動定義一個無參的構造函數。如果已定義則編譯器不會自動添加!

構造器的方法名必須和類名一致!

例子：定義一個“點”(Point)類用來表示二維空間中的點(有兩個座標)。要求如下：

可以生成具有特定座標的點對象。

提供可以設置座標的方法。

提供可以計算該“點”距另外一點距離的方法。

public class Point {
	double x, y;
	//定義的構造器
	public Point(double _x, double _y) {
		x = _x;
		y = _y;
	}
	
	public double getDistance(Point p){
		return Math.sqrt((x-p.x)*(x-p.x)+(y-p.y)*(y-p.y));
	}
	
	
	public static void main(String [] args){
		Point p =new Point(3.0, 4.0);
		Point origin =new Point(0.0, 0.0);
		System.out.println(p.getDistance(origin));
	}
}

構造方法的重載： 構造方法也是方法，只不過有特殊的作用而已。與普通方法一樣，構造方法也可以重載。

例子：構造方法重載(創建不同用戶對象)

public class User {
	int id; // id
	String name; // 賬戶名
	String pwd; // 密碼
	public User() {
	}

	public User(int id, String name) {
		super();
		this.id = id;
		this.name = name;
	}

	public User(int id, String name, String pwd) {
		this.id = id;
		this.name = name;
		this.pwd = pwd;
	}

	public static void main(String[] args) {
		User u1 = new User();
		User u2 = new User(101, "devinzhang");
		User u3 = new User(101, "devinzhang", "13234");
	}

}

構造器注意一下幾點：如果方法構造中形參名與屬性名相同時，需要使用this關鍵字區分屬性與形參。this.id 表示屬性id;id表示形參id

五. 垃圾回收機制(Garbage Collection)

Java引入了垃圾回收機制，令C++程序員最頭疼的內存管理問題迎刃而解。Java程序員可以將更多的精力放到業務邏輯上而不是內存管理工作上，大大的提高了開發效率。

5.1. 垃圾回收原理和算法

內存管理：

Java的內存管理很大程度指的就是對象的管理，其中包括對象空間的分配和釋放。

對象空間的分配：使用new關鍵字創建對象即可

對象空間的釋放：將對象賦值null即可。垃圾回收器將負責回收所有”不可達”對象的內存空間。

垃圾回收過程：任何一種垃圾回收算法一般要做兩件基本事情。垃圾回收機制保證可以將“無用的對象”進行回收。無用的對象指的就是沒有任何變量引用該對象。Java的垃圾回收器通過相關算法發現無用對象，並進行清除和整理。

發現無用的對象。

回收無用對象佔用的內存空間。

垃圾回收相關算法：

1. 引用計數法：堆中每個對象都有一個引用計數。被引用一次，計數加1. 被引用變量值變爲null，則計數減1，直到計數爲0，則表示變成無用對象。優點是算法簡單，缺點是“循環引用的無用對象”無法別識別。

/**
 * 1. 引用計數法,缺點是“循環引用的無用對象”無法別識別。循環引用示例
 * @author devinzhang
 */
public class Stu {
	String name;
	Stu friend;

	public static void main(String[] args) {
		Stu s1 = new Stu();
		Stu s2 = new Stu();
		
		s1.friend=s2;
		s2.friend=s1;
		s1=null;
		s2=null;
	}
}

2. 引用可達法(根搜索算法)：程序把所有的引用關係看作一張圖，從一個節點GC ROOT開始，尋找對應的引用節點，找到這個節點以後，繼續尋找這個節點的引用節點，當所有的引用節點尋找完畢之後，剩餘的節點則被認爲是沒有被引用到的節點，即無用的節點。

5.2. 通用的分代垃圾回收機制

分代垃圾回收機制，是基於這樣一個事實：不同的對象的生命週期是不一樣的。因此，不同生命週期的對象可以採取不同的回收算法，以便提高回收效率。我們將對象分爲三種狀態：年輕代、年老代、持久代。JVM將堆內存劃分爲 Eden、Survivor 和 Tenured/Old 空間。

1. 年輕代：所有新生成的對象首先都是放在Eden區。年輕代的目標就是儘可能快速的收集掉那些生命週期短的對象，對應的是Minor GC，每次 Minor GC 會清理年輕代的內存，算法採用效率較高的複製算法，頻繁的操作，但是會浪費內存空間。當“年輕代”區域存放滿對象後，就將對象存放到年老代區域。

2. 年老代：在年輕代中經歷了N(默認15)次垃圾回收後仍然存活的對象，就會被放到年老代中。因此，可以認爲年老代中存放的都是一些生命週期較長的對象。年老代對象越來越多，我們就需要啓動Major GC和Full GC(全量回收)，來一次大掃除，全面清理年輕代區域和年老代區域。

3. 持久代：用於存放靜態文件，如Java類、方法等。持久代對垃圾回收沒有顯著影響。

Minor GC：用於清理年輕代區域。Eden區滿了就會觸發一次Minor GC。清理無用對象，將有用對象複製到“Survivor1”、“Survivor2”區中(這兩個區，大小空間也相同，同一時刻Survivor1和Survivor2只有一個在用，一個爲空)

Major GC：用於清理老年代區域。

Full GC：用於清理年輕代、年老代區域。成本較高，會對系統性能產生影響。

垃圾回收過程：

1、新創建的對象，絕大多數都會存儲在Eden中，

2、當Eden滿了（達到一定比例）不能創建新對象，則觸發垃圾回收（GC），將無用對象清理掉，然後剩餘對象複製到某個Survivor中，如S1，同時清空Eden區

3、當Eden區再次滿了，會將S1中的不能清空的對象存到另外一個Survivor中，如S2，同時將Eden區中的不能清空的對象，也複製到S1中，保證Eden和S1，均被清空。

4、重複多次(默認15次)Survivor中沒有被清理的對象，則會複製到老年代Old(Tenured)區中，

5、當Old區滿了，則會觸發一個一次完整地垃圾回收（FullGC），之前新生代的垃圾回收稱爲（minorGC）

5.3. JVM調優和Full GC

在對JVM調優的過程中，很大一部分工作就是對於Full GC的調節。有如下原因可能導致Full GC：

1.年老代(Tenured)被寫滿

2.持久代(Perm)被寫滿

3.System.gc()被顯式調用（程序建議GC啓動，不是調用GC）

4.上一次GC之後Heap的各域分配策略動態變化

5.4. 開發中容易造成內存泄露的操作

在實際開發中，經常會造成系統的崩潰。如下這些操作我們應該注意這些使用場景。注意如下四種情況時最容易造成內存泄露的場景：

創建大量無用對象：比如，我們在需要大量拼接字符串時，使用了String而不是StringBuilder。

String str = "";
for (int i = 0; i < 10000; i++) {   
    str += i;     //相當於產生了10000個String對象
}

靜態集合類的使用：像HashMap、Vector、List等的使用最容易出現內存泄露，這些靜態變量的生命週期和應用程序一致，所有的對象Object也不能被釋放。

各種連接對象(IO流對象、數據庫連接對象、網絡連接對象)未關閉： IO流對象、數據庫連接對象、網絡連接對象等連接對象屬於物理連接，和硬盤或者網絡連接，不使用的時候一定要關閉。

監聽器的使用：釋放對象時，沒有刪除相應的監聽器。

本節要點：

1. 程序員無權調用垃圾回收器。

2. 程序員可以調用System.gc()，該方法只是通知JVM，並不是運行垃圾回收器。儘量少用，會申請啓動Full GC，成本高，影響系統性能。

3. finalize方法，是Java提供給程序員用來釋放對象或資源的方法，但是儘量少用。

六. this關鍵字和static關鍵字

6.1. this關鍵字

對象創建的過程和this的本質： 構造方法是創建Java對象的重要途徑，通過new關鍵字調用構造器時，構造器也確實返回該類的對象，但這個對象並不是完全由構造器負責創建。創建一個對象分爲如下四步：

1. 分配對象空間，並將對象成員變量初始化爲0或空

2. 執行屬性值的顯示初始化

3. 執行構造方法(執行構造方法之前，已經創建了對象。)

4. 返回對象的地址給相關的變量

this的本質 ：就是“創建好的對象的地址”! 由於在構造方法調用前，對象已經創建。因此，在構造方法中也可以使用this代表“當前對象” 。

this最常的用法：

1. 在程序中產生二義性之處，應使用this來指明當前對象;普通方法中，this總是指向調用該方法的對象。構造方法中，this總是指向正要初始化的對象。

2. 使用this關鍵字調用重載的構造方法，避免相同的初始化代碼。但只能在構造方法中用，並且必須位於構造方法的第一句。

3. this不能用於static方法中。

public class TestThis {
    int a, b, c;
 
    TestThis() {
        System.out.println("正要初始化一個Hello對象");
    }
    TestThis(int a, int b) {
        // TestThis(); //這樣是無法調用構造方法的！
        this(); // 調用無參的構造方法，並且必須位於第一行！
        a = a;// 這裏都是指的局部變量而不是成員變量
// 這樣就區分了成員變量和局部變量. 這種情況佔了this使用情況大多數！
        this.a = a;
        this.b = b;
    }
    TestThis(int a, int b, int c) {
        this(a, b); // 調用帶參的構造方法，並且必須位於第一行！
        this.c = c;
    }
 
    void sing() {
    }
    void eat() {
        this.sing(); // 調用本類中的sing();
        System.out.println("你媽媽喊你回家喫飯！");
    }
 
    public static void main(String[] args) {
        TestThis hi = new TestThis(2, 3);
        hi.eat();
    }
}

6.2. static關鍵字

在類中，用static聲明的成員變量爲靜態成員變量，也稱爲類變量。類變量的生命週期和類相同，在整個應用程序執行期間都有效。它有如下特點：

1. 爲該類的公用變量，屬於類，被該類的所有實例共享，在類被載入時被顯式初始化。

2. 對於該類的所有對象來說，static成員變量只有一份。 被該類的所有對象共享!!

3. 一般用“類名.類屬性/方法”來調用。(也可以通過對象引用或類名(不需要實例化)訪問靜態成員。)

4. 在static方法中不可直接訪問非static的成員。

核心要點：

static修飾的成員變量和方法，從屬於類。

普通變量和方法從屬於對象的。

/**
 * 測試static關鍵字的用法
 * @author devinzhang
 */
public class User2 {
	int id; // id
	String name; // 賬戶名
	String pwd; // 密碼

	static String company = "阿里巴巴"; // 公司名稱

	public User2(int id, String name) {
		this.id = id;
		this.name = name;
	}

	// 登錄系統
	public void login() {
		printCompany();
		System.out.println(company);
		System.out.println("登錄" + name);
	}

	public static void printCompany() {
		// login();//調用非靜態成員，編譯就會報錯
		System.out.println(company);
	}

	public static void main(String[] args) {
		User2 u = new User2(101, "devinzhang");
		User2.printCompany(); // 一般用“類名.類屬性/方法”來調用。
		User2.company = "騰訊";
		User2.printCompany();
	}

}

七. 靜態初始化塊和參數傳值機制

7.1. 靜態初始化塊

構造方法用於對象的初始化！ 靜態初始化塊，用於類的初始化操作！ 在靜態初始化塊中不能直接訪問非static成員。

注意事項： 靜態初始化塊執行順序(之後介紹完繼承再看這裏)：

1. 上溯到Object類，先執行Object的靜態初始化塊，再向下執行子類的靜態初始化塊，直到我們的類的靜態初始化塊爲止。

2. 構造方法執行順序和上面順序一樣!!

/**
 * 測試static初始化塊。
 * 
 * @author devinzhang
 *
 */
public class User {

	int id; // id
	String name; // 賬戶名
	String pwd; // 密碼， 成員變量；
	static String company;// 公司名稱，靜態成員變量；

	public User() {
		System.out.println("調用構造器！");
	}

	// 靜態代碼塊
	static {
		System.out.println("執行類的初始化工作！");
		company = "阿里巴巴";
		printCompany();
	}

	public static void printCompany() {
		System.out.println(company);
	}

	public static void main(String[] args) {
		User u1 = new User();
	}

}

7.2. 參數傳遞機制

Java中，方法中所有參數都是“值傳遞”，也就是 “傳遞的是值的副本”。也就是說，我們得到的是“原參數的複印件，而不是原件”。因此，複印件改變不會影響原件。

基本數據類型參數的傳值：傳遞的是值的副本。副本改變不會影響原件。

引用類型參數的傳值：傳遞的是值的副本。但是引用類型指的是“對象的地址”。因此，副本和原參數都指向了同一個“地址”，改變“副本指向地址對象的值，也意味着原參數指向對象的值也發生了改變”。

測試參數傳遞機制例子：

public class User4 {
	int id;
	String name;
	String pwd;

	public User4(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public void testParameterTransfer01(User4 u) {
		u.name = "張開放";
	}

	public void testParameterTransfer02(User4 u) {
		u = new User4(200, "王雪豔");
	}

	public static void main(String[] args) {
		User4 u1 = new User4(100, "胡帆");

		u1.testParameterTransfer01(u1);
		System.out.println(u1.name);

		u1.testParameterTransfer02(u1);
		System.out.println(u1.name);

	}

}

八. 包和package

包機制是Java中管理類的重要手段。開發中，我們會遇到大量同名的類，通過包我們很容易對解決類重名的問題，也可以實現對類的有效管理。包對於類，相當於文件夾對於文件的作用。

我們通過package實現對類的管理，package的使用有兩個要點：

1. 通常是類的第一句非註釋性語句。

2. 包名：域名倒着寫即可，再加上模塊名，便於內部管理類。

// package的命名舉例
com.sun.test;
com.oracle.test;
cn.sxt.gao.test;
cn.sxt.gao.view;
cn.sxt.gao.view.model;

注意事項：

1. 寫項目時都要加包，不要使用默認包。

2. com.gao和com.gao.car，這兩個包沒有包含關係，是兩個完全獨立的包。只是邏輯上看起來後者是前者的一部分。

// package的使用
package cn.sxt;
public class Test {
    public static void main(String[] args) {
        System.out.println("helloworld");
    }
}

8.1. JDK中的主要包

Java中的常用包	說明
java.lang	包含一些Java語言的核心類，如String、Math、Integer、System和Thread，提供常用功能。
java.awt	包含了構成抽象窗口工具集（abstract window toolkits）的多個類，這些類被用來構建和管理應用程序的圖形用戶界面(GUI)。
java.io	包含能提供多種輸入/輸出功能的類。
java.net	包含執行與網絡相關的操作的類。
java.util	包含一些實用工具類，如定義系統特性、使用與日期日曆相關的函數。

8.2. 導入類import

如果我們要使用其他包的類，需要使用import導入，從而可以在本類中直接通過類名來調用，否則就需要書寫類的完整包名和類名。import後，便於編寫代碼，提高可維護性。

注意事項：

1. Java會默認導入java.lang包下所有的類，因此這些類我們可以直接使用。

2. 如果導入兩個同名的類，只能用包名+類名來顯示調用相關類：

8.3. 靜態導入

靜態導入(static import)是在JDK1.5新增加的功能，其作用是用於導入指定類的靜態屬性，這樣我們可以直接使用靜態屬性。

package leetcode;

//以下兩種靜態導入的方式二選一即可
import static java.lang.Math.*; //導入Math類的所有靜態屬性
import static java.lang.Math.PI; //導入Math類的PI屬性

public class Daoru {
	public static void main(String[] args) {
		System.out.println(PI);
		System.out.println(random());
	}

}

九. 總結

1. 面向對象可以幫助我們從宏觀上把握、從整體上分析整個系統。但是具體到實現部分的微觀操作(就是一個個方法)，仍然需要面向過程的思路去處理。

2. 類可以看成一類對象的模板，對象可以看成該類的一個具體實例。

3. 對於一個類來說，一般有三種常見的成員：屬性field、方法method、構造器constructor。

4. 構造器也叫構造方法，用於對象的初始化。構造器是一個創建對象時被自動調用的特殊方法，目的是對象的初始化。構造器的名稱應與類的名稱一致。

5. Java引入了垃圾回收機制，令C++程序員最頭疼的內存管理問題迎刃而解。Java程序員可將更多的精力放到業務邏輯上而不是內存管理工作，大大提高開發效率。

6. this的本質就是“創建好的對象的地址”! this不能用於static方法中。

7. 在類中，用static聲明的成員變量爲靜態成員變量，也稱爲類變量。類變量的生命週期和類相同，在整個應用程序執行期間都有效。在static方法中不可直接訪問非static的成員。

8. Java方法中所有參數都是“值傳遞”，也就是“傳遞的是值的副本”。也就是說，我們得到的是“原參數的複印件，而不是原件”。因此，複印件改變不會影響原件。

9. 通過package實現對類的管理;如果我們要使用其他包的類，需要使用import導入，從而可以在本類中直接通過類名來調用。

〖JAVA養成計劃〗4. JAVA面向對象基礎之一！

文章目錄

一. 面向過程和麪向對象

二. 對象和類的概念

2.1. 類的定義

2.2. 類的屬性和方法

2.3. 一個典型類的定義和UML圖

三. 面向對象的內存分析(堆棧角度)重要

四. 構造方法和其重載

五. 垃圾回收機制(Garbage Collection)

5.1. 垃圾回收原理和算法

5.2. 通用的分代垃圾回收機制

5.3. JVM調優和Full GC

5.4. 開發中容易造成內存泄露的操作

六. this關鍵字和static關鍵字

6.1. this關鍵字

6.2. static關鍵字

七. 靜態初始化塊和參數傳值機制

7.1. 靜態初始化塊

7.2. 參數傳遞機制

八. 包和package

8.1. JDK中的主要包

8.2. 導入類import

8.3. 靜態導入

九. 總結

『論文筆記』CBAM:Convolutional Block Attention Module(注意力機制)+TensorFlow2.0復現！

『自己的工作4』TensorFlow2.0自動微分和手工求導的結果對比！

〖TensorFlow2.0筆記23〗TensorFlow2.0學習筆記總結!

矩陣論筆記：詳細介紹矩陣的三角分解(LR分解)+平方根分解(Cholesky分解)！

『論文筆記』ACNet: Strengthening the Kernel Skeletons for Powerful CNN via Asymmetric Convolution Blocks！

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結