面試中遇到的問題加以整理。歡迎指正。

問答題（共30分，每個5分）：

1 寫出java的資料型別

                                           整數型別（byte，short，int，long）

                                數值型

                                            浮點型別（float，double）

              基本資料型別      字元型（char）

                                 布林型（boolean）

資料型別

                         類（class）

            引用型別     介面（interface）

                        陣列（[]）

2  Collection和Collections的區別

 Collection是集合類的上級介面，繼承與他的介面主要有Set和List.

（Collections是針對集合類的一個幫助類，他提供一系列靜態方法實現對各種集合的搜尋、排序、執行緒安全化等操作。）

Collections是一個操作 Set、List 和 Map 等集合的工具類。

Collections中提供了大量方法對集合元素進行排序、查詢和修改等操作等方法。

3 final,finally,finalize區別，儘可能多說

Final：用於宣告屬性、方法和類，分別表示屬性不可變（地址不能改變）、方法不可覆蓋、類不可繼承；

 Finally：是異常處理語句結構的一部分，表示總是執行；

 Finalize：是object類的一個方法，在垃圾收集器執行的時候會呼叫被回收物件的此方法，可以覆蓋此方法提供的垃圾收集時的其他資源的回收，例如關閉檔案等。

4 描述一下集合框架體系

5介紹一個io流

輸入輸出流是相對於計算機記憶體來說的

6 說出5個常見的異常，用文字說不得分

算術異常類：ArithmeticExecption

空指標異常類：NullPointerException

型別強制轉換異常：ClassCastException

陣列負下標異常：NegativeArrayException

陣列下標越界異常：ArrayIndexOutOfBoundsException

違背安全原則異常：SecturityException

檔案已結束異常：EOFException

檔案未找到異常：FileNotFoundException

字串轉換為數字異常：NumberFormatException

操作資料庫異常：SQLException

輸入輸出異常：IOException

程式設計題（每個10分，4,5題各15分）：

1.      多型的表現（過載和重寫），並各寫出一個多型的案例

重寫

publicclass Person {

    public String name;

    public int age;

    public String getInfo() {

        return "Name: "+ name +"\n" +"age: "+ age;

    }

}

publicclass Student extends Person {

    public String school;

    public String getInfo() {    //覆蓋方法

        return "Name: "+ name + "\nage: "+ age

        + "\nschool: "+ school;

}

}

過載在同一個類中可以定義多個同名方法

         public class PrintStream{

            public void print(int i) {……}

            public void print(float f) {……}

            public void print(String s) {……}

            }

2 寫出其中一種執行緒的實現方式（執行緒的實現方式有多種，如果都會，可以都寫出來）

在Java中建立執行緒的兩種方式

1 繼承Java.lang.Thread類，並覆蓋run()方法

class MyThread extends Thread {

    public void run( ) {

        /* 覆蓋該方法*/

     }

 }

啟動繼承Thread的執行緒

MyThread t = newMyThread();

t.start();

2 實現Java.lang.Runnable介面，並實現run()方法

class MyThread implements Runnable{

     public void run( ) {

           /* 實現該方法*/

     }

 }

啟動實現Runnable介面的執行緒

MyThread mt = newMyThread();

Thread t = newThread(mt);

t.start();

packagetestjava1;

/*實現Java.lang.Runnable介面，並實現run()方法*/

publicclass Runnable1 implements Runnable {

       public void run() {

              System.out.println("實現了Runnable介面的實現方式");

       }

       public static void main(String[] args) {

              Runnable1 mythread1 = newRunnable1();

              Thread t = new Thread(mythread1);

              Thread t1 = new Thread(mythread1);

              t.start();

              System.out.println(Thread.currentThread().getName());

       }

}

packagetestjava1;

/*1 繼承Java.lang.Thread類，並覆蓋run()方法*/

publicclass MyThread extends Thread {

       public void run() {

              super.run();// 引用父類的run方法

              System.out.println("執行緒起來了，通過實現繼承了Thread類的方式");

       }

       public static void main(String[] args) {

              // 創一個建一個物件

              MyThread myThread = newMyThread();

              // 用start方法啟動一個執行緒

              myThread.start();

              // 訪問當前執行緒Thread.currentThread().getName())，該方法為靜態方法，因為直接用類名呼叫方法

              System.out.println(Thread.currentThread().getName());

       }

}

3 如何判斷一個數是素數？請用程式實現

//判斷一個數是不是素數

import java.util.*;

public class JudgmentPrime {

