1，JDK：Java Development Kit，java的開發和運行環境，java的開發工具和jre。

2，JRE：Java Runtime Environment，java程序的運行環境，java運行的所需的類庫+JVM(java虛擬機)。

3，配置環境變量：讓java jdkbin目錄下的工具，可以在任意目錄下運行，原因是，將該工具所在目錄告訴了系統，當使用該工具時，由系統幫我們去找指定的目錄。

環境變量的配置：

1)永久配置方式：JAVA_HOME=%安裝路徑%Javajdk

path=%JAVA_HOME%bin

2)臨時配置方式：set path=%path%;C:Program FilesJavajdkbin

特點：系統默認先去當前路徑下找要執行的程序，如果沒有，再去path中設置的路徑下找。

classpath的配置:

1)永久配置方式：classpath=.;c:;e:

2)臨時配置方式：set classpath=.;c:;e:

注意：在定義classpath環境變量時，需要注意的情況

如果沒有定義環境變量classpath，java啟動jvm后，會在當前目錄下查找要運行的類文件；

如果指定了classpath，那么會在指定的目錄下查找要運行的類文件。

還會在當前目錄找嗎？兩種情況：

CLASSPATH是什么？它的作用是什么？

它是javac編譯器的一個環境變量。它的作用與import、package關鍵字有關。當你寫下improt java.util.*時，編譯器面對import關鍵字時，就知道你要引入java.util這個package中的類；但是編譯器如何知道你把這個package放在哪里了呢？所以你首先得告訴編譯器這個package的所在位置；如何告訴它呢？就是設置CLASSPATH啦 :) 如果java.util這個package在c:/jdk/ 目錄下，你得把c:/jdk/這個路徑設置到CLASSPATH中去！當編譯器面對import java.util.*這個語句時，它先會查找CLASSPATH所指定的目錄，并檢視子目錄java/util是否存在，然后找出名稱吻合的已編譯文件(.class文件)。如果沒有找到就會報錯！CLASSPATH有點像c/c++編譯器中的INCLUDE路徑的設置哦，是不是？當c/c++編譯器遇到include 這樣的語句，它是如何運作的？哦，其實道理都差不多！搜索INCLUDE路徑，檢視文件！當你自己開發一個package時，然后想要用這個package中的類；自然，你也得把這個package所在的目錄設置到CLASSPATH中去！CLASSPATH的設定，對JAVA的初學者而言是一件棘手的事。所以Sun讓JAVA2的JDK更聰明一些。你會發現，在你安裝之后，即使完全沒有設定CLASSPATH，你仍然能夠編譯基本的JAVA程序，并且加以執行。

PATH環境變量

PATH環境變量。作用是指定命令搜索路徑，在命令行下面執行命令如javac編譯java程序時，它會到PATH變量所指定的路徑中查找看是否能找到相應的命令程序。我們需要把jdk安裝目錄下的bin目錄增加到現有的PATH變量中，bin目錄中包含經常要用到的可執行文件如javac/java/javadoc等待，設置好PATH變量后，就可以在任何目錄下執行javac/java等工具了。

4，javac命令和java命令做什么事情呢？

要知道java是分兩部分的：一個是編譯，一個是運行。

javac：負責的是編譯的部分，當執行javac時，會啟動java的編譯器程序。對指定擴展名的.java文件進行編譯。生成了jvm可以識別的字節碼文件。也就是class文件，也就是java的運行程序。

java：負責運行的部分.會啟動jvm.加載運行時所需的類庫,并對class文件進行執行.

一個文件要被執行,必須要有一個執行的起始點,這個起始點就是main函數.

標示符：

1)，數字不可以開頭。

2)，不可以使用關鍵字。

變量的作用域和生存期:

1. 變量的作用域：作用域從變量定義的位置開始，到該變量所在的那對大括號結束；

生命周期：變量從定義的位置開始就在內存中活了；

變量到達它所在的作用域的時候就在內存中消失了；

數據類型：

1)：基本數據類型：byte、short、int、long、float、double、char、boolean

運算符號：

4)、邏輯運算符。

& | ^ ! && ||

邏輯運算符除了 ! 外都是用于連接兩個boolean類型表達式。

&: 只有兩邊都為true結果是true。否則就是false。

|:只要兩邊都為false結果是false，否則就是true

^:異或：和或有點不一樣。

兩邊結果一樣，就為false。

兩邊結果不一樣，就為true.

& 和 &&區別： & ：無論左邊結果是什么，右邊都參與運算。

&&:短路與，如果左邊為false，那么右邊不參數與運算。

