java基礎的知識

1. java的基礎知識~！！

哎呀，問的好。
對此，本人以一個高深的Java專家給你作答（裝的）：
區別如下：
1、方法有返回類型，方法名小寫，不能和類名相同；構造方法沒有返回類型，void也不行，名與類名相同。
2、構造方法是初始化對象的重要途徑，所以就算你給一個類沒有定義構造方法，方法在這個類的載入得時候，會自動提供一個沒有參數的構造方法。所以，常見得 Student s=new Student();那麼，s這個實例，是通過構造方法初始化的；而普通方法不行
3、他們運行順序不同。一個類在初始化的時候，例如People是Student的父類，有構造方法 public PeoPle(){}那麼，當實例化Student p=new Student()得時候，父類的構造方法會隱式執行（你可自己敲代碼嘗試，父類構造方法中寫個輸出語句：例如System.out.println("父類構造方法")）。你會發現，沒有調用任何父類，也沒有實例化父類，但是構造方法卻執行了。
4、方法僅僅是類成員，構造方法也是類成員，但是，構造方法有對類屬性得初始化的功能。所以，常見到 public PeoPle(String name){this.name=name}或者 public PeoPle(){name="wangsan",age=14},完成了對People類屬性name或者age的初始化
…………
難以言盡
但是，只是作為理解，會用就可以了。

2. java基礎知識——<>的意義

首先你要理解面向對象編程。

「Everything is Object」——「萬物皆對象」。語出Java之父，那個急死你·搞死你說的。

意思就是其實啥玩意你都可以看成一個對象，或者一個類。

類是對一類事物的抽象定義，對象是這個類具體的實現實例。

「人」是一種類，而「劉德華」就是人這個類的具體對象。

從這個理念出發，擴展出反射的概念。那麼，其實，我們能將「人」這個類本身，也視為一個對象。

Class c2 = boolean.class，實際上定義了一個「類對象」，這個對象中有這個類的相關屬性方法（這里有點繞）。
具體來說就是「boolean」這個類的一些性質。從底層上來說，boolean.class是boolean這種數據結構的字形碼。

用我的例子來說， Class c = 人.class,我們得到的就是「人」這個類的類對象，也就是他的位元組碼。我們可以通過這個位元組碼，去構造一個新的人。這就是Java的反射機制了。

考慮如下情形：你是一個架構層的開發員（你的客戶就是Java程序員），你在指定任何一套供人擴展的框架時，肯定會定義很多底層操作。比如 新建一個類。但是你不知道這個類的類名，方法名什麼的（你不知道你的客戶會寫出什麼類名）。
那麼如何能實現這個需求呢。這時候只能使用反射，拿到這個類的位元組碼（類對象），通過反射機制，去得到這個類的實例。

任何類名都可以通過 類名.class 點出它的類對象（字形碼），也可以通過該類的某個實力 o.getClass()方法得到這個字形碼。就是你寫的這兩個例子所代表的含義。

3. Java開發的基礎知識有哪些

