一段最簡單的java代碼程序有哪些？

public class HelloWorld{

成都創(chuàng)新互聯(lián)公司自2013年起，是專業(yè)互聯(lián)網(wǎng)技術(shù)服務(wù)公司，擁有項目成都做網(wǎng)站、成都網(wǎng)站制作網(wǎng)站策劃，項目實施與項目整合能力。我們以讓每一個夢想脫穎而出為使命，1280元阿克陶做網(wǎng)站,已為上家服務(wù),為阿克陶各地企業(yè)和個人服務(wù),聯(lián)系電話:028-86922220

public static void main(String[] args){

System.out.println("hello world!");

}

}

一. 基本概念

Java是一種可以撰寫跨平臺應(yīng)用軟件的面向?qū)ο蟮某绦蛟O(shè)計語言。Java 技術(shù)具有卓越的通用性、高效性、平臺移植性和安全性，廣泛應(yīng)用于PC、數(shù)據(jù)中心、游戲控制臺、科學(xué)超級計算機(jī)、移動電話和互聯(lián)網(wǎng)，同時擁有全球最大的開發(fā)者專業(yè)社群。

二. 體系

Java分為三個體系，分別為Java SE（J2SE，Java2 Platform Standard Edition，標(biāo)準(zhǔn)版），

JavaEE（J2EE，Java 2 Platform, Enterprise Edition，企業(yè)版）。

Java ME（J2ME，Java 2 Platform Micro Edition，微型版）。

java編碼規(guī)范有哪些？

JAVA代碼規(guī)范：

(1) 類名首字母應(yīng)該大寫。字段、方法以及對象（句柄）的首字母應(yīng)小寫。對于所有標(biāo)識符，其中包含的所有單詞都應(yīng)緊靠在一起，而且大寫中間單詞的首字母。例如：

ThisIsAClassName

thisIsMethodOrFieldName

若在定義中出現(xiàn)了常數(shù)初始化字符，則大寫static final基本類型標(biāo)識符中的所有字母。這樣便可標(biāo)志出它們屬于編譯期的常數(shù)。

Java包（Package）屬于一種特殊情況：它們?nèi)际切懽帜福幢阒虚g的單詞亦是如此。對于域名擴(kuò)展名稱，如com，org，net或者edu等，全部都應(yīng)小寫（這也是Java 1.1和Java 1.2的區(qū)別之一）。

(2) 為了常規(guī)用途而創(chuàng)建一個類時，請采取"經(jīng)典形式"，并包含對下述元素的定義：

equals()

hashCode()

toString()

clone()（implement Cloneable）

implement Serializable

(3) 對于自己創(chuàng)建的每一個類，都考慮置入一個main()，其中包含了用于測試那個類的代碼。為使用一個項目中的類，我們沒必要刪除測試代碼。若進(jìn)行了任何形式的改動，可方便地返回測試。這些代碼也可作為如何使用類的一個示例使用。

(4) 應(yīng)將方法設(shè)計成簡要的、功能性單元，用它描述和實現(xiàn)一個不連續(xù)的類接口部分。理想情況下，方法應(yīng)簡明扼要。若長度很大，可考慮通過某種方式將其分割成較短的幾個方法。這樣做也便于類內(nèi)代碼的重復(fù)使用（有些時候，方法必須非常大，但它們?nèi)詰?yīng)只做同樣的一件事情）。

(5) 設(shè)計一個類時，請設(shè)身處地為客戶程序員考慮一下（類的使用方法應(yīng)該是非常明確的）。然后，再設(shè)身處地為管理代碼的人考慮一下（預(yù)計有可能進(jìn)行哪些形式的修改，想想用什么方法可把它們變得更簡單）。

(6) 使類盡可能短小精悍，而且只解決一個特定的問題。下面是對類設(shè)計的一些建議：

■一個復(fù)雜的開關(guān)語句：考慮采用"多形"機(jī)制

■數(shù)量眾多的方法涉及到類型差別極大的操作：考慮用幾個類來分別實現(xiàn)

■許多成員變量在特征上有很大的差別：考慮使用幾個類

(7) 讓一切東西都盡可能地"私有"--private?？墒箮斓哪骋徊糠?公共化"（一個方法、類或者一個字段等等），就永遠(yuǎn)不能把它拿出。若強(qiáng)行拿出，就可能破壞其他人現(xiàn)有的代碼，使他們不得不重新編寫和設(shè)計。若只公布自己必須公布的，就可放心大膽地改變其他任何東西。在多線程環(huán)境中，隱私是特別重要的一個因素--只有private字段才能在非同步使用的情況下受到保護(hù)。

(8) 謹(jǐn)惕"巨大對象綜合癥"。對一些習(xí)慣于順序編程思維、且初涉OOP領(lǐng)域的新手，往往喜歡先寫一個順序執(zhí)行的程序，再把它嵌入一個或兩個巨大的對象里。根據(jù)編程原理，對象表達(dá)的應(yīng)該是應(yīng)用程序的概念，而非應(yīng)用程序本身。

(9) 若不得已進(jìn)行一些不太雅觀的編程，至少應(yīng)該把那些代碼置于一個類的內(nèi)部。

(10) 任何時候只要發(fā)現(xiàn)類與類之間結(jié)合得非常緊密，就需要考慮是否采用內(nèi)部類，從而改善編碼及維護(hù)工作（參見第14章14.1.2小節(jié)的"用內(nèi)部類改進(jìn)代碼"）。

(11) 盡可能細(xì)致地加上注釋，并用javadoc注釋文檔語法生成自己的程序文檔。

(12) 避免使用"魔術(shù)數(shù)字"，這些數(shù)字很難與代碼很好地配合。如以后需要修改它，無疑會成為一場噩夢，因為根本不知道"100"到底是指"數(shù)組大小"還是"其他全然不同的東西"。所以，我們應(yīng)創(chuàng)建一個常數(shù)，并為其使用具有說服力的描述性名稱，并在整個程序中都采用常數(shù)標(biāo)識符。這樣可使程序更易理解以及更易維護(hù)。

(13) 涉及構(gòu)建器和異常的時候，通常希望重新丟棄在構(gòu)建器中捕獲的任何異常--如果它造成了那個對象的創(chuàng)建失敗。這樣一來，調(diào)用者就不會以為那個對象已正確地創(chuàng)建，從而盲目地繼續(xù)。

(14) 當(dāng)客戶程序員用完對象以后，若你的類要求進(jìn)行任何清除工作，可考慮將清除代碼置于一個良好定義的方法里，采用類似于cleanup()這樣的名字，明確表明自己的用途。除此以外，可在類內(nèi)放置一個boolean（布爾）標(biāo)記，指出對象是否已被清除。在類的finalize()方法里，請確定對象已被清除，并已丟棄了從RuntimeException繼承的一個類（如果還沒有的話），從而指出一個編程錯誤。在采取象這樣的方案之前，請確定finalize()能夠在自己的系統(tǒng)中工作（可能需要調(diào)用System.runFinalizersOnExit(true)，從而確保這一行為）。

(15) 在一個特定的作用域內(nèi)，若一個對象必須清除（非由垃圾收集機(jī)制處理），請采用下述方法：初始化對象；若成功，則立即進(jìn)入一個含有finally從句的try塊，開始清除工作。

(16) 若在初始化過程中需要覆蓋（取消）finalize()，請記住調(diào)用super.finalize()（若Object屬于我們的直接超類，則無此必要）。在對finalize()進(jìn)行覆蓋的過程中，對super.finalize()的調(diào)用應(yīng)屬于最后一個行動，而不應(yīng)是第一個行動，這樣可確保在需要基礎(chǔ)類組件的時候它們依然有效。

(17) 創(chuàng)建大小固定的對象集合時，請將它們傳輸至一個數(shù)組（若準(zhǔn)備從一個方法里返回這個集合，更應(yīng)如此操作）。這樣一來，我們就可享受到數(shù)組在編譯期進(jìn)行類型檢查的好處。此外，為使用它們，數(shù)組的接收者也許并不需要將對象"造型"到數(shù)組里。

(18) 盡量使用interfaces，不要使用abstract類。若已知某樣?xùn)|西準(zhǔn)備成為一個基礎(chǔ)類，那么第一個選擇應(yīng)是將其變成一個interface（接口）。只有在不得不使用方法定義或者成員變量的時候，才需要將其變成一個abstract（抽象）類。接口主要描述了客戶希望做什么事情，而一個類則致力于（或允許）具體的實施細(xì)節(jié)。

(19) 在構(gòu)建器內(nèi)部，只進(jìn)行那些將對象設(shè)為正確狀態(tài)所需的工作。盡可能地避免調(diào)用其他方法，因為那些方法可能被其他人覆蓋或取消，從而在構(gòu)建過程中產(chǎn)生不可預(yù)知的結(jié)果（參見第7章的詳細(xì)說明）。

