范文為教學中作為模范的文章，也常常用來指寫作的模板。常常用于文秘寫作的參考，也可以作為演講材料編寫前的參考。范文怎么寫才能發揮它最大的作用呢？以下是我為大家搜集的優質范文，僅供參考，一起來看看吧

java編程思想內容篇一

計算器

班級：****** 姓名：******

學號： ******* 指導老師：******

實驗名稱:java計算器

1實驗目的: java編程語言在編程方面的具體應用,以及使用面向對象方法,對小應用程序進行需求分

析、概要設計、詳細設計，最后使用java編程實現的全過程。

2實驗意義：

在編程我們使用的java語言，是目前比較流行的編程語言。在當今這個時代，java語言在編程方面的優勢使得編程有了更好的選擇。java語言最大的特點是具有跨平臺性，使其不受平臺不同的影響，得到了廣泛的應用。實訓性質

本課程是計算機信息管理專業的一門實踐性課程，是《java編程》課程的實踐性教學環節。實訓目標

⑴綜合應用java程序設計的知識解決實際問題。

⑵學會在應用程序的設計過程中，應用面向對象的程序設計方法。⑶學會應用jdbc創建數據庫應用程序。

⑷學會開發基于swing的應用程序及多文檔應用程序的設計。實訓任務

用java語言開發工具（例如jdk、jcreator、netbeans等）制作一個簡單的可運行的完整的應用程序或小型系統，并編制出各階段必要的文檔。

將創建一個計算器，可以進行常用的加減乘除算術運算。本實例的知識點有：窗口布局器gridlayout的應用，對按鈕消息的監聽和響應。

6實訓條件

<軟件:>windows xp,netbeans ide 6.52 7開發背景: java是由sun microsystems公司于1995年5月推出的java程序設計語言（以下簡稱java語言）和java平臺的總稱。java語言是一個支持網絡計算的面向對象程序設計語言。java語言吸收了smalltalk語言和c++語言的優點，并增加了其它特性，如支持并發程序設計、網絡通信、和多媒體數據控制等。

8系統部分分析:

1)java語言是簡單的。java語言的語法與c語言和c++語言很接近，使得大多數程序員很容易學習和使用java。另一方面，java丟棄了c++ 中很少使用的、很難理解的、令人迷惑的那些特性，如操作符重載、多繼承、自動的強制類型轉換。

2)java語言是一個面向對象的。java語言提供類、接口和繼承等原語，為了簡單起見，只支持類之間的單繼承，但支持接口之間的多繼承，并支持類與接口之間的實現機制（關鍵字為implements）。java語言全面支持動態綁定，而c++ 語言只對虛函數使用動態綁定

3)java語言是分布式的。java語言支持internet應用的開發，在基本的java應用編程接口中有一個網絡應用編程接口（），它提供了用于網絡應用編程的類庫，包括url、urlconnection、socket、serversocket等。java的rmi(遠程方法激活)機制也是開發分布式應用的重要手段。

4)java語言是健壯的。java的強類型機制、異常處理、廢料的自動收集等是java程序健壯性的重要保證。對指針的丟棄是java的明智選擇。java的安全檢查機制使得java更具健壯性。

5)java語言是安全的。java通常被用在網絡環境中，為此，java提供了一個安全機制以防惡意代碼的攻擊。除了java語言具有的許多安全特性以外，java對通過網絡下載的類具有一個安全防范機制（類classloader），如分配不同的名字空間以防替代本地的同名類、字節代碼檢查，并提供安全管理機制.6)java語言是體系結構中立的。java程序（后綴為java的文件）在java平臺上被編譯為體系結構中立的字節碼格式（后綴為class的文件）, 然后可以在實現這個java平臺的任何系統中運行。

7)java語言是可移植的。這種可移植性來源于體系結構中立性，另外，java還嚴格規定了各個基本數據類型的長度。java系統本身也具有很強的可移植性，java編譯器是用java實現的.8)java語言是解釋型的。如前所述，java程序在java平臺上被編譯為字節碼格式，然后可以在實現這個java平臺的任何系統中運行。

9)java是高性能的。與那些解釋型的高級腳本語言相比，java的確是高性能的。事實上，java的運行速度隨著jit(just-in-time)編譯器技術的發展越來越接近于c++。

10)java語言是多線程的。在java語言中，線程是一種特殊的對象，它必須由thread類或其子（孫）類來創建。

11)java語言是動態的。java語言的設計目標之一是適應于動態變化的環境。

目錄

課程設計題目 ……………………………… p1

課程設計簡介 ……………………………… p2

課程設計源代碼…………………………… p5

課程設計運行結果 ……………………… p15 課程設計心得體會 ………………………

p16