| 和|| 區別：|：兩邊都運算。

||：短路或，如果左邊為true，那么右邊不參與運算。

5)、位運算符:用于操作二進制位的運算符。

& | ^

<< >> >>>(無符號右移)

練習：對兩個變量的數據進行互換。不需要第三方變量。

int a = 3,b = 5;-->b = 3,a = 5;

方法一：

a = a + b; a = 8;

b = a - b; b = 3;

a = a - b; a = 5;

方法二：

a = a ^ b;//

b = a ^ b;//b = a ^ b ^ b = a

a = a ^ b;//a = a ^ b ^ a = b;

練習：高效的算出 2*8 = 2<<3;

重載的定義是：在一個類中，如果出現了兩個或者兩個以上的同名函數，只要它們的參數的個數，或者參數的類型不同，即可稱之為該函數重載了。

如何區分重載：當函數同名時，只看參數列表。和返回值類型沒關系。

重寫：父類與子類之間的多態性，對父類的函數進行重新定義。如果在子類中定義某方法與其父類有相同的名稱和參數，我們說該方法被重寫 (Overriding)。

Java內存管理

Java內存管理：深入Java內存區域

Java與C++之間有一堵由內存動態分配和垃圾收集技術所圍成的高墻，墻外面的人想進去，墻里面的人卻想出來。

概述：

對于從事C和C++程序開發的開發人員來說，在內存管理領域，他們既是擁有最高權力的皇帝，又是從事最基礎工作的勞動人民—既擁有每一個對象的"所有權"，又擔負著每一個對象生命開始到終結的維護責任。

對于Java程序員來說，在虛擬機的自動內存管理機制的幫助下，不再需要為每一個new操作去寫配對的delete/free代碼，而且不容易出現內存泄漏和內存溢出問題，看起來由虛擬機管理內存一切都很美好。不過，也正是因為Java程序員把內存控制的權力交給了Java虛擬機，一旦出現內存泄漏和溢出方面的問題，如果不了解虛擬機是怎樣使用內存的，那排查錯誤將會成為一項異常艱難的工作。

運行時數據區域

Java虛擬機在執行Java程序的過程中會把它所管理的內存劃分為若干個不同的數據區域。這些區域都有各自的用途，以及創建和銷毀的時間，有的區域隨著虛擬機進程的啟動而存在，有些區域則是依賴用戶線程的啟動和結束而建立和銷毀。根據《Java虛擬機規范(第2版)》的規定，Java虛擬機所管理的內存將會包括以下幾個運行時數據區域，如下圖所示：

程序計數器　　　　　

　　程序計數器(Program Counter Register)是一塊較小的內存空間，它的作用可以看做是當前線程所執行的字節碼的行號指示器。在虛擬機的概念模型里(僅是概念模型，各種虛擬機可能會通過一些更高效的方式去實現)，字節碼解釋器工作時就是通過改變這個計數器的值來選取下一條需要執行的字節碼指令，分支、循環、跳轉、異常處理、線程恢復等基礎功能都需要依賴這個計數器來完成。 由于Java虛擬機的多線程是通過線程輪流切換并分配處理器執行時間的方式來實現的，在任何一個確定的時刻，一個處理器(對于多核處理器來說是一個內核)只會執行一條線程中的指令。因此，為了線程切換后能恢復到正確的執行位置，每條線程都需要有一個獨立的程序計數器，各條線程之間的計數器互不影響，獨立存儲，我們稱這類內存區域為"線程私有"的內存。 如果線程正在執行的是一個Java方法，這個計數器記錄的是正在執行的虛擬機字節碼指令的地址；如果正在執行的是Natvie方法，這個計數器值則為空(Undefined)。此內存區域是唯一一個在Java虛擬機規范中沒有規定任何OutOfMemoryError情況的區域。

Java虛擬機棧

　　與程序計數器一樣，Java虛擬機棧(Java Virtual Machine Stacks)也是線程私有的，它的生命周期與線程相同。虛擬機棧描述的是Java方法執行的內存模型：每個方法被執行的時候都會同時創建一個棧幀(Stack Frame)用于存儲局部變量表、操作棧、動態鏈接、方法出口等信息。每一個方法被調用直至執行完成的過程，就對應著一個棧幀在虛擬機棧中從入棧到出棧的過程。

經常有人把Java內存區分為堆內存(Heap)和棧內存(Stack)，這種分法比較粗糙，Java內存區域的劃分實際上遠比這復雜。這種劃分方式的流行只能說明大多數程序員最關注的、與對象內存分配關系最密切的內存區域是這兩塊。其中所指的"堆"在后面會專門講述，而所指的"棧"就是現在講的虛擬機棧，或者說是虛擬機棧中的局部變量表部分。