(20) 對象不應(yīng)只是簡單地容納一些數(shù)據(jù)；它們的行為也應(yīng)得到良好的定義。

(21) 在現(xiàn)成類的基礎(chǔ)上創(chuàng)建新類時，請首先選擇"新建"或"創(chuàng)作"。只有自己的設(shè)計要求必須繼承時，才應(yīng)考慮這方面的問題。若在本來允許新建的場合使用了繼承，則整個設(shè)計會變得沒有必要地復(fù)雜。

(22) 用繼承及方法覆蓋來表示行為間的差異，而用字段表示狀態(tài)間的區(qū)別。一個非常極端的例子是通過對不同類的繼承來表示顏色，這是絕對應(yīng)該避免的：應(yīng)直接使用一個"顏色"字段。

(23) 為避免編程時遇到麻煩，請保證在自己類路徑指到的任何地方，每個名字都僅對應(yīng)一個類。否則，編譯器可能先找到同名的另一個類，并報告出錯消息。若懷疑自己碰到了類路徑問題，請試試在類路徑的每一個起點，搜索一下同名的.class文件。

(24) 在Java 1.1 AWT中使用事件"適配器"時，特別容易碰到一個陷阱。若覆蓋了某個適配器方法，同時拼寫方法沒有特別講究，最后的結(jié)果就是新添加一個方法，而不是覆蓋現(xiàn)成方法。然而，由于這樣做是完全合法的，所以不會從編譯器或運行期系統(tǒng)獲得任何出錯提示--只不過代碼的工作就變得不正常了。

(25) 用合理的設(shè)計方案消除"偽功能"。也就是說，假若只需要創(chuàng)建類的一個對象，就不要提前限制自己使用應(yīng)用程序，并加上一條"只生成其中一個"注釋。請考慮將其封裝成一個"獨生子"的形式。若在主程序里有大量散亂的代碼，用于創(chuàng)建自己的對象，請考慮采納一種創(chuàng)造性的方案，將些代碼封裝起來。

(26) 警惕"分析癱瘓"。請記住，無論如何都要提前了解整個項目的狀況，再去考察其中的細(xì)節(jié)。由于把握了全局，可快速認(rèn)識自己未知的一些因素，防止在考察細(xì)節(jié)的時候陷入"死邏輯"中。

(27) 警惕"過早優(yōu)化"。首先讓它運行起來，再考慮變得更快--但只有在自己必須這樣做、而且經(jīng)證實在某部分代碼中的確存在一個性能瓶頸的時候，才應(yīng)進(jìn)行優(yōu)化。除非用專門的工具分析瓶頸，否則很有可能是在浪費自己的時間。性能提升的隱含代價是自己的代碼變得難于理解，而且難于維護(hù)。

(28) 請記住，閱讀代碼的時間比寫代碼的時間多得多。思路清晰的設(shè)計可獲得易于理解的程序，但注釋、細(xì)致的解釋以及一些示例往往具有不可估量的價值。無論對你自己，還是對后來的人，它們都是相當(dāng)重要的。如對此仍有懷疑，那么請試想自己試圖從聯(lián)機(jī)Java文檔里找出有用信息時碰到的挫折，這樣或許能將你說服。

(29) 如認(rèn)為自己已進(jìn)行了良好的分析、設(shè)計或者實施，那么請稍微更換一下思維角度。試試邀請一些外來人士--并不一定是專家，但可以是來自本公司其他部門的人。請他們用完全新鮮的眼光考察你的工作，看看是否能找出你一度熟視無睹的問題。采取這種方式，往往能在最適合修改的階段找出一些關(guān)鍵性的問題，避免產(chǎn)品發(fā)行后再解決問題而造成的金錢及精力方面的損失。

(30) 良好的設(shè)計能帶來最大的回報。簡言之，對于一個特定的問題，通常會花較長的時間才能找到一種最恰當(dāng)?shù)慕鉀Q方案。但一旦找到了正確的方法，以后的工作就輕松多了，再也不用經(jīng)歷數(shù)小時、數(shù)天或者數(shù)月的痛苦掙扎。我們的努力工作會帶來最大的回報（甚至無可估量）。而且由于自己傾注了大量心血，最終獲得一個出色的設(shè)計方案，成功的快感也是令人心動的。堅持****草草完工的誘惑--那樣做往往得不償失

求java代碼300行左右，要有注釋，能運行，基礎(chǔ)點的越基礎(chǔ)的越好，300行以上就好，不要太長的

300行能干啥啊，你還不如自己做做練習(xí)題。

package suoha;

import java.util.ArrayList;import java.util.Random;

public class MainFunction {

private ArrayListMyCard cards = new ArrayListMyCard();

private int[] cardNumArr = new int[52];

private int[] mycards = new int[5];

private int[] p1cards = new int[5];

public static void main(String[] args) {

MainFunction mainfunc = new MainFunction();

mainfunc.makeCards();

mainfunc.cardNumArr = mainfunc.shuffleCards(mainfunc.cardNumArr);

mainfunc.catchCards();

mainfunc.showAllCardsOfHand();

//mainfunc.printNums();

}

/**

* 洗牌

* @param cardNums

* @return

*/

private int[] shuffleCards(int[] cardNums){

int size = cardNums.length;

int[] returnNums = new int[size];

//System.out.println(cardNums[0]+"=========================");

Random rand = new Random();

for(int i=size-1;i0;i--){

int nextInt = rand.nextInt(i);

returnNums[size-1-i] = cardNums[nextInt];

cardNums[nextInt] = cardNums[i];

cardNums[i] = returnNums[size-1-i];

//System.out.println("suijishu:"+nextInt+"||zhi:"+returnNums[size-1-i]);

}

returnNums[size-1] = cardNums[0];

return returnNums;

}

/**

* 抓牌

*/

private void catchCards(){

for(int i=0;i5;i++){

mycards[i] = cardNumArr[2*i];

p1cards[i] = cardNumArr[2*i+1];

}

}

private void showAllCardsOfHand(){

System.out.print("你手中的牌是：||");

for(int i=0;i5;i++){

MyCard myCard = cards.get(mycards[i]-1);

System.out.print(myCard.toString()+"||");

}

System.out.println();

System.out.print("對家手中的牌是：||");

for(int i=0;i5;i++){

MyCard myCard = cards.get(p1cards[i]-1);

System.out.print(myCard.toString()+"||");

}

}

/**

* 顯示牌的順序

*/

private void printNums(){

for(int i=0;icardNumArr.length;i++){

System.out.print(cardNumArr[i]+",");

}

}

/**

* 制作卡片

*/

private void makeCards(){

for(int i=1;i=13;i++){

for(int j=1;j=4;j++){

//System.out.println((i-1)*4+j);

MyCard card = new MyCard((i-1)*4+j, j, i);

cardNumArr[(i-1)*4+j-1] = (i-1)*4+j;

cards.add(card);

}

// MyCard card1 = new MyCard((i-1)*4+1, 1, i);

// MyCard card2 = new MyCard((i-1)*4+2, 2, i);

// MyCard card3 = new MyCard((i-1)*4+3, 3, i);

// MyCard card4 = new MyCard((i-1)*4+4, 4, i);

// cards.add(card1);

// cards.add(card2);

// cards.add(card3);

// cards.add(card4);

}

}

}

java的流操作，在公司的項目中長用到么？求具體代碼

io。就是操作文件嘛。在公司經(jīng)常有用到的。

現(xiàn)在是講例子1：

//創(chuàng)建一個新文件

importjava.io.*;

classhello{

publicstaticvoidmain(String[] args) {

File f=newFile("D:\\hello.txt");

try{

f.createNewFile();

}catch(Exception e) {

e.printStackTrace();

}

}

}

//程序運行之后，在d盤下會有一個名字為hello.txt的文件。

例子2：

//File類的兩個常量

importjava.io.*;

classhello{

publicstaticvoidmain(String[] args) {

System.out.println(File.separator);

System.out.println(File.pathSeparator);

}

}

運行結(jié)果：\

;

現(xiàn)在用常量來改動寫上面的代碼：

importjava.io.*;

classhello{

publicstaticvoidmain(String[] args) {

String fileName="D:"+File.separator+"hello.txt";

File f=newFile(fileName);

try{

f.createNewFile();

}catch(Exception e) {

e.printStackTrace();

}

}

}

用這些，建議使用常量，因為代碼寫的少了。

案例3：

//刪除一個文件

importjava.io.*;

classhello{

publicstaticvoidmain(String[] args) {

String fileName="D:"+File.separator+"hello.txt";

File f=newFile(fileName);

if(f.exists()){

f.delete();

}else{

System.out.println("文件不存在");

}

}

}

案例4：創(chuàng)建一個文件夾