package computerpad;import .*;import .event.*;import .*;import .*;import list;import format;public class computerpad extends frame implements actionlistener {

numberbutton numberbutton[];

operationbutton oprationbutton[];

button 小數點按鈕,正負號按鈕,退格按鈕，求倒數按鈕,等號按鈕,清零按鈕;

panel panel;

jtextfield resultshow;

string 運算符號[]={“+”,“-”,“*”,“/”};

linkedlist 鏈表;

boolean 是否按下等號=false;

public computerpad()

{

super(“計算器”);

鏈表=new linkedlist();

numberbutton=new numberbutton[10];

for(int i=0;i<=9;i++)

{

numberbutton[i]=new numberbutton(i);

numberbutton[i].addactionlistener(this);

}

oprationbutton=new operationbutton[4];

for(int i=0;i<4;i++)

{

oprationbutton[i]=new operationbutton(運算符號[i]);

oprationbutton[i].addactionlistener(this);

}

小數點按鈕=new button(“.”);

正負號按鈕

=new button(“+/-”);

等號按鈕=new button(“=”);

求倒數按鈕=new button(“1/x”);

退格按鈕=new button(“退格”);

清零按鈕=new button(“c”);

eground();

eground();

eground();

eground();

eground();

eground();

ionlistener(this);

ionlistener(this);

ionlistener(this);

ionlistener(this);

ionlistener(this);

ionlistener(this);

resultshow=new jtextfield(10);

izontalalignment();

eground();

t(new font(“timesroman”,,14));

der(new softbevelborder(d));

kground();

table(false);

panel=new panel();

out(new gridlayout(4,5));

(numberbutton[1]);

(numberbutton[2]);

(numberbutton[3]);

(oprationbutton[0]);

(清零按鈕);

(numberbutton[4]);

(numberbutton[5]);

(numberbutton[6]);

(oprationbutton[1]);

(退格按鈕);

(numberbutton[7]);

(numberbutton[8]);

(numberbutton[9]);

(oprationbutton[2]);

(求倒數按鈕);

(numberbutton[0]);

(正負號按鈕);

(小數點按鈕);

(oprationbutton[3]);

(等號按鈕);

add(panel,);

add(resultshow,);

addwindowlistener(new windowadapter()

{ public void windowclosing(windowevent e)

{

(0);

}

});

setvisible(true);

setbounds(100,50,240,180);

setresizable(false);

validate();

} public void actionperformed(actionevent e)

{

if(rce()instanceof numberbutton)

{

numberbutton b=(numberbutton)rce();

if(()==0)

{

int number=ber();

(“"+number);

t(”“+number);

是否按下等號=false;

}

else if(()==1&&是否按下等號==false)

{

int number=ber();

string num=(string)first();

string s=(”“+number);

(0,s);

t(s);

}

else if(()==1&&是否按下等號==true)

{

int number=ber();

first();

(”“+number);

是否按下等號=false;

t(”“+number);

}

else if(()==2)

{

int number=ber();

(”“+number);

t(”“+number);

}

else if(()==3)

{

int number=ber();

string num=(string)t();

string s=(”“+number);

(2,s);

t(s);

}

}

else if(rce()instanceof operationbutton)

{

operationbutton b=(operationbutton)rce();

if(()==1)

{

string fuhao=運算符號();

(fuhao);

}

else if(()==2)

{

string fuhao=運算符號();

(1,fuhao);

}

else if(()==3)

{

string fuhao=運算符號();

string number1=(string)first();

string number2=(string)t();

string 運算符號=(string)(1);

try

{

double n1=ouble(number1);

double n2=ouble(number2);

double n=0;

if((”+“))

{

n=n1+n2;

}

else if((”-“))

{

n=n1-n2;

}

else if((”*“))

{

n=n1*n2;

}

else if((”/“))

{

n=n1/n2;

}

();

(”“+n);

(fuhao);

t(”“+n);

}

catch(exception ee)

{

}

}

}

else if(rce()==等號按鈕)

{

是否按下等號=true;

if(()==1||()==2)

{

string num=(string)first();

t(”“+num);

}

else if(()==3)

{

string number1=(string)first();

string number2=(string)t();

string 運算符號=(string)(1);

try

{

double n1=ouble(number1);

double n2=ouble(number2);

double n=0;

if((”+“))

{

n=n1+n2;

}

else if((”-“))

{

n=n1-n2;

}

else if((”*“))

{

n=n1*n2;

}

else if((”/“))

{

n=n1/n2;

}

t(”“+n);

(0,”“+n);

last();

last();

}

catch(exception ee)

{

}

}

}

else if(rce()==小數點按鈕)

{

if(()==0)

{

是否按下等號=false;

}

else if(()==1)

{

string dot=el();

string num=(string)first();

string s=null;

if(f(dot)==-1)

{

s=(dot);

(0,s);

}

else

{

s=num;

}

(0,s);

t(s);

}

else if(()==3)

{

string dot=el();

string num=(string)t();

string s=null;

if(f(dot)==-1)

{

s=(dot);

(2,s);

}

else

{

s=num;

}

t(s);

}

}

else if(rce()==退格按鈕)

{

if(()==1)

{

string num=(string)first();

if(()>=1)

{

num=ing(0,()-1);

(0,num);

t(num);

}

else

{

last();

t(”0“);

}

}

else if(()==3)

{

string num=(string)t();

if(()>=1)

{ num=ing(0,()-1);

(2,num);

t(num);

}

else

{

last();

t(”0“);

}

}

}

else if(rce()==正負號按鈕)

{

if(()==1)

{

string number1=(string)first();

try

{

double d=ouble(number1);

d=-1*d;

string str=f(d);

(0,str);

t(str);

}

catch(exception ee)

{

}

}

else if(()==3)

{

string number2=(string)t();

try

{

double d=ouble(number2);

d=-1*d;

string str=f(d);

(2,str);

t(str);

}

catch(exception ee){

}

}

}

else if(rce()==求倒數按鈕)

{

if(()==1||()==2)

{

string number1=(string)first();

try

{

double d=ouble(number1);

d=1.0/d;

string str=f(d);

(0,str);

t(str);

}

catch(exception ee){

}

}

else if(()==3)

{

string number2=(string)t();

try

{

double d=ouble(number2);

d=1.0/d;

string str=f(d);

(0,str);

t(str);

}

catch(exception ee){

}

}

}

else if(rce()==清零按鈕)

{

是否按下等號=false;

t(”0“);

();

}

} public static void main(string args[])

{

new computerpad();

}

}

package computerpad;import .*;import .event.*;import .*;public class numberbutton extends button {

int number;

public numberbutton(int number)

{

super(”"+number);

=number;

setforeground();

}

public int getnumber()

{

return number;

} }

import .*;import .event.*;import .*;public class operationbutton extends button {

string 運算符號;

public operationbutton(string s)

{

super(s);

運算符號=s;

setforeground();

}

public string get運算符號()

{

return 運算符號;

} } 14 java實訓心得：

未接觸java之前，聽人說java這門語言如何的強大和難以入門，但學習之后，給我的感覺卻是語言沒有所謂的難于不難，關鍵是自己有沒有真正投入去學，有沒有花時間去學。java是一門很好的語言，經過周圍人對java的宣傳，我一開始不敢去學習這門語言，因為一門高級語言總是讓人想到一開始的學習會很難，但是后來在自己的努力和老師同學的幫助下，我加入了java學習者的行列。

老師把我們帶進了門，那么，以后漫長的深入學習還是要靠自己。經常性的編寫一些程序，或則去看懂、研究透別人編寫的程序對于我們打好基礎是非常有利的。讓我們懷著對java的一腔熱情，用自己的刻苦努力去把java學好。將來，用自己的成績去回報有恩于我們的社會、家人和朋友。

java編程思想內容篇二

java編程思想，java學習必讀經典，不管是初學者還是大牛都值得一讀，這里總結書中的重點知識，這些知識不僅經常出現在各大知名公司的筆試面試過程中，而且在大型項目開發中也是常用的知識，既有簡單的概念理解題（比如is-a關系和has-a關系的區別），也有深入的涉及rtti和jvm底層反編譯知識。

中的多態性理解（注意與c++區分）

? java中除了static方法和final方法（private方法本質上屬于final方法，因為不能被子類訪問）之外，其它所有的方法都是動態綁定，這意味著通常情況下，我們不必判定是否應該進行動態綁定—它會自動發生。? final方法會使編譯器生成更有效的代碼，這也是為什么說聲明為final方法能在一定程度上提高性能（效果不明顯）。

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? 如果某個方法是靜態的，它的行為就不具有多態性：

class staticsuper {

public static string staticget(){

return “base staticget()”;

}

public string dynamicget(){

return “base dynamicget()”;

} }

class staticsub extends staticsuper {

public static string staticget(){

return “derived staticget()”;

}

public string dynamicget(){

return “derived dynamicget()”;

} }

public class staticpolymorphism {

public static void main(string[] args){ staticsuper sup = new staticsub();.println(get());.println(cget());

}

}

輸出：

base staticget()derived dynamicget()? 構造函數并不具有多態性，它們實際上是static方法，只不過該static聲明是隱式的。因此，構造函數不能夠被override。

? 在父類構造函數內部調用具有多態行為的函數將導致無法預測的結果，因為此時子類對象還沒初始化，此時調用子類方法不會得到我們想要的結果。

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? class glyph {

void draw(){

.println(“()”);

}

glyph(){

.println(“glyph()before draw()”);draw();

.println(“glyph()after draw()”);

} }

class roundglyph extends glyph {

private int radius = 1;

roundglyph(int r){ radius = r;

.println(“lyph().radius = ” + radius);

}

void draw(){

.println(“round().radius = ” + radius);

} }

public class polyconstructors {

public static void main(string[] args){

new roundglyph(5);

}

}

輸出： glyph()before draw()round().radius = 0 glyph()after draw()lyph().radius = 5 為什么會這樣輸出？這就要明確掌握java中構造函數的調用順序：

（1）在其他任何事物發生之前，將分配給對象的存儲空間初始化成二進制0；

（2）調用基類構造函數。從根開始遞歸下去，因為多態性此時調用子類覆蓋后的draw()方法（要在調用roundglyph構造函數之前調用），由于步驟1的緣故，我們此時會發現radius的值為0；

（3）按聲明順序調用成員的初始化方法；（4）最后調用子類的構造函數。

? 只有非private方法才可以被覆蓋，但是還需要密切注意覆蓋private方法的現象，這時雖然編譯器不會報錯，但是也不會按照我們所期望的來執行，即覆蓋private方法對子類來說是一個新的方法而非重載方法。因此，在子類中，新方法名最好不要與基類的private方法采取同一名字（雖然沒關系，但容易誤解，以為能夠覆蓋基類的private方法）。

? java類中屬性域的訪問操作都由編譯器解析，因此不是多態的。父類和子類的同名屬性都會分配不同的存儲空間，如下：

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? // direct field access is determined at compile super {

public int field = 0;

public int getfield(){

return field;

} }

class sub extends super {

public int field = 1;

public int getfield(){

return field;

}

public int getsuperfield(){

return ;

} }

public class fieldaccess {

public static void main(string[] args){ super sup = new sub();

.println(“ = ” + +

“, ld()= ” + ld());sub sub = new sub();

.println(“ = ” + + ? ? ? ? ? “, ld()= ” + ld()+ “, erfield()= ” + erfield());

}

}

輸出：

= 0, ld()= 1 = 1, ld()= 1, erfield()= 0 sub子類實際上包含了兩個稱為field的域，然而在引用sub中的field時所產生的默認域并非super版本的field域，因此為了得到，必須顯式地指明。

-a關系和is-like-a關系

? is-a關系屬于純繼承，即只有在基類中已經建立的方法才可以在子類中被覆蓋，如下圖所示：

基類和子類有著完全相同的接口，這樣向上轉型時永遠不需要知道正在處理的對象的確切類型，這通過多態來實現。

? is-like-a關系：子類擴展了基類接口。它有著相同的基本接口，但是他還具有由額外方法實現的其他特性。

缺點就是子類中接口的擴展部分不能被基類訪問，因此一旦向上轉型，就不能調用那些新方法。

3.運行時類型信息（rtti + 反射）

? 概念

rtti：運行時類型信息使得你可以在程序運行時發現和使用類型信息。? 使用方式

java是如何讓我們在運行時識別對象和類的信息的，主要有兩種方式（還有輔助的第三種方式，見下描述）： ? 一種是“傳統的”rtti，它假定我們在編譯時已經知道了所有的類型，比如shape s =(shape)s1； ? 另一種是“反射”機制，它運行我們在運行時發現和使用類的信息，e()。

? 其實還有第三種形式，就是關鍵字instanceof，它返回一個bool值，它保持了類型的概念，它指的是“你是這個類嗎？或者你是這個類的派生類嗎？”。而如果用==或equals比較實際的class對象，就沒有考慮繼承—它或者是這個確切的類型，或者不是。

? 工作原理

要理解rtti在java中的工作原理，首先必須知道類型信息在運行時是如何表示的，這項工作是由稱為class對象的特殊對象完成的，它包含了與類有關的信息。java送class對象來執行其rtti，使用類加載器的子系統實現。

無論何時，只要你想在運行時使用類型信息，就必須首先獲得對恰當的class對象的引用，獲取方式有三種：

（1）如果你沒有持有該類型的對象，e()就是實現此功能的便捷途，因為它不需要對象信息；

（2）如果你已經擁有了一個感興趣的類型的對象，那就可以通過調用getclass()方法來獲取class引用了，它將返回表示該對象的實際類型的class引用。class包含很有有用的方法，比如： package rtti;

interface hasbatteries{} interface waterproof{} interface shoots{}

class toy { toy(){}

toy(int i){} }

class fancytoy extends toy implements hasbatteries, waterproof, shoots { fancytoy(){

super(1);

} }

public class rttitest {

static void printinfo(class cc){

.println(“class name: ” + e()+ “, is interface? [” + rface()+ “]”);.println(“simple name: ” + plename());.println(“canonical name: ” + onicalname());

}

public static void main(string[] args){ class c = null;

try {

c = e(“oy”);// 必須是全限定名（包名+類名）

} catch(classnotfoundexception e){

.println(“can't find fancytoy”);(1);

}

printinfo(c);

for(class face : erfaces()){ printinfo(face);

}

class up = erclass();object obj = null;

try { // requires default = tance();

} catch(instantiationexception e){

.println(“can't instantiate”);(1);

} catch(illegalaccessexception e){ .println(“can't access”);(1);

}

printinfo(ss());

}

}

輸出：

class name: oy, is interface? [false] simple name: fancytoy canonical name: oy class name: teries, is interface? [true] simple name: hasbatteries canonical name: teries class name: roof, is interface? [true] simple name: waterproof canonical name: roof class name: , is interface? [true] simple name: shoots canonical name: class name: , is interface? [false] simple name: toy canonical name: （3）java還提供了另一種方法來生成對class對象的引用，即使用類字面常量。比如上面的就像這樣：;來引用。

這樣做不僅更簡單，而且更安全，因為它在編譯時就會受到檢查（因此不需要置于try語句塊中），并且它根除了對forname方法的引用，所以也更高效。類字面常量不僅可以應用于普通的類，也可以應用于接口、數組以及基本數據類型。

注意：當使用“.class”來創建對class對象的引用時，不會自動地初始化該class對象，初始化被延遲到了對靜態方法（構造器隱式的是靜態的）或者非final靜態域（注意final靜態域不會觸發初始化操作）進行首次引用時才執行：。而使用e時會自動的初始化。

為了使用類而做的準備工作實際包含三個步驟：

-加載：由類加載器執行。查找字節碼，并從這些字節碼中創建一個class對象

-鏈接：驗證類中的字節碼，為靜態域分配存儲空間，并且如果必需的話，將解析這個類創建的對其他類的所有引用。

-初始化：如果該類具有超類，則對其初始化，執行靜態初始化器和靜態初始化塊。這一點非常重要，下面通過一個實例來說明這兩者的區別：

package rtti;

import ;class initable {

static final int staticfinal = 47;

static final int staticfinal2 = t(1000);

static {

.println(“initializing initable”);

} }

class initable2 {

static int staticnonfinal = 147;

static {

.println(“initializing initable2”);

} }

class initable3 {

static int staticnonfinal = 74;

static {

.println(“initializing initable3”);

} }

public class classinitialization {

public static random rand = new random(47);

public static void main(string[] args){

// does not trigger initialization class initable = ;

.println(“after creating initable ref”);

// does not trigger initialization

.println(final);

// does trigger initialization(rand()is static method).println(final2);

// does trigger initialization(not final)

.println(nonfinal);

try {

class initable3 = e(“le3”);

} catch(classnotfoundexception e){

.println(“can't find initable3”);(1);

}

.println(“after creating initable3 ref”);.println(nonfinal);

} }

輸出：

after creating initable ref 47 initializing initable 258 initializing initable2 147 initializing initable3 after creating initable3 ref 74

rtti的限制？如何突破？ — 反射機制

如果不知道某個對象的確切類型，rtti可以告訴你，但是有一個限制：這個類型在編譯時必須已知，這樣才能使用rtti識別它，也就是在編譯時，編譯器必須知道所有要通過rtti來處理的類。

可以突破這個限制嗎？是的，突破它的就是反射機制。

t類庫一起對反射的概念進行了支持，該類庫包含了field、method以及constructor類（每個類都實現了member接口）。這些類型的對?

象是由jvm在運行時創建的，用以表示未知類里對應的成員。這樣你就可以使用constructor創建新的對象，用get()/set()方法讀取和修改與field對象關聯的字段，用invoke()方法調用與method對象關聯的方法。另外，還可以調用getfields()、getmethods()和getconstructors()等很便利的方法，以返回表示字段、方法以及構造器的對象的數組。這樣，匿名對象的類信息就能在運行時被完全確定下來，而在編譯時不需要知道任何事情。

####反射與rtti的區別

當通過反射與一個未知類型的對象打交道時，jvm只是簡單地檢查這個對象，看它屬于哪個特定的類（就像rtti那樣），在用它做其他事情之前必須先加載那個類的class對象，因此，文件對于jvm來說必須是可獲取的：要么在本地機器上，要么可以通過網絡取得。所以rtti與反射之間真正的區別只在于：對rtti來說，文件（也就是可以用普通方法調用對象的所有方法）；而對于反射機制來說，.class文件在編譯時是不可獲取的，文件。下面的例子是用反射機制打印出一個類的所有方法（包括在基類中定義的方法）：

package typeinfo;

import uctor;import ;import n;

// using reflection to show all the methods of a class.// even if the methods are defined in the base class showmethods { private static string usage =

“usage: n” +

“showmethods ” +

“to show all methods in class or: n” +

“showmethods wordn” +

“to search for methods involving 'word'”;

private static pattern p = e(“w+.”);

public static void main(string[] args){ if( < 1){ .println(usage);(0);} int lines = 0;try { class

c = e(args[0]);method[] methods = hods();constructor[] ctors = structors();if( == 1){ for(method method : methods){

.println(r(ng()).replaceall(“"));} for(constructor ctor : ctors){

.println(r(ng()).replaceall(”“));} lines = + ;} else { for(method method : methods){ if(ng().indexof(args[1])!=-1){

.println(r(ng()).replaceall(”“));lines++;} } for(constructor ctor : ctors){ if(ng().indexof(args[1])!=-1){

.println(r(ng()).replaceall(”“));lines++;} } } } catch(classnotfoundexception e){ .println(”no such class: “ + e);}

} }

輸出：

public static void main(string[])public final native void wait(long)throws interruptedexception public final void wait()throws interruptedexception public final void wait(long,int)throws interruptedexception public boolean equals(object)public string tostring()public native int hashcode()public final native class getclass()public final native void notify()public final native void notifyall()public showmethods()4.代理模式與java中的動態代理

? 代理模式

在任何時刻，只要你想要將額外的操作從“實際”對象中分離到不同的地方，特別是當你希望能夠很容易地做出修改，從沒有使用額外操作轉為使用這些操作，或者反過來時，代理就顯得很有用（設計模式的關鍵是封裝修改）。例如，如果你希望跟蹤對某個類中方法的調用，或者希望度量這些調用的開銷，那么你應該怎樣做呢？這些代碼肯定是你不希望將其合并到應用中的代碼，因此代理使得你可以很容易地添加或移除它們。

? ? ? interface interface {

void dosomething();

void somethingelse(string arg);? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? }

class realobject implements interface {

@override public void dosomething(){

.println(”dosomething.“);

}

@override public void somethingelse(string arg){

.println(”somethingelse “ + arg);

} }

class simpleproxy implements interface {

private interface proxy;

public simpleproxy(interface proxy){

= proxy;

}

@override public void dosomething(){

.println(”simpleproxy dosomething.“);thing();

}

@override public void somethingelse(string arg){

.println(”simpleproxy somethingelse “ + arg);

ingelse(arg);

} }

public class simpleproxydemo {

public static void consumer(interface iface){ thing();

ingelse(”bonobo“);

} ? ? ? ? ? ? public static void main(string[] args){ consumer(new realobject());

consumer(new simpleproxy(new realobject()));

}

}

輸出：

ingelse bonobo simpleproxy proxy somethingelse bonobo somethingelse bonobo ? 動態代理

java的動態代理比代理的思想更向前邁進了一步，因為它可以動態地創建代理并動態地處理對所代理方法的調用。

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? import tionhandler;import ;import ;

class dynamicproxyhandler implements invocationhandler {

private object proxy;

public dynamicproxyhandler(object proxy){

= proxy;

}

@override public object invoke(object proxy, method method, object[] args)

throws throwable {

.println(”*** proxy: “ + ss()+

”.method: “ + method + ”.args: “ + args);

if(args!= null){

for(object arg : args)

.println(” “ + arg);

}

return (, args);

} }

public class simpledynamicproxy { ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

public static void consumer(interface iface){ thing();

ingelse(”bonobo“);

}

public static void main(string[] args){ realobject real = new realobject();consumer(real);

// insert a proxy and call again:

interface proxy =(interface)xyinstance(.getclassloader(), new class[]{ },new dynamicproxyhandler(real));

consumer(proxy);

}

}

輸出：

ingelse bonobo *** proxy: class typeinfo.$: public abstract void thing().args: null dosomething.*** proxy: class typeinfo.$: public abstract void ingelse().args: [;@6a8814e9 bonobo somethingelse bonobo 5.即時編譯器技術 — jit java虛擬機中有許多附加技術用以提升速度，尤其是與加載器操作相關的，被稱為“即時”（just-in-time，jit）編譯器的技術。這種技術可以把程序全部或部分翻譯成本地機器碼（這本來是jvm的工作），程序運行速度因此得以提升。當需要裝載某個類時，文件，然后將該類的字節碼裝入內存。此時，有兩種方案可供選擇：

（1）一種就是讓即時編譯器編譯所有代碼。但這種做法有兩個缺陷：這種加載動作散落在整個程序生命周期內，累加起來要花更多時間；并且會增加可執行代碼的長度（字節碼要比即時編譯器展開后的本地機器碼小很多），這將導致頁面調度，從而降低程序速度。（2）另一種做法稱為惰性評估（lazy evaluation），意思是即時編譯器只在必要的時候才編譯代碼，這樣，從不會被執行的代碼也許就壓根不會被jit所編譯。新版jdk中的java hotspot技術就采用了類似方法，代碼每次被執行的時候都會做一些優化，所以執行的次數越多，它的速度就越快。

6.訪問控制權限 ? ? java訪問權限修飾詞：public、protected、包訪問權限（默認訪問權限，有時也稱friendly）和private。

包訪問權限：當前包中的所有其他類對那個成員具有訪問權限，但對于這個包之外的所有類，這個成員卻是private。

protected：繼承訪問權限。有時基類的創建者會希望有某個特定成員，把對它的訪問權限賦予派生類而不是所有類。這就需要protected來完成這一工作。protected也提供包訪問權限，也就是說，相同包內的其他類都可以訪問protected元素。protected指明“就類用戶而言，這是private的，但對于任何繼承于此類的導出類或其他任何位于同一個包內的類來說，它卻是可以訪問的”。比如： 基類： ?

? ? ? ? ? ? ? ? ? ? package ;public class cookie {

public cookie(){

.println(”cookie constructor“);

}

void bite(){ // 包訪問權限，其它包即使是子類也不能訪問它 .println(”bite“);

} }

子類：

package t;

import .cookie;

public class chocolatechip extends cookie {

public chocolatechip(){

.println(”chocolatechip constructor“);

}

public void chomp(){

bite();// error, the method bite()from the type cookie is not visible

} }

可以發現子類并不能訪問基類的包訪問權限方法。此時可以將cookie中的bite指定為public，但這樣做所有的人就都有了訪問權限，為了只允許子類訪問，可以將bite指定為protected即可。

7.組合和繼承之間的選擇

? 組合和繼承都允許在新的類中放置子對象，組合是顯式的這樣做，而繼承則是隱式的做。?

?

? ? 組合技術通常用于想在新類中使用現有類的功能而非它的接口這種情形。即在新類中嵌入某個對象，讓其實現所需要的功能，但新類的用戶看到的只是為新類所定義的接口，而非所嵌入對象的接口。為取得此效果，需要在新類中嵌入一個現有類的private對象。但有時，允許類的用戶直接訪問新類中的組合成分是極具意義的，即將成員對象聲明為public。如果成員對象自身都隱藏了具體實現，那么這種做法是安全的。當用戶能夠了解到你正在組裝一組部件時，會使得端口更加易于理解。比如car對象可由public的engine對象、wheel對象、window對象和door對象組合。但務必要記得這僅僅是一個特例，一般情況下應該使域成為private。在繼承的時候，使用某個現有類，并開發一個它的特殊版本。通常，這意味著你在使用一個通用類，并為了某種特殊需要而將其特殊化。稍微思考一下就會發現，用一個“交通工具”對象來構成一部“車子”是毫無意義的，因為“車子”并不包含“交通工具”，它僅是一種交通工具（is-a關系）。

“is-a”（是一個）的關系是用繼承來表達的，而“has-a”（有一個）的關系則是用組合來表達的。

到底是該用組合還是繼承，一個最清晰的判斷方法就是問一問自己是否需要從新類向基類進行向上轉型，需要的話就用繼承，不需要的話就用組合方式。

關鍵字

對final關鍵字的誤解

當final修飾的是基本數據類型時，它指的是數值恒定不變（就是編譯期常量，如果是static final修飾，則強調只有一份），而對對象引用而不是基本類型運用final時，其含義會有一點令人迷惑，因為用于對象引用時，final使引用恒定不變，一旦引用被初始化指向一個對象，就無法再把它指向另一個對象。然而，對象其自身卻是可以被修改的，java并未提供使任何對象恒定不變的途徑（但可以自己編寫類以取得使對象恒定不變的效果），這一限制同樣適用數組，它也是對象。? 使用final方法真的可以提高程序效率嗎？

將一個方法設成final后，編譯器就可以把對那個方法的所有調用都置入“嵌入”調用里。只要編譯器發現一個final方法調用，就會（根據它自己的判斷）忽略為執行方法調用機制而采取的常規代碼插入方法（將自變量壓入堆棧；跳至方法代碼并執行它；跳回來；清除堆棧自變量；最后對返回值進行處理）。相反，它會用方法主體內實際代碼的一個副本來替換方法調用。這樣做可避免方法調用時的系統開銷。當然，若方法體積太大，那么程序也會變得雍腫，可能受到到不到嵌入代碼所帶來的任何性能提升。因為任何提升都被花在方法內部的時間抵消了。

在最近的java版本中，虛擬機（特別是hotspot技術）能自動偵測這些情況，并頗為“明智”地決定是否嵌入一個final 方法。然而，最好還是不要完全相信編譯器能正確地作出所有判斷。通常，只有在方法的代碼量非常少，或者想明確禁止方法被覆蓋的時候，才應考慮將一個方法設為final。?

類內所有private 方法都自動成為final。由于我們不能訪問一個private 方法，所以它絕對不會被其他方法覆蓋（若強行這樣做，編譯器會給出錯誤提示）。可為一個private方法添加final指示符，但卻不能為那個方法提供任何額外的含義。

9.策略設計模式與適配器模式的區別

? 策略設計模式

創建一個能夠根據所傳遞的參數對象的不同而具有不同行為的方法，被稱為策略設? 計模式，這類方法包含所要執行的算法中固定不變的部分，而“策略”包含變化的部分。策略就是傳遞進去的參數對象，它包含要執行的代碼。適配器模式

在你無法修改你想要使用的類時，可以使用適配器模式，適配器中的代碼將接受你所擁有的接口，并產生你所需要的接口。

內部類與組合是完全不同的概念，這一點很重要。

? 為什么需要內部類？ — 主要是解決了多繼承的問題，繼承具體或抽象類 ? ? 10.內部類

?

一般來說，內部類繼承自某個類或實現某個接口，內部類的代碼操作創建它的外圍類的對象。所以可以認為內部類提供了某種進入其外圍類的窗口。內部類最吸引人的原因是：每個內部類都能獨立地繼承自一個（接口的）實現，所以無論外圍類是否已經繼承了某個（接口的）實現，對于內部類都沒有影響。

如果沒有內部類提供的、可以繼承多個具體的或抽象的類的能力，一些設計與編程問題就很難解決。從這個角度看，內部類使得多重繼承的解決方案變得完整。接口解決了部分問題，而內部類有效的實現了“多重繼承”。也就是說，內部類允許繼承多個非接口類型。?

考慮這樣一種情形：如果必須在一個類中以某種方式實現兩個接口。由于接口的靈活性，你有兩種選擇：使用單一類或者使用內部類。但如果擁有的是抽象的類或具體的類，而不是接口，那就只能使用內部類才能實現多重繼承。

使用內部類，還可以獲得其他一些特性：創建內部類對象的時刻并不依賴于外圍類對象的創建。

-內部類并沒有令人迷惑的is-a關系，它就是一個獨立的實體。

類型 — 不可變

? ? 用于string的“+”與“+=”是java中僅有的兩個重載過的操作符，而java并不允許程序員重載任何操作符。

考慮到效率因素，編譯器會對string的多次+操作進行優化，優化使用stringbuilder操作（javap-c class字節碼文件名 命令查看具體優化過程）。這讓你覺得可以隨意使用string對象，反正編譯器會為你自動地優化性能。但編譯器能優化到什么程度還不好說，不一定能優化到使用stringbuilder代替string相同的效果。比如：

? ? ? ? ? ? ? public class witherstringbuilder {

public string implicit(string[] fields){ string result = ”“;

for(int i = 0;i < ;i++)result += fields[i];

return result;

} ? ? ? ? ? ? ? ?

public string explicit(string[] fields){

stringbuilder result = new stringbuilder();

for(int i = 0;i < ;i++)(fields[i]);

return ng();

} }

運行javap-c witherstringbuilder，可以看到兩個方法對應的字節碼。implicit方法：

public implicit([]);code: 0: ldc #16 // string 2: astore_2 3: iconst_0 4: istore_3 5: goto 32 8: new #18 // class java/lang/stringbuilder 11: dup 12: aload_2 13: invokestatic #20 // method java/lang/f:(ljava/lang/object;)ljava/lang/string;16: invokespecial #26 // method java/lang/stringbuilder.”< init>”:(ljava/lang/string;)v 19: aload_1 20: iload_3 21: aaload 22: invokevirtual #29 // method java/lang/ pend:(ljava/lang/string;)ljava/lang/stringbuilder;25: invokevirtual #33 // method java/lang/ string:()ljava/lang/string;28: astore_2 29: iinc 3, 1 32: iload_3 33: aload_1 34: arraylength 35: if_icmplt 8 38: aload_2 39: areturn public implicit([]);code: 0: ldc #16 // string 2: astore_2 3: iconst_0 4: istore_3 5: goto 32 8: new #18 // class java/lang/stringbuilder 11: dup 12: aload_2 13: invokestatic #20 // method java/lang/f:(ljava/lang/object;)ljava/lang/string;16: invokespecial #26 // method java/lang/stringbuilder.”< init>”:(ljava/lang/string;)v 19: aload_1 20: iload_3 21: aaload 22: invokevirtual #29 // method java/lang/ pend:(ljava/lang/string;)ljava/lang/stringbuilder;25: invokevirtual #33 // method java/lang/ string:()ljava/lang/string;28: astore_2 29: iinc 3, 1 32: iload_3 33: aload_1 34: arraylength 35: if_icmplt 8 38: aload_2 39: areturn 可以發現，stringbuilder是在循環之內構造的，這意味著每經過循環一次，就會創建一個新的stringbuilder對象。

explicit方法：

public explicit([]);code: 0: new #18 // class java/lang/stringbuilder 3: dup 4: invokespecial #45 // method java/lang/stringbuilder.”< init>”:()v 7: astore_2 8: iconst_0 9: istore_3 10: goto 24 13: aload_2 14: aload_1 15: iload_3 16: aaload 17: invokevirtual #29 // method java/lang/ pend:(ljava/lang/string;)ljava/lang/stringbuilder;20: pop 21: iinc 3, 1 24: iload_3 25: aload_1 26: arraylength 27: if_icmplt 13 30: aload_2 31: invokevirtual #33 // method java/lang/ string:()ljava/lang/string;34: areturn } 可以看到，不僅循環部分的代碼更簡短、更簡單，而且它只生成了一個stringbuilder對象。顯式的創建stringbuilder還允許你預先為其指定大小。如果你已經知道最終的字符串大概有多長，那預先指定stringbuilder的大小可以避免多次重新分配緩沖。

####總結

因此，當你為一個類重寫tostring()方法時，如果字符串操作比較簡單，那就可以信賴編譯器，它會為你合理地構造最終的字符串結果。但是，如果你要在tostring()方法中使用循環，那么最好自己創建一個stringbuilder對象，用它來構造最終的結果。

? .printf()()方法模仿自c的printf，可以格式化字符串，兩者是完全等價的。

java中，ter類處理。

()方法參考了c中的sprintf()方法，以生成格式化的string對象，是一個static方法，()方法一樣的參數，但返回一個string對象。當你只需使用format()方法一次的時候，該方法很方便。

import ;import ter;

public class simpleformat {

public static void main(string[] args){

int x = 5;

double y = 5.324667;

.printf(”row 1: [%d %f]n“, x, y);.format(”row 1: [%d %f]n“, x, y);

formatter f = new formatter();(”row 1: [%d %f]n“, x, y);

string str = (”row 1: [%d %f]n", x, y);.println(str);integer[][] a = {

{1, 2, 3}, {4, 5, 6},{7, 8, 3}, {9, 10, 6}

};

.println(string(a));

} }

12.序列化控制

? 當我們對序列化進行控制時，可能某個特定子對象不想讓java序列化機制自動保存與恢復。如果子對象表示的是我們不希望將其序列化的敏感信息（如密碼），通常會面臨這種情況。即使對象中的這些信息是private屬性，一經序列化處理，人們就可以通過讀取文件或者攔截網絡傳輸的方式來訪問到它。有兩種辦法可以防止對象的敏感部分被序列化：

? 實現externalizable代替實現serializable接口來對序列化過程進行控制，externalizable繼承了serializable接口，同時增添了兩個方法：writeexternal()和readexternal()。

兩者在反序列化時的區別：

-對serializable對象反序列化時，由于serializable對象完全以它存儲的二進制位為基礎來構造，因此并不會調用任何構造函數，因此serializable類無需默認構造函數，但是當serializable類的父類沒有實現serializable接口時，反序列化過程會調用父類的默認構造函數，因此該父類必需有默認構造函數，否則會拋異常。-對externalizable對象反序列化時，會先調用類的不帶參數的構造方法，這是有別于默認反序列方式的。如果把類的不帶參數的構造方法刪除，或者把該構造方法的訪問權限設置為private、默認或protected級別，dexception: no valid constructor異常，因此externalizable對象必須有默認構造函數，而且必需是public的。

-externalizable的替代方法：如果不是特別堅持實現externalizable接口，那么還有另一種方法。我們可以實現serializable接口，并添加writeobject()和readobject()的方法。一旦對象被序列化或者重新裝配，就會分別調用那兩個方法。也就是說，只要提供了這兩個方法，就會優先使用它們，而不考慮默認的序列化機制。

這些方法必須含有下列準確的簽名：

private void writeobject(objectoutputstream stream)throws ioexception;

private void readobject(objectinputstream stream)

throws ioexception, classnotfoundexception

-可以用transient關鍵字逐個字段地關閉序列化，它的意思是“不用麻煩你保存或恢復數據—我自己會處理的”。由于externalizable對象在默認情況下不保存它們的任何字段，所以transient關鍵字只能和serializable對象一起使用。

java編程思想內容篇三

這是一份試圖提綱挈領的讀書筆記，《java編程思想》這本八百多頁的書娓娓道來地包含了太多細節，這對讀者是非常貼心的，我也強烈建議細細讀這本書，如果你希望在短時間內學會java這種語言，那么這本書不是最好的選擇，你可以看看譚浩強系列。我把看這本書的過程中，個人覺得每一章中最重要的思想、用整理在這里，希望自己回顧的時候有所參照和提高。也希望大家帶著同樣的目的來看本篇讀書筆記。

第一章 對象導論

比起過程型語言編寫的程序，用面向對象語言編寫的程序更加簡單、易于理解、可復用。《c++編程思想》里也有這一章，是一個拋磚引自己的玉的章節，不明白可以跳過，回頭再看。

第二章 一切都是對象

java語言里面，一切都是對象，并且程序員是通過引用來操縱對象。一個簡單的例子，非常輕松地讓讀者進入java的世界。需要注意的是java數據會儲存在5個不同的地方：寄存器、堆棧、堆、常量存儲、非ram存儲，用new創建的一般對象都放在堆中，而特殊的基本對象放在堆棧中，如果想把基本對象也放在堆中，需要包裝基本類型。

第三章 操作符

java中的操作符語法類似于c，所以學習起來一點困難也沒有。要特別注意兩個比較大的整數相加或者相乘的時候的溢出問題，用long或者biginteger解決這個問題。

第四章 控制執行流程

我想起《pointer on c》這本書第一章就有這一句話，本書適合那些希望迅速學習一門新語言而不是被“為什么if和for很重要”的弱智問題耽擱進度的讀者。呵呵，這一章很不厭其煩地介紹了運算、操作符優先級、類型轉換、選擇循環等基本特性，有c或者c++編程經驗的讀者可以大概瀏覽一下。

第五章 初始化和清理

關于初始化：

1.初始化很重要，一定不要忘記。而且java編譯器會很好的防止使用未初始化數據的意外，這是比c和c++更優的地方。

2.編譯器初始化的順序為：

a.類首次加載的時候，有關靜態初始化的所有動作都會執行。

a1.類的加載包括首次創建該類型的對象，或者該類的靜態方法/靜態域首次被訪問

a2.靜態域的初始化在一切初始化之前，即靜態變量散布在代碼不同的地方，它們也會在任何方法（包括構造器）調用之前被初始化

b.當用new calssname()創建對象的時候，會在堆上開辟足夠的存儲空間，這塊存儲空間被清零，然后執行字段的初始化動作。（這里的字段初始化都是非靜態的，因為靜態的變量已經在a中執行完畢，而且靜態變量存儲在不同的地方，靜態數據只占用一份存儲空間）

c.執行構造器

關于清理

c++關于清理的部分包含很大不確定性。目前需要知道的事情是，正常情況下，我們是不需要調用finalize方法的，而且垃圾回收區會自動回收不再使用的對象，同時我們需要自己注意一些需要關閉的文件。

需要注意的是，用=對數組進行“賦值”的時候，實際上是引用的傳遞，就是說，二者指向同一堆。

第六章 訪問權限控制

關于包

你應該有一個自己的域名，這樣發布你的java程序的時候，就可以將你的包名設置為你的域名倒轉。想要正確讓包工作，要正確設置classpath，對于新手來說，這的確是一個挑戰。我當初就難到了。

關于訪問權限修飾詞

值得注意的是，如果兩個編譯單元放在同一個目錄下并且都沒有設置包名的話，他們對于對方都是擁有包訪問權限的。訪問權限修飾詞是修飾方法和數據，而不是類。類只有兩種訪問權限，包訪問權限或public訪問權限。默認為包訪問權限。如果不希望其它任何人對該類擁有訪問權限，可以把所有的構造器設置為private。但是有一個例外，可以通過該類自己的static成員內部創建（于是就有了工廠設計模式和單例設計模式）。

第七章 復用類

有三種方法復用類：組合，繼承，代理。

組合即是在新的類里面放上已經定義的類的對象，然后通過調用它的方法來實現自己的功能。

繼承是通過extends關鍵詞繼承某一父類，這樣就能訪問父類的所有public方法（因此為了繼承，一般的規則是將父類的所有數據成員都指定為private，將所有的方法都指定為public）。子類的初始化需要注意的是，（當創建了一個子類的對象時，該對象包含一個基類的子對象）java會在子類的構造器中插入對基類默認構造器的調用。但是如果沒有默認的基類構造器，或者想調用一個帶參數的基類構造器，就必須用關鍵詞super顯式地編寫調用基類構造器的語句，并且配上適當的參數列表。

代理很有意思，（我們姑且使用導出類和基類這樣的字眼，但要清楚我們不是在討論繼承里面的關鍵詞）在導出類里保存一個基類的對象，然后用自己的方法對該基類的種種方法進行包裝。

如何決定使用哪種方法復用類呢？is-a就繼承，has-a就用組合。而且，組合比繼承總體上使用更廣泛、代價更小。

向上轉型

這個就牛逼了，第八章，第九章，第十章都與此密切相關。看完本書之后印象最深的就是向上轉型了。

使用final的原因有很多種，一定要弄清楚為什么使用final，是由于設計還是效率。

final作用于數據的時候：final作用在基本對象比如int上，該值就成為不可改變的，一旦被初始化就無法再被更改，但是作用在普通的對象引用的時候，final使引用恒定不變，但是引用指向的對象是可變的。編譯器需要我們確保final對象一定要被初始化，我們可以通過在構造器中初始化他們，以達到相對自由的效果（稱為空白final，我認為這個名字容易讓人誤解）。java允許在參數列表中以聲明的方式將參數指明為final，這一特性主要用來向匿名內部類傳遞數據（這很重要）。

final作用于方法的時候，說明作者想保持該方法在繼承的過程中不被改變，并且不被覆蓋。同時，被final修飾的方法會被關閉“動態綁定”，這樣編譯器就會為final方法調用生成“有限”有效的代碼。之所以說有限，是因為隨著編譯器的牛逼，它生成的代碼越來越有效。

final作用于類的時候，即是作者聲明對該類的設計不允許任何繼承。

學習得更深入一些，可能對以下事實感到有興趣：java中所有的事物都是對象，每個類的編譯代碼都存在于電腦中的文件夾里（文件夾的層次根據反轉域名得到），該文件只有在需要使用程序代碼時才被加載。具體的說，就是“類在其任何static成員函數（包括構造函數）被訪問時加載”。第八章 多態

多態的重要基本原理就是向上轉型：繼承允許將對象視為它自己本身的類型或其基類型加以處處理。

將一個方法調用和一個方法主題關聯起來稱為綁定，java中所有的方法都是后期綁定（除了static方法和final方法），所以我們可以編寫只與基類打交道的程序代碼，并且這些代碼對所有的導出類都可以正確運行。

(為什么static不動態綁定：因為static方法的主要用法就是用類名.方法名這樣的方式來調用，不存在“發送消息給某個對象，讓對象判斷自己怎么做”這樣的情況。

為什么final不動態綁定：這是早期final的一種用法，由程序員指定某方法為final，意味著程序員明了動態綁定的機制，并且聲明該方法不需要動態綁定，這樣可以獲得更好的性能。這種用法已經很少使用了。)

初始化的時候，導出類的構造函數會自動調用基類的默認構造函數，此過程一直遞歸到最基本的基類。如果需要調用有參數的構造函數就需要手動執行。反過來，如果需要進行清理工作（大部分時候我們都不需要），務必手動執行基類的清理工作先。比如繼承鏈的每個類都實現dispose()方法，那么執行某個類的清理工作的時候，e()。不過此種情況下，e()之前釋放成員對象，清理順序與執行順序是相反的。

此外，構造器方面有更加復雜的調用機制，我們不用理它，只需要知道一條有效的準則“用盡可能簡單的方法使對象進入正常狀態，如果可以的話避免調用其它方法”。

java編譯器能夠允許向上多態，就是因為java的機制能保存對象的類型信息，即rtti，正因為這種機制，java編譯器也允許向下轉型，以獲得擴展類的“擴展出”的方法。（另，擴展類“擴展”了方法的這種繼承不是“純繼承”，這樣做好不好？用戶自己度量）。向下轉型失敗的話會拋出一個classcastexception。

雖然這一章都是在講多態，但是多態并不總是解決問題最好的方案，它有可能使事情不必要地復雜起來，我們應該總是優先考慮更加靈活的組合。

第九章 接口

一種專門提供“接口”的類叫抽象類，若含有至少一個abstract方法，該類就必須被聲明為abstract的。抽象方法沒有方法體，派生類必須實現它，否則派生類也必須被生命為抽象的。

interface關鍵詞使抽象的概念更進了一步：1.這個“類”完全抽象。2.一個類可以向上轉型為多種interface。要讓一個類遵循某個特定接口，需要使用implement關鍵字。

在這一章中出現了“策略設計模式”這個詞。創建一個能夠根據所傳遞的參數對象的不同而具有不同行為的方法，被稱為策略設計模式。

策略設計模式跟適配器設計模式聯合使用可以提供非常強大的功能，比如我們遇到了無法更改的類（別人編寫的），想要它滿足我們的接口然后放到設計模式里面去（當然滿足了接口之后的用法就不止如此了），就可以編寫一個適配器，包裝該類同時產生我所需要的接口。

使用抽象類和接口的兩個原因是：1.在多重繼承關系中（這真的很常見，看看java api就知道了），導出類可以被向上轉型為每一個接口。2.防止客戶端程序員創建該類的對象。那么我們該使用抽象類還是接口呢？事實上，如果知道某事物應該成為一個基類，那么第一選擇應該是使它成為一個接口。

接口之間的繼承能夠形成很好的體系，更像我們的現實生活。但是要特別注意的是，在不同接口中使用相同的方法名通常會造成代碼可讀性的混亂，令人不快。

工廠方法設計模式是又一個重要的設計模式。我們在代碼中增加額外的間接性，一個重要的原因是想要創建框架。

java編程思想內容篇四

in the following code, which is the earliest statement, where the object originally held in e, may be garbage collected:

class test {

static void main(string args []){

ee e = new employee(“bob”, 48);

atepay();

n(etails());

6.e = null;

7.e = new employee(“denise”, 36);

atepay();

n(etails());

10.}

11.}

only one:

in the following code, which is the earliest statement, where the object originally held in e, may be garbage collected:

class test {

static void main(string args []){

ee e = new employee(“bob”, 48);

atepay();

n(etails());

6.e = null;

7.e = new employee(“denise”, 36);

atepay();

n(etails());

10.}

11.}

only one:

10

11

7

8

2:exhibit :

class test（e static int j = 0;

e static boolean methodb(int k)（5.j += k;

true;

6.)

static void methoda(int i){

n b:

10.b = i < 10 | methodb(4);

11.b = i < 10 || methodb(8);

12.)

static void main(string args[] }（a(0);

n(j);

17.)

18.)

what is the result?

program prints “0”

program prints “4”

program prints “8”

program prints “12”

3:what is written to the standard output given the following statement:n(4|7);

select the right answer:

a.4

b.5

c.6

d.7

4:

select valid identifier of java:

select valid identifier of java:

a.%passwd

b.3d_game

c.$charge

5:設有變量說明語句int a=1,b=0;

則執行以下程序段的輸出結果為()。

switch(a)

{

case 1:

switch(b)

{

case 0:printf(“**0**”);break;

case 1:printf(“**1**”);break;

}

case 2:printf(“**2**”);break;

}

printf(“ ”);

a.**0**

b.**0****2**

c.**0****1****2**

d.有語法錯誤

6:in the following pieces of code, which one will compile without any error?

buffer sb1 = “abcd”;

n b = new boolean(“abcd”);

c.c: byte b = 255;

fl = 1.2;

7:

what is the result when you compile and run the following code?

public class throwsdemo

{

static void throwmethod()

{

n(“inside throwmethod.”);

throw new illegalaccessexception(“demo”);

}

public static void main(string args[])

{

try

{

throwmethod();

}

catch(illegalaccessexception e)

{

n(“caught ” + e);

}

}

}

choices:

what is the result when you compile and run the following code?

public class throwsdemo

{

static void throwmethod()

{

n(“inside throwmethod.”);

throw new illegalaccessexception(“demo”);

}

public static void main(string args[])

{

try

{

throwmethod();

}

catch(illegalaccessexception e)

{

n(“caught ” + e);

}

}

}

choices:

ation error

e error

e successfully, nothing is ed by caught:laccessexcption: demo

8:which of the following statements are not legal?

l = 4990;

i = 4l;

d = 34.4;

t = 0.9f.9:

give the following java class:

public class example{

public static void main(string args[]){

static int x[] = new int[15];

n(x[5]);

}

}

which statement is corrected?

give the following java class:

public class example{

public static void main(string args[]){

static int x[] = new int[15];

n(x[5]);

}

}

which statement is corrected?

compile, some error will run, some error will is is null.10:下面關于變量及其范圍的陳述哪些是錯的。

a.實例變量是類的成員變量。

b.實例變量用關鍵字static聲明。

c.在方法中定義的局部變量在該方法被執行時創建

d.局部變量在使用前必須被初始化。

11:

public class x{

public object m(){

object o = new float(3.14f);//line 3

object [] oa = new object[1];//line 4

oa[0] = o;//line 5

o=null;//line 6

return oa[0];//line 7

}

}

when is the float object, created in line 3,eligible for garbage collection?

public class x{

public object m(){

object o = new float(3.14f);//line 3

object [] oa = new object[1];//line 4

oa[0] = o;//line 5

o=null;//line 6

return oa[0];//line 7

}

}

when is the float object, created in line 3,eligible for garbage collection?

after line after line 6

after line 7(that is,as the method returns)

in this method

12:

which is the most appropriate code snippet that can be inserted at line 18 in the following code?

(assume that the code is compiled and run with assertions enabled)

.*;

class asserttest

4.{

e hashmap cctld;

asserttest()

8.{

= new hashmap();

(“in”, “india”);

(“uk”, “united kingdom”);

(“au”, “australia”);

13.// more code...14.}

15.// other methods.... string getcountry(string countrycode)

17.{

18.// what should be inserted here?

country =(string)(countrycode);

country;

21.}

22.}

which is the most appropriate code snippet that can be inserted at line 18 in the following code?

(assume that the code is compiled and run with assertions enabled)

.*;

class asserttest

4.{

e hashmap cctld;

asserttest()

8.{

= new hashmap();

(“in”, “india”);

(“uk”, “united kingdom”);

(“au”, “australia”);

13.// more code...14.}

15.// other methods.... string getcountry(string countrycode)

17.{

18.// what should be inserted here?

country =(string)(countrycode);

country;

21.}

22.}

countrycode!= null;

countrycode!= null : “country code can not be null”;

cctld!= null : “no country code data is available”;

cctld : “no country code data is available”;

13:

give the following code:

public class example{

public static void main(string args[]){

int l=0;

do{

n(“doing it for l is:”+l);

}while(—l>0)

n(“finish”);

}

}

which well be output:

give the following code:

public class example{

public static void main(string args[]){

int l=0;

do{

n(“doing it for l is:”+l);

}while(—l>0)

n(“finish”);

}

}

which well be output:

it for l is 3

it for l is 1

it for l is 2

it for l is 0

14:which statements about java code security are not true?

bytecode verifier loads all classes needed for the execution of a ing code is performed by the runtime runtime the bytecodes are loaded, checked and run in an interpreter. class loader adds security by separating the namespaces for the classes of the local file system from those imported from network sources.15:a class design requires that a member variable should be accessible only by same package, which modifer word should be used?

ted

modifer

e

16:character流與byte流的區別是

a.每次讀入的字節數不同

b.前者帶有緩沖，后者沒有

c.前者是塊讀寫，后者是字節讀寫

d.二者沒有區別，可以互換使用

簡答題

17:找出兩個字符串中最大子字符串,如“abractyeyt”,“dgdsaeactyey”的最大子串為“actyet”

18:假設你有一個用1001個整數組成的數組，這些整數是任意排列的，但是你知道所有的整數都在1到1000(包括1000)之間。此外，除一個數字出現兩次外，其他所有數字只出現一次。假設你只能對這個數組做一次處理，用一種算法找出重復的那個數字。如果你在運算中使用了輔助的存儲方式，那么你能找到不用這種方式的算法嗎?

19:到底在哪里使用cascade=“...”?

20:使用tomcat部署應用程序 emoryerror 嗎?如何解決的。

21:請寫一個java程序實現數據庫緩沖池的功能?

22:有200個正整數，且每個數均在1000至9999之間。請編制函數，其函數的功能是：要求按每個數的后三位的大小進行升序排列，然后取出滿足此條件的前10個數依次存入數組bb中，如果后三位的數值相等，則按原先的數值進行降序排列。

23:anonymous inner class(匿名內部類)是否可以extends(繼承)其它類，是否可以implements(實現)interface(接口)?

24:找出字符串a中包含的字符可以進行的所有不同組合。例如：abccd中，ab，ac，bc，cc，abd等都是可能的組合。

25:下面的代碼在絕大部分時間內都運行得很正常，請問在什么情況下會出現問題?問題的根源在哪里?

import .linkedlist;

public class stack {

linkedlist list = new linkedlist();

public synchronized void push(object x){

synchronized(list){

t(x);

notify();

}

}

public synchronized object pop()

throws exception {

synchronized(list){

if(()<= 0){

wait();

}

return last();

}

}

}

java編程思想內容篇五

一 基礎知識點

1.面向對象程序設計（object-oriented programming oop），uml(unitied modelling language 統一建模語言)。將對象想像成“服務提供者”，它們看起來像什么？能夠提供哪 些服務？需要哪些對象？ 中動態綁定是默認行為。java采用動態內存分配方式，通過new操作在堆(heap)的內 存池中動態創建對象。java存儲結構類型：1）寄存器2）堆棧，主要存儲對象引用3）堆，主要用于存放所有的java對象4）常量存儲，也就是程序代碼區5）非ram存儲，如流對象 和持久化對象。基本類型不用new來創建變量，而且這個變量直接存儲”值”，并置于堆棧中。eger和bigdecimal的使用。當變量作為類的成員使用時 當變量作為類的成員使用時，java才確保給定其默認初 當變量作為類的成員使用時 始值，但是在方法中定義的變量，它有可能是任意值。面向對象的程序設計可以歸納為“向 對象發送消息”。關鍵字static。c只能為public和protected成員進行文檔注釋，但是也可以通過-private進行標記注 釋。javadoc常用方法： @see 引用其他類，link #member label}，{@ {@docroot}，{@inheritdoc},@version，@ author，@since,@param，@return,@throws,@deprecated。5.整數除法會直接去掉結果的小數位。基本類型的對象如果直接對它們賦值，對象指向同 一個常量存儲區，但是如果通過對象來初始化則會指向不同的堆的存儲區。如：

string st1 = new string(“a”);string st2 = new string(“a”);st1==st2 false string st1 = “a”;string st2 = “a”;st1==st2 true

6.邏輯操作符：與(&&)、或(||)、非(!)，其中與(&&)、或(||)會產生短路現象。& |也支持邏輯 也支持邏輯

運算操作。運算操作

7.直接常量中l代表long，f代表float，d代表double。顯示二進制形式的話，可以通過integer 和long類的靜態方法tobinarystring()。如：rystring(10l)。

8.在返回void的方法中沒有return語句，那么在該方法的結尾處會有一個隱式的return。

一 般情況下每個方法都會有一個顯示的return語句。用于強行退出循環，不執行循環中剩余的語句，而continue則停止執行當前的迭代，然后退回循環起始處，開始下一次迭代。goto仍是java的一個保留字，但在語言中并未使用它。break和continue與標簽一起使用，可以中斷循環，直到標簽所在的地方。this用法： public class leaf { int i = 0;leaf increment(){ i++;return this;} }

10.回答一個新技術的問題大概思路和步驟是：我們想干什么，怎么干，干的過程中遇到了 什么問題，現在用什么方式來解決。答題時，先答是什么，再答有什么作用和要注意什么（這 部分最重要，展現自己的心得）。ze的使用：垃圾回收只與內存有關，當“垃圾回收”時，finalize()得到調用。java中 的對象都能被垃圾回收器回收，但是在“本地方法”的情況下，有可能在分配內存時采用類 似c語言的做法通過malloc()函數來分配存儲空間時，這時只能通過free()函數來釋放空間，而這些釋放操作必須要放到finalize()方法中，垃圾回收器才能正確的釋放內存。“垃圾回收” 都不保證一定會發生。

12.垃圾回收原理：引用記數 引用記數是一種簡單但速度很慢的垃圾回收技術。每個對象都含有一個 引用記數

java 編程思想第四版 讀書筆記

引用記數器，當有引用連接至對象時，引用計數加1。當引用離開作用域或被置為null時，引用計數減1。垃圾回收器會在含有全部對象的列表上遍歷，當發現某個對象的引用計數為0 時，就立即釋放其占用的空間。定位交互自引用的對象組所需的工作量極大，所以并沒有被 應用于任何一種java虛擬機中。java虛擬機采用一種自適應 自適應的垃圾

回收技術，java虛擬機會 自適應 進行監視，如果所有對象都很穩定，垃圾回收器的效率降低的話，就切換到“標記-清掃” 方式；同樣，java虛擬機會跟蹤“標記-清掃”的效果，要是堆空間出現很多碎片，就會切 換回“停止-復制”方式。“停止-復制”，先暫停程序的運行，然后將所有存活 存活的對象從當前 存活 堆復制到另一個堆，沒有被復制的全部都是垃圾。“標記-清掃”，從堆棧和靜態存儲區出發，遍歷所有的引用，進而找出所有存活的對象，每當它找到一個存活對象，就會給對象設一個 標記，這個過程中不會回收任何對象，只有全部標記工作完成的時候，清理動作才會開始。在清理過程中，沒有標記的對象將被釋放，不會發生下任何復制動作。13.初始化順序:先靜態對象，后“非靜態”對象，先變量，再構造函數，然后是方法。靜態 初始化只有在必要時刻才會進行，如果不引用其對象，那么該對象中的靜態成員將不會被創 建，而且它們只會在第一次被訪問時進行初始化，其后不會再次被初始化。14.對象的創建過程：1）當首次創建對象時，或類的靜態方法/靜態域首次被訪問時，java 解釋器必須查找類路徑，文件。2），有關靜態初始化的所有動作都會 執行。3）當用new 創建對象時，在堆上為對象分配存儲空間，而且這塊存儲空間會被清零，也就是說它會自動地將對象中的所有基本類型數據都設置成默認值，而引用是被設置成 null。4）執行所有出現于字段定義處的初始化動作。5）執行構造器。15.數組：常用方法的使用。binarysearch(),copyof(),aslist(),copyofrange(),equals(),fill(),sort(),tostring(),hashcode()。可變 參數列表:void f(float i,character? args)。枚舉類型:enum,它可以在switch語句內使用。16.類的結構依次為：1）包的注釋2）package的設置3)import導入設置4)類的注釋5）類的編 寫。的訪問權限：類的訪問權限只有public和默認包訪問權限，成員和方法有 public,protected,默認包訪問權限和private。使用類的客戶端程序是無法訪問包訪問權限成員 的。包訪問權限的類的對象可以由包內任何其他類來創建和使用，但是包外則不行。18.為了繼承，一般的規則是將所有的數據成員都指定為private，將所有的方法指定為public 或protected。java會自動在導出類的構造器中插入對基類構造器的調用。調用基類的構造器 必須是你在導出類構造器中要做的第一件事。19.代理，它是繼承與組合之間的中庸之道，因為我們將一個成員對象置于所要構造的類中（就像組合），但與此同時我們在新類中暴露了該成員對象的所有方法（就像繼承）。20.清理方法的順序：首先，執行類的所有特定的清理動作，其順序同生成順序相反；然后，調用基類的清理方法。除了內存之外，不能依賴垃圾回收器去做任何事，如果需要進行清理，最好是編寫自己的清理方法，但不要使用finalize()。@override注解可以防止在你不想重載 時而意外地進行了重載。21.組合與繼承之間的選擇：組合技術通常用于想在新類中使用現有類的功能而非它的接口，也就是在新類的嵌入某個對象，讓其實現所需要的功能，但新類的用戶看到的只是為新類所 定義的接口，而非所嵌入對象的接口，一般情況下會在新類中嵌入一個現有類的private對象。而繼承，它是指使用某個現有類，并開發一個它的特殊版本。“is-a”（是一個）的關系是用 繼承來表達的，而“has-a”（有一個）的關系則是用組合來表達的。的用法：根據慣例，既是static又是final的域將用大寫表示，并使用下劃線分隔各個單 詞。類中所有的private方法都隱式的指定為是final的。final類中所有的方法都隱式指定為是 final的。當前用hashmap替代了hashtable，用arraylist替代了vector。

java 編程思想第四版 讀書筆記

中除了static方法和final方法（private方法屬于final方法）之外，其他所有的方法都是 后期綁定。接口中的屬性都是public static final的，方法都是public 24.多態：只有普通的方法調用可以是多態的。任何域訪問操作都將由編譯器解析，因此不 是多態的。如果某個方法是靜態的，它的行為也不具有多態性。25.初始化的實際過程：1）在其他任

何事物發生之前，將分配給對象的存儲空間初始化成二 進制的零。2）如前所述那樣調用基類構造器，此時，調用被覆蓋后的方法（要在調用子類 構造器之前調用）。3）按照聲明的順序調用成員的初始化方法。4）調用導出類的構造器主 體。編寫構造器時有一條有效的準則： “用盡可能簡單的方法使對象進入正常狀態；如果可 以的話，避免調用其他方法”。在構造器內唯一能夠安全調用的那些方法是基類中的final方 法（也適用于private方法，它們自動屬于final方法）。這些方法不能被覆蓋。26.一條通用的準則是： “用繼承表達行為間的差異，并用字段表達狀態上的變化”。27.一個內部類的對象能訪問其外圍對象的所有成員，還擁有其外圍類的所有元素的訪問權。在內部類中，如果你需要生成對外部類對象的引用，可以使用外部類的名字后面緊跟圓點和 this，（outerclass out = ）。有時你可能想要告知某些其他對象，去創建其某個 內部類的對象，可以在new表達式中提供對其他外部類對象的引用，語法（outerclass out = new outerclass, lass inner = innerclass()）。在擁 有外部類對象之前是不可能創建內部類對象的，但是，嵌套類（靜態內部類）除外。如果定 義一個匿名內部類，并希望它使用一個在其外部定義的對象，那么其參數引用必須是final 的。匿名類的實例初始化的實際效果就是構造器，而且你不能重載實例初始化方法，它可以 擴展類，也可以實現接口，但是實現接口，也只能實現一個接口。28.嵌套類（靜態內部類）：1)要創建嵌套類的對象，并不需要其外圍類的對象；2)不能從嵌 套類的對象中訪問非靜態的外圍類對象。30.為什么需要內部類：1）每個內部類都能獨立繼承自一個（接口的）實現，所以無論外圍 類是否已經繼承了某個（接口的）實現，對于內部類都沒有影響。2）內部類可以更好的實 現“多重繼承”。3）內部類可以有多個實例，每個實例都有自己的狀態信息，并且與其外圍 類對象的信息相互獨立。4）在單個外圍類中，可以讓多個內部類以不同的方式實現同一個 接口或繼承同一個類。5）創建內部類對象的時刻并不依賴于外圍類對象的創建。

6）內部類 并沒有令人迷惑的“is-a”關系，它是一個獨立的實體。31.閉包：它是一個可調用的對象，它記錄了一些信息，這些信息來自于創建它的作用域。通過內部類提供閉包的功能是優良的解決方案。使用局部內部類而不使用匿名內部類的的理 由是需要不止一個該內部類的對象，或者需要一個已命名的構造器。32.內部類的繼承：內部類的構造器必須連接到指向其外圍類對象的引用，必須在構造器內 使用如下語法：();33.容器：list、set、query、map。程序中不應該使用過時的vector,hashtable和stack。常用的類有:collection,collections,arrays,arraylist,linkedlist,hashset,treeset,linkedhashset, hashmap,treemap,linkedhashmap,query,stack，priorityquery 迭代器：iteratror,listiterator3

java 編程思想第四版 讀書筆記

34.異常：把當前異常對象重新拋出時，printstacktrace()方法顯示原來異常拋出點的調用棧 信息，要想更新這個信息，可以調用fillinstacktrace()方法。如： throw(exception)stacktrace()。35.異常鏈：在捕獲一個異常后拋出另一個異常，而且希望把原始異常的信息保存下來。現 在所有的throwable的子類在構造器中都可以接受一個cause(因由)對象作為參數。這個cause 就用來表示原始異常，這樣通過把原始異常傳遞給新的異常，使得即使在當前位置創建并拋 出了新的異常，也能通過這個異常鏈追蹤到異常最初發生的位置。只有三種基本異常類（error、exception、runtimeexception）提供了帶cause參數的構造器，其他的異常只能使用 initcause()方法。36.當覆蓋方法的時候，只能拋出在基類方法的異常說明里列出的那些異常，或者拋出的異 常的子類或者不拋出異常。標準異常： throwable這個java類被用來表示任何可以作為異常被拋出的類。throwable 對象可分為兩種類型（指從throwable繼承而得到的類型）：error用來表示編譯時和系統錯誤（除

特殊情況外，一般不用你關心）；exception是可以被拋出的基本類型，在java類庫、用 戶方法以及運行時故障中都可能拋出exception型異常。所以java程序員關心的基類型通常是 exception。eexception:java運行時異常，它屬于java的標準運行時檢測的一部分，它會自動被 java虛擬機拋出，它也被稱為“不受檢查異常”，這種異常屬于錯誤，將被自動捕獲，不用 自己進行處理。除此之外的異常需要進行聲明，并進行捕獲或都向上拋出。只能在代碼中忽 略runtimeexception（及其子類）類型的異常，其他類型異常的處理都是由編譯器強制實施 的。runtimeexception代表的編程錯誤：1）無法預料的錯誤；2）作為程序同，應該在代碼 中進行檢查的錯誤。會捕獲基類異常本身以及所有從它派生的異常，如果將基類異常放在前面，子類異 常放在后面的話，子類異常永遠不會被捕獲，編輯器會報錯。unreachable catch block for

is already handled by the catch block for exception。

40.異常處理的一個重要目標就是把錯誤處理的代碼同錯誤發生的地點分離。應該在下列情 況下使用異常：1）在恰當的級別處理問題。（在知道該如何處理的情況下捕獲異常）

2）解 決問題并且重新調用產生異常的方法。3）進行少許修被，然后繞過異常發生的地方繼續執

java 編程思想第四版 讀書筆記

行。4）用別的數據進行計算，以代替方法預計會返回的值。5）把當前運行環境下能做的事 情盡量做完，然后把相同的異常重拋到更高層。6）把當前運行環境下能做的事情盡量做完，然后把不同的異常拋到更高層。7）終止程序。8）進行簡化。9）讓類庫和程序更安全。41.字符器：string,stringbuilder,formatter.格式化語法： %[argument_index$][flags][width][.precision]conversion 在默認的情況下，數據是右對齊，不過可以通過使用“-”標志來改變對齊方向。42.正則表達式：意思是“我要插入一個正則表達式的反斜線，所以其后的字符具有特殊的 意義”。數字的正則表達式是:d，普通反斜線：，換行：n，制表符：t。要表示“一個 或多個之前的表達式”，使用+。“零個或多個”，使用?。(-|+)?:+在正則表達式中有特殊意 義，必須使用將其轉義。string類有matches()和split()方法處理正則表達式。n類和matcher類來構造正則表達式對象。 包，用static e()方法來編譯正則表達式生成一個pattern對象，再將你想要檢索 的字符串傳入pattern對象的matcher()方法，它會生成一個matcher對象，最后通過操作matcher 對象來實現相關功能。還可以通過scanner來完成正則表達式相關功能。44.在java中，所有的類型轉換都是在運行進進行正確性檢查的。e()獲得 class對象的引用，也可以通過object類的getclass()方法來獲得。45.使用類的準備工作：1）加載，這是由類加載器執行，該步驟將查找字節碼，并從這些字 節碼中創建一個class對象。2）鏈接，將驗證類中的字節碼，為靜態域分配存儲空間，并且 如果必需的話，將解析這個類創建的對其他類的所有引用。3）初始化，如果該類具有超類，則對其初始化，執行靜態初始化器和靜態初始化塊。（構造器隱式地是靜態的）。和反射之間的區別：對rtti來說，文件。而對于反 射機制來說，.class文件在編譯時是不可獲取的，文件。47.泛型中t代表類型class，要顯式地指明類型，必須在點操作符與方法名之間插入尖括號，然后把類型置于尖括號中；如果是在定義該方法的類的內部，必須在點操作符之前使用this 關鍵字，如果是使用static的方法，必須在點操作符之前加上類名。在泛型代碼內部，無法 獲得任何有關泛型參數類型的信息。在泛型中創建數組，tance()。泛 型(

)會擦除出現在方法或類內部的有關實際類型的信息。但是可以引入類型標簽來傳遞 類型信息（class

）。

、

superclass> 48.任何基本類型都不能作為類型參數，但是可以使用它們的包裝類，如不能使用 arraylist，但可以使用arraylist 49.異常的分類：1）error:稱為錯誤，由java虛擬機生成并拋出，包括動態鏈接失敗、虛擬 機錯誤等，程序對其不做處理；2)exception:所有異常類的父類，其子類對應了各種各樣可 能出現的異常事件，一般需要用戶顯示的聲明或捕獲；

3)runtime exception:一類特殊的異常，如被0除、數據下標超范圍等，其產生比較頻繁，處理麻煩，如果顯式的聲明或捕獲將會對 程序可讀性和運行效率影響很大。因此由系統自動檢測并將它們交給缺省的異常處理程序（用戶可不必對其處理）。50.使用自定義異常一般步驟：1）ion類聲明自己的異常類；2）在 方法適當的位置生成自定義異常的實例，并用throw語句拋出； 在方法的聲明部分用throws 3）語句聲明該方法可能拋出的異常。