1、Java語言的優點：
1)Java是純面向對象語言
2)與平台無關性，一次編譯到處運行
3)Java提供了狠多內置類庫
4)提供了對web應用的支持
5)具有較好的安全性（數組邊界檢測、Bytecode檢測）和健壯性（強制型機制、垃圾回收器、異常處理）
6)去除c++難以理解的一些特性（頭文件 指針 運算符重載 多重繼承）
2、java與c++的異同：
1)Java為解釋型語言，c++為編譯型語言，java會慢但是跨平台
2)Jave為純面向對象，c++既面向對象又能面向過程。Jave無全局變數和全局函數
3)Java沒有指針，更安全
4)Java不支持多繼承但是有介面概念
5)Java不需人工分配管理內存（申請 釋放），提供垃圾回收器自動回收。當堆棧或靜態存儲區沒有對這個對象的引用時，就會被回收。沒有析構函數，但是有finalize()方法。
6)Java沒有運算符重載，沒有預處理功能。
3、public static void main(String [] args)是程序的入口。
4、java可有多個main()文件，但只有與文件名相同的用public修飾的類的main()才能作為程序的入口。註：有且僅有一個類被public修飾並與文件同名。
5、靜態快在main函數之前執行。初始化執行順序：父靜態變數 父靜態代碼塊 子靜態代碼變數 子靜態代碼塊 父非靜態變數 父非靜態代碼塊 父類構造函數 子非靜態變數 子非靜態代碼塊 子類構造函數
6、構造函數：
1)與類同名，無返回值
2)可以有多個，根據參數不同
3)總是伴隨new操作一起調用
4)主要用來初始化對象
5)不能被繼承
6)可用super來顯示調用父類構造函數
7、淺復制僅僅復制考慮的對象，不復制它引用的對象。深復制兩者都復制
8、面向對象和面向過程有什麼不同：
1)面向對象是用符合常規思維的方式去處理客觀世界的問題，面向過程是則重以事件為中心，模塊化。
2)面向對象是使計算機世界向客觀世界靠攏，使問題的處理更清晰。面向過程是清晰准確表達過程的模塊，把客觀世界的問題抽象成計算機可以處理的過程。
9、面向對象的特徵和優點：抽象 繼承 封裝 多態有較高的開發效率，代碼可重用。較高的可維護性，代碼更清晰明了。
10、java只支持單根繼承，extends繼承是 is a 關系，組合是 has a關系。
在java語言中能用到組合的盡量不要用繼承。
11、多態：
重載（同個類中有多個同名方法） 水平關系
重寫（子類重寫父類，方法名和參數列表相同） 垂直關系
12、抽象類和介面的異同：
1)只要包含一個抽象方法都是抽象類，介面的方法全部是抽象方法，稱為純抽象類。
2)抽象類的子類需實現父類的抽象方法。
3)介面中的變數都默認為：static final 必須賦初值。
4)介面實現用implements。一個類可以實現多個介面實現類似多繼承的關系。
5)介面被運用於常用的功能，如：添加刪除。抽象類用於生活公共類的角色，不適用經常對代碼修改的情況
13、this和super的區別：
This用來指向當前實例對象
Super用來訪問父類的方法和成員變數
子類繼承父類時，子類構造函數中super（）必須放第一句。
14、break continue return 的區別：
Break 用於直接強行跳出當前循環，不執行剩餘代碼
Continue 用於停止當次循環，回到起始處進行下次循環。
Return 跳轉 用來表示從一個方法中返回。
Break out跳出多重循環
15、static的作用：
a 為對象分配單一的存儲空間，與創建對象個數無關
b 實現某個方法或屬性和類而不是與對象關聯在一起
C 變數可達到全局的效果，在內存中只有一個復制
16、不可變類的實現：
類中的所有成員變數被private修飾
沒有寫set方法
類定義final
17、值傳遞和引用傳遞的區別:
值傳遞：實參會把它的值傳遞給形參
引用傳遞：傳遞的是對象，形參和實參指向同個存儲單元。
18、有八種基本數據類型，類型轉換的優先順序：byte不能與booleam互換。
19、round 表示四捨五入 ceil表示向上取整 floor表示向下取整，i++表示先執行後加
一，++i表示先加一後執行。
20、String s1=」abc」是存放在常量區
String s2=」abc」s2應用常量區的對象，不會創建新的對象。
String s3=new String（「abc」）是在堆中創建對象，
String s4=new String（「abc」）又必須在堆中創建新對象。
21、「==」與「equals」
「==」用來比較兩個變數的值是否相等，如果一個變數指向餓數據是對象（引用類型），就有兩塊內存。對象本身佔用一塊內存（堆內存），變數也佔用一塊內存。String s4 = new String（「abc」）。變數s所對應的內存中存儲的數值就是對象佔用那塊內存的首地址。如果想看兩個變數是否指向同一個對象，即要看他們對應內存中的數值（首地址）是否相同。
equals比較的不是引用，而是數值內容，即比較的是abc。
22、數組也是對象。數組提供length屬性來獲取數組的長度，而String是通過length()計算。
23、異常處理
1）try catch finally模式
2）Finally塊中的代碼一定會被執行，除非這兩種情況：當程序在try之前就遇到異常或者在try中通過exit（）強制退出。
3）jvm將錯誤表示為一個異常並拋出，通過catch來捕獲，然後進行處理。安全性和魯棒性。
4）異常分為兩大類：錯誤（error）和異常（Excetion）
異常分為：檢查異常和運行異常。
檢查異常又稱為編譯異常。
比如：IO異常、SQL異常
運行異常為：空指針異常、類型轉換異常、算術異常、數組越界異常、數組存儲異常、緩存區溢出異常。
先捕獲子類後捕獲父類，盡早拋出異常，能處理就處理，不處理就拋出，運行時異常實際不必處理，直接拋出。
24、Java IO：位元組流（8位）不會用到緩存 字元流（16位）用到緩存
25、Socket稱為套接字。用來實現不同虛擬機或不同計算機之間的通信。
分為兩種類型：面向連接的TCP,可靠。無面向連接的UDP，不可靠。
任何一個Socket都是由一個IP地址和埠號唯一確定。
26、java平台獨立性是指一個平台上編寫和編譯程序，而在其他平台上運行。有JVM和java API。
Java語言是一種動態解釋型語言，類class只有被載入到JVM上才能運行。不會一次載入全部類後執行，而是先載入基類，其他類是需要時再載入。
27、垃圾回收GC：回收不會再使用的內存。三個任務：分配內存；確保被引用的內存不被錯誤地回收；回收不再被引用的對象的內存。
28、java中內存泄露問題：
兩種情況：
1）在堆中申請的空間沒有得到釋放
2）對象不再被使用，但是仍在內存中保留著
原因：靜態集合類、各種連接、監聽器、變數不合理的作用域
29、java中堆和棧的區別：
分配在棧：基本數據類型的變數、對象的引用變數
變數出了作用域就會被自動釋放
分配在堆：引用類型變數、需要通過new創建的變數。主要為運行時創建的對象
JVM是基於堆棧的虛擬機，每個java程序都運行在一個單獨的JVM實例上，所以一個java程序中的對個線程運行在，每個實例又唯一對應一個堆，所以這些線程之間會共享堆內存。
只需要申請堆空間，不需要考慮釋放問題。
使用棧中的引用變數來訪問堆中的數組和對象。
堆只要是用來存放對象的，棧主要是用來放執行程序的。
棧的速度快，但大小和生存期確定，缺乏靈活性。堆是動態分配內存，靈活性強但速度慢。
30、容器：java Collections框架：list 、Queue 、set 、stack 、map
list 、Queue 、set 、stack都繼承Collection介面。
1）List是有序的Collection。按對象的進入順序保存對象，可保存重復對象。
2）Set是集合的概念，集合中不能有重復的元素。
3）map是鍵映射到值得數據結構。值可以重復，但是鍵是唯一的，不能重復。
31、迭代器：是一個對象，一種訪問一個容器對象的各個元素，而又不必暴露該對象內部的細節方法。
1）使用容器的iterator()方法返回一個Iterator，然後通過Iterator的next（）方法返回一個元素。
2）使用Iterator的hasNext（）方法判斷容器中是否還有元素，如果有可以使用next()獲取下一個元素。
3）通過remove()來刪除迭代器返回的元素。
32、collection和collections的區別：
Collection：是一個集合介面，為各個具體集合提供最大化的統一操作。
Collections：是針對集合類的一個包裝類。不能實例化，相當於一個工具類，服務於Collection框架。
33、多線程：
線程：執行代碼的一個執行單元。
進程：一個正在執行的程序
各線程共享程序的內存空間（代碼段、數據、堆空間）有獨立的棧空間。
線程優點：
1）減少程序的響應時間
2）相比進程，創建個切換開銷小
3）多CPU和多核本身就具有多線程能力
4）簡化程序結構，便於理解和維護。
34、如何實現java多線程：
1）繼承Thread類，重寫run()方法
2）實現Runnable介面，並實現介面的run（）方法。
3）實現Callable介面，重寫call()方法。
35、同步
要想實現同步操作，必須獲得每個線程對象的鎖，獲得它可以保證同一時刻只有一個線程能夠進入臨界區，並且在這個鎖被釋放之前，其他線程就能再進入臨界區，如果還有其他線程想要獲得該對象的鎖，只能進入等待隊列等待。
36、多進程同步的實現方法：
1）synchronized關鍵字
2）Wait（）方法與notify（）方法
3）Lock
37、終止線程的方法：stop()方法與suspeng()方法。
Java提供兩種線程：守護線程（服務進程）、用戶進程。
38、如何通過JDBC來訪問資料庫：
1）載入JDBC驅動器，將JDBC驅動 jar包復制到lib下
2）載入JDBC驅動
3）創建資料庫連接
4）建立Statement對象或是PrepareStatement對象。用於對資料庫操作
5）執行SQL語句
6）訪問結果集ReaultSet對象
7）依次關閉ReaultSet Statement Connection。
39、Class.forName（）方法的作用是把類載入到JVM中。
在使用JDBC連接資料庫之前，一般會調用Class.forName（「com.mysql.jdbc.Driver」）方法來載入驅動。
Statement用於執行不帶參數的簡單SQL語句，並返回它所生成結果的對象。每次執行SQL，資料庫都會編譯該SQL語句。
PrepareStatement可執行帶參數的。效率更高，可讀性，可維護性更高，安全性更好
40、JDBC提供了getString()、getInt()、getIData()等方法從ResultSet中獲取數據。
41、在JDBC連接時連接池數目有限，所以一定要保證釋放不再使用的連接。
createStatement和prepareStatement最好放在循環外面，而且使用statement後需要及時關閉。最好是執行一次executeQuery後馬上關閉statement。
42、Hibernate是JDBC的封裝。採用配置文件的形式將資料庫的連接參數寫到XML中，但
是最後對資料庫的訪問還是要通過JDBC來完成。
43、Hibernate是個持久層框架，它將表中的信息映射到XML中，再從XML文件映射到相應的持久化類中。
Java Web
1、瀏覽器的作用：
1)、完成與伺服器端的交互。
2)、完成html的解析，實現用戶需要看的內容以直觀的信息展示出來。
2、HTTP的請求方法有：GET POST HEAD TRACE OPTIONS
GET：是最簡單的請求方法，從伺服器端獲取用戶所需的資源，並將其作為響應返回給客戶端。獲取伺服器端的信息（查詢）。若需上傳數據則添加到URL後面。數據暴露安全不夠，並且數量受限制。
POST：除了能夠從伺服器端獲取資源外，同時還可以向伺服器上傳數據。上傳的數據不是在URL中明文顯示，可以上傳大量數據，用戶不可見
3、Servlet:
採用Java語言編寫的伺服器程序，運行於Web伺服器中的Servlet容器中，主要功能是提供請求、響應的服務模式，可以生成動態的Web內容。
Web伺服器獲取到一個對servlet的請求時，會將其交給Tomcat容器進行處理，容器再通過調用Servlet的方法（doGet（） doPost（））來響應請求。
步驟：
發起servlet請求——>Web伺服器交給容器處理——>容器創建兩個對象HttpServletResponse HttpServletRequire——>創建單獨線程，並將兩個對象以參數形式傳遞進入線程——>線程容器調用Servlet的service（）方法中的doGet()或doPost（）完成響應——>容器將響應消息以HTML形式返回給客戶。
4、Servlet的生命周期：
載入——>創建——> 初始化——> 處理客戶請求——> 卸載
5、JSP的優點：
JSP:嵌入java代碼的html文件。主要解決servlet與HTML的分離。實現業務邏輯與視圖進行分離。
6、JSP與servlet的異同：
相同：
本質都是Servlet文件，只要是JSP能完成的工作，使用Servlet都能完成.JSP最終都是會轉化為servlet來運行。
不同：
Servlet是處於控制層，主要是做流程式控制制和業務處理。JSP是處於視圖層，主要用於顯示。
Servlet沒有內置對象，JSP中的內置對象主要是通過HttpServletResponse 對象、HttpServletRequire對象得到。
7、MVC模型：
模型層（M）：實現系統業務邏輯。JavaBean或EJB
視圖層（V）：實現用戶的交互。JSP
控制層（C）: 實現視圖與模型的邏輯控制。servlet
8、控制層：
控制器接收用戶的輸入並調用模型和視圖去完成。
控制器本身不輸出任何東西，也不執行任何處理。
只是接收請求並決定使用哪個模型去處理請求，決定使用哪個視圖去顯示模型處理返回數據
9、MVC的優點：
1）低耦合性，實現視圖層與邏輯層分離。
2）高重用性和可適用性
3）部署迅速
4）容易維護
10、Servlet中的forward和redirect有什麼區別：
Forward是伺服器內部的重定向，伺服器直接訪問目標地址的url，地址不變。
Redirect:客戶端的重定向，完全跳轉，地址改變。
11、JSP的內置對象：
1）require（請求對象）
2）Response（響應對象）
3）pageContext（頁面上下文對象）
4）Session（會話對象）
5）Application（應用程序對象）
6）Out（輸出對象）
7）Config（配置對象）
8）Page（頁面對象）
9）Exception（異常對象）
12、request對象的方法：
1）setAttribute（String name ，Object）設置name的屬性值
2）getAttribute（String name ）獲取name的屬性值
3）getParameter（String name ）獲取用戶提交的數據，name與表單的name對應一致
4）getSession（）用來獲取與請求相關的會話
13、JSP中的動作：
1）JSP:include 用來頁面請求時引進一個文件
2）Jsp：useBean 用來實例化一個javabean
3）Jsp:setProperty 用來設置已經實例化的bean對象的屬性
4）Jsp:getProperty 用來獲取已經實例化的bean對象的屬性
5）Jsp:foward 用來將請求跳轉到另外一個頁面
14、JSP中include指令和include動作
指令：<% @include file =」test.jsp 「%>
動作：
15、會話跟蹤技術：
對同一個用戶對伺服器的連續請求和接收響應進行監視。
1）page一個頁面
2）Request一個請求
3）Session 一個用戶體驗
4）Application 整個Web應用程序
16、字元串編碼：GBK 、UTF-8
17、什麼是Ajar
非同步js與XML。
結合了java技術、js技術、xml技術。 客戶端技術
功能：在不刷新頁面的情況下通過與伺服器進行少量的數據交互來提高頁面的交互性，減少響應時間，改善用戶體驗
18、cookie和session的區別：
Session：指用來在客戶端與伺服器端之間保持狀態的解決方案以及存儲結構。
Cookie:由Web伺服器保存在用戶瀏覽器上的小文件。
19、web伺服器：接收來自於客戶端的請求，然後把對請求的處理結果反饋個客戶端
兩大web伺服器：IIS Apache。
20、web容器：TomcatJBoss
負責給servlet提供http請求和響應對象，調用doGet（）過doPost（）方法來處理用戶請求。
21、EJB的類別：
1）session Bean（會話Bean）實現伺服器端的業務邏輯，協調Bean之間的交互
2）Entity Bean（實體Bean）資料組件 代表資料庫中的記錄
3）Message Bean（消息驅動 Bean)處理非同步消息，一般不是由用戶來調用的
22、EJB與Javabean的異同：
1）EJB:主要用於伺服器端的開發，Javabean主要用在客戶端的開發。
2）EJB組件可以部署在EJB容器中，不直接訪問組件，而是通過容器訪問，javabean不可部署
3）EJB是分布式對象，可以被遠程調用，javabean不是，只能在內部被訪問
23、EJB的角色：
1）Enterprise Bean Provider（企業級組件開發者）
2）Application Assembler（應用組合者）
3）EJB Deployer（EJB部署者)
4）EJB Sever Provider（EJB伺服器提供者）
5）EJB Container Provider(EJV容器提供者）
6）System Administrator(系統管理員）
24、資料庫連接池的工作機制：
原因：
1）建立資料庫是非常耗時的操作
2）資料庫連接個數是有限的
資料庫連接池負責分配 管理 釋放資料庫連接。當客戶需要訪問資料庫是，就可以直接從池中獲取資料庫的連接，而不用去創建連接，同時標志為忙狀態。
25、JAVAEE開發的調優方法：
1）優化設計
2）盡可能使用資料庫連接
3）使用框架
4）優化I/O
5）優化查詢
26、struts框架的優點：
1）實現表現和邏輯的分離
2）提供頁面導航功能
3）提供表單驗證
4）提供資料庫連接池
5）提供了異常處理機制
6）支持國際化
27、數據驗證分為：
1）表單驗證
2)業務邏輯驗證
28、國際化：
程序在不修改內部代碼的情況下，根據不同地區顯示相應的界面
29、什麼事控制反轉：
也稱依賴注入，一種降低對象之間耦合關系的設計思想。
使上層不仔依賴於下層的介面，調用者（子)決定被調用者(父）。通過注入一個實例化的對象來實現解耦和目的。
30、Spring框架
提供了對輕量級loc的良好支持，也提供對AOP技術的非常好的封裝。
31、Hibernate框架，持久層框架
實現Java對象與關系資料庫記錄的映射，簡化開發人員訪問資料庫的流程，提高軟體開發的效率
任何使用到JDBC的都可以使用Hibernata
提高性能方法：
1）延遲載入
2）緩存技術
3）優化查詢語句
32、實現分頁：
1)Hibernate自帶的分頁機制
2)用SQL語句實現，使用limit關鍵字
33、SSH：
struts實現視圖部分
Hibernate實現模型部分
Spring實現業務部分
採用SSH框架，不僅能實現視圖、控制器與模型的徹底分離，而且還能實現業務邏輯與數據持久層的分離