importjava.io.*;

classhello{

publicstaticvoidmain(String[] args) {

String fileName="D:"+File.separator+"hello";

File f=newFile(fileName);

f.mkdir();

}

}

案例5：列出指定目錄的全部文件（包括隱藏文件）：

importjava.io.*;

classhello{

publicstaticvoidmain(String[] args) {

String fileName="D:"+File.separator;

File f=newFile(fileName);

String[] str=f.list();

for(inti =0; i str.length; i++) {

System.out.println(str[i]);

}

}

}

大概的簡單的東西，就這些了吧。你自己好好看看吧，歡迎追問。

如何寫出好的Java代碼

如何寫出好的Java代碼

1． 優(yōu)雅需要付出代價。

從短期利益來看，對某個問題提出優(yōu)雅的解決方法，似乎可能花你更多的時間。但當(dāng)它終于能夠正確執(zhí)行并可輕易套用于新案例中，不需要花上數(shù)以時計，甚至以天計或以月計的辛苦代價時，你會看得到先前所花功夫的回報（即使沒有人可以衡量這一點）。這不僅給你一個可更容易開發(fā)和調(diào)試的程序，也更易于理解和維護(hù)。這正是它在金錢上的價值所在。這一點有賴某種人生經(jīng)驗才能夠了解，因為當(dāng)你努力讓某一段程序代碼變得比較優(yōu)雅時，你并不是處于一種具生產(chǎn)力的狀態(tài)下。但是，請抗拒那些催促你趕工的人們，因為那么做只會減緩你的速度罷了。

2． 先求能動，再求快。

即使你已確定某段程序代碼極為重要，而且是系統(tǒng)的重要瓶頸，這個準(zhǔn)則依然成立。盡可能簡化設(shè)計，讓系統(tǒng)能夠先正確動作。如果程序的執(zhí)行不夠快，再量測其效能。幾乎你總是會發(fā)現(xiàn)，你所認(rèn)為的”瓶頸”其實都不是問題所在。把你的時間花在刀口上吧。

3． 記住”各個擊破”的原理。

如果你所探討的問題過于混雜，試著想像該問題的基本動作會是什么，并假設(shè)這一小塊東西能夠神奇地處理掉最難的部分。這”一小塊”東西其實就是對象–請撰寫運用該對象的程序代碼，然后檢視對象，并將其中困難的部分再包裝成其他對象，依此類推。

4． 區(qū)分class開發(fā)者和class使用者（使用端程序員）。

Class 使用者扮演著”客戶”角色，不需要（也不知道）class的底層運作方式。Class開發(fā)者必須是class設(shè)計專家，并撰寫class，使它能夠盡可能被大多數(shù)新手程序員所用，而且在程序中能夠穩(wěn)當(dāng)執(zhí)行。一套程序庫只有在具備通透性的情況下，使用起來才會容易。

5．當(dāng)你撰寫class時，試著給予明了易懂的名稱，減少不必要的注解。

你給客戶端程序員的接口，應(yīng)該保持概念上的單純性。不了這個目的，當(dāng)函數(shù)的重載（overloading）適合制作出直覺、易用的接口時，請善加使用。

6． 也必你的分析和設(shè)計必須讓系統(tǒng)中的classes保持最少，須讓其Public interfaces保持最少，以及讓這些classes和其他classes之間的關(guān)聯(lián)性（ 尤其是base classes）保持最少。

如果你的設(shè)計所得結(jié)果更甚于此，請問問自己，是否其中每一樣?xùn)|西在整個程序生命期中都饒富價值？如果并非如此，那么，維護(hù)它們會使你付出代價。開發(fā)團(tuán)隊的成員都有不維護(hù)”無益于生產(chǎn)力提升”的任何東西的傾向；這是許多設(shè)計方法無法解釋的現(xiàn)象。

7． 讓所有東西盡量自動化。先撰寫測試用的程序代碼（在你撰寫class之前），并讓它和class結(jié)合在一起。請使用makefile或類似工具，自動進(jìn)行測試動作。

通過這種方式，只要執(zhí)行測試程序，所有的程序變動就可以自動獲得驗證，而且可以立即發(fā)現(xiàn)錯誤。由于你知道的測試架構(gòu)所具備的安全性，所以當(dāng)你發(fā)現(xiàn)新的需求時，你會更勇于進(jìn)行全面修改。請記住，程序語言最大的改進(jìn)，是來自型別檢查、異常處理等機(jī)制所賦予的內(nèi)置測試動作。但這些功能只能協(xié)助你到達(dá)某種程度。開發(fā)一個穩(wěn)固系統(tǒng)時，你得自己驗證自己的classes或程序的性質(zhì)。

8． 在你撰寫class之前先寫測試碼，以便驗證你的class 是否設(shè)計完備。如果你無法撰寫測試碼，你便無法知道你的class 的可能長相。撰寫測試碼通常能夠顯現(xiàn)出額外的特性（features）或限制 ( constraints)__它們并不一定總是能夠在分析和設(shè)計過程中出現(xiàn)。測試碼也可做為展示class 用法的示例程序。

9． 所有軟件設(shè)計上的問題，都可以通過”引入額外的概念性間接層（conceptual indirection）”加以簡化。這個軟件工程上的基礎(chǔ)法則是抽象化概念的根據(jù)，而抽象化概念正是面向?qū)ο蟪绦蛟O(shè)計的主要性質(zhì)。

10． 間接層(indirection)應(yīng)該要有意義（和準(zhǔn)則-9致）。

這里所指的意義可以像”將共用程序代碼置于惟一函數(shù)”這么簡單。如果你加入的間接層（或抽象化、或封裝等等）不具意義，它可能就和沒有適當(dāng)?shù)拈g接層一樣糟糕。

11． 讓class盡可能微小而無法切割（atomic）。

賦予每個class單一而清楚的用途。如果你的classes或你的系統(tǒng)成長得過于復(fù)雜，請將復(fù)雜的classes切割成比較簡單的幾個classes。最明顯的一個判斷指針就是class的大?。喝绻艽?，那么它工作量過多的機(jī)會就可能很高，那就應(yīng)該被切割。重新設(shè)計class的建議線索是：

1） 復(fù)雜的switch語句：請考慮運用多態(tài)（Polymorphism）。

2） 許多函數(shù)各自處理類型極為不同的動作：請考慮切割為多個不同的（classes）。

12． 小心冗長的引數(shù)列（argument lists）。

冗長的引數(shù)列會使函數(shù)的調(diào)用動作不易撰寫、閱讀、維護(hù)。你應(yīng)該試著將函數(shù)搬移到更適當(dāng)?shù)腸lass中，并盡量以對象為引數(shù)。

13． 不要一再重復(fù)。

如果某段程序代碼不斷出現(xiàn)于許多derived class函數(shù)中，請將該段程序代碼置于某個base class 函數(shù)內(nèi)，然后在derived class函數(shù)中調(diào)用。這么做不僅可以省下程序代碼空間，也可以讓修改該段程序代碼動作更易于進(jìn)行。有時候找出此種共通程序代碼還可以為接口增加實用功能。

14． 小心switch語句或成串的if-else 子句。

通常這種情況代表所謂的”type-check coding”。也就是說究竟會執(zhí)行哪一段程序代碼，乃是依據(jù)某種型別信息來做抉擇（最初，確切型別可能不十分明顯）。你通常可以使用繼承和多態(tài)來取代此類程序代碼；Polymorphical method （多態(tài)函數(shù)）的調(diào)用會自動執(zhí)行此類型別檢驗，并提供更可靠更容易的擴(kuò)充性。

15． 從設(shè)計觀點來看，請找出變動的事物，并使它和不變的事物分離。

也就是說，找出系統(tǒng)中可能被你改變的元素，將它們封裝于classes中。你可以在《Thinking in Patterns with Java》（可免費下載于 www. BruceEckel. Com）大量學(xué)習(xí)到這種觀念。

16． 不要利用subclassing來擴(kuò)充基礎(chǔ)功能。

如果某個接口元素對class而言極重要，它應(yīng)該被放在base class 里頭，而不是直到衍生（derivation）時才被加入。如果你在繼承過程中加入了函數(shù)，或許你應(yīng)該重新思考整個設(shè)計。

17． 少就是多。

從class 的最小接口開始妨展，盡可能在解決問題的前提下讓它保持既小又單純。不要預(yù)先考量你的class被使用的所有可能方式。一旦class被實際運用，你自然會知道你得如何擴(kuò)充接口。不過，一旦class被使用后，你就無法在不影響客戶程序代碼的情況下縮減其接口。如果你要加入更多函數(shù)倒是沒有問題–不會影響既有的客戶程序代碼，它們只需重新編譯即可。但即使新函數(shù)取代了舊函數(shù)的功能，也請你保留既有接口。如果你得通過”加入更多引數(shù)”的方式來擴(kuò)充既有函數(shù)的接口，請你以新引數(shù)寫出一個重載化的函數(shù)；通過 這種方式就不會影響既有函數(shù)的任何客戶了。