局部變量表存放了編譯期可知的各種基本數據類型(boolean、byte、char、short、int、float、long、double)、對象引用(reference類型)，它不等同于對象本身，根據不同的虛擬機實現，它可能是一個指向對象起始地址的引用指針，也可能指向一個代表對象的句柄或者其他與此對象相關的位置)和returnAddress類型(指向了一條字節碼指令的地址)。

其中64位長度的long和double類型的數據會占用2個局部變量空間(Slot)，其余的數據類型只占用1個。局部變量表所需的內存空間在編譯期間完成分配，當進入一個方法時，這個方法需要在幀中分配多大的局部變量空間是完全確定的，在方法運行期間不會改變局部變量表的大小。 在Java虛擬機規范中，對這個區域規定了兩種異常狀況：如果線程請求的棧深度大于虛擬機所允許的深度，將拋出StackOverflowError異常；如果虛擬機棧可以動態擴展(當前大部分的Java虛擬機都可動態擴展，只不過Java虛擬機規范中也允許固定長度的虛擬機棧)，當擴展時無法申請到足夠的內存時會拋出OutOfMemoryError異常。

本地方法棧

　　本地方法棧(Native Method Stacks)與虛擬機棧所發揮的作用是非常相似的，其區別不過是虛擬機棧為虛擬機執行Java方法(也就是字節碼)服務，而本地方法棧則是為虛擬機使用到的Native方法服務。虛擬機規范中對本地方法棧中的方法使用的語言、使用方式與數據結構并沒有強制規定，因此具體的虛擬機可以自由實現它。甚至有的虛擬機(譬如Sun HotSpot虛擬機)直接就把本地方法棧和虛擬機棧合二為一。與虛擬機棧一樣，本地方法棧區域也會拋出StackOverflowError和OutOfMemoryError異常。

Java堆

　　對于大多數應用來說，Java堆(Java Heap)是Java虛擬機所管理的內存中最大的一塊。Java堆是被所有線程共享的一塊內存區域，在虛擬機啟動時創建。此內存區域的唯一目的就是存放對象實例，幾乎所有的對象實例都在這里分配內存。這一點在Java虛擬機規范中的描述是：所有的對象實例以及數組都要在堆上分配，但是隨著JIT編譯器的發展與逃逸分析技術的逐漸成熟，棧上分配、標量替換優化技術將會導致一些微妙的變化發生，所有的對象都分配在堆上也漸漸變得不是那么"絕對"了。

　　Java堆是垃圾收集器管理的主要區域，因此很多時候也被稱做"GC堆"(Garbage Collected Heap，幸好國內沒翻譯成"垃圾堆")。如果從內存回收的角度看，由于現在收集器基本都是采用的分代收集算法，所以Java堆中還可以細分為：新生代和老年代；再細致一點的有Eden空間、From Survivor空間、To Survivor空間等。如果從內存分配的角度看，線程共享的Java堆中可能劃分出多個線程私有的分配緩沖區(Thread Local Allocation Buffer，TLAB)。不過，無論如何劃分，都與存放內容無關，無論哪個區域，存儲的都仍然是對象實例，進一步劃分的目的是為了更好地回收內存，或者更快地分配內存。在本章中，我們僅僅針對內存區域的作用進行討論，Java堆中的上述各個區域的分配和回收等細節將會是下一章的主題。

　　根據Java虛擬機規范的規定，Java堆可以處于物理上不連續的內存空間中，只要邏輯上是連續的即可，就像我們的磁盤空間一樣。在實現時，既可以實現成固定大小的，也可以是可擴展的，不過當前主流的虛擬機都是按照可擴展來實現的(通過-Xmx和-Xms控制)。如果在堆中沒有內存完成實例分配，并且堆也無法再擴展時，將會拋出OutOfMemoryError異常。

方法區

　　方法區(Method Area)與Java堆一樣，是各個線程共享的內存區域，它用于存儲已被虛擬機加載的類信息、常量、靜態變量、即時編譯器編譯后的代碼等數據。雖然Java虛擬機規范把方法區描述為堆的一個邏輯部分，但是它卻有一個別名叫做Non-Heap(非堆)，目的應該是與Java堆區分開來。