4. java基礎知識有那些

基礎語法:
jdk的安裝和環境配置,
變數和常量,
條件判斷語句,
循環語句,
循環控制語句
方法和數組:
方法的定義和調用,
方法的重載和遞歸操作,
數組的定義和初始化,
數組的遍歷和常見的方法調用
面向對象:
類的定義和對象的創建,
對象的實例化流程,
抽象,
封裝,
繼承,
多態思想,
介面的設計和實現
異常和常用類:
異常機制和異常體系,
try-catch語句,
throw和throws關鍵字,
自定義異常,
String,
StringBuffer,
StringBuilder類,
System,
Runtime類,
Math,
Random,
BigDecimal類
多線程:
並行和並發,
進程和線程,
線程的啟動方式,
線程安全的處理方式,
同步鎖和死鎖的概述,
線程的生命周期和狀態,
聯合線程和後台線程,
線程優先順序和線程禮讓和定時器
集合框架:
ArrayList和LinkedList,
HashSet和TreeSet,
LinkedHashSet,
Comparable介面和Comparator介面,
HashMap和TreeMap,
LinkedhashMap,
泛型的定義和使用
IO和網路編程:
File類的基本使用,
FilenameFilter介面的使用,
IO流的體系結構,
位元組流和字元流的使用,
緩沖流,標准流,列印流,轉換流,數據流,管道流,對象流,
對象序列化和發序列化,
字元編碼和解碼,
Properties類載入資源,
RandomAccessFile類,
NIO操作,
網路概述和分層模型,
網路三要素,
TCP和UDP協議和編程