18． 大聲念出你的classes,確認(rèn)它們符合邏輯。

請base class和derived class 之間的關(guān)系是”is-a”(是一種)，讓class和成員對象之間的關(guān)系是”has-a”(有一個)。

19． 當(dāng)你猶豫不決于繼承（inheritance）或合成（組合，composition）時，請你問問自己，是否需要向上轉(zhuǎn)型（upcast）為基礎(chǔ)型別。

如果不需要，請優(yōu)先選擇合成（也就是是使用成員對象）。這種作法可以消除”過多基礎(chǔ)型別”。如果你采用繼承，使用者會認(rèn)為他們應(yīng)該可以向上轉(zhuǎn)型。

20． 運用數(shù)據(jù)成員來表示數(shù)值的變化，運用經(jīng)過覆寫的函數(shù)（overrided method）來代表行為的變化 。

也就是說，如果你找到了某個 class, 帶有一些狀態(tài)變量，而其函數(shù)會依據(jù)這些變量值切換不同的行為，那么你或許就應(yīng)該重新設(shè)計，在subclasses 和覆寫后的函數(shù)（overrided methods）中展現(xiàn)行為止的差異。

21． 小心重載（overloading）。

函數(shù)不應(yīng)該依據(jù)引數(shù)值條件式地選擇執(zhí)行某一段程序代碼。這種情況下你應(yīng)該撰寫兩個或更多個重載函數(shù)（overloaded methods）

22． 使用異常體系（exception hierarchies）

最好是從Java標(biāo)準(zhǔn)異常體系中衍生特定的classes, 那么，捕捉異常的人便可以捕捉特定異常，之后才捕捉基本異常。如果你加入新的衍生異常，原有的客戶端程序仍能通過其基礎(chǔ)型別來捕捉它。

23． 有時候簡單的聚合（aggregation）就夠了。

飛機(jī)上的”旅客舒適系統(tǒng)”包括數(shù)個分離的元素：座椅、空調(diào)、視訊設(shè)備等等，你會需要在飛機(jī)上產(chǎn)生許多這樣的東西。你會將它們聲明為Private成員并開發(fā)出一個全新的接口嗎？不會的，在這個例子中，元素也是Public接口的一部分，所以仍然是安全的。當(dāng)然啦，簡單聚合并不是一個常被運用的解法，但有時候的確是。

24． 試著從客戶程序員和程序維護(hù)的角度思考。

你的class應(yīng)該設(shè)計得盡可能容易使用。你應(yīng)該預(yù)先考量可能性有的變動，并針對這些 可能的變動進(jìn)行設(shè)計，使這些變動日后可輕易完成。

25． 小心”巨大對象并發(fā)癥”。

這往往是剛踏OOP領(lǐng)域的過程式（procedural）程序員的一個苦惱，因為他們往往最終還是寫出一個過程式程序，并將它們擺放到一個或兩個巨大對象中。注意，除了application framework (應(yīng)用程序框架，譯注：一種很特殊的、大型OO程序庫，幫你架構(gòu)程序本體)之外，對象代表的是程序中的觀念，而不是程序本身。

26． 如果你得用某種丑陋的方式來達(dá)成某個動作，請將丑陋的部分局限在某個class里頭。

27． 如果你得用某種不可移植方式來達(dá)成某個動作，請將它抽象化并局限于某個class里頭。這樣一個”額外間接層”能夠防止不可移植的部分?jǐn)U散到整個程序。這種作法的具體呈現(xiàn)便是Bridge設(shè)計模式（design pattern）。

28． 對象不應(yīng)僅僅只用來持有數(shù)據(jù)。

對象也應(yīng)該具有定義明確界限清楚的行為。有時候使用”數(shù)據(jù)對象”是適當(dāng)?shù)?，但只有在通用形容器不適用時，才適合刻意以數(shù)據(jù)對象來包裝、傳輸一群數(shù)據(jù)項。

29． 欲從既有的classes身上產(chǎn)生新的classes時，請以組合(composition)為優(yōu)先考量。

你應(yīng)該只在必要時才使用繼承。如果在組合適用之處你卻選擇了繼承，你的設(shè)計就滲雜了非必要的復(fù)雜性。

30． 運用繼承和函數(shù)覆寫機(jī)制來展現(xiàn)行為上的差異，運用fields(數(shù)據(jù)成員)來展現(xiàn)狀態(tài)上的差異。

這句話的極端例子，就是繼承出不同的classes表現(xiàn)各種不同的顏色，而不使用”color”field.

31． 當(dāng)心變異性（variance）。

語意相異的兩個對象擁有相同的動作（或說責(zé)任）是可能的。OO世界中存在著一種天生的引誘，讓人想要從某個class繼承出另一個subclass,為的是獲得繼承帶來的福利。這便是所謂”變異性”。但是，沒有任何正當(dāng)理由足以讓我們強(qiáng)迫制造出某個其實并不存在的superclass/subclass關(guān)系。比較好的解決方式是寫出一個共用的base class,它為兩個derived classes制作出共用接口–這種方式會耗用更多空間，但你可以如你所盼望地從繼承機(jī)制獲得好處，而且或許能夠在設(shè)計上獲得重大發(fā)現(xiàn)。

32． 注意繼承上的限制。

最清晰易懂的設(shè)計是將功能加到繼承得來的class里頭；繼承過程中拿掉舊功能（而非增加新功能）則是一種可疑的設(shè)計。不過，規(guī)則可以打破。如果你所處理的是舊有的class程序庫，那么在某個class的subclass限制功能，可能會比重新制定整個結(jié)構(gòu)（俾使新class得以良好地相稱于舊 class）有效率得多。

33． 使用設(shè)計模式（design patterns）來減少”赤裸裸無加掩飾的機(jī)能（naked functionality）”。

舉個例子，如果你的class只應(yīng)該產(chǎn)出惟一一個對象，那么請不要以加思索毫無設(shè)計的手法來完成它，然后撰寫”只該產(chǎn)生一份對象”這樣的注解就拍拍屁股走人。請將它包裝成singleton（譯注：一個有名的設(shè)計模式，可譯為”單件”）。如果主程序中有多而混亂的”用以產(chǎn)生對象”的程序代碼，請找出類似 factory method這樣的生成模式（creational patterns），使價錢可用以封裝生成動作減少”赤裸裸無加掩飾的機(jī)能”（naked functionality）不僅可以讓你的程序更易理解和維護(hù)，也可以阻止出于好意卻帶來意外的維護(hù)者。

34． 當(dāng)心”因分析而導(dǎo)致的癱瘓（analysis paralysis）”。

請記住，你往往必須在獲得所有信息之前讓項目繼續(xù)前進(jìn)。而且理解未知部分的最好也最快的方式，通常就是實際前進(jìn)一步而不只是紙上談兵。除非找到解決辦法，否則無法知道解決辦法。Java擁有內(nèi)置的防火墻，請讓它們發(fā)揮作用。你在單一class或一組classes中所犯的錯誤，并不會傷害整個系統(tǒng)的完整性。

35． 當(dāng)你認(rèn)為你已經(jīng)獲得一份優(yōu)秀的分析、設(shè)計或?qū)崿F(xiàn)時，請試著加以演練。

將團(tuán)隊以外的某些人帶進(jìn)來-他不必非得是個顧問不可，他可以是公司其他團(tuán)隊的成員。請那個人以新鮮的姿態(tài)審視你們的成果，這樣可以在尚可輕易修改的階段找出問題，其收獲會比因演練而付出的時間和金錢代價來得高。實現(xiàn) （Implementation）

36. 一般來說，請遵守Sun的程序編寫習(xí)慣。

價錢可以在以下網(wǎng)址找到相關(guān)文檔：java.sun.com/docs/codeconv/idex.html。本書盡可能遵守這些習(xí)慣。眾多Java程序員看到的程序代碼，都有是由這些習(xí)慣構(gòu)成的。如果你固執(zhí)地停留在過去的編寫風(fēng)格中，你的（程序代碼）讀者會比較辛苦。不論你決定采用什么編寫習(xí)慣，請在整個程序中保持一致。你可以在home.wtal.de/software-solutions/jindent上找到一個用來重排Java程序的免費工具。

37. 無論使用何種編寫風(fēng)格，如果你的團(tuán)隊（或整個公司，那就更好了）能夠加以標(biāo)準(zhǔn)化，那么的確會帶來顯著效果。這代表每個人都可以在其他人不遵守編寫風(fēng)格修改其作品，這是個公平的游戲。標(biāo)準(zhǔn)化的價值在于，分析程序代碼時所花的腦力較小，因而可以專心于程序代碼的實質(zhì)意義。