　　對于習慣在HotSpot虛擬機上開發和部署程序的開發者來說，很多人愿意把方法區稱為"永久代"Permanent Generation)，本質上兩者并不等價，僅僅是因為HotSpot虛擬機的設計團隊選擇把GC分代收集擴展至方法區，或者說使用永久代來實現方法區而已。對于其他虛擬機(如BEA JRockit、IBM J9等)來說是不存在永久代的概念的。即使是HotSpot虛擬機本身，根據官方發布的路線圖信息，現在也有放棄永久代并"搬家"至Native Memory來實現方法區的規劃了。

　　Java虛擬機規范對這個區域的限制非常寬松，除了和Java堆一樣不需要連續的內存和可以選擇固定大小或者可擴展外，還可以選擇不實現垃圾收集。相對而言，垃圾收集行為在這個區域是比較少出現的，但并非數據進入了方法區就如永久代的名字一樣"永久"存在了。這個區域的內存回收目標主要是針對常量池的回收和對類型的卸載，一般來說這個區域的回收"成績"比較難以令人滿意，尤其是類型的卸載，條件相當苛刻，但是這部分區域的回收確實是有必要的。在Sun公司的BUG列表中，　　曾出現過的若干個嚴重的BUG就是由于低版本的HotSpot虛擬機對此區域未完全回收而導致內存泄漏。根據Java虛擬機規范的規定，當方法區無法滿足內存分配需求時，將拋出OutOfMemoryError異常。

運行時常量池

　　運行時常量池(Runtime Constant Pool)是方法區的一部分。Class文件中除了有類的版本、字段、方法、接口等描述等信息外，還有一項信息是常量池(Constant Pool Table)，用于存放編譯期生成的各種字面量和符號引用，這部分內容將在類加載后存放到方法區的運行時常量池中。 Java虛擬機對Class文件的每一部分(自然也包括常量池)的格式都有嚴格的規定，每一個字節用于存儲哪種數據都必須符合規范上的要求，這樣才會被虛擬機認可、裝載和執行。但對于運行時常量池，Java虛擬機規范沒有做任何細節的要求，不同的提供商實現的虛擬機可以按照自己的需要來實現這個內存區域。不過，一般來說，除了保存Class文件中描述的符號引用外，還會把翻譯出來的直接引用也存儲在運行時常量池中。運行時常量池相對于Class文件常量池的另外一個重要特征是具備動態性，Java語言并不要求常量一定只能在編譯期產生，也就是并非預置入Class文件中常量池的內容才能進入方法區運行時常量池，運行期間也可能將新的常量放入池中，這種特性被開發人員利用得比較多的便是String類的intern()方法。既然運行時常量池是方法區的一部分，自然會受到方法區內存的限制，當常量池無法再申請到內存時會拋出OutOfMemoryError異常。

對象訪問

　　介紹完Java虛擬機的運行時數據區之后，我們就可以來探討一個問題：在Java語言中，對象訪問是如何進行的？對象訪問在Java語言中無處不在，是最普通的程序行為，但即使是最簡單的訪問，也會卻涉及Java棧、Java堆、方法區這三個最重要內存區域之間的關聯關系，如下面的這句代碼：

　　　　　　　　　　Object obj = new Object();

假設這句代碼出現在方法體中，那"Object obj"這部分的語義將會反映到Java棧的本地變量表中，作為一個reference類型數據出現。而"new Object()"這部分的語義將會反映到Java堆中，形成一塊存儲了Object類型所有實例數據值(Instance Data，對象中各個實例字段的數據)的結構化內存，根據具體類型以及虛擬機實現的對象內存布局(Object Memory Layout)的不同，這塊內存的長度是不固定的。另外，在Java堆中還必須包含能查找到此對象類型數據(如對象類型、父類、實現的接口、方法等)的地址信息，這些類型數據則存儲在方法區中。

　　由于reference類型在Java虛擬機規范里面只規定了一個指向對象的引用，并沒有定義這個引用應該通過哪種方式去定位，以及訪問到Java堆中的對象的具體位置，因此不同虛擬機實現的對象訪問方式會有所不同，主流的訪問方式有兩種：使用句柄和直接指針。 如果使用句柄訪問方式，Java堆中將會劃分出一塊內存來作為句柄池，reference中存儲的就是對象的句柄地址，而句柄中包含了對象實例數據和類型數據各自的具體地址信息，如下圖所示：

　　如果使用的是直接指針訪問方式，Java 堆對象的布局中就必須考慮如何放置訪問類型數據的相關信息，reference中直接存儲的就是對象地址，如下圖所示：