5. java基礎知識

7.Swing組件中常用於提示的組件叫 面板容器 。
8.AWT基本組件類有（至少寫出兩個）： Dialog與FileDialogTextArea等。
9.如果一個對象未被實例化就使用了，這會導致空指針異常。中文稱為數組小標越界的異常。
10.Java異常處理機制一般是通過語句try-catch來處理。
11. 子類想要訪問父類的同名方法，應當使用super關鍵字。
12. 網路常見協議有 TCP 、UDP、Telnet,FTP,POP3等。

6. Java基礎有哪些知識點

java的運行環境是Eclipse..基礎就是要熟練掌握和運用以下知識點:1.變數.數據類型.運算符.2.條件結構(if-else和switch)3.循環結構(while/do-while/for)4.OOP思想(面向對象編程)----類和對象5.數組和字元串以上這些都是最基礎的了..如果有漏掉的就請其他兄弟補充一下吧..

7. JAVA基礎包括那些知識

1、 對象的初始化
(1) 非靜態對象的初始化
在創建對象時，對象所在類的所有數據成員會首先進行初始化。
基本類型：int型，初始化為0。
如果為對象：這些對象會按順序初始化。
※在所有類成員初始化完成之後，才調用本類的構造方法創建對象。
構造方法的作用就是初始化。
(2) 靜態對象的初始化
程序中主類的靜態變數會在main方法執行前初始化。
不僅第一次創建對象時，類中的所有靜態變數都初始化，並且第一次訪問某類（注意此時
未創建此類對象）的靜態對象時，所有的靜態變數也要按它們在類中的順序初始化。
2、 繼承時，對象的初始化過程
(1) 主類的超類由高到低按順序初始化靜態成員，無論靜態成員是否為private。
(2) 主類靜態成員的初始化。
(3) 主類的超類由高到低進行默認構造方法的調用。注意，在調用每一個超類的默認構造
方法前，先進行對此超類進行非靜態對象的初始化。
(4) 主類非靜態成員的初始化。
(5) 調用主類的構造方法。
3、 關於構造方法
(1) 類可以沒有構造方法，但如果有多個構造方法，就應該要有默認的構造方法，否則在繼承此類時，需要在子類中顯式調用父類的某一個非默認的構造方法了。
(2) 在一個構造方法中，只能調用一次其他的構造方法，並且調用構造方法的語句必須是
第一條語句。
4、 有關public、private和protected
(1) 無public修飾的類，可以被其他類訪問的條件是：a.兩個類在同一文件中，b.兩個類
在同一文件夾中，c.兩個類在同一軟體包中。
(2) protected：繼承類和同一軟體包的類可訪問。
(3) 如果構造方法為private，那麼在其他類中不能創建該類的對象。
5、 抽象類
(1) 抽象類不能創建對象。
(2) 如果一個類中一個方法為抽象方法，則這個類必須為abstract抽象類。
(3) 繼承抽象類的類在類中必須實現抽象類中的抽象方法。
(4) 抽象類中可以有抽象方法，也可有非抽象方法。抽象方法不能為private。
(5) 間接繼承抽象類的類可以不給出抽象方法的定義。
6、 final關鍵字
(1) 一個對象是常量，不代表不能轉變對象的成員，仍可以其成員進行操作。
(2) 常量在使用前必須賦值，但除了在聲明的同時初始化外，就只能在構造方法中初始化
。
(3) final修飾的方法不能被重置（在子類中不能出現同名方法）。
(4) 如果聲明一個類為final，則所有的方法均為final，無論其是否被final修飾，但數據
成員可為final也可不是。
7、 介面interface （用implements來實現介面）
(1) 介面中的所有數據均為 static和final即靜態常量。盡管可以不用這兩個關鍵字修飾
，但必須給常量賦初值。
(2) 介面中的方法均為public，在實現介面類中，實現方法必須可public關鍵字。
(3) 如果使用public來修飾介面，則介面必須與文件名相同。
8、 多重繼承
(1) 一個類繼承了一個類和介面，那麼必須將類寫在前面，介面寫在後面，介面之間用逗
號分隔。
(2) 介面之間可多重繼承，注意使用關鍵字extends。
(3) 一個類雖只實現了一個介面，但不僅要實現這個介面的所有方法，還要實現這個介面
繼承的介面的方法，介面中的所有方法均須在類中實現。
9、 介面的嵌入
(1) 介面嵌入類中，可以使用private修飾。此時，介面只能在所在的類中實現，其他類不
能訪問。
(2) 嵌入介面中的介面一定要為public。
10、類的嵌入
(1) 類可以嵌入另一個類中，但不能嵌入介面中。
(2) 在靜態方法或其他方法中，不能直接創建內部類對象，需通過手段來取得。
手段有兩種：
class A {
class B {}
B getB() {
B b = new B();
return b;
}
}
static void m() {
A a = new A();
A.B ab = a.getB(); // 或者是 A.B ab = a.new B();
}
(3) 一個類繼承了另一個類的內部類，因為超類是內部類，而內部類的構造方法不能自動
被調用，這樣就需要在子類的構造方法中明確的調用超類的構造方法。
接上例：
class C extends A.B {
C() {
new A().super(); // 這一句就實現了對內部類構造方法的調用。
}
}
構造方法也可這樣寫：
C(A a) {
a.super();
} // 使用這個構造方法創建對象，要寫成C c = new C(a); a是A的對象。
11、異常類
JAVA中除了RunTimeException 類，其他異常均須捕獲或拋出。
至於資料庫，WEB，JSP，JS之類的那是高級部分了