38. 遵守標(biāo)準(zhǔn)的大小寫規(guī)范。

將 class名稱的第一個字母應(yīng)為大寫。數(shù)據(jù)成員、函數(shù)、對象（references）的第一個字母應(yīng)為小寫。所有識別名稱的每個字都應(yīng)該連在一塊兒，所有非首字的第一個字母都應(yīng)該大寫。例如： ThisIsAClassName thisIsAMethodOrFieldName 如果你在static final 基本型別的定義處指定了常量初始式（constant initializers）,那么該識別名稱應(yīng)該全為大寫，代表一個編譯期常量。 Packages是個特例，其名稱皆為小寫，即使非首字的字母亦是如此。域名（org, net, edu 等等）皆應(yīng)為小寫。（這是Java 1.1遷移至Java 2時的一項改變） 。

39、不要自己發(fā)明”裝飾用的”Private數(shù)據(jù)成員名稱。

通常這種的形式是在最前端加上底線和其他字符，匈牙利命名法（Hungarian notation）是其中最差的示范。在這種命名法中，你得加入額外字符來表示數(shù)據(jù)的型別、用途、位置等等。仿佛你用的是匯編語言（assembly language）而編譯器沒有提供任何協(xié)肋似的。這樣的命名方式容易讓人混淆又難以閱讀，也不易推行和維護(hù)。就讓classes和packages來進(jìn)行”名稱上的范

圍制定（name scoping）”吧。

40、當(dāng)你擬定通用性的class時，請遵守正規(guī)形式（canonical form）。

包括equals( )、hashCode( )、clone( ) ( 實現(xiàn)出Cloneable),并實現(xiàn)出Comparable和Serialiable等等。

41、對于那些”取得或改變Private數(shù)據(jù)值”的函數(shù)，請使用Java Beans 的”get”、”set”、”is”等命名習(xí)慣，即使你當(dāng)時不認(rèn)為自己正在撰寫Java Bean。這么做不僅可以輕易以Bean的運用方式來運用你的class,也是對此類函數(shù)的一種標(biāo)準(zhǔn)命名方式，使讀者更易于理解。

42、對于你所擬定的每一個class，請考慮為它加入static public test( )，其中含有class功能測試碼。

你不需要移除該測試就可將程序納入項目。而且如果有所變動，你可以輕易重新執(zhí)行測試。這段程序代碼也可以做為class的使用示例。

43、有時候你需要通過繼承，才得以訪問base class的protected成員。

這可能會引發(fā)對多重基類（multiple base types）的認(rèn)識需求。如果你不需要向上轉(zhuǎn)型，你可以先衍生新的class發(fā)便執(zhí)行protected訪問動作，然后在”需要用到上述 protected成員”的所有classes中，將新class聲明為成員對象，而非直接繼承。

44、避免純粹為了效率考量而使用final函數(shù)。

只有在程序能動但執(zhí)行不夠快時，而且效能量測工具（profiler）顯示某個函數(shù)的調(diào)用動作成為瓶頸時，才使用final函數(shù)。

45、如果兩個classes因某種功能性原因而產(chǎn)生了關(guān)聯(lián)（例如容器containers和迭代器iterators）,那么請試著讓其中某個class成為另一個class 的內(nèi)隱類（inner class）。

這不僅強(qiáng)調(diào)二者間的關(guān)聯(lián)，也是通過”將class名稱嵌套置于另一個class 內(nèi)”而使同一個class 名稱在單一Package中可被重復(fù)使用。Java 容器庫在每個容器類中都定義了一個內(nèi)隱的（inner）Iterator class,因而能夠提供容器一份共通接口。運用內(nèi)隱類的另一個原因是讓它成為private實現(xiàn)物的一部分。在這里，內(nèi)隱類會為信息隱藏帶來好處，而不是對上述的class關(guān)聯(lián)性提供肋益，也不是為了防止命名空間污染問題(namespace pollution)。

46、任何時候你都要注意那些高度耦合（coupling）的 classes.請考慮內(nèi)隱類（inner classes）為程序擬定和維護(hù)帶來的好處。內(nèi)隱類的使用并不是要去除classes間的耦合，而是要讓耦合關(guān)系更明顯也更便利。

47、不要成為”過早最佳化”的犧牲品。

那會讓人神經(jīng)錯亂。尤其在系統(tǒng)建構(gòu)初期，先別煩惱究竟要不要撰寫（或避免）原生函數(shù)（native methods）、要不要將某些數(shù)聲明為final、要不要調(diào)校程序代碼效率等等。你的主要問題應(yīng)該是先證明設(shè)計的正確性，除非設(shè)計本身需要某種程度的效率。

48、讓范圍（作用域，scope）盡可能愈小愈好，這么一來對象的可視范圍和壽命都將盡可能地小。

這種作法可降低”對象被用于錯誤場所，因而隱藏難以察覺的臭蟲”的機(jī)會。假設(shè)你有個容器，以及一段走訪該容器的程序片段。如果你復(fù)制該段程序代碼，將它用于新的容器身上，你可能會不小心以舊容器的大小做為新容器的走訪上限值。如果舊容器已不在訪問范圍內(nèi)，那么編譯期便可找出這樣的錯誤。

49、使用Java 標(biāo)準(zhǔn)程序庫提供的容器。

請熟悉他們的用法。你將因此大幅提升你的生產(chǎn)力。請優(yōu)先選擇ArrayList來處理序列（sequences），選擇HashSet來處理集合（sets）、選擇HashMap來處理關(guān)聯(lián)式數(shù)組（associative arrays），選擇Linkedlist (而不是Stack) 來處理 shacks和queues。

50、對一個強(qiáng)固的（robust）程序而言，每一個組成都必須強(qiáng)固。

請在你所撰寫的每個class中運用Java 提供的所有強(qiáng)固提升工具：訪問權(quán)限、異常、型別檢驗等等。通過這種方式，你可以在建構(gòu)系統(tǒng)時安全地移往抽象化的下一個層次。

51、寧可在編譯期發(fā)生錯誤，也不要在執(zhí)行期發(fā)生錯誤。

試著在最靠近問題發(fā)生點的地方處理問題。請優(yōu)先在”擲出異常之處”處理問題，并在擁有足夠信息以處理異常的最接近處理函數(shù)（handler）中捕捉異常。請進(jìn)行現(xiàn)階段你能夠?qū)υ摦惓Ｋ龅奶幚?；如果你無法解決問題，應(yīng)該再次擲出異常。

52、當(dāng)心冗長的函數(shù)定義。

函數(shù)應(yīng)該是一種簡短的、”描述并實現(xiàn)class接口中某個可分離部分”的功能單元。過長且復(fù)雜的函數(shù)不僅難以維護(hù)，維護(hù)代價也高?；蛟S它嘗試做太多事情了。如果你發(fā)現(xiàn)這一類函數(shù)，代表它應(yīng)該被切割成多相函數(shù)。這種函數(shù)也提醒你或許得撰寫新的class。小型函數(shù)同樣能夠在你的class中被重復(fù)運用。（有時候函數(shù)必須很大才行，但它們應(yīng)該只做一件事情。）

53、盡可能保持”Private”。

一旦你對外公開了程序庫的概況（method、Class 或field）。你便再也無法移除它們。因為如果移除它們，便會破壞某個現(xiàn)有的程序代碼，使得它們必須重新被編寫或重新設(shè)計。如果你只公開必要部分，那么你便可以改變其他東西而不造成傷害。設(shè)計總是會演化，所以這是個十分重要的自由度。通過這種方式，實現(xiàn)碼的更動對derived class 造成的沖擊會降最低。在多線程環(huán)境下，私密性格外重要-只有private數(shù)據(jù)可受保護(hù)而不被un-synchronized（未受同步控制）的運用所破壞。

54、大量運用注解，并使用javadoc的”注解文檔語法”來產(chǎn)生程序的說明文檔。

不過注解應(yīng)該賦予程序代碼真正的意義；如果只是重申程序代碼已經(jīng)明確表示的內(nèi)容，那是很煩人的。請注意，通常Java class和其函數(shù)的名稱都很長，為的便是降低注解量。

55、避免使用”魔術(shù)數(shù)字”，也就是那種寫死在程序代碼里頭的數(shù)字–如果你想改變它們，它們就會成為你的惡夢，因為你永遠(yuǎn)都沒有辦法知道”100″究竟代表” 數(shù)組大小”或其他東西。你應(yīng)該產(chǎn)生具描述性的常量度名稱，并在程序中使用該常量名稱。這使程序更易于理解也更易于維護(hù)。

56、撰寫構(gòu)造函數(shù)時，請考慮異常狀態(tài)。最好情境下，構(gòu)造函數(shù)不執(zhí)行任何會擲出異常的動作。