二 專項復習

1.容器 2.正則表達式

java 編程思想第四版 讀書筆記

3.設計模式 4.異常 5.泛型 6.反射 7.多線程

常用包（加粗是抽象類，斜體是接口，普通是類）三 j2se 常用包（加粗是抽象類，斜體是接口，普通是類）

提供利用 java 編程語言進行程序設計的基礎類。process、processbuilder、runtime、system、string、object、class、classloader、math、compiler、thread、threadgroup、runnable、threadlocal、inheritablethreadlocal、package .util arraylist、arrays、collection、collections、linkedlist、hashset、treeset、iterator、listiterator、map、hashmap、treemap、comparator 歷史遺留的類：dictionary、hashtable、properties、stack、vector、enumeration 使用迭代函數的步驟：1）通過調用類集的iterator()或listiterator()方法獲得對類集頭的迭代函 數；2）建立一個調用hasnext()方法的循環，只要hasnext()返回true，就進行循環迭代；3）在循環內部，通過調用next()方法來得到每一個元素。gregoriancalendar、timezone、simpletimezone、locale、dateformat、bitset、calendar、simpledateformat、random、observer、observable、timer、timertask gregoriancalendar定義了兩個域：ad和bc。它們代表由公歷定義的兩個紀元。bc公元前，ad公元后 inputstream、outputstream reader、writer outputstream、reader writer、fileinputstream、fileoutputstream、inputstream outputstream reader writer bytearrayinputstream、bytearrayoutputstream、filteroutputstream、filterinputstream、bufferedinputstream、bufferedoutputstream、sequenceinputstream、printstream、randomaccessfile filereader、filewriter、chararrayreader、chararraywriter、bufferedreader、bufferedwriter、printwriter objectinputstream、izable 或 alizable 接口的對象才能從流讀取。 inetaddress、url、urlconnection java中有兩類tcp套接字。一種是服務器端的，另一種是客戶端的。serversocket類設 計成在等待客戶建立連接之前不做任何事的“監聽器”。socket類為建立連向服務器套接 字以及啟動協議交換而設計。或 文件。所以，http:/// 與http:/// 是相同 的。java通過兩個類實現udp協議頂層的數據報：datagrampacket對象是數據容器，datagramsocket是用來發送和接受datagrampackets的機制。