8. java基礎知識 有哪些知識點 要全面 不用詳細。。

第2章 一切都是對象
2.1 用句柄操縱對象
2.2 必須創建所有對象
2.2.1 保存在什麼地方
2.2.2 特殊情況：主類型
2.2.3 Java中的數組
2.3 絕對不要清除對象
2.3.1 作用域
2.3.2 對象的作用域
2.4 新建數據類型：類
2.4.1 欄位和方法
2.5 方法、自變數和返回值
2.5.1 自變數列表
2.6 構建Java程序
2.6.1 名字的可見性
2.6.2 使用其他組件
2.6.3 static關鍵字
2.7 我們的第一個Java程序
2.8 注釋和嵌入文檔
2.8.1 注釋文檔
2.8.2 具體語法
2.8.3 嵌入HTML
2.8.4 @see：引用其他類
2.8.5 類文檔標記
2.8.6 變數文檔標記
2.8.7 方法文檔標記
2.8.8 文檔示例
2.9 編碼樣式
2.10 總結
2.11 練習

第3章 控製程序流程
3.1 使用Java運算符
3.1.1 優先順序
3.1.2 賦值
3.1.3 算術運算符
3.1.4 自動遞增和遞減
3.1.5 關系運算符
3.1.6 邏輯運算符
3.1.7 按位運算符
3.1.8 移位運算符
3.1.9 三元if-else運算符
3.1.10 逗號運算符
3.1.11 字串運算符+
3.1.12 運算符常規操作規則
3.1.13 造型運算符
3.1.14 Java沒有「sizeof」
3.1.15 復習計算順序
3.1.16 運算符總結
3.2 執行控制
3.2.1 真和假
3.2.2 if-else
3.2.3 反復
3.2.4 do-while
3.2.5 for
3.2.6 中斷和繼續
3.2.7 切換
3.3 總結
3.4 練習