次佳情境下，class 只繼承自（或合成自）強(qiáng)固的（robust）classes，所以如有任何異常被擲出，并不需要清理。其他情況下，你就得在finally子句清理合成后的classes。如果某個構(gòu)造函數(shù)一定會失敗，適當(dāng)?shù)膭幼骶褪菙S出異常，使調(diào)用者不至于盲目認(rèn)為對象已被正確產(chǎn)生而繼續(xù)執(zhí)行。

57、如果你的class需要在”客戶程序員用完對象”后進(jìn)行清理動作，請將清理動作，放到單一而定義明確的函數(shù)中。最好令其名稱為cleanup() 以便能夠?qū)⒂猛靖嬖V他人。此外請將boolean旗標(biāo)放到class中，用以代表對象是否已被清理，使finalize()得以檢驗其死亡條件（請參考第 4章）。

58、finalize() 只可用于對象死亡條件的檢驗（請參考4章），俾有益于調(diào)試。

特殊情況下可能需要釋放一些不會被垃圾回收的內(nèi)存。因為垃圾回收器可能不會被喚起處理你的對象，所以你無法使用finalize()執(zhí)行必要的清理動作?；谶@個原因，你得擬定自己的”清理用”函數(shù)。在class finalize()中，請檢查確認(rèn)對象的確已被清理，并在對象尚未被清理時，擲出衍生自Runtime Exception 的異常。使用這種架構(gòu)前，請先確認(rèn)finalize()在你的系統(tǒng)上可正常動作（這可能需要調(diào)用System.gc()來確認(rèn)）。

59、如果某個對象在某個特定范圍（scope）內(nèi)必須被清理（cleaned up）,而不是被垃圾回收機(jī)制收回，請使用以下方法；將對象初始化，成功后立刻進(jìn)入擁有finally子句的一個try區(qū)段內(nèi)。Finally子句會引發(fā)清理動作。

60、當(dāng)你在繼承過程中覆寫了finalize(),請記得調(diào)用super. Finalize()。

但如果你的”直接上一層superclass”是Object，，就不需要這個動作。你應(yīng)該讓super.finalize() 成為被覆寫（overridden）之finalize()的最后一個動作而不是第一個動作，用以確保base class的組件在你需要它們的時候仍然可用。

61、當(dāng)你撰寫固定大小的對象容器，請將它們轉(zhuǎn)換為數(shù)組–尤其是從某個函數(shù)返回此一容器時。

通過這種方式，你可以獲得數(shù)組的”編譯期型別檢驗”的好處，而且數(shù)組接收者可能不需要”先將數(shù)組中的對象加以轉(zhuǎn)型”便能加以使用。請注意，容器庫的base class (Java. Util. Collection) 具有兩個toArray()，能夠達(dá)到這個目的。

62、在interface(接口)和abstract class(抽象類)之間，優(yōu)先選擇前者。

如果你知道某些東西即將被設(shè)計為一個base class,你的第一選擇應(yīng)該是讓它成為interface;只有在一定得放進(jìn)函數(shù)或數(shù)據(jù)成員時，才應(yīng)該將它改為abstract class. Interface只和”客戶端想進(jìn)行什么動作”有關(guān)，class則比較把重心放在實現(xiàn)細(xì)節(jié)上。

63、在構(gòu)造函數(shù)中只做惟一必要動作：將對象設(shè)定至適當(dāng)狀態(tài)。

避免調(diào)用其他函數(shù)（除了final函數(shù)），因為這些函數(shù)可能會被其他人覆寫因而使你在建構(gòu)過程中得不可預(yù)期的結(jié)果（請參考第7章以取得更詳細(xì)的信息）。小型而簡單的構(gòu)造函數(shù)比較不可能擲出異常或引發(fā)問題。

64、為了避免一個十分令人泄氣的經(jīng)驗，請確認(rèn)你的classpath中的每個名稱，都只有一個未被放到packages里頭class。否則編譯器會先找到另一個名稱相同的class，并回報錯誤消息。如果你懷疑你的classpath出了問題，試著從classpath中的每個起點查找同名的.class文件。最好還是將所有classes都放到packages里頭。

65、留意一不小心犯下的重載（overloading）錯誤。

如果你覆寫base class 函數(shù)時沒有正確拼寫其名稱，那么便會增加一個新的函數(shù)，而不是覆寫原有的函數(shù)。但是情況完全合法，所以你不會從編譯器或執(zhí)行期系統(tǒng)得到任何錯誤消息–你的程序代碼只是無法正確作用，如此而已。

66、當(dāng)心過早最佳化。

先讓程序動起來，再讓它快–但只有在你必須（也就是說只有在程序被證明在某段程序代碼上遭遇效能瓶頸）時才這么做。除非你已經(jīng)使用效能量測工具（profiler）找出瓶頸所在，否則你可能性只是在浪費你的時間。效能調(diào)校的”隱藏成本”便是讓你的程序代碼變得更不可讀、更難維持。

67、記住，程序代碼被閱讀的時間多于它被撰寫的時間。

清晰的設(shè)計能夠制作出去易懂的程序。注解、細(xì)節(jié)說明、示例都是無價的。這些東西能夠幫助你和你的后繼者。如果沒有其他信息，那么Java 線上文檔找出一些有用的信息時，你所遭遇的挫敗應(yīng)該足以讓你相信這一點。

java基礎(chǔ)技能中強(qiáng)調(diào)程序代碼的讀寫能力如果一個類很長你會怎樣讀寫

Java經(jīng)典面試題 帶答案（二） 原創(chuàng)

2022-04-29 14:34:07

?

qdwd888 ?

碼齡1年

關(guān)注

所謂引用傳遞就是把一個對象在堆中保存的數(shù)據(jù)傳遞給一個變量，此時新的變量與原有的變量對應(yīng)同一個內(nèi)存存儲空間，當(dāng)新的變量修改對象的屬性時，內(nèi)存中的數(shù)據(jù)也會修改。

3.接口與抽象類的區(qū)別?

1：接口里面不可以實現(xiàn)方法體，抽象類可以實現(xiàn)方法體。

2：接口可以多繼承接口，抽象類不可以。

3：接口需要被子類實現(xiàn)，抽象類是要被子類繼承(單一繼承)。

4：接口中只能有公有的方法和屬性而且必須賦初始值，抽象類中可以有私有方法和屬性.

5: 接口中不能存在靜態(tài)方法，但屬性可以和final，抽象類中方法中可以有靜態(tài)方法，屬性也可以。

4.談?wù)劺^承,為什么要使用繼承?

所謂繼承就是找出幾個類中共同的部分，提取出來作為父類。而子類只需要繼承父類，就可以共享父類的方法。

使用繼承能夠減少重復(fù)的代碼。

5.方法重載的好處?

所謂重載就是在一個類中可以定義多個相同的方法，但是方法的參數(shù)類型和參數(shù)的個數(shù)以及順序要不同。

重載的好處就是能夠讓我們很快的掌握該方法的功能,我們只要要記住該方法就能很快的理解該方法的參數(shù)以及參數(shù)的作用

6.項目中印象最深的部分?

我覺得在該項目中我體現(xiàn)到了反射技術(shù)的強(qiáng)大之處，原來我一直不清楚反射是一種什么樣的技術(shù)，只知道一些概念上的知識，經(jīng)過這個項目之后，終于知道該怎樣靈活運用反射，以及在什么時候運用。

談?wù)勀銓γ嫦驅(qū)ο蟮睦斫馀c認(rèn)識?

我覺得使用面向?qū)ο筮@種思維的方式比較符合我們?nèi)祟惖乃枷?，不需要去學(xué)習(xí)一些什么新的思考方式，就按照現(xiàn)實生活做的一些故事就能讓人理解該內(nèi)容的知識以及他們的作用。

我的看法就是：

1：當(dāng)加入新的功能的時候不會修改原有的代碼。(面向接口編程)

2: 當(dāng)我們寫的一個類可以重復(fù)的運用在其他項目中。(代碼的復(fù)用性)

3：當(dāng)寫一個新類的時候要考慮到他的可擴(kuò)展性。(靈活性)

7.談?wù)劶峡蚣?

集合框架分為三部分，第一部分是collection接口，第二部分是Map接口、第三部分是collections幫助類

首先說一下collection接口，collection接口下面的接口分為set接口、list接口，在往下面就是他們一些實現(xiàn)類。

說到實現(xiàn)類在分為兩部分，第一部分是set的實現(xiàn)類有TreeSet、HashSet，第二部分是list的實現(xiàn)類有： Arraylist、LinkedList、Vector。

8.再說Map接口，map接口下面有treeMap、HashMap、HashTable三個實現(xiàn)類。

最后說collections幫助類，collections提供了一系列靜態(tài)方法實現(xiàn)對各種集合的搜索、排序、線程完全化等操作。