　　這兩種對象的訪問方式各有優勢，使用句柄訪問方式的最大好處就是reference中存儲的是穩定的句柄地址，在對象被移動(垃圾收集時移動對象是非常普遍的行為)時只會改變句柄中的實例數據指針，而reference本身不需要被修改。使用直接指針訪問方式的最大好處就是速度更快，它節省了一次指針定位的時間開銷，由于對象的訪問在Java中非常頻繁，因此這類開銷積少成多后也是一項非常可觀的執行成本。就本書討論的主要虛擬機Sun HotSpot而言，它是使用第二種方式進行對象訪問的，但從整個軟件開發的范圍來看，各種語言和框架使用句柄來訪問的情況也十分常見。

類

匿名對象使用場景：

1：當對方法只進行一次調用的時候，可以使用匿名對象。

2：當對象對成員進行多次調用時，不能使用匿名對象。必須給對象起名字。

類中怎么沒有定義主函數呢？

注意：主函數的存在，僅為該類是否需要獨立運行，如果不需要，主函數是不用定義的。

主函數的解釋：保證所在類的獨立運行，是程序的入口，被jvm調用。

成員變量和局部變量的區別：

1：成員變量直接定義在類中。

局部變量定義在方法中，參數上，語句中。

2：成員變量在這個類中有效。

局部變量只在自己所屬的大括號內有效，大括號結束，局部變量失去作用域。

3：成員變量存在于堆內存中，隨著對象的產生而存在，消失而消失。

局部變量存在于棧內存中，隨著所屬區域的運行而存在，結束而釋放。

構造函數：用于給對象進行初始化，是給與之對應的對象進行初始化，它具有針對性，函數中的一種。

特點：

1：該函數的名稱和所在類的名稱相同。

2：不需要定義返回值類型。

3：該函數沒有具體的返回值。

記住：所有對象創建時，都需要初始化才可以使用。

注意事項：一個類在定義時，如果沒有定義過構造函數，那么該類中會自動生成一個空參數的構造函數，為了方便該類創建對象，完成初始化。如果在類中自定義了構造函數，那么默認的構造函數就沒有了。

一個類中，可以有多個構造函數，因為它們的函數名稱都相同，所以只能通過參數列表來區分。所以，一個類中如果出現多個構造函數。它們的存在是以重載體現的。

構造代碼塊和構造函數有什么區別？

構造代碼塊：是給所有的對象進行初始化，也就是說，所有的對象都會調用一個代碼塊。只要對象一建立。就會調用這個代碼塊。

構造函數：是給與之對應的對象進行初始化。它具有針對性。

執行順序：(優先級從高到低。)靜態代碼塊>mian方法>構造代碼塊>構造方法。其中靜態代碼塊只執行一次。構造代碼塊在每次創建對象是都會執行。

靜態代碼塊的作用：比如我們在調用C語言的動態庫時會可把.so文件放在此處。

構造代碼塊的功能：(可以把不同構造方法中相同的共性的東西寫在它里面)。例如：比如不論任何機型的電腦都有開機這個功能，此時我們就可以把這個功能定義在構造代碼塊內。

Person p = new Person();

創建一個對象都在內存中做了什么事情？

1：先將硬盤上指定位置的Person.class文件加載進內存。

2：執行main方法時，在棧內存中開辟了main方法的空間(壓棧-進棧)，然后在main方法的棧區分配了一個變量p。

3：在堆內存中開辟一個實體空間，分配了一個內存首地址值。new

4：在該實體空間中進行屬性的空間分配，并進行了默認初始化。

5：對空間中的屬性進行顯示初始化。

6：進行實體的構造代碼塊初始化。

7：調用該實體對應的構造函數，進行構造函數初始化。()

8：將首地址賦值給p ，p變量就引用了該實體。(指向了該對象)

封 裝(面向對象特征之一)：是指隱藏對象的屬性和實現細節，僅對外提供公共訪問方式。

好處：將變化隔離；便于使用；提高重用性；安全性。

封裝原則：將不需要對外提供的內容都隱藏起來，把屬性都隱藏，提供公共方法對其訪問。

this:代表對象。就是所在函數所屬對象的引用。

this到底代表什么呢？哪個對象調用了this所在的函數，this就代表哪個對象，就是哪個對象的引用。

開發時，什么時候使用this呢？

在定義功能時，如果該功能內部使用到了調用該功能的對象，這時就用this來表示這個對象。

this 還可以用于構造函數間的調用。

調用格式：this(實際參數)；

this對象后面跟上 . 調用的是成員屬性和成員方法(一般方法)；

this對象后面跟上 () 調用的是本類中的對應參數的構造函數。

注意：用this調用構造函數，必須定義在構造函數的第一行。因為構造函數是用于初始化的，所以初始化動作一定要執行。否則編譯失敗。