第4章 初始化和清除
4.1 由構建器保證初始化
4.2 方法過載
4.2.1 區分過載方法
4.2.2 主類型的過載
4.2.3 返回值過載
4.2.4 默認構建器
4.2.5 this關鍵字
4.3 清除：收尾和垃圾收集
4.3.1 finalize()用途何在
4.3.2 必須執行清除
4.4 成員初始化
4.4.1 規定初始化
4.4.2 構建器初始化
4.5 數組初始化
4.5.1 多維數組
4.6 總結
4.7 練習

第5章 隱藏實施過程
5.1 包：庫單元
5.1.1 創建獨一無二的包名
5.1.2 自定義工具庫
5.1.3 利用導入改變行為
5.1.4 包的停用
5.2 Java訪問指示符
5.2.1 「友好的」
5.2.2 public：介面訪問
5.2.3 private：不能接觸
5.2.4 protected：「友好的一種」
5.3 介面與實現
5.4 類訪問
5.5 總結
5.6 練習

第6章 類再生
6.1 合成的語法
6.2 繼承的語法
6.2.1 初始化基礎類
6.3 合成與繼承的結合
6.3.1 確保正確的清除
6.3.2 名字的隱藏
6.4 到底選擇合成還是繼承
6.5 protected
6.6 遞增開發
6.7 上溯造型
6.7.1 何謂「上溯造型」？
6.8 final關鍵字
6.8.1 final數據
6.8.2 final方法
6.8.3 final類
6.8.4 final的注意事項
6.9 初始化和類裝載
6.9.1 繼承初始化
6.10 總結
6.11 練習