9.什么是異常?描述下異常處理?

所謂異常就在執(zhí)行程序的時發(fā)生的錯誤，他能終止正在執(zhí)行的程序。

異常的處理：1：使用try-catch捕獲異常。

2：使用throw-throws拋出異常。

10.多線程的優(yōu)先級?為什么要分優(yōu)先級?

因為有有一些線程可能比較重要，所以才劃分優(yōu)先級。

異?？蚣艿念惤Y(jié)構(gòu)?

Throwable所有錯誤的超類，他下面有兩個子類：error和Exception。

error代表系統(tǒng)級的錯誤能捕獲，但是不能處理。

Exception代表異常主要出自于程序，可以捕獲也能處理。Exception有分為兩類：編譯期異常、運行期異常。

區(qū)別他是運行期異常還是編譯期異常就看他是不是RuntimeException的子類，如果是的話，就是運行期異常否則是編譯期異常。

談?wù)凥ashMap與Hashtable的區(qū)別。

HashMap:hashmap中可以有空值，線程不安全的類。hashmap的父類是abstractMap抽象類(效率高)

HashTable:hashtable中不允許有空值，線程安全的類.hashtable的父類是Dictionary類(效率低)

說一下iterator。

iterator是一個接口，用于實現(xiàn)對容器里面的元素遍歷操作。

任何的遍歷都可以使用iterator。

什么是泛型?它有什么樣的好處?

泛型就是自己指定一種類型，以后存放的東西就只能有這一種類型。

泛型的好處是在編譯的時候檢查類型安全，并且所有的強(qiáng)制轉(zhuǎn)換都是自動和隱式的，提高代碼的重用率。

說一下你在項目中遇到的異常,并說出什么時候發(fā)生的,怎么解決的。

空指針異常最常見。根據(jù)異常提示找到相應(yīng)的類進(jìn)行處理。發(fā)生的原因很多，比如沒有初始化變量，沒有進(jìn)行賦值等都是空指針?biāo)摹?/p>

你的程序遇到錯時怎么解決的?

根據(jù)錯誤提示找到錯誤的API進(jìn)行相應(yīng)的處理。

談?wù)労偷膮^(qū)別

是位運算符，表示按位與運算，是邏輯運算符，表示邏輯與（and）。

System.out和System.in是什么意思?

System.out是輸出。

System.in是輸入

java為什么能夠跨平臺?

對于不同的系統(tǒng)平臺有不同的虛擬機(jī)，虛擬機(jī)提供了硬件平臺規(guī)范。

用java開發(fā)的程序被編譯成由java虛擬機(jī)指令組成的字節(jié)代碼，虛擬機(jī)會將這些指令翻譯成操作系統(tǒng)特定的指令.（因為jvm屏蔽了底層操作系統(tǒng)的硬件）。

private變量能不能被其他類訪問?如果能,怎么訪問?

能。通過反射. getDeclaredField_r();

演示java項目如何打包成jar文件

1：選擇導(dǎo)出 jar 直到輸出

java的環(huán)境變量如何配置?為什么要配置?

1:在我的電腦 屬性 高級 環(huán)境變量 系統(tǒng)變量 新建 變量名 java-Home,設(shè)置值：java的JDK目錄

2:在選擇新建 設(shè)置變量名 PATH 變量值 %java_home%/bin目錄

為了方便在dos窗口操作。

static和非static修飾的變量哪個生命周期長?

static的生命周期長。因為他一直在內(nèi)存里面。

什么是線程同步?

線程同步就是說在同一時間訪問的資源的時候，資源只能被一個線程所使用.

什么是封裝?封裝的好處是什么?

封裝：封裝就是把一個已經(jīng)實現(xiàn)好的功能的代碼，放在一個方法中（實現(xiàn)了隱藏）。

好處：代碼的重用性、好全性、只需要調(diào)用該方法不管具體的實現(xiàn)

在線程中wait與sleep的區(qū)別?

1：wait是Object定義的方法，而sleep是線程Thread定義的方法。

2:sleep是讓當(dāng)前線程睡泯，所以可以放在任何位置，而wait是讓當(dāng)前線程放棄資源的使用權(quán)，必須放在同步塊或同步方法里面。

3：sleep他不會釋放對象鎖，而wait會釋放對象同步鎖.

4:sleep是等待一段時間后會自動醒來，而wait必須讓其他的線程喚醒。

Class 和class的區(qū)別

class是java的關(guān)鍵字。

Class是類的名字。

awt和swing的區(qū)別?

awt是重量級的組件。

swing是輕量級的組件.

比如:(在swing組件中當(dāng)我們調(diào)用repaint()方法時，會很快調(diào)用paint()，而對于重量級組件會首先調(diào)用upate()方法，然后upate()方法再調(diào)用paint()方法，在重量級組件中實現(xiàn)雙緩沖，我們就要重寫upate()方法，在重寫的時候記得實現(xiàn)帥新屏幕).

為什么實現(xiàn)一個接口必須要實現(xiàn)接口里面所有的方法？

因為這是sun公司的規(guī)定。如果不實現(xiàn)它里面所有的方法那就不叫接口。

線程和進(jìn)程的區(qū)別是什么?

進(jìn)程是一個小的應(yīng)用程序，需要分配內(nèi)存空間。

線程是進(jìn)程中的一個順序控制流，也可以這樣理解(線程是進(jìn)程的實體).

Java基礎(chǔ)技能中強(qiáng)調(diào)程序代碼的讀寫能力,如果一個類很長,你會怎樣讀寫?

1：類分解，每個類只做他該做的事情。

2:方法分解。

抽象方法能不能是private和static修飾符?

能。

用接口有什么好處?

1：使用接口有很好的擴(kuò)展性。

2：接口可以多繼承接口。

3：隱藏實現(xiàn)。

什么是反射?

所謂反射就是在編譯的時候不知道加載什么，只有等到運行的時候才知道該執(zhí)行什么。

創(chuàng)建對象的方式有哪些?

1：new 2：反射 3:clone 4:反序列化

transient是什么意思?

transient代表無法到達(dá)某一對象所拋出的異常。但也不代表沒有該對象。

在設(shè)計類的時候,你是怎么使用靜態(tài)變量和成員變量的?

如果需要一直存在于內(nèi)存當(dāng)中，就選擇靜態(tài)變量否則就選擇成員變量。

定義 《一線大廠Java面試題解析+后端開發(fā)學(xué)習(xí)筆記+最新架構(gòu)講解視頻+實戰(zhàn)項目源碼講義》無償開源 威信搜索公眾號【編程進(jìn)階路】 抽象方法的意義何在?

1：為了減少重復(fù)代碼。

2：抽象方法有很好的擴(kuò)展性。

談集合遍歷的方式

forEach()、for()、iterator

java安全性體現(xiàn)在什么地方? 1:Java提供一個用于網(wǎng)絡(luò)/分布式的計算環(huán)境。因此，Java強(qiáng)調(diào)安全性，如確保無病毒、小應(yīng)用程序運行安全控制等等。

2:Java的驗證技術(shù)是以公鑰（public-key）加密算法為基礎(chǔ)，而且從環(huán)境變量、類加載器、文件系統(tǒng)、網(wǎng)絡(luò)資源和名字空間等方面實施安全策略。

談?wù)劸€程所擁有的幾種狀態(tài)

就緒：線程分配了CPU以外的全部資源，等待獲得CPU調(diào)度

執(zhí)行：線程獲得CPU，正在執(zhí)行

阻塞：線程由于發(fā)生I/O或者其他的操作導(dǎo)致無法繼續(xù)執(zhí)行，就放棄處理機(jī)，轉(zhuǎn)入線程就緒隊列

掛起：由于終端請求，操作系統(tǒng)的要求等原因，導(dǎo)致掛起。

面向?qū)ο蟮奶卣饔心男?

封裝、繼承、多態(tài)

解釋一下在項目里你怎么去實現(xiàn)多線程的。

1:一般是實現(xiàn)Runnable接口，new Thread().start(); 重寫run();

啟動線程時可以調(diào)用run()方法嗎?

可以.因為run方法里面執(zhí)行的代碼就是線程所要執(zhí)行的方法.

Java程序的執(zhí)行過程是怎樣的?

java源程序 編譯.class字節(jié)碼 類加載器 字節(jié)碼校驗器 解釋執(zhí)行

Java的引用數(shù)據(jù)類型有哪些?

對象、集合、數(shù)組、接口

變量按作用域分類分為幾種?

分為兩種。局部變量和全局變量.

集合里的接口有哪些?請你創(chuàng)建一個List類的實例。

Collection接口、set接口、list接口、map接口、iterator接口

List list = new ArrayList();

int與Integer的區(qū)別?