static：★★★ 關鍵字，是一個修飾符，用于修飾成員(成員變量和成員函數)。

特點：

1、static變量

　按照是否靜態的對類成員變量進行分類可分兩種：一種是被static修飾的變量，叫靜態變量或類變量；另一種是沒有被static修飾的變量，叫實例變量。兩者的區別是：

　對于靜態變量在內存中只有一個拷貝(節省內存)，JVM只為靜態分配一次內存，在加載類的過程中完成靜態變量的內存分配，可用類名直接訪問(方便)，當然也可以通過對象來訪問(但是這是不推薦的)。

　對于實例變量，沒創建一個實例，就會為實例變量分配一次內存，實例變量可以在內存中有多個拷貝，互不影響(靈活)。

2、靜態方法

　靜態方法可以直接通過類名調用，任何的實例也都可以調用，因此靜態方法中不能用this和super關鍵字，不能直接訪問所屬類的實例變量和實例方法(就是不帶static的成員變量和成員成員方法)，只能訪問所屬類的靜態成員變量和成員方法。因為實例成員與特定的對象關聯！這個需要去理解，想明白其中的道理，不是記憶！！！

　因為static方法獨立于任何實例，因此static方法必須被實現，而不能是抽象的abstract。

3、static代碼塊

　static代碼塊也叫靜態代碼塊，是在類中獨立于類成員的static語句塊，可以有多個，位置可以隨便放，它不在任何的方法體內，JVM加載類時會執行這些靜態的代碼塊，如果static代碼塊有多個，JVM將按照它們在類中出現的先后順序依次執行它們，每個代碼塊只會被執行一次。

4、static和final一塊用表示什么

static final用來修飾成員變量和成員方法，可簡單理解為"全局常量"！

對于變量，表示一旦給值就不可修改，并且通過類名可以訪問。

對于方法，表示不可覆蓋，并且可以通過類名直接訪問。

備注：

1，有些數據是對象特有的數據，是不可以被靜態修飾的。因為那樣的話，特有數據會變成對象的共享數據。這樣對事物的描述就出了問題。所以，在定義靜態時，必須要明確，這個數據是否是被對象所共享的。

2，靜態方法只能訪問靜態成員，不可以訪問非靜態成員。

(這句話是針對同一個類環境下的，比如說，一個類有多個成員(屬性，方法，字段)，靜態方法A，那么可以訪問同類名下其他靜態成員，你如果訪問非靜態成員就不行)

因為靜態方法加載時，優先于對象存在，所以沒有辦法訪問對象中的成員。

3，靜態方法中不能使用this，super關鍵字。

因為this代表對象，而靜態在時，有可能沒有對象，所以this無法使用。

4，主函數是靜態的。

成員變量和靜態變量的區別：

1，成員變量所屬于對象。所以也稱為實例變量。

靜態變量所屬于類。所以也稱為類變量。

2，成員變量存在于堆內存中。

靜態變量存在于方法區中。

3，成員變量隨著對象創建而存在。隨著對象被回收而消失。

靜態變量隨著類的加載而存在。隨著類的消失而消失。

4，成員變量只能被對象所調用 。

靜態變量可以被對象調用，也可以被類名調用。

所以，成員變量可以稱為對象的特有數據，靜態變量稱為對象的共享數據。

靜態代碼塊：就是一個有靜態關鍵字標示的一個代碼塊區域。定義在類中。

作用：可以完成類的初始化。靜態代碼塊隨著類的加載而執行，而且只執行一次(new 多個對象就只執行一次)。如果和主函數在同一類中，優先于主函數執行。

final

　根據程序上下文環境，Java關鍵字final有"這是無法改變的"或者"終態的"含義，它可以修飾非抽象類、非抽象類成員方法和變量。你可能出于兩種理解而需要阻止改變、設計或效率。

final類不能被繼承，沒有子類，final類中的方法默認是final的。

final方法不能被子類的方法覆蓋，但可以被繼承。

final成員變量表示常量，只能被賦值一次，賦值后值不再改變。

final不能用于修飾構造方法。

注意：父類的private成員方法是不能被子類方法覆蓋的，因此private類型的方法默認是final類型的。

1、final類

final類不能被繼承，因此final類的成員方法沒有機會被覆蓋，默認都是final的。在設計類時候，如果這個類不需要有子類，類的實現細節不允許改變，并且確信這個類不會載被擴展，那么就設計為final類。

2、final方法

如果一個類不允許其子類覆蓋某個方法，則可以把這個方法聲明為final方法。