第7章 多形性
7.1 上溯造型
7.1.1 為什麼要上溯造型
7.2 深入理解
7.2.1 方法調用的綁定
7.2.2 產生正確的行為
7.2.3 擴展性
7.3 覆蓋與過載
7.4 抽象類和方法
7.5 介面
7.5.1 Java的「多重繼承」
7.5.2 通過繼承擴展介面
7.5.3 常數分組
7.5.4 初始化介面中的欄位
7.6 內部類
7.6.1 內部類和上溯造型
7.6.2 方法和作用域中的內部類
7.6.3 鏈接到外部類
7.6.4 static內部類
7.6.5 引用外部類對象
7.6.6 從內部類繼承
7.6.7 內部類可以覆蓋嗎？
7.6.8 內部類標識符
7.6.9 為什麼要用內部類：控制框架
7.7 構建器和多形性
7.7.1 構建器的調用順序
7.7.2 繼承和finalize()
7.7.3 構建器內部的多形性方法的行為
7.8 通過繼承進行設計
7.8.1 純繼承與擴展
7.8.2 下溯造型與運行期類型標識
7.9 總結
7.10 練習

第8章 對象的容納
8.1 數組
8.1.1 數組和第一類對象
8.1.2 數組的返回
8.2 集合
8.2.1 缺點：類型未知
8.3 枚舉器（反復器）
8.4 集合的類型
8.4.1 Vector
8.4.2 BitSet
8.4.3 Stack
8.4.4 Hashtable
8.4.5 再論枚舉器
8.5 排序
8.6 通用集合庫
8.7 新集合
8.7.1 使用Collections
8.7.2 使用Lists
8.7.3 使用Sets
8.7.4 使用Maps
8.7.5 決定實施方案
8.7.6 未支持的操作
8.7.7 排序和搜索
8.7.8 實用工具
8.8 總結
8.9 練習

