1.談談你對面向對象程序設計的理解？面向對象程序設計的重點和難點是什麼？html
對面向對象的理解java
在我理解,面向對象是向現實世界模型的天然延伸，這是一種「萬物皆對象」的編程思想。在現實生活中的任何物體均可以歸爲一類事物，而每個個體都是一類事物的實例。面向對象的編程是以對象爲中心，以消息爲驅動，因此程序=對象+消息。程序員
面向對象有三大特性，封裝、繼承和多態。web
封裝就是將一類事物的屬性和行爲抽象成一個類，使其屬性私有化，行爲公開化，提升了數據的隱祕性的同時，使代碼模塊化。這樣作使得代碼的複用性更高。算法
繼承則是進一步將一類事物共有的屬性和行爲抽象成一個父類，而每個子類是一個特殊的父類--有父類的行爲和屬性，也有本身特有的行爲和屬性。這樣作擴展了已存在的代碼塊，進一步提升了代碼的複用性。spring
若是說封裝和繼承是爲了使代碼重用，那麼多態則是爲了實現接口重用。多態的一大做用就是爲了解耦--爲了解除父子類繼承的耦合度。若是說繼承中父子類的關係式IS-A的關係，那麼接口和實現類之之間的關係式HAS-A。簡單來講，多態就是容許父類引用(或接口)指向子類(或實現類)對象。不少的設計模式都是基於面向對象的多態性設計的。數據庫
總結一下，若是說封裝和繼承是面向對象的基礎，那麼多態則是面向對象最精髓的理論。掌握多態必先了解接口，只有充分理解接口才能更好的應用多態。
原文：https://blog.csdn.net/weixin_40066829/article/details/78111476
編程
2.什麼是類，類實例，如何創建類的實例，在spring中又是如何建立類的？json
類的具體表現或者實例就是對象，而對象的抽象或者總歸納就是類。設計模式
建立對象的根本途徑是構造器，經過new關鍵字來調用某個類的構造器便可建立這個類的實例
1 // 使用Person類定義一個Person類型的變量
2 Person p;
3 // 經過new關鍵字調用Person類的構造器,返回一個Person實例
4 // 將該Person實例賦給p變量
5 p = new Person();
上面代碼也可簡寫成下面的形式:
1 // 定義p變量的同時併爲p變量賦值
2 Person p = new Person();
spring建立對象的三種方式：
一、採用默認的構造函數建立
二、採用靜態工廠方法
一、寫一個靜態工廠方法類
public class HelloWorldFactory {
public static HelloWorld getInstance(){
return new HelloWorld();
}
}
二、在spring的配置文件中進行聲明
<bean id="helloWorld2" class="com.itheima05.spring.bean.HelloWorldFactory" factory-method="getInstance"></bean>
告訴spring容器利用HelloWorldFactory類中的getInsatance靜態方法產生對象
可是具體的對象的建立的過程是由程序員來完成的
三、實例工廠方法
一、寫一個實例工廠類
public class HelloWorldFactory {
public HelloWorld getInstance(){
return new HelloWorld();
}
}
二、在spring的配置文件中
一、<bean id="helloWorld3" class="com.itheima05.spring.bean.HelloWorldFactory2"></bean>
spring容器爲HelloWorldFactory2建立對象
二、<bean id="helloWorldFactory" factory-bean="helloWorld3" factory-method="getInstance"></bean>
告訴spring容器，利用helloWorld3對象調用getInstance方法
建立對象的時機
一、在默認的狀況下，在spring容器啓動的時候建立對象
在spring配置文件中，只要根據以上的三種方式的其中一種配置了，spring容器就會建立對象
好處：spring容器和web容器整合的時候，當web容器啓動的時候就能夠初始化spring容器了，若是這個時候
spring容器內部有錯誤，則直接會報錯
若是該bean中存放着大量的數據，並且數據的初始化發生在建立對象的時候，這個時候，數據會過早的駐留在內存中
二、若是在spring的配置文件中一個bean的配置中有lazy-init="true"，那麼該bean在調用getBean方法時建立對象
很差處：不能過早的發現錯誤
好處：按照需求加載數據(何時要何時加載)
3.什麼是抽象類?什麼是接口?
抽象類：抽象類就是不能使用new方法進行實例化的類，即沒有具體實例對象的類，抽象類有點相似於「模板」的做用,目的是根據其格式來建立和修改新的類，對象不能由抽象類直接建立，只能夠經過抽象類派生出新的子類，再由其子類來建立對象，當一個類被聲明爲抽象類時，要在這個類前面加上修飾符abstract,在抽象類中的成員方法能夠包括通常方法和抽象方法
抽象方法：抽象方法就是以abstract修飾的方法，這種方法只聲明返回的數據類型，方法名稱和所須要的參數，沒有方法體，也就是說抽象方法只須要聲明而不須要事先，當一個方法爲抽象方法時，意味着這個方法必須被子類的方法所重寫，不然其子類的該方法仍然是abstract的，而這個子類也必須是抽象的，即聲明爲avstract
二者聯繫：抽象類中不必定包含抽象方法，可是包含抽象方法的類必定要被聲明爲抽象類，抽象類自己不具有實際的功能，只能用於派生其子類，抽象類中能夠包含構造方法，可是構造方法不能被聲明爲抽象，抽象類不能用final來修飾，即一個類不能既是最終類又是抽象類，abstract不能與private，static,final,native並列修飾同一個方法
接口:
Java接口是一些方法特徵的集合，沒有方法的實現。Java接口中定義的方法在不一樣的地方被實現(implements)，能夠具備徹底不一樣的行爲（功能）。
注意：(1)、java接口不能被實例化。
(2)、Java接口中聲明的成員自動設置爲public，所以java接口中不能聲明私有的成員。
(3)、Java接口中不能出現方法體實現。
(4)、實現(implements)某個java接口，就必須實現其中定義的全部方法。
接口(interface)的特徵:
1.全部的成員變量都是public、static、final類型。
2.全部的方法都是public、abstract類型。
3.全部的嵌套類型（類或接口）都是public、static類型。
抽象類（abstract class）和接口（interface）有什麼異同？
答：抽象類和接口都不可以實例化，但能夠定義抽象類和接口類型的引用。一個類若是繼承了某個抽象類
或者實現了某個接口都須要對其中的抽象方法所有進行實現，不然該類仍然須要被聲明爲抽象類。接口比
抽象類更加抽象，由於抽象類中能夠定義構造器，能夠有抽象方法和具體方法，而接口中不能定義構造器 並且其中的方法所有都是抽象方法。抽象類中的成員能夠是 private、默認、protected、public 的，而接口中 的成員全都是 public 的。抽象類中能夠定義成員變量，而接口中定義的成員變量實際上都是常量。有抽象 方法的類必須被聲明爲抽象類，而抽象類未必要有抽象方法。
4.什麼是內部類？內部類有什麼好處？
大部分時候，類被定義成一個獨立的程序單元.在某些狀況下，也會把一個類放在另外一個類的內部定義,這個定義在其餘類內部的類就被稱爲內部類，包含內部類的類也被稱爲外部類。
內部類主要有以下做用：
（1）內部類提供了更好的封裝，能夠把內部類隱藏在外部類以內，不容許同一個包中的其餘類訪問該類。
（2）內部類成員能夠直接訪問外部類的私有數據，由於內部類被當成其外部類成員，同一個類的成員之間能夠換互相訪問。但外部類不能訪問內部類的實現細節。
（3）匿名內部類適合用於建立那些僅須要一次使用的類。
補充：
從語法角度來看，定義內部類與定義外部類的語法大體相同，內部類除須要定義在其餘類裏面以外，還存在以下兩點區別：
（1）內部類比外部類能夠多使用三個修飾符：private、protected、static——外部類不可使用這三個修飾符。
（2）非靜態內部類不能擁有靜態成員。
5.如何進行整數、浮點數和字符串間的轉換？
- 調用基本數據類型對應的包裝類中的方法 parseXXX(String)或 valueOf(String)便可返回相應基本類型；
- 一種方法是將基本數據類型與空字符串（""）鏈接（+）便可得到其所對應的字符串；另外一種方法是調用 String 類中的 valueOf()方法返回相應字符串
6.說說continue如何控制循環過程的執行。
（1）break;
while循環break是用於永久終止循環。即不執行本次循環中break後面的語句，直接跳出循環。
（2）continue;
while循環continue是用於終止本次循環。即本次循環中continue後面的代碼不執行，進行下一次循環的入口判斷。
7.說說你對泛型的理解。
泛型，即「參數化類型」。一提到參數，最熟悉的就是定義方法時有形參，而後調用此方法時傳遞實參。那麼參數化類型怎麼理解呢？顧名思義，就是將類型由原來的具體的類型參數化，相似於方法中的變量參數，此時類型也定義成參數形式（能夠稱之爲類型形參），而後在使用/調用時傳入具體的類型（類型實參）。
8.說說Java中異常的分類，以及Java程序中是如何處理異常的。
Throwable類是Java異常類型的頂層父類，一個對象只有是 Throwable 類的（直接或者間接）實例，他纔是一個異常對象，才能被異常處理機制識別。JDK中內建了一些經常使用的異常類，咱們也能夠自定義異常。
Throwable又派生出Error類和Exception類。
錯誤：Error類以及他的子類的實例，表明了JVM自己的錯誤。錯誤不能被程序員經過代碼處理，Error不多出現。所以，程序員應該關注Exception爲父類的分支下的各類異常類。
異常：Exception以及他的子類，表明程序運行時發送的各類不指望發生的事件。能夠被Java異常處理機制使用，是異常處理的核心。
Java 經過面向對象的方法進行異常處理，把各類不一樣的異常進行分類，並提供了良好的接口。在 Java 中，每一個異常都是一個對象，它是 Throwable 類或其子類的實例。當一個方法出現異常後便拋出一個異常 對象，該對象中包含有異常信息，調用這個對象的方法能夠捕獲到這個異常並能夠對其進行處理。Java 的 異常處理是經過 5 個關鍵詞來實現的：try、catch、throw、throws 和 finally。通常狀況下是用 try 來執行一 段程序，若是系統會拋出（throw）一個異常對象，能夠經過它的類型來捕獲（catch）它，或經過老是執行 代碼塊（finally）來處理；try 用來指定一塊預防全部異常的程序；catch 子句緊跟在 try 塊後面，用來指定 你想要捕獲的異常的類型；throw 語句用來明確地拋出一個異常；throws 用來聲明一個方法可能拋出的各 種異常（固然聲明異常時容許無病呻吟）；finally 爲確保一段代碼無論發生什麼異常情況都要被執行；try語 句能夠嵌套，每當遇到一個 try 語句，異常的結構就會被放入異常棧中，直到全部的 try 語句都完成。若是 下一級的 try 語句沒有對某種異常進行處理，異常棧就會執行出棧操做，直到遇到有處理這種異常的 try 語 句或者最終將異常拋給 JVM。
9.說說進程和線程的區別，Java中如何建立線程？
區別：
（1）進程是資源的分配和調度的一個獨立單元，而線程是CPU調度的基本單元
（2）同一個進程中能夠包括多個線程，而且線程共享整個進程的資源（寄存器、堆棧、上下文），一個進行至少包括一個線程。
（3）進程結束後它擁有的全部線程都將銷燬，而線程的結束不會影響同個進程中的其餘線程的結束
（4）線程是輕兩級的進程，它的建立和銷燬所須要的時間比進程小不少，全部操做系統中的執行功能都是建立線程去完成的
（5）線程中執行時通常都要進行同步和互斥，由於他們共享同一進程的全部資源
（6）線程有本身的私有屬性TCB，線程id，寄存器、硬件上下文，而進程也有本身的私有屬性進程控制塊PCB，這些私有屬性是不被共享的，用來標示一個進程或一個線程的標誌
Java 5 之前實現多線程有兩種實現方法：一種是繼承 Thread 類；另外一種是實現 Runnable 接口。兩種方 式都要經過重寫 run()方法來定義線程的行爲，推薦使用後者，由於 Java 中的繼承是單繼承，一個類有一個 父類，若是繼承了 Thread 類就沒法再繼承其餘類了，顯然使用 Runnable 接口更爲靈活。
補充：Java 5 之後建立線程還有第三種方式：實現 Callable 接口，該接口中的 call 方法（線程執行體）能夠在線程執行結束時產生一個返回值
10.什麼是註解？試舉例你使用過的註解。
定義：註解（Annotation），也叫元數據。一種代碼級別的說明。它是JDK1.5及之後版本引入的一個特性，與類、接口、枚舉是在同一個層次。它能夠聲明在包、類、字段、方法、局部變量、方法參數等的前面，用來對這些元素進行說明，註釋。
做用分類：
①編寫文檔：經過代碼裏標識的元數據生成文檔
② 代碼分析：經過代碼裏標識的元數據對代碼進行分析
③編譯檢查：經過代碼裏標識的元數據讓編譯器可以實現基本的編譯檢查
11.什麼是對象序列化？
對象的序列化（Serialize）是指將一個Java對象寫入IO流中，與此對應的是，對象的反序列化（Deserialize）則指從IO流中恢復該Java對象。
對象序列化的目標是將對象保存到磁盤中，或容許在網絡中直接傳輸對象。對象序列化機制容許把內存中的Java對象轉換成平臺無關的二進制流，從而容許把這種二進制流持久地保存在磁盤上，經過網絡將這種二進制流傳輸到另外一個網絡節點。其餘程序一旦得到了這種二進制流（不管是從磁盤中獲取的，仍是經過網絡獲取的），均可以將這種二進制流恢復成原來的Java對象。
12.列舉你使用過的集合類，並說明用途和注意事項。
13.什麼是XML，什麼是Web Service，什麼是Json？在Java中如何處理Json？
XML全稱爲Extensible Markup Language， 意思是可擴展的標記語言。XML語法上和HTML比較類似， 但HTML中的元素是固定的， 而XML的標籤是能夠由用戶自定義的。
a) xml, eXtensible Markup Language, 可擴展標記語言. 是一種標記語言.
b) xml是一種很是靈活的語言, 沒有固定的標籤, 全部的標籤均可以自定義.
c) 一般, xml被用於信息的記錄和傳遞. 所以, xml常常被用於充當配置文件.
Web Service:
從表面上看，Web Service 就是一個應用程序，它向外界暴露出一個可以經過 Web 進行調用的 API。這 就是說，你可以用編程的方法透明的調用這個應用程序，不須要了解它的任何細節，跟你使用的編程語言 也沒有關係。例如能夠建立一個提供天氣預報的 Web Service，那麼不管你用哪一種編程語言開發的應用均可 以經過調用它的 API 並傳入城市信息來得到該城市的天氣預報。之因此稱之爲 Web Service，是由於它基於 HTTP 協議傳輸數據，這使得運行在不一樣機器上的不一樣應用無須藉助附加的、專門的第三方軟件或硬件，就 可相互交換數據或集成。 補充：這裏必需要說起的一個概念是 SOA（Service-Oriented Architecture，面向服務的架構），SOA 是一種思 想，它將應用程序的不一樣功能單元經過中立的契約聯繫起來，獨立於硬件平臺、操做系統和編程語言，使 得各類形式的功能單元可以更好的集成。顯然，Web Service 是 SOA 的一種較好的解決方案，它更多的是一 種標準，而不是一種具體的技術。
Json:
JSON是JavaScript Object Notation的簡稱，中文含義爲「JavaScript 對象表示法」，它是一種數據交換的文本格式，而不是一種編程語言。
JSON 是一種輕量級的數據交換格式，它基於 ECMAScript (w3c制定的js規範)的一個子集，採用徹底獨立於編程語言的文本格式來存儲和表示數據。簡潔和清晰的層次結構使得 JSON 成爲理想的數據交換語言。易於人閱讀和編寫，同時也易於機器解析和生成，並有效地提高網絡傳輸效率。
---------------------------------------------------------------------------------------------------------------------
json簡介
百度百科：
JSON(JavaScript Object Notation, JS 對象標記) 是一種輕量級的數據交換格式。它基於 ECMAScript 規範的一個子集，採用徹底獨立於編程語言的文本格式來存儲和表示數據。簡潔和清晰的層次結構使得 JSON 成爲理想的數據交換語言。 易於人閱讀和編寫，同時也易於機器解析和生成，並有效地提高網絡傳輸效率。
什麼是 JSON ？
JSON 指的是 JavaScript 對象表示法（JavaScript Object Notation）
JSON 是輕量級的文本數據交換格式
JSON 獨立於語言 *
JSON 具備自我描述性，更易理解
* JSON 使用 JavaScript 語法來描述數據對象，可是 JSON 仍然獨立於語言和平臺。JSON 解析器和 JSON 庫支持許多不一樣的編程語言。
相似 XML
JSON 是純文本
JSON 具備「自我描述性」（人類可讀）
JSON 具備層級結構（值中存在值）
JSON 可經過 JavaScript 進行解析
JSON 數據可以使用 AJAX 進行傳輸
相比 XML 的不一樣之處
沒有結束標籤
更短
讀寫的速度更快
可以使用內建的 JavaScript eval() 方法進行解析
使用數組
不使用保留字
-------------------------------------------------------------------------------------------------------------------
14.三大框架的做用
三大框架是用來開發web應用程序中使用的.
Struts:基於MVC的充當了其中的視圖層和控制器
Hibernate:作持久化的,對JDBC輕量級的封裝,使得咱們能過面向對象的操做數據庫
Spring: 採用了控制反轉的技術,管理Bean,下降了各層之間的耦合.
15.什麼是MVC
Model View Controller，是模型-視圖-控制器的縮寫，一種軟件設計典範，用一種業務邏輯、數據、界面顯示分離的方法組織代碼，將業務邏輯彙集到一個組件裏，在改進和個性化定製界面的及用戶交互的時候，不須要從新編寫業務邏輯。mvc用於映射傳統的輸入、處理、輸出功能在一個邏輯的圖形用戶界面的結構中。
mvc就是相似三層的一種架構，主要採用封裝（分層）的思想，來下降耦合度，從而使咱們的系統更靈活，擴展性更好。
（1）model是應用程序中用於處理數據邏輯的部分。一般模型對象負責在數據庫中存取數據。
（2）view是應用程序中處理數據顯示的部分。一般視圖是依據數據模型建立的。
（3）controller是應用程序中處理數據交互的部分。一般控制器負責從視圖讀取數據，控制用戶輸入，並向模型發送。
模型（Model） 「數據模型」（Model）用於封裝與應用程序的業務邏輯相關的數據以及對數據的處理方法。「模型」有對數據直接訪問的權力，例如對數據庫的訪問。「模型」不依賴「視圖」和「控制器」，也就是說，模型不關心它會被如何顯示或是如何被操做。可是模型中數據的變化通常會經過一種刷新機制被公佈。爲了實現這種機制，那些用於監視此模型的視圖必須事先在此模型上註冊，從而，視圖能夠了解在數據模型上發生的改變。
視圖（View） 視圖層可以實現數據有目的的顯示（理論上，這不是必需的）。在視圖中通常沒有程序上的邏輯。爲了實現視圖上的刷新功能，視圖須要訪問它監視的數據模型（Model），所以應該事先在被它監視的數據那裏註冊。
控制器（Controller） 控制器起到不一樣層面間的組織做用，用於控制應用程序的流程。它處理事件並做出響應。「事件」包括用戶的行爲和數據模型上的改變。
補充：
一、mvc的優勢
（1）多個視圖共享一個模型，大大提升代碼的可重用性。
（2）三個模塊相互獨立，改變其中一個不會影響其餘兩，因此依據這種設計模式能構建良好的鬆耦合性的組件。
（3）控制器提升了應用程序的靈活性和可控制性。控制器能夠用來鏈接不一樣的模型和視圖去完成用戶的需求，這樣控制器能夠爲構造應用程序提升強有力的手段。
二、mvc的缺點
（1）增長了系統結構和實現的複雜性。
對於簡單頁面，嚴格遵循mvc，使模型、視圖與控制器分離，會增長結構的複雜性，並可能產生過多的更新操做，下降運行效率。
（2）視圖與控制器過於緊密的鏈接。
視圖與控制器是相互分離，但確實聯繫緊密的部件，視圖沒有控制器的存在，其應用是頗有限的，反之亦然，這樣就妨礙了他們的獨立重用。
（3）視圖對模型數據的低效率訪問。
依據模型操做接口的不一樣，視圖可能須要屢次調用才能得到足夠的顯示數據。對未變化數據的沒必要要的頻繁訪問，也將損害操做性能。
（4）目前，一些高級的界面工具或構造器不支持mvc。
改造這些工具以適應MVC須要和創建分離的部件的代價是很高的，從而形成使用MVC的困難。
綜上，對於開發存在大量用戶界面，而且業務邏輯複雜的大型應用程序，MVC將會使你的軟件在健壯性、代碼重用和結構方面上一個新的臺階。儘管在最初構建MVC框架時會花費必定的工做量，但從長遠角度看，它會大大提升後期軟件開發的效率。因此咱們在具體適用時，要綜合考慮其適用範圍，
16.jsp與servlet的區別與聯繫
jsp和servlet的區別和聯繫：
1.jsp經編譯後就變成了Servlet.
(JSP的本質就是Servlet，JVM只能識別java的類，不能識別JSP的代碼,Web容器將JSP的代碼編譯成JVM可以識別的java類)
2.jsp更擅長表現於頁面顯示,servlet更擅長於邏輯控制.
3.Servlet中沒有內置對象，Jsp中的內置對象都是必須經過HttpServletRequest對象，HttpServletResponse對象以及HttpServlet對象獲得.
Jsp是Servlet的一種簡化，使用Jsp只須要完成程序員須要輸出到客戶端的內容，Jsp中的Java腳本如何鑲嵌到一個類中，由Jsp容器完成。
而Servlet則是個完整的Java類，這個類的Service方法用於生成對客戶端的響應。
聯繫：
JSP是Servlet技術的擴展，本質上就是Servlet的簡易方式。JSP編譯後是「類servlet」。
Servlet和JSP最主要的不一樣點在於：
Servlet的應用邏輯是在Java文件中，而且徹底從表示層中的HTML裏分離開來。
而JSP的狀況是Java和HTML能夠組合成一個擴展名爲.jsp的文件。
JSP側重於視圖，Servlet主要用於控制邏輯
Servlet更多的是相似於一個Controller，用來作控制。
理解如下三點便可：
一、不一樣之處在哪？
- Servlet在Java代碼中經過HttpServletResponse對象動態輸出HTML內容
- JSP在靜態HTML內容中嵌入Java代碼，Java代碼被動態執行後生成HTML內容
二、各自的特色
- Servlet可以很好地組織業務邏輯代碼，可是在Java源文件中經過字符串拼接的方式生成動態HTML內容會致使代碼維護困難、可讀性差
- JSP雖然規避了Servlet在生成HTML內容方面的劣勢，可是在HTML中混入大量、複雜的業務邏輯一樣也是不可取的
三、經過MVC雙劍合璧
既然JSP和Servlet都有自身的適用環境，那麼可否揚長避短，讓它們發揮各自的優點呢？答案是確定的——MVC(Model-View-Controller)模式很是適合解決這一問題。
MVC模式（Model-View-Controller）是軟件工程中的一種軟件架構模式，把軟件系統分爲三個基本部分：模型（Model）、視圖（View）和控制器（Controller）：
- Controller——負責轉發請求，對請求進行處理
- View——負責界面顯示
- Model——業務功能編寫（例如算法實現）、數據庫設計以及數據存取操做實現
在JSP/Servlet開發的軟件系統中，這三個部分的描述以下所示：
- Web瀏覽器發送HTTP請求到服務端，被Controller(Servlet)獲取並進行處理（例如參數解析、請求轉發）
- Controller(Servlet)調用核心業務邏輯——Model部分，得到結果
- Controller(Servlet)將邏輯處理結果交給View（JSP），動態輸出HTML內容
- 動態生成的HTML內容返回到瀏覽器顯示
MVC模式在Web開發中的好處是很是明顯，它規避了JSP與Servlet各自的短板，Servlet只負責業務邏輯而不會經過out.append()動態生成HTML代碼；JSP中也不會充斥着大量的業務代碼。這大大提升了代碼的可讀性和可維護性。
原文：https://www.cnblogs.com/sanyouge/p/7325656.html
17.JDBC的鏈接步驟
下面的代碼以鏈接本機的 Oracle 數據庫爲例，演示 JDBC 操做數據庫的步驟。
// 加載驅動。
Class.forName("oracle.jdbc.driver.OracleDriver");
// 建立鏈接。
Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
// 建立語句。
PreparedStatement ps = con.prepareStatement("select * from emp where sal between ? and ?");
ps.setInt(1, 1000);
ps.setInt(2, 3000);
// 執行語句。
ResultSet rs = ps.executeQuery();
// 處理結果。
while(rs.next()) {
System.out.println(rs.getInt("empno") + " - " + rs.getString("ename"));
}
// 關閉資源。
finally {
if(con != null) {
try {
con.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
提示：關閉外部資源的順序應該和打開的順序相反，也就是說先關閉 ResultSet、再關閉 Statement、在關閉 Connection。上面的代碼只關閉了 Connection（鏈接），雖然一般狀況下在關閉鏈接時，鏈接上建立的語句 和打開的遊標也會關閉，但不能保證老是如此，所以應該按照剛纔說的順序分別關閉。此外，第一步加載 驅動在 JDBC 4.0 中是能夠省略的（自動從類路徑中加載驅動），可是咱們建議保留
Statement 和 PreparedStatement 有什麼區別？哪一個性能更好？
答：與 Statement 相比，①PreparedStatement 接口表明預編譯的語句，它主要的優點在於能夠減小 SQL的 編譯錯誤並增長 SQL 的安全性（減小 SQL 注射攻擊的可能性）；②PreparedStatement 中的 SQL 語句是能夠 帶參數的，避免了用字符串鏈接拼接 SQL 語句的麻煩和不安全；③當批量處理 SQL 或頻繁執行相同的查詢 時，PreparedStatement 有明顯的性能上的優點，因爲數據庫能夠將編譯優化後的 SQL 語句緩存起來，下次 執行相同結構的語句時就會很快（不用再次編譯和生成執行計劃）。
18.用Java 寫一個冒泡排序。
冒泡排序的思想
該排序算法意在從後往前像氣泡同樣，依次冒出數組中值小的元素；或者從前日後依次冒出數組中值大的元素。
以升序爲例，假設數組的長度爲size。從數組的最後一個元素（即第size-1個元素）開始，從後往前兩兩進行比較，即最開始比較第size-1個元素和第size-2個元素的值的大小，若發現前者比後者小，則進行交換，不然不交換，以後無論是否已進行交換操做，繼續往前遍歷，遍歷到第0個元素爲止，這時候肯定第0個元素爲數組中最小的值；而後，再從新開始比較第size-1個元素和第size-2個元素的值的大小，對其進行前面所述的操做，直到遍歷到第1個元素爲止，這時候肯定第1個元素爲數組中第二小的值；以此類推，直到對整個數組操做完爲止。
public static void swap( int [] arr, int a, int b) {
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
/* 冒泡排序。 */
public static void bubbleSort( int [] arr) {
for ( int x=0; x<arr.length-1; x++) {
for ( int y=0; y<arr.length-1-x; y++) {
if (arr[y]>arr[y+1]){
swap(arr,y,y+1);
}
}
}
}
1九、用Java 寫一個折半查找。
答：折半查找，也稱二分查找、二分搜索，是一種在有序數組中查找某一特定元素的搜索算法。搜素過程 從數組的中間元素開始，若是中間元素正好是要查找的元素，則搜素過程結束；若是某一特定元素大於或
者小於中間元素，則在數組大於或小於中間元素的那一半中查找，並且跟開始同樣從中間元素開始比較。
若是在某一步驟數組已經爲空，則表示找不到指定的元素。這種搜索算法每一次比較都使搜索範圍縮小一 半，其時間複雜度是 O(logN)。 import java.util.Comparator;
1 public static int halfSearch( int [] arr, int key) {
3 int max,min,mid;
4 min = 0;
5 max = arr.length-1;
6 mid = (max+min)/2;
7 while (arr[mid]!=key) {
9 if (key>arr[mid])
10 min = mid + 1;
11 else if (key<arr[mid])
12 max = mid - 1;
13 if (max<min)
14 return -1;
15 mid = (max+min)/2;
16 }
17 return mid;
18 }
20.Java實現同步的幾種方式
https://www.cnblogs.com/jiansen/p/7351872.html
編寫多線程程序有幾種實現方式？
答：Java 5 之前實現多線程有兩種實現方法：一種是繼承 Thread 類；另外一種是實現 Runnable 接口。兩種方 式都要經過重寫 run()方法來定義線程的行爲，推薦使用後者，由於 Java 中的繼承是單繼承，一個類有一個 父類，若是繼承了 Thread 類就沒法再繼承其餘類了，顯然使用 Runnable 接口更爲靈活。
補充：Java 5 之後建立線程還有第三種方式：實現 Callable 接口，該接口中的 call 方法能夠在線程執行結束時產生一個返回值.
synchronized 關鍵字的用法？
答：synchronized 關鍵字能夠將對象或者方法標記爲同步，以實現對對象和方法的互斥訪問，能夠用 synchronized(對象) { … }定義同步代碼塊，或者在聲明方法時將 synchronized 做爲方法的修飾符。
什麼是線程同步 如何實現線程同步
當使用多個線程來訪問同一個數據時，很是容易出現線程安全問題(好比多個線程都在操做同一數據致使數據不一致),因此咱們用同步機制來解決這些問題。
實現同步機制有兩個方法：
1.同步代碼塊：
synchronized(同一個數據){} 同一個數據：就是N條線程同時訪問一個數據。
2.同步方法：
public synchronized 數據返回類型 方法名(){}
就是使用 synchronized 來修飾某個方法，則該方法稱爲同步方法。對於同步方法而言，無需顯示指定同步監視器，同步方法的同步監視器是 this 也就是該對象的自己（這裏指的對象自己有點含糊，其實就是調用該同步方法的對象）經過使用同步方法，可很是方便的將某類變成線程安全的類，具備以下特徵：
1，該類的對象能夠被多個線程安全的訪問。
2，每一個線程調用該對象的任意方法以後，都將獲得正確的結果。
3，每一個線程調用該對象的任意方法以後，該對象狀態依然保持合理狀態。
注：synchronized關鍵字能夠修飾方法，也能夠修飾代碼塊，但不能修飾構造器，屬性等。
實現同步機制注意如下幾點： 安全性高，性能低，在多線程用。性能高，安全性低，在單線程用。
1，不要對線程安全類的全部方法都進行同步，只對那些會改變共享資源方法的進行同步。
2，若是可變類有兩種運行環境，當線程環境和多線程環境則應該爲該可變類提供兩種版本：線程安全版本和線程不安全版本(沒有同步方法和同步塊)。在單線程中環境中，使用線程不安全版本以保證性能，在多線程中使用線程安全版本.
21.Druid 鏈接池簡介
Druid首先是一個數據庫鏈接池。Druid是目前最好的數據庫鏈接池，在功能、性能、擴展性方面，都超過其餘數據庫鏈接池，包括DBCP、C3P0、BoneCP、Proxool、JBoss DataSource。Druid已經在阿里巴巴部署了超過600個應用，通過一年多生產環境大規模部署的嚴苛考驗。
同時Druid不只僅是一個數據庫鏈接池，它包括四個部分：
Druid是一個JDBC組件，它包括三個部分：
基於Filter－Chain模式的插件體系。
DruidDataSource 高效可管理的數據庫鏈接池。
SQLParser
Druid的功能
一、替換DBCP和C3P0。Druid提供了一個高效、功能強大、可擴展性好的數據庫鏈接池。
二、能夠監控數據庫訪問性能，Druid內置提供了一個功能強大的StatFilter插件，可以詳細統計SQL的執行性能，這對於線上分析數據庫訪問性能有幫助。
三、數據庫密碼加密。直接把數據庫密碼寫在配置文件中，這是很差的行爲，容易致使安全問題。DruidDruiver和DruidDataSource都支持PasswordCallback。
四、SQL執行日誌，Druid提供了不一樣的LogFilter，可以支持Common-Logging、Log4j和JdkLog，你能夠按須要選擇相應的LogFilter，監控你應用的數據庫訪問狀況。
五、擴展JDBC，若是你要對JDBC層有編程的需求，能夠經過Druid提供的Filter機制，很方便編寫JDBC層的擴展插件。
22.Dubbo（原文：https://blog.csdn.net/houshaolin/article/details/76408399）
1. 服務提供者在啓動時，向註冊中心註冊本身提供的服務。
2. 服務消費者在啓動時，向註冊中心訂閱本身所需的服務。
3. 註冊中心返回服務提供者地址列表給消費者，若是有變動，註冊中心將基於長鏈接推送變動數據給消費者。
4. 服務消費者，從提供者地址列表中，基於軟負載均衡算法，選一臺提供者進行調用，若是調用失敗，再選另外一臺調用。
5. 服務消費者和提供者，在內存中累計調用次數和調用時間，定時每分鐘發送一次統計數據到監控中心。
23.轉發和重定向的區別？
請求轉發 ：
a) 只發送一次請求
b) 地址欄不發生改變
c) 數據能夠一直傳遞
d) 只能跳轉內部資源, 不能訪問外部資源
// 請求轉發
req.getRequestDispatcher("dis2").forward(req, resp);
重定向：
a) 會發送屢次請求
b) 地址欄會發生改變
c) 數據不能繼續傳遞
d) 內部資源和外部資源均可以訪問
// 重定向
resp.sendRedirect("red2?mouse="+req.getParameter("mouse"));
forward 是容器中控制權的轉向，是服務器請求資源，服務器直接訪問目標地址的 URL，把那個 URL 的 響應內容讀取過來，而後把這些內容再發給瀏覽器，瀏覽器根本不知道服務器發送的內容是從哪兒來的， 因此它的地址欄中仍是原來的地址。redirect 就是服務器端根據邏輯，發送一個狀態碼，告訴瀏覽器從新去 請求那個地址，所以從瀏覽器的地址欄中能夠看到跳轉後的連接地址，很明顯 redirect 沒法訪問到服務器 保護起來資源，可是能夠從一個網站 redirect 到其餘網站。forward 更加高效，因此在知足須要時儘可能使用 forward（經過調用 RequestDispatcher 對象的 forward()方法，該對象能夠經過 ServletRequest 對象的 getRequestDispatcher()方法得到），而且這樣也有助於隱藏實際的連接；在有些狀況下，好比須要訪問一個 其它服務器上的資源，則必須使用重定向（經過 HttpServletResponse 對象調用其 sendRedirect()方法實現）。
24.JSP 有哪些內置對象？做用分別是什麼？
JSP 有 9 個內置對象：
- request：封裝客戶端的請求，其中包含來自 GET 或 POST請求的參數；
- response：封裝服務器對客戶端的響應；
- pageContext：經過該對象能夠獲取其餘對象；
- session：封裝用戶會話的對象；
- application：封裝服務器運行環境的對象；
- out：輸出服務器響應的輸出流對象；
- config：Web 應用的配置對象；
- page：JSP 頁面自己（至關於 Java 程序中的 this）；
- exception：封裝頁面拋出異常的對象。