       public staticvoid main(String[] args) {

              Scanners = new Scanner(System.in);

              System.out.println("請輸入一個數");

              intnum = s.nextInt();

              if(num <= 1)

                     System.out.println("請輸入大於1的正整數");

              else {

                     //設定一個標誌位

                     booleanflag = true;

                     for(int i = 2; i < num; i++) {

                            if(num % i == 0) {

                                   // 只要有一次能除盡，就不是素數

                                   //然後後面的迴圈就不用再執行了

                                   flag= false;

                                   break;

                            }

                            //如果每一次都除不盡，說明最後的標誌位沒有發生改變

                            //那麼我們可以得出結論，是素數

                     }//for迴圈結束，通過flag能夠得出結論

                     if(flag) {// 相當於flag == true

                            System.out.println("是素數");

                     }else {

                            System.out.println("不是素數");

                     }

              }

       }

}

4 用map來實現對詩的檢索，注意，詩名稱可能有重複

package test5;

importjava.util.HashMap;

importjava.util.Map;

importjava.util.Scanner;

importjava.util.Set;

/*1.使用hashmap實現詩詞查詢功能。

選做：考慮詩重名的情況*/還沒有複習

public classPoetry1 {

       public static void main(String[] args) {

              Map map = new HashMap();

              map.put("絕句李清照", "生當作人傑,死亦為鬼雄.至今思項羽,不肯過江東");

              map.put("絕句杜甫", "江邊踏青罷,回首見旌旗.風起春城暮,高樓鼓角悲.");

              map.put("登鸛雀樓王維", "白日依山盡，黃河入海流。欲窮千里目，更上一層樓。");

              map.put("鹿柴王維", "空山不見人，但聞人語響。返影入深林，復照青苔上。");

              map.put("月夜劉方平", "更深月色半人家，北斗闌干南鬥斜。  今夜偏知春氣暖，蟲聲新透綠窗紗。 ");

              map.put("靜夜思李白", "床前明月光，疑是地上霜。舉頭望明月，低頭思故鄉。");

              map.put("月夜文天祥", "月到中天雲劃開，斷橋幻出玉樓臺。  夜深一鶴掠舟過，疑是坡仙赤壁來。");

              Scanner s = newScanner(System.in);

              System.out.println("請輸入詩的名字:");

              String a = s.next();

              System.out.println("請輸入詩的作者:");

              String b = s.next();

              if (map.containsKey(a + b)) {

                     System.out.println(map.get(a+ b));

              } else {

                     System.out.println("沒有這首詩");

              }

       }

}

class Poetry2 {

       public String title;// 題目

       public String author;// 作者

       public String content;// 內容

       public Poetry2() {

       }

       public Poetry2(String author, Stringcontent) {

              this.author = author;

              this.content = content;

       }

       public String getTitle() {

              return title;

       }

       public void setTitle(String title) {

              this.title = title;

       }

       public String getAuthor() {

              return author;

       }

       public void setAuthor(String author) {

              this.author = author;

       }

       public String getContent() {

              return content;

       }

       public void setContent(String content) {

              this.content = content;

       }

}

5 寫出單例模式的一種實現

class Single{

      privatestatic Single onlyone = new Single();//私有的，只能在類的內部訪問

      privateString name;

     public static Single getSingle() {   //static修飾

          return onlyone;

      }

      privateSingle() {}     //private的構造器，不能在類的外部建立該類的物件

}

public classTestSingle{

       public static void main(String args[]) {        

          Single  s1 = Single.getSingle();      //訪問靜態方法

          Single  s2 = Single.getSingle();

          if (s1==s2){

               System.out.println("s1 isequals to s2!");

          }

       }

}

6用繼承和多型的形式寫出動物類（或者介面），以及繼承或實現類貓和狗，貓和狗，又表現出不同的行為（多型）

package test1;

//練習多型Animal

public class Animal {

       public intage;// 年齡

       public Stringcategory;// 類別

       publicAnimal() {// 構造無引數方法

       }

       publicAnimal(int age, String category) {// 有引數的方法

              this.age= age;

              this.category= category;

       }

       public voideat() {

              System.out.println();

       }

       public voidmove() {

              System.out.println();

       }

       public intgetAge() {

              returnage;

       }

       public voidsetAge(int age) {

              this.age= age;

       }

       public StringgetCategory() {

              returncategory;

       }

       public voidsetCategory(String category) {

              this.category= category;

       }

}

}

package test1;

//練習多型

public class Cat extends Animal {

       public intage;

       public voideat(){

              System.out.println("貓吃魚");

       }

       public voidmove(){

              System.out.println("貓捉老鼠");

       }

       public staticvoid main(String[] args) {

              Animala=new Cat();//利用多型

              a.eat();

              a.move()；

       }

}

 package test1;

//練習多型

public class Dog extends Animal {

       public int age;

       public voideat(){

              System.out.println("狗吃肉");

       }

       public voidmove(){

              System.out.println("狗看門");

       }

       public staticvoid main(String[] args) {

              Animala=new Dog();//利用多型

              a.eat();

              a.move();

       }

}

1:建立時的區別：   Statement stm=con.createStatement();
   PreparedStatement pstm=con.prepareStatement(sql);
執行的時候:
    stm.execute(sql);
    pstm.execute(); 