第9章 違例差錯控制
9.1 基本違例
9.1.1 違例自變數
9.2 違例的捕獲
9.2.1 try塊
9.2.2 違例控制器
9.2.3 違例規范
9.2.4 捕獲所有違例
9.2.5 重新「擲」出違例
9.3 標准Java違例
9.3.1 RuntimeException的特殊情況
9.4 創建自己的違例
9.5 違例的限制
9.6 用finally清除
9.6.1 用finally做什麼
9.6.2 缺點：丟失的違例
9.7 構建器
9.8 違例匹配
9.8.1 違例准則
9.9 總結
9.10 練習

第10章 Java IO系統
10.1 輸入和輸出
10.1.1 InputStream的類型
10.1.2 OutputStream的類型
10.2 增添屬性和有用的介面
10.2.1 通過FilterInputStream從InputStream里讀入數據
10.2.2 通過FilterOutputStream向OutputStream里寫入數據
10.3 本身的缺陷：RandomAccessFile
10.4 File類
10.4.1 目錄列表器
10.4.2 檢查與創建目錄
10.5 IO流的典型應用
10.5.1 輸入流
10.5.2 輸出流
10.5.3 快捷文件處理
10.5.4 從標准輸入中讀取數據
10.5.5 管道數據流
10.6 StreamTokenizer
10.6.1 StringTokenizer
10.7 Java 1.1的IO流
10.7.1 數據的發起與接收
10.7.2 修改數據流的行為
10.7.3 未改變的類
10.7.4 一個例子
10.7.5 重定向標准IO
10.8 壓縮
10.8.1 用GZIP進行簡單壓縮
10.8.2 用Zip進行多文件保存
10.8.3 Java歸檔（jar）實用程序
10.9 對象串聯
10.9.1 尋找類
10.9.2 序列化的控制
10.9.3 利用「持久性」
10.10 總結
10.11 練習

第11章 運行期類型鑒定
11.1 對RTTI的需要
11.1.1 Class對象
11.1.2 造型前的檢查
11.2 RTTI語法
11.3 反射：運行期類信息
11.3.1 一個類方法提取器
11.4 總結
11.5 練習

第12章 傳遞和返回對象
12.1 傳遞句柄
12.1.1 別名問題
12.2 製作本地副本
12.2.1 按值傳遞
12.2.2 克隆對象
12.2.3 使類具有克隆能力
12.2.4 成功的克隆
12.2.5 Object.clone()的效果
12.2.6 克隆合成對象
12.2.7 用Vector進行深層復制
12.2.8 通過序列化進行深層復制
12.2.9 使克隆具有更大的深度
12.2.10 為什麼有這個奇怪的設計
12.3 克隆的控制
12.3.1 副本構建器
12.4 只讀類
12.4.1 創建只讀類
12.4.2 「一成不變」的弊端
12.4.3 不變字串
12.4.4 String和StringBuffer類
12.4.5 字串的特殊性

9. JAVA基礎知識

實現排序有好幾種，我隨便寫一種給你參考下吧。
EXP：實現Comparator介面來比較對象，實現排序功能。
1.定義一個學生類Student .java，須重寫toString()方法。
public class Student {
private String name;
private int age;
private int score;
public Student(String name, int age, int score) {
super();
this.name = name;
this.age = age;
this.score = score;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getScore() {
return score;
}
public void setScore(int score) {
this.score = score;
}
public String toString() {
return "Student [name=" + name + ", age=" + age + ", score=" + score
+ "]";
}
}
2.寫一個比較類MyComparator.java，須實現Comparator介面
public class MyComparator implements Comparator<Student> {
public int compare(Student s1, Student s2) {
if (s1.getScore() > s2.getScore()) {
return 1;
} else if (s1.getScore() < s2.getScore()) {
return -1;
} else {
return 0;
}
}
}
3.寫一個測試類Test.java
public class Test {
public static void main(String args[]) throws IOException {
new Test().sort();
}

private void sort() {
Student s1 = new Student("小明", 20, 150);
Student s2 = new Student("小艾", 20, 100);
Student s3 = new Student("小白", 20, 190);
Student s4 = new Student("小黑", 20, 90);
Student s5 = new Student("小黃", 20, 130);
List<Student> list = new ArrayList<Student>();
list.add(s1);
list.add(s2);
list.add(s3);
list.add(s4);
list.add(s5);
Collections.sort(list, new MyComparator());
System.out.println(list);
}
}
4.輸出結果：
[Student [name=小黑, age=20, score=90],
Student [name=小艾, age=20, score=100],
Student [name=小黃, age=20, score=130],
Student [name=小明, age=20, score=150],
Student [name=小白, age=20, score=190]]