使用final方法的原因有二：

第一、把方法鎖定，防止任何繼承類修改它的意義和實現。

第二、高效。編譯器在遇到調用final方法時候會轉入內嵌機制，大大提高執行效率。

3、final變量(常量)

　用final修飾的成員變量表示常量，值一旦給定就無法改變！

　final修飾的變量有三種：靜態變量、實例變量和局部變量，分別表示三種類型的常量。

　從下面的例子中可以看出，一旦給final變量初值后，值就不能再改變了。

　另外，final變量定義的時候，可以先聲明，而不給初值，這中變量也稱為final空白，無論什么情況，編譯器都確保空白final在使用之前必須被初始化。但是，final空白在final關鍵字final的使用上提供了更大的靈活性，為此，一個類中的final數據成員就可以實現依對象而有所不同，卻有保持其恒定不變的特征。

4、final參數

當函數參數為final類型時，你可以讀取使用該參數，但是無法改變該參數的值。

生成Java幫助文檔：命令格式：javadoc –d 文件夾名 –auther –version *.java

/** //格式

*類描述

*@author 作者名

*@version 版本號

*/

/**

*方法描述

*@param 參數描述

*@return 返回值描述

*/

繼 承(面向對象特征之一)

java中對于繼承，java只支持單繼承。java雖然不直接支持多繼承，但是可實現多接口。

1：成員變量。

當子父類中出現一樣的屬性時，子類類型的對象，調用該屬性，值是子類的屬性值。

如果想要調用父類中的屬性值，需要使用一個關鍵字：super

This：代表是本類類型的對象引用。

Super：代表是子類所屬的父類中的內存空間引用。

注意：子父類中通常是不會出現同名成員變量的，因為父類中只要定義了，子類就不用在定義了，直接繼承過來用就可以了。

2：成員函數。

當子父類中出現了一模一樣的方法時，建立子類對象會運行子類中的方法。好像父類中的方法被覆蓋掉一樣。所以這種情況，是函數的另一個特性：重寫

3：構造函數。

發現子類構造函數運行時，先運行了父類的構造函數。為什么呢?

原因：子類的所有構造函數中的第一行，其實都有一條隱身的語句super();

super(): 表示父類的構造函數，并會調用于參數相對應的父類中的構造函數。而super():是在調用父類中空參數的構造函數。

為什么子類對象初始化時，都需要調用父類中的函數？(為什么要在子類構造函數的第一行加入這個super()?)

因為子類繼承父類，會繼承到父類中的數據，所以必須要看父類是如何對自己的數據進行初始化的。所以子類在進行對象初始化時，先調用父類的構造函數，這就是子類的實例化過程。

注意：子類中所有的構造函數都會默認訪問父類中的空參數的構造函數，因為每一個子類構造內第一行都有默認的語句super();

如果父類中沒有空參數的構造函數，那么子類的構造函數內，必須通過super語句指定要訪問的父類中的構造函數。

如果子類構造函數中用this來指定調用子類自己的構造函數，那么被調用的構造函數也一樣會訪問父類中的構造函數。

問題：

super()和this()是否可以同時出現的構造函數中？

兩個語句只能有一個定義在第一行，所以只能出現其中一個。

super()或者this():為什么一定要定義在第一行？

因為super()或者this()都是調用構造函數，構造函數用于初始化，所以初始化的動作要先完成。

在方法覆蓋時，注意兩點：

1：子類覆蓋父類時，必須要保證，子類方法的權限必須大于等于父類方法權限可以實現繼承。否則，編譯失敗。(舉個例子，在父類中是public的方法，如果子類中將其降低訪問權限為private，那么子類中重寫以后的方法對于外部對象就不可訪問了，這個就破壞了繼承的含義)

2：覆蓋時，要么都靜態，要么都不靜態。(靜態只能覆蓋靜態，或者被靜態覆蓋)

繼承的一個弊端：打破了封裝性。對于一些類，或者類中功能，是需要被繼承，或者復寫的。

這時如何解決問題呢？介紹一個關鍵字，final。

final特點：(詳細解釋見前面)

1：這個關鍵字是一個修飾符，可以修飾類，方法，變量。

2：被final修飾的類是一個最終類，不可以被繼承。

3：被final修飾的方法是一個最終方法，不可以被覆蓋。

4：被final修飾的變量是一個常量，只能賦值一次。

抽象類: abstract

抽象類的特點：

1：抽象方法只能定義在抽象類中，抽象類和抽象方法必須由abstract關鍵字修飾(可以描述類和方法，不可以描述變量)。