int是原始數(shù)據(jù)類型，integer是int的包裝類，他提供轉(zhuǎn)換類型的很多方法。

checked異常與unchecked異常的區(qū)別是什么?

區(qū)分他們的區(qū)別主要是看他們是不是runtime的子類，如果是runtime的子類那么就是運行期異常，否則是編譯期異常。

final與finally、finalize的區(qū)別?

final用于聲明屬性、方法和類，分別表示屬性不可更改，方法不可重寫，類不可以繼承。

finally是異常處理語句結(jié)構(gòu)的一部分，他表示總是執(zhí)行。

finalize是Object類的一個方法，在垃圾收集器執(zhí)行的時候會調(diào)用被回收對象的此方法，可以覆蓋此方法提供垃圾收集時的其他資源回收，例如關(guān)閉文件等。

重寫與重載的區(qū)別?參數(shù)一樣,返回類型不一樣 是重載嗎?

重載：方法名相同，參數(shù)類型不同，參數(shù)個數(shù)不同，參數(shù)順序不同。

重寫：方法名相同，參數(shù)的類型相同，返回的類型相同。

不是。因為重載是根據(jù)參數(shù)來斷定的。

寫一個數(shù)組的創(chuàng)建。

int[] i = new int[5];

int[] i={1,2,3,4,5};

什么時候用輸入流,什么時候用輸出流?

讀取數(shù)據(jù)的時候使用輸入流。

寫入數(shù)據(jù)的時候使用輸出流.

雙緩沖如何實現(xiàn)的?為什么要用雙緩沖?

先在內(nèi)存中分配一個和我門動畫窗口一樣大的空間（在內(nèi)存中的空間我門是看不到的），然后利用 getGraphics_r()方法去獲得給空間并將它全部一次性的顯示到我門的屏幕上．這樣在我門的動畫窗口上面是顯示出來就非常的流暢了．避免了上面的閃爍效果．

舉出常用的list類。哪種情況用哪種好?

arraylist、LinkedList、Vector.

arraylist是連續(xù)的空間，遍歷速度快，插入和刪除就比較慢。

linkedList是一個雙向鏈表存放數(shù)據(jù)。如果刪除和添加元素比較多的話，要效率高的就可以使用LinkedList。

vector和arraylist的功能一樣，唯一的區(qū)別就是vector是線程安全的，而arraylist是線程不安全的。

Map、list與set的區(qū)別?里面常用的類有哪些?

map是以鍵值對的方式存數(shù)據(jù)。

list里面的數(shù)據(jù)可以重復(fù)，有順序

set里面的數(shù)據(jù)不可以重復(fù)，沒有順序。

list的常用類有arraylist

set的常用類有treeset

map的常用類用hashmap

什么時候用繼承Thread?什么時候?qū)崿F(xiàn)Runnable接口?

當(dāng)一個類中沒有繼承的時候可以使用thread。

如果一個類中已經(jīng)使用了繼承，就只有實現(xiàn)runnable接口

對對象進(jìn)行比較怎么做?為什么不用“==”?

其實如果是非String的話，==與equals并沒有區(qū)別。

因為String他是重寫了object的方法，所以這才有了equals比較內(nèi)容，==比較地址。

靜態(tài)變量與成員變量的區(qū)別。

靜態(tài)變量在對象加載之前初始化，而成員變量是在編譯期間初始化。

靜態(tài)變量可以直接通過類名點的方式進(jìn)行訪問，而成員變量則不行。

訪問修飾符有哪幾種?它們之間的區(qū)別是什么?

有四種。

前提：在一個項目中。

public可以在所有包中的所有類隨意進(jìn)行訪問。

private只能在被當(dāng)前類訪問。

protected:在同一包中，或子類可以進(jìn)行訪問。

默認(rèn)：同包下能被訪問。

對象的序列化怎么實現(xiàn)的?

實現(xiàn)Serializable接口。

講一下多態(tài)的概念。

多態(tài)就是相同的行為不同的體現(xiàn)方式。(比如：愛好，每個人都要自己的愛好，但是愛好都不同)

子類繼承父類,父類的構(gòu)造方法能被繼承嗎?

能。

子類中怎么調(diào)用父類的方法?

通過super.方法

this、super的用法與區(qū)別?

this的訪問當(dāng)前類的屬性和方法。

super是訪問父類的屬性和方法。

什么是構(gòu)造方法?構(gòu)造方法的作用?(目的、意義)

構(gòu)造方法是在調(diào)用的時候被new出來的，每個類都有構(gòu)造方法。

作用：為對象分配內(nèi)存、初始化類變量、初始化屬性、返回引用。

Error和Exception的區(qū)別是什么?

Error:是系統(tǒng)級的錯誤，可以捕獲，但不同處理。

exception是程序錯誤，可以捕獲也可以進(jìn)行處理。

輸入輸出流分幾種?分別在什么時候使用?

輸入流：InputStream、Read

輸出流:OutputStream、writer

讀取字節(jié)，使用InputStream 以字符讀取用Read

輸出字節(jié),使用OutputStream 以字符輸出用writer

異常捕獲的流程?如果有異常發(fā)生是怎樣的流程?

try{

容易發(fā)生異常的代碼

}catch(錯誤的類型){

打印錯誤信息

}finally{

不管有沒有異常都要執(zhí)行

}

String是基本數(shù)據(jù)類型嗎?基本數(shù)據(jù)類型有哪些?

不是。

基本數(shù)據(jù)類型：byte、short、int、long、float、double、char、boolean

Collection與Collections的區(qū)別?

Collection是一個接口.

collections是一個幫助類。(主要對查找、排序)

HashMap等是實現(xiàn)的 Collection的接口嗎?

不是。

hashMap實現(xiàn)的是map接口。他是以鍵值對的形式保存。

游戲中的paint()方法從何處來的?讓窗本重繪最好采用哪種方法?

NO!!!沒做過。

為什么從集合中取出來的元素都是Object類型的?.

因為他們都是object的子類。

如果try塊中有多種異常,在catch塊中如何處理?

直接在類型catch中寫一個Exception異常。

如果要拋出異常怎么做?

使用throw明確要拋出異常的代碼，在方法中使用throws拋出異常類型。

實現(xiàn)接口使用什么關(guān)鍵字?在實現(xiàn)一個接口時必須要做什么?

使用interface關(guān)鍵字。

實現(xiàn)一個接口必須實現(xiàn)這個接口里面的所有方法.

GUI響應(yīng)一個事件的代碼如何寫?

確定事件源；確定監(jiān)聽器，監(jiān)聽器需要實現(xiàn)監(jiān)聽器接口，重寫其中的方法；完成事件源和監(jiān)聽器的注冊

JVM是什么?它的作用是什么?它和java運行環(huán)境有什么區(qū)別?

Java虛擬機(jī)是一個抽象的計算機(jī)，和實際的計算機(jī)一樣，它具有一個指令集并使用不同的存儲區(qū)域。

它負(fù)責(zé)執(zhí)行指令，還要管理數(shù)據(jù)、內(nèi)存和寄存器。Java解釋器負(fù)責(zé)將字節(jié)代碼翻譯成特定機(jī)器的機(jī)器代碼

沒有java虛擬機(jī)就更不要說運行環(huán)境了。

集合和數(shù)組的區(qū)別。

1：集合中可以存放不同元素的類型，而數(shù)組中只能放同一種類型的數(shù)據(jù)。

2：集合的長度可以隨著元素的多少自動增長，而數(shù)據(jù)的長度一旦定義就不能更改。

3:集合中只能放置對象，數(shù)組中可以是對象也可以基本數(shù)據(jù)類型。

4：集合提供了很好的算法，而數(shù)組里面的算法有限。

final這個修飾符的用法?

final主要修飾屬性、方法、類。分別代表屬性的值不可更改、方法不可以重寫、類不可以繼承。

如何定義一個常量?定義常量的意義何在?

文章題目：java代碼長得有哪些 java比較大小的代碼
文章URL：http://www.yijiale78.com/article44/hhsdhe.html

成都網(wǎng)站建設(shè)公司_創(chuàng)新互聯(lián)，為您提供網(wǎng)頁設(shè)計公司、做網(wǎng)站、全網(wǎng)營銷推廣、網(wǎng)站建設(shè)、服務(wù)器托管、移動網(wǎng)站建設(shè)

廣告

聲明：本網(wǎng)站發(fā)布的內(nèi)容（圖片、視頻和文字）以用戶投稿、用戶轉(zhuǎn)載內(nèi)容為主，如果涉及侵權(quán)請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網(wǎng)站立場，如需處理請聯(lián)系客服。電話：028-86922220；郵箱：631063699@qq.com。內(nèi)容未經(jīng)允許不得轉(zhuǎn)載，或轉(zhuǎn)載時需注明來源： 創(chuàng)新互聯(lián)