2: pstm一旦綁定了SQL,此pstm就不能執行其他的Sql，即只能執行一條SQL命令。  stm可以執行多條SQL命令。
3: 對於執行同構的sql（只有值不同，其他結構都相同）,用pstm的執行效率比較的高，對於異構的SQL語句，Statement的執行效率要高。
4：當需要外部變數的時候，pstm的執行效率更高.

2 、switch(表示式)中表達式的返回值必須是下述幾種型別之一：int, byte, char, short,列舉, 字串；String

3、說出至少三種包名

Java.lang   java.io java.util   java.net

4 、重寫和過載的區別

重寫是在子類和父類之間，具有相同的方法名、引數列表和返回值型別，但是方法體不同。overwrite重寫

過載必須是在同一個類下，方法名相同，引數列表必須不同和返回值型別也可以不同。override過載

5、基本型別資料轉換為String型別時，呼叫了對應封裝類的toString()方法

6、List和set的遍歷

List list = newArrayList();

list.add("hello");

list.add("world");

Iterator it =list.iterator();

while(it.hasNext()){

String s =(String)it.next();

System.out.println(s);

}

7、Collections.sort(listB,new Comparator<B>() {}）這一句意思是，要對List<B>就行排序

8、Arraylist和linkedlist的區別

Arraylist

Linkedlist：插入刪除等頻繁效率比較低下，查詢效率低

9、map的遍歷迴圈

Set<String> set =map.keySet();// 把map.keySet值放在set集合中

       //方法1

       Iterator it = set.iterator();

       System.out.println("列印map的key");

       while (it.hasNext()) {

           System.out.println(it.next() + " ");

       }

方法二

for (Entry<String,String> entry : map.entrySet())

       {

           System.out.println("key是：" + entry.getKey() + "##值是:"

                  + entry.getValue());

       }

昨天上課，給大家梳理了資料庫，今天再梳理梳理
java的知識點，重點:
資料型別，迴圈，排序(注意冒泡和選擇排序，選擇更好理解我覺得，但是要注意區別)，面向物件三大特徵(封裝，繼承，多型(過載和重寫))，構造方法，訪問修飾符，static關鍵字，介面，抽象類，final關鍵字，異常體系，集合體系，執行緒實現，泛型，jdbc訪問資料庫。另外還有平時給大家講的知識點。網路程式設計咱沒講，可以自己看看。單例模式

Io口

封裝 通過將資料宣告為私有額，再提供公有的方法get  set  對屬性操作  （保護類中的資訊，隱藏細節資訊，提高系統獨立性，便於修改，增強程式碼可維護性）

繼承  子類擁有父類的資料結構，只能單繼承

，子類繼承了父類，就繼承了父類的方法和屬性，在子類中可以使用父類定義的方法和屬性也可以自己建立新的方法和屬性，通常來說子類的功能比父類多， 子類不能繼承父類的private 成員變數和方法

多型（一個介面多個方法，實現前提 ：繼承，方法重寫，指向父類的引用）

前期是繼承的關係，子類的物件替代父類的物件使用，一個變數只有一種確定的資料型別，一個引用型別的變數可以只想多種不同型別的物件。

過載  同一個類中允許同時存在一個以上的同名方法，引數型別個數即可。

（1）同一個類中可以定義多個同名的方法

（2）方法的引數列表必須不同

（3）方法的返回值可以相同可不同

（4）呼叫時根據方法引數型別累區別

重寫 在子類中定義一個方法，其名稱， 返回值型別和引數列表正好與父類的某個方法,名稱，返回值型別引數列表匹配

重寫方法的返回值必須和被重寫方法的返回值一致

super

表示呼叫父類的構造方法，只是呼叫方法，不構造物件,若子類的構造方法引用super，必須放在super的首個語句

引用父類成分，private不能訪問，存在繼承的關係  super用於訪問父類定義的屬性  super 用於呼叫父類定義的成員方法 super用於在子類中呼叫父類的構造方法  在構造方法中super 放在第一行 

collection  分為set 和list

     hashset   不保證元素的排列順序，執行緒不安全，可以有null元素

set 

    treeset

     arraylist  遍歷元素和隨機訪問元素的效率高，插入刪除頻繁時效率底下

list

  linkedlist  插入刪除元素效率高，查詢效率低

     hashmap  執行緒不安全，允許空，不保證原色的排列順序

map    treemap   key是有序的

    hashtable   古老的map實現類，執行緒安全，不允許空

一個物件被當作垃圾回收的情況

1:物件被賦值為空

2:物件引用超過作用域

3；finalizer機制

static  限定該成員方法為靜態方法

final 限定該成員方法不能被重寫過載

abstract 限定該成員方法為抽象方法，不提供具體實現

servlet生命週期

init（）  初始化階段，web容器通過呼叫init方法來初始化servlet例項，在整個servlet整個生命週期類，init（）方法被呼叫一次

service（）方法   根據請求的http方法來呼叫doget（0和dopost（）

終止階段destroy（），銷燬資源

get請求和post請求i

get用於資訊獲取，一般是對後臺資料的資訊進行查詢  get請求的引數會跟在url後進行傳遞，以？分割url和傳輸資料，引數之間以&相連，一般瀏覽器對url長度有限制

post表示可能修改伺服器上的資源的請求，一般是對後天資料庫進行增刪改操作，post請求放在http的包體中，用類似key-value格式傳送資料，相對來說get會把請求的引數暴露在url中，安全性比post差

HTTP 請求的基本格式

   <request line> 請求行

   <headers> 請求頭（引數頭）

   <blank line> 空白行

   [<request-body>] 請求實體（GET沒有， POST有）

單列模式 

例項化一個靜態私有變數，宣告一個私有的方法，建一個公有的方法，公有方法返回變數，新建測試類測試

public class single{

private static single  a= new single();

private single(){}

public static single getA(){

return a;

}public static void main(String args[]){

single s1=null;

s1.getA();

}

}

抽象類            

抽象方法沒有宣告       只能單繼承      abstract不能修飾構造方法    訪問型別是publicprotected default    抽象方法可以有main方法 繼承抽象類用extends

介面

只有宣告   可以繼承多個介面  介面不能有構造方法   介面預設是public staticfinal

介面的實現用implements

5種常見的異常

NullPointerException  空指標異常

ClassCastException    型別強制轉換異常

ArrayIndexOutOfBoundException 陣列下標越界

ArithmeticException  算術運算異常

NumberFormatException  數字格式異常

FileNotFoundException  檔案未找到

throws 和throw的區別

throw丟擲異常   throws宣告異常

throws宣告一個可能丟擲的所有異常資訊

throw丟擲一個具體的異常

throws不現實捕獲的異常 throw需要使用者自己捕獲異常

執行緒的兩種實現方式

1:extends Thread

2:implement Runnable

執行緒的 生命週期  

新建狀態 就緒狀態  執行狀態  等待狀態  休眠狀態  阻塞狀態  死亡狀態 

執行緒休眠 sleep

當前執行緒進入阻塞狀態，即使沒有其他程序也會等待指定時間，其他等待執行的執行緒機會均等

執行緒禮讓yield

當前執行緒進入暫停執行的狀態，若沒有等待執行緒，當前執行緒恢復，優先順序高的先執行

    inputstream  位元組輸入流 

位元組流

    ooutputstream  位元組輸出流

    reader    字元輸入流

字元流

    writer   字元輸出流

MySql

ddl：資料定義語言，定義對資料庫的操作（庫，表，列，索引）

dml 資料操作語音，定義對資料庫記錄的操作 增刪改查 isert delete update select

dcl 資料控制語言 定義對資料庫表字段 使用者的訪問許可權和安全級別

5個約束

notnull 非空  foreign key   外來鍵

unique key  唯一鍵   check 檢查

primary key  主鍵

tomcat閃退的原因

java home沒有配置或配置錯誤

配置javahome 是jdk安裝路徑

path 中新增%java-home%\bin

tomcat檔案目錄

bin 存放可執行檔案

conf存放tomcat的配置檔案

  web.xml設定tomcat支援的型別，    server.xml修改埠號

   tomcat-user-xml 配置管理tomcat的使用者和許可權

webapps  存放應用程式  war檔案

重定向：客戶端發揮作用，以前的request中存放的變數全部失效，並進入一個新的request作用域。兩次請求，url改編為定向後的url response.sendredirect

轉發：以前的request中存放的變數不會失效，就像把兩個頁面拼到了一起，一次請求和一次響應，位址列的url地址不會變，轉發速度快，在同一個伺服器request.getRequestDispatcher(“路徑”).forward(request,response);

session  儲存一次回話資訊  失效的原因

使用者關閉當前正在使用的瀏覽器

關閉網頁伺服器    使用者向伺服器請求超時

執行程式結束session

jsp的動作元素

<jsp:include> 在頁面得到請求時動態包含一個頁面

<jsp:forward>網頁重定向

<jsp:plugin> 載入javabeen組建

<jsp:param>設定傳送引數

<jsp:usebeen>使用usebeen組建

<jsp:setproperty>設定javabeen屬性值

<jsp:getproperty>獲取javabeen屬性值

jsp和servlet的關係

jsp本質上servlet

tomcat等web容器會把jsp轉化成servlet

jsp更擅長頁面顯示，servlet更擅長邏輯控制

servlet完全有java程式碼組成，jsp由html和jsp標籤組成

在struts框架中，jsp位於mvc設計模式檢視層，servlet位於控制層

jsp的內建物件

out request   response   pagecontext session   config exception   page aplication  

JSTL 是什麼：Java Server Pages 標準標籤庫 (JSTL)包含的各種標籤可用於 JSP 頁面中。 <>

JSP 標準標籤庫 (JSTL) - 提供兩組標籤，一組使用 EL（Expression Language，表示式語言），而另一組支援使用請求時表示式。

為什麼要用JSTL：可以編寫沒有java程式碼的jsp頁面。使JSP頁面很容易被WEB設計人員理解，表達更清晰。減少程式出錯，是程式容易維護。

    JSP 標準標籤庫包括：核心標籤庫，I18N與格式化標籤庫，資料庫訪問標籤庫，XML處理標籤庫，函式標籤庫。

JS，是JavaScript的縮寫形式，而JavaScript是一種基於物件和事件驅動並且具有相對安全性的客戶端指令碼語言。

它在Web開發中JS佔據著舉足輕重的地位，所有互動、邏輯層的程式碼都應該由它來實現。

JS的引入方式大體可以分為兩種：

第一種是直接寫入當前頁面中，需要寫在標籤之間即可。

第二種是寫入一個js的檔案中，然後通過

EL表示式 

${expression}

EL 提供“.“和“[ ]“兩種運算子來存取資料。

<%@ pageisELIgnored="true" %> 表示是否禁用EL語言,TRUE表示禁止.FALSE表示不禁止.

< %=request. getParameter(“username”)%> 等價於 ${ param. username }

javascript 資料型別

字串string

數字number

布林 boolean

陣列array

物件object

空 null

undefined 未定義

javascript是什麼

屬於網路指令碼語言 應用於web應用開發通過嵌入html實現功能

是一種解釋性指令碼語言 程式碼不進行於預編譯  用於html頁面新增互動行為  跨平臺性  通過嵌入html頁面寫成單獨的js檔案有利於結構的分離

javascript顯示資料

windows.alert

document.write

innerHTML

console.log

javaweb

單選框

<input type="radio"value="男"name="sex">男

下拉列表

<select id=“city”>

<option value="青島">青島</option>

複選框

<input type="checkbox"name="hobby" value="足球">足球

linux  版本 centos（使用）  小紅帽   suse  麒麟。

MVC模式是什麼

模型model 檢視view  控制器

controller

    Model（模型）表示應用程式核心（比如資料庫記錄列表）。

   View（檢視）顯示資料（資料庫記錄）。

  Controller（控制器）處理輸入（寫入  資料MVC模式同時提供了對 HTML、CSS 和 JavaScript 的完全控制。庫記錄）。

什麼是 事務

事務(Transaction)是訪問並可能更新資料庫中各種資料項的一個程式執行單元(unit)。

原子性（atomicity）。一個事務是一個不可分割的工作單位，事務中包括的諸操作要麼都做，要麼都不做。

一致性（consistency）。事務必須是使資料庫從一個一致性狀態變到另一個一致性狀態。一致性與原子性是密切相關的。

隔離性（isolation）。一個事務的執行不能被其他事務干擾。即一個事務內部的操作及使用的資料對併發的其他事務是隔離的，併發執行的各個事務之間不能互相干擾。

永續性（durability）。持續性也稱永久性（permanence），指一個事務一旦提交，它對資料庫中資料的改變就應該是永久性的。接下來的其他操作或故障不應該對其有任何影響。

軟體開發流程 

軟體計劃 需求分析和定義軟體設計 軟體實現 軟體測試 軟體執行維護

jdbc連線資料庫步驟

載入mysql驅動

建立資料庫連線

例項化驅動連結

呼叫sql語句，處理結果集

關閉資料庫連線

Ddl：增刪改查 （create    alter  drop       show ）  

dml：增刪改查 （insert     update   delete    select  ）

jsp內建物件   out(輸出物件)   page（頁面物件）  pagecontext（頁面上下文物件）    request（請求物件）  response（響應物件）  session（會話物件）  aplication（整個專案的作用域）  exception（列外物件）  config(配置物件)

javascript常用事件

    常用的事件主要有:
    (1)單擊事件:onclick。使用者單擊滑鼠按鍵時產生的事件，同時。onclick指定的事件處理程式或程式碼將被呼叫執行.
    (2)改變事件:onchange。當text或textarea元素內的字元值改變或select表格選項狀態改變時發生該事件。
    (3)選中事件:onselect。當text或textarea物件中的文字被選中時會引發該事件。如:
<ipnut type="text" value="預設資訊”onselect=alert(”您選中T文字框中的文字”)>
    (4)獲得焦點事件:onfocus。使用者單擊text或textarea以及select物件，即游標落在文字框或選擇框時會產生該事件。如:
    <select name= "zhengjian" onfocus=alert(”我成為焦點”)>
    (5)失去焦點事件:onblur.失去焦點事件正好與獲得焦點事件相對，當text或textarea以及select物件不再擁有焦點而退出後臺時，引發該事件。
    (6)載人檔案事件:onload,’當頁面檔案載人時產生該事件。onload的一個作用就是在首次載人一個頁面檔案時檢測cookie的值，並用一個變數為其賦值，使它可以被原始碼使用，本事件是window的事件，但是在HTML中指定事件處理程式時，一般把它寫在<body>標記中。如:
    <body onload=alert(”正在載入頁面，請等待一”)>
    (7)解除安裝檔案事件:onunload。與載人檔案事件。nload正好相反，當Web頁面退出時引發的事件，並可更新。ookie的狀態。如:
    <body onunload=confirm(”你確定要離開本頁?”)>
    (8)滑鼠鎮蓋事件:onmouseover,onmouseover是當滑鼠位於元素上方時所引發的事件。如:
    <input type= "boutton" value=”按鈕”onmouseover="window. status=‘請您注意下面的狀態列·;returntrue">
    (9)滑鼠離開事件:onmouseout,onmouseout是當滑鼠離開元素時引發的事件。如果和滑鼠覆蓋事件同時使用，可以建立動態按鈕的效果。
    (10)一般事件。
   ondbclick:滑鼠雙擊事件。
   onkeypress:當鍵盤上的某個鍵被按下並且釋放時觸發的事件，要求頁面內必須有啟用的物件。
    onkeydown:當鍵盤上某個鍵被按下時觸發的事件，要求頁面內必須有啟用的物件。
    onkeyup:當鍵盤上某個鍵被放開時觸發的事件，要求頁面內必須有啟用的物件。
    (11)頁面相關事件。
    onabort:圖片在下載時被使用者中斷時觸發的事件。
    onbeforeunload:當前頁面的內容將要被改變時觸發的事件

String物件賦值 new和=的區別

對於字串：其物件的引用都是儲存在棧中的，如果是編譯期已經建立好(直接用雙引號定義的)的就儲存在常量池中，如果是執行期（new出來的）才能確定的就儲存在堆中。對於equals相等的字串，在常量池中永遠只有一份，在堆中有多份。

string s=“tt”
 string s1=“tt”    s等於s1
 string s=new string（“ss”）     (地址不同)
   string s1=new string（“ss”） s不等於s1

Servlet生命週期

Servlet被伺服器例項化後，容器執行其init方法，請求到達時執行其service方法，service方法自動派遣執行與請求對應的doXXX方法（doGet，doPost）等，當伺服器決定將例項銷燬的時候呼叫其destroy方法。

mvc設計模式

一般在Java Web裡，JSP充當V，Servlet充當C,JavaBean充當M，

MVC（模型Model-檢視View-控制器Controller）是一種設計模式，

對事務的理解

為了避免特殊情況下資料不統一，使用事務：要麼全執行，要麼全不執行！最好理解的示例應該是轉賬吧，如果我給你轉了500萬，你賬上多了，但突然停電了，我的賬上又沒減500萬，那這500萬誰出啊？呵呵，如果用事務，這就不會發生，這時會回滾，那銀行就不會虧500萬啦

原子性（Atomicity）
原子性是指事務是一個不可分割的工作單位，事務中的操作要麼都發生，要麼都不發生。 

一致性（Consistency）
事務必須使資料庫從一個一致性狀態變換到另外一個一致性狀態。

隔離性（Isolation）
事務的隔離性是多個使用者併發訪問資料庫時，資料庫為每一個使用者開啟的事務，不能被其他事務的操作資料所幹擾，多個併發事務之間要相互隔離。

永續性（Durability）
永續性是指一個事務一旦被提交，它對資料庫中資料的改變就是永久性的，接下來即使資料庫發生故障也不應該對其有任何影響。

事務指邏輯上的一組操作，組成這組操作的各個單元，要麼全部成功，要麼全部不成功。

資料庫開啟事務命令

start transaction  開啟事務

rollback  回滾事務

commit   提交事務

重定向和轉發的區別

轉發：
request.getRequestDispatcher("success.jsp").forward(request,response);
在伺服器元件收到使用者請求後。經過它的處理後有傳遞給了另一個元件。不修改使用者的請求碼。各元件處理完之後在返回給使用者，例如主頁面的框架。
          使用者請求-----》伺服器-------》元件1-------》元件2------->伺服器-------》使用者
   （請求不變）  request中存放的變數不會失效，像吧兩個頁面拼接在一起
重定向：
response.sendRedirect("success.jsp");變數會失效，進入一個新頁面
在伺服器元件收到使用者請求後。經過處理修改使用者請求。在返回給使用者。這樣使用者再次使用這個請求就會被動的使用新的請求了。（重定向一般是為了防止使用者提交完資料後點瀏覽器重新整理或點後退之後產生重複提交）
使用者請求-----》伺服器-------》元件------>伺服器-------》使用者-------》新的請求

                                                    （修改使用者請求）

過載和重寫

   過載   同一個類中允許同時存在一個以上的同名方法，只要他們的引數個數活著型別不同即可

同一個類中可以定義多個同名的放法   過載方法的引數列表必須不同

過載方法的返回值型別可以不相同可以不同 呼叫時根據方法引數型別來區別

  重寫 在子類中定義一個方法，名稱返回值型別 引數列表正好與父類中的某個方法名稱 返回值型別 引數列表正好相同，子類重寫了父類的方法   重寫方法不用為private 否則在子類中只是定義一個方法，並沒有重寫

如何遍歷hashmap

Map<String, String> map = new HashMap<String, String>();

for (Entry<String, String> entry : map.entrySet()) {

entry.getKey();

entry.getValue();

}

Map<String, String> map = new HashMap<String, String>();

for (String key : map.keySet()) {

map.get(key);

}

java.util.Collection是一個集合介面。它提供了對集合物件進行基本操作的通用介面方法。

java.util.Collections是一個包裝類。它包含有各種有關集合操作的靜態多型方法。此類不能例項化，就像一個工具類，服務於Java的Collection框架

資料庫中 drop和delete的區別

1. truncate和 delete只刪除資料不刪除表的結構(定義) 
    drop語句將刪除表的結構被依賴的約束(constrain),觸發器(trigger),索引(index); 依賴於該表的儲存過程/函式將保留,但是變為invalid狀態. 
2.delete語句是dml,這個操作會放到rollback segement中,事務提交之後才生效;如果有相應的trigger,執行的時候將被觸發. 

3.delete語句不影響表所佔用的extent, 

4.速度,一般來說: drop>; truncate >; delete 
5.安全性:小心使用drop 和truncate,尤其沒有備份的時候.否則哭都來不及 
使用上,想刪除部分資料行用delete,注意帶上where子句. 回滾段要足夠大. 
想刪除表,當然用drop 
想保留表而將所有資料刪除. 如果和事務無關,用truncate即可. 如果和事務有關,或者想觸發trigger,還是用delete. 

main方法宣告為private的後果

首先Java規定了main()方法必須是公共的，以便於外部程式對主方法的訪問，因為程式都是從main()方法起始的，並且main()方法也必須是靜態的，很大程度上這是為了安全性的考慮

建立索引可以大大提高系統的效能:
第一，通過建立唯一性索引，可以保證資料庫表中每一行資料的唯一性。 
第二，可以大大加快資料的檢索速度，這也是建立索引的最主要的原因。 
第三，可以加速表和表之間的連線，特別是在實現資料的參考完整性方面特別有意義。 
第四，在使用分組和排序 子句進行資料檢索時，同樣可以顯著減少查詢中分組和排序的時間。 
第五，通過使用索引，可以在查詢的過程中，使用優化隱藏器，提高系統的效能。 

增加索引也有許多不利的方面:
第一，建立索引和維護索引要耗費時間，這種時間隨著資料量的增加而增加。 
第二，索引需要佔物理空間，除了資料表佔資料空間之外，每一個索引還要佔一定的物理空間，如果要建立聚簇索引，那麼需要的空間就會更大。 
第三，當對錶中的資料進行增加、刪除和修改的時候，索引也要動態的維護，這樣就降低了資料的維護速度。

while和do while區別

一、while語句的一般形式為：
while(表示式)語句
其中表達式是迴圈條件，語句為迴圈體。
while語句的語義是：計算表示式的值，當值為真(非0)時， 執行迴圈體語句。

二、do-while語句的一般形式為:
        do
            語句
        while(表示式)；
這個迴圈與while迴圈的不同在於:它先執行迴圈中的語句,然後再判斷表示式是否為真, 如果為真則繼續迴圈；如果為假, 則終止迴圈。因此, do-while迴圈至少要執行一次迴圈語句。
使用while語句應注意以下幾點：
1、while語句中的表示式一般是關係表達或邏輯表示式，只要表示式的值為真(非0)即可繼續迴圈。
2、迴圈體如包括有一個以上的語句，則必須用{}括起來，組成複合語句。

equals和==的區別
==操作比較的是兩個變數的值是否相等,對於引用型變量表示的是兩個變數在堆中儲存的地址是否相同,即棧中的內容是否相同.
equals操作表示的兩個變數是否是對同一個物件的引用,即堆中的內容是否相同

介面和抽象類的關係，及其特點

抽象類abstract可以有方法的生命，沒有方法的實現，以分號結束

被子類繼承,子類若是非抽象類，必須實現父類中的抽象方法

含有抽象方法的類必須是抽象類

抽象類中可以沒有抽象方法

不能用abstract修飾私有方法，構造方法，靜態方法

              同一個類中使用   不能被重寫    有實體

介面 介面是特殊的抽象類，所有的方法為抽象方法

所有屬性為公開靜態的常量 public abstract fianl

介面直接可以實現多繼承，用extends ，隔開

介面中沒構造方法

異常

異常通常指，你的程式碼可能在編譯時沒有錯誤，可是執行時會出現異常。比如常見的空指標異常。也可能是程式可能出現無法預料的異常，比如你要從一個檔案讀資訊，可這個檔案不存在，程式無法執行下去了，故程式要抓這些異常，通過異常處理機制來丟擲這些異常，程式設計師就可以通過丟擲的異常來修改程式碼

final修飾時。。。

final可以用來修飾變數（包括類屬性、物件屬性、區域性變數和形參）、方法（包括類方法和物件方法）和類

1. final修飾類:

final修飾類即表示此類已經是“最後的、最終的”含義。因此，用final修飾的類不能被繼承，即不能擁有自己的子類。

2. final修飾方法：

final修飾的方法表示此方法已經是“最後的、最終的”含義，亦即此方法不能被重寫（可以過載多個final修飾的方法）。

3. final 修飾變數：

final修飾的變量表示此變數是“最後的、最終的”含義。一旦定義了final變數並在首次為其顯示初始化後，final修飾的變數值不可被改變。

&和&&的區別

、&和&&的區別。
&和&&都可以用作邏輯與的運算子，表示邏輯與（and），當運算子兩邊的表示式的結果都為true時，整個運算結果才為true，否則，只要有一方為false，則結果為false。
&&還具有短路的功能，即如果第一個表示式為false，則不再計算第二個表示式，例如，對於if(str != null && !str.equals(“”))表示式，當str為null時，後面的表示式不會執行，所以不會出現NullPointerException如果將&&改為&，則會丟擲NullPointerException異常。If(x==33 & ++y>0) y會增長，If(x==33&& ++y>0)不會增長

uri和url的區別

URL（Uniform Resoure Locator：統一資源定位器）是WWW頁的地址。
URI表示的是統一的資源標識，它是以某種統一的（標準化的）方式標識資源的簡單字串。

URI 是從虛擬根路徑開始的
URL是整個連結

jdbc中常用物件

Connection：與目標資料庫建立jdbc連線；
Statement：向建立連線的資料庫傳送操作指令並返回操作結果
ResultSet：裝載資料庫指令執行結果

繼承

子類擁有父類資料結構的方法和機制，只能是單繼承

子類繼承父類就繼承了父類的方法和屬性

在子類中，可以用父類定義的方法和屬性，也可以建立新的方法和屬性

子類通常比父類功能多

子類不繼承父類private成員變數和方法

多型

有繼承關係 子類的物件可以替代父類物件的使用

一個變數只能有一種確定的資料型別

一個引用型別變數可以指向各種不同型別的物件

三個前提是（繼承,方法的重寫，指向父類的引用）

Java的特點是單繼承，也就是說所有的類都繼承object

String buffer 是執行緒安全的 ，String builder是執行緒不安全的

StringBuilder與StringBuffer有公共父類AbstractStringBuilder(抽象類)。

如果程式不是多執行緒的，那麼使用StringBuilder效率高於StringBuffer。

繼承的原則

單一繼承，一個子類只能有一個父類，一個父類可以有多個子類

程序是一個具有獨立功能的程式關於某個資料集合的一次執行活動。它可以申請和擁有系統資源，是一個動態的概念，是一個活動的實體。它不只是程式的程式碼，還包括當前的活動，通過程式計數器的值和處理暫存器的內容來表示

通常在一個程序中可以包含若干個執行緒，它們可以利用程序所擁有的資源。在引入執行緒的作業系統中，通常都是把程序作為分配資源的基本單位，而把執行緒作為獨立執行和獨立排程的基本單位。由於執行緒比程序更小，基本上不擁有系統資源，故對它的排程所付出的開銷就會小得多，能更高效的提高系統內多個程式間併發執行的程度。

過濾器。。。

資料庫三大正規化

第一正規化:確保每列的原子性.
    如果每列(或者每個屬性)都是不可再分的最小資料單元(也稱為最小的原子單元),則滿足第一正規化

第二正規化:在第一正規化的基礎上更進一層,目標是確保表中的每列都和主鍵相關.
    如果一個關係滿足第一正規化,並且除了主鍵以外的其它列,都依賴於該主鍵,則滿足第二正規化.

第三正規化:在第二正規化的基礎上更進一層,目標是確保每列都和主鍵列直接相關,而不是間接相關.
    如果一個關係滿足第二正規化,並且除了主鍵以外的其它列都不依賴於主鍵列,則滿足第三正規化

String類是否可以被繼承  不可以被繼承   是final修飾的。

　一、堆疊空間分配區別：
　　1、棧（作業系統）：由作業系統自動分配釋放 ，存放函式的引數值，區域性變數的值等。其操作方式類似於資料結構中的棧；
　　2、堆（作業系統）： 一般由程式設計師分配釋放， 若程式設計師不釋放，程式結束時可能由OS回收，分配方式倒是類似於連結串列。
　　二、堆疊快取方式區別：
　　1、棧使用的是一級快取， 他