2：抽象方法只定義方法聲明，并不定義方法實現。

3：抽象類不可以被創建對象(實例化)。

4：只有通過子類繼承抽象類并覆蓋了抽象類中的所有抽象方法后，該子類才可以實例化。否則，該子類還是一個抽象類。

抽象類的細節：

1：抽象類中是否有構造函數？有，用于給子類對象進行初始化。

2：抽象類中是否可以定義非抽象方法？

可以。其實，抽象類和一般類沒有太大的區別，都是在描述事物，只不過抽象類在描述事物時，有些功能不具體。所以抽象類和一般類在定義上，都是需要定義屬性和行為的。只不過，比一般類多了一個抽象函數。而且比一般類少了一個創建對象的部分。

3：抽象關鍵字abstract和哪些不可以共存？final , private , static

4：抽象類中可不可以不定義抽象方法？可以。抽象方法目的僅僅為了不讓該類創建對象。

接 口：★★★★★

1：是用關鍵字interface定義的。

2：接口中包含的成員，最常見的有全局常量、抽象方法。

注意：接口中的成員都有固定的修飾符。

成員變量：public static final

成員方法：public abstract

interface Inter{

public static final int x = 3;

public abstract void show();

}

3：接口中有抽象方法，說明接口不可以實例化。接口的子類必須實現了接口中所有的抽象方法后，該子類才可以實例化。否則，該子類還是一個抽象類。

4：類與類之間存在著繼承關系，類與接口中間存在的是實現關系。

繼承用extends ；實現用implements ；

5：接口和類不一樣的地方，就是，接口可以被多實現，這就是多繼承改良后的結果。java將多繼承機制通過多現實來體現。

6：一個類在繼承另一個類的同時，還可以實現多個接口。所以接口的出現避免了單繼承的局限性。還可以將類進行功能的擴展。

7：其實java中是有多繼承的。接口與接口之間存在著繼承關系，接口可以多繼承接口。

java類是單繼承的。classB Extends classA

java接口可以多繼承。Interface3 Extends Interface0, Interface1, interface……

不允許類多重繼承的主要原因是，如果A同時繼承B和C，而b和c同時有一個D方法，A如何決定該繼承那一個呢？

但接口不存在這樣的問題，接口全都是抽象方法繼承誰都無所謂，所以接口可以繼承多個接口。

抽象類與接口：

抽象類：一般用于描述一個體系單元，將一組共性內容進行抽取，特點：可以在類中定義抽象內容讓子類實現，可以定義非抽象內容讓子類直接使用。它里面定義的都是一些體系中的基本內容。

接口：一般用于定義對象的擴展功能，是在繼承之外還需這個對象具備的一些功能。

抽象類和接口的共性：都是不斷向上抽取的結果。

抽象類和接口的區別：

1：抽象類只能被繼承，而且只能單繼承。

接口需要被實現，而且可以多實現。

2：抽象類中可以定義非抽象方法，子類可以直接繼承使用。

接口中都是抽象方法，需要子類去實現。

3：抽象類使用的是 is a 關系。

接口使用的 like a 關系。

4：抽象類的成員修飾符可以自定義。

接口中的成員修飾符是固定的。全都是public的。

多 態★★★★★

多 態★★★★★(面向對象特征之一)：函數本身就具備多態性，某一種事物有不同的具體的體現。

體現：父類引用或者接口的引用指向了自己的子類對象。//Animal a = new Cat();父類可以調用子類中覆寫過的(父類中有的方法)

多態的好處：提高了程序的擴展性。繼承的父類或接口一般是類庫中的東西，(如果要修改某個方法的具體實現方式)只有通過子類去覆寫要改變的某一個方法，這樣在通過將父類的應用指向子類的實例去調用覆寫過的方法就行了！

多態的弊端：當父類引用指向子類對象時，雖然提高了擴展性，但是只能訪問父類中具備的方法，不可以訪問子類中特有的方法。(前期不能使用后期產生的功能，即訪問的局限性)

多態的前提：

1：必須要有關系，比如繼承、或者實現。

2：通常會有覆蓋操作。

如果想用子類對象的特有方法，如何判斷對象是哪個具體的子類類型呢？

可以可以通過一個關鍵字 instanceof ;//判斷對象是否實現了指定的接口或繼承了指定的類

格式：<對象 instanceof 類型> ，判斷一個對象是否所屬于指定的類型。

Student instanceof Person = true;//student繼承了person類

總結

以上是生活随笔為你收集整理的java package报错_Java基础知识总结 - 超详细篇(上)的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。