java中是進行程序設計時（JAVA採用什麼程序設計方法）

本文目錄一覽：

• 1、Java中是進行程序設計時，是怎樣實現模塊間的調用的？
• 2、在進行java語言程序設計時為什麼有的時候會出現編譯正常但也運行不了的情況
• 3、如何優化java程序設計和編碼,提高java性能
• 4、java程序設計有哪些設計原則
• 5、在進行Java程序設計時，B/S結構和C/S結構之間有什麼區別？

Java中是進行程序設計時，是怎樣實現模塊間的調用的？

什麼叫模塊間的調用，模塊一說應該是面向過程編程里的概念，在這裡就不知道你說的模塊是指什麼東東。

如果是一個類要調用另一個類的方法，如果是靜態方法可以直接：類名.方法名()這樣調用。否則實例化類後再調用其中的方法。

在進行java語言程序設計時為什麼有的時候會出現編譯正常但也運行不了的情況

已經有異常了，

java.lang.ArrayIndexOutOfBoundsException: 16 16行出現數組下標越界

at Calculator.init(Calculator.java:19)

at Calculator.main(Calculator.java:37)

注意你的數組下標的使用哦！

如何優化java程序設計和編碼,提高java性能

　下面給你提供一些在JAVA程序的設計和編碼中，經常採用的一些方法和技巧，可以提高JAVA程序的性能：

1．對象的生成和大小的調整。

JAVA程序設計中一個普遍的問題就是沒有好好的利用JAVA語言本身提供的函數，從而常常會生成大量的對象（或實例）。由於系統不僅要花時間生成對象，以後可能還需花時間對這些對象進行垃圾回收和處理。因此，生成過多的對象將會給程序的性能帶來很大的影響。

例1：關於String ,StringBuffer，+和append

JAVA語言提供了對於String類型變數的操作。但如果使用不當，會給程序的性能帶來影響。如下面的語句：

String name=new String(“HuangWeiFeng”);

System.out.println(name+”is my name”);

看似已經很精簡了，其實並非如此。為了生成二進位的代碼，要進行如下的步驟和操作：

(1) 生成新的字元串 new String（STR_1);

(2) 複製該字元串;

(3) 載入字元串常量”HuangWeiFeng”（STR_2);

(4) 調用字元串的構架器（Constructor）;

(5) 保存該字元串到數組中（從位置0開始）;

(6) 從java.io.PrintStream類中得到靜態的out變數;

(7) 生成新的字元串緩衝變數new StringBuffer(STR_BUF_1);

(8) 複製該字元串緩衝變數;

(9) 調用字元串緩衝的構架器（Constructor）;

(10) 保存該字元串緩衝到數組中（從位置1開始）;

(11) 以STR_1為參數，調用字元串緩衝(StringBuffer)類中的append方法;

(12) 載入字元串常量”is my name”(STR_3);

(13) 以STR_3為參數，調用字元串緩衝(StringBuffer)類中的append方法;

(14) 對於STR_BUF_1執行toString命令;

(15) 調用out變數中的println方法，輸出結果。

由此可以看出，這兩行簡單的代碼，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五個對象變數。這些生成的類的實例一般都存放在堆中。堆要對所有類的超類，類的實例進行初始化，同時還要調用類極其每個超類的構架器。而這些操作都是非常消耗系統資源的。因此，對對象的生成進行限制，是完全有必要的。

經修改，上面的代碼可以用如下的代碼來替換。

StringBuffer name=new StringBuffer(“HuangWeiFeng”);

System.out.println(name.append(“is my name.”).toString());

系統將進行如下的操作：

(1) 生成新的字元串緩衝變數new StringBuffer(STR_BUF_1);

(2) 複製該字元串緩衝變數;

(3) 載入字元串常量”HuangWeiFeng”(STR_1);

(4) 調用字元串緩衝的構架器（Constructor）;

(5) 保存該字元串緩衝到數組中（從位置1開始）;

(6) 從java.io.PrintStream類中得到靜態的out變數;

(7) 載入STR_BUF_1;

(8) 載入字元串常量”is my name”(STR_2);

(9) 以STR_2為參數，調用字元串緩衝(StringBuffer)實例中的append方法;

(10) 對於STR_BUF_1執行toString命令(STR_3);

(11)調用out變數中的println方法，輸出結果。

由此可以看出，經過改進後的代碼只生成了四個對象變數：STR_1,STR_2,STR_3和STR_BUF_1.你可能覺得少生成一個對象不會對程序的性能有很大的提高。但下面的代碼段2的執行速度將是代碼段1的2倍。因為代碼段1生成了八個對象，而代碼段2隻生成了四個對象。

代碼段1：

String name= new StringBuffer(“HuangWeiFeng”);

name+=”is my”;

name+=”name”;

代碼段2：

StringBuffer name=new StringBuffer(“HuangWeiFeng”);

name.append(“is my”);

name.append(“name.”).toString();

因此，充分的利用JAVA提供的庫函數來優化程序，對提高JAVA程序的性能時非常重要的.其注意點主要有如下幾方面；

(1) 儘可能的使用靜態變數（Static Class Variables）

如果類中的變數不會隨他的實例而變化，就可以定義為靜態變數，從而使他所有的實例都共享這個變數。

例：

public class foo

{

SomeObject so=new SomeObject();

}

就可以定義為：

public class foo

{

static SomeObject so=new SomeObject();

}

(2) 不要對已生成的對象作過多的改變。

對於一些類(如：String類)來講，寧願在重新生成一個新的對象實例，而不應該修改已經生成的對象實例。

例：

String name=”Huang”;

name=”Wei”;

name=”Feng”;

上述代碼生成了三個String類型的對象實例。而前兩個馬上就需要系統進行垃圾回收處理。如果要對字元串進行連接的操作，性能將得更差，因為系統將不得為此生成更多得臨時變數，如上例1所示。

(3) 生成對象時，要分配給它合理的空間和大小JAVA中的很多類都有它的默認的空間分配大小。對於StringBuffer類來講，默認的分配空間大小是16個字元。如果在程序中使用StringBuffer的空間大小不是16個字元，那麼就必須進行正確的初始化。

(4) 避免生成不太使用或生命周期短的對象或變數。對於這種情況，因該定義一個對象緩衝池。以為管理一個對象緩衝池的開銷要比頻繁的生成和回收對象的開銷小的多。

(5) 只在對象作用範圍內進行初始化。JAVA允許在代碼的任何地方定義和初始化對象。這樣，就可以只在對象作用的範圍內進行初始化。從而節約系統的開銷。

例：

SomeObject so=new SomeObject();

If(x==1) then

{

Foo=so.getXX();

}

可以修改為：

if(x==1) then

{

SomeObject so=new SomeObject();

Foo=so.getXX();

}

2．異常(Exceptions)

JAVA語言中提供了try/catch來發方便用戶捕捉異常，進行異常的處理。但是如果使用不當，也會給JAVA程序的性能帶來影響。因此，要注意以下兩點：

(1) 避免對應用程序的邏輯使用try/catch

如果可以用if,while等邏輯語句來處理，那麼就儘可能的不用try/catch語句。

(2) 重用異常

在必須要進行異常的處理時，要儘可能的重用已經存在的異常對象。以為在異常的處理中，生成一個異常對象要消耗掉大部分的時間。

3. 線程(Threading)

一個高性能的應用程序中一般都會用到線程。因為線程能充分利用系統的資源。在其他線程因為等待硬碟或網路讀寫而 時，程序能繼續處理和運行。但是對線程運用不當，也會影響程序的性能。

例2：正確使用Vector類

Vector主要用來保存各種類型的對象（包括相同類型和不同類型的對象）。但是在一些情況下使用會給程序帶來性能上的影響。這主要是由Vector類的兩個特點所決定的。第一，Vector提供了線程的安全保護功能。即使Vector類中的許多方法同步。但是如果你已經確認你的應用程序是單線程，這些方法的同步就完全不必要了。第二，在Vector查找存儲的各種對象時，常常要花很多的時間進行類型的匹配。而當這些對象都是同一類型時，這些匹配就完全不必要了。因此，有必要設計一個單線程的，保存特定類型對象的類或集合來替代Vector類.用來替換的程序如下（StringVector.java）：

public class StringVector

{

private String [] data;

private int count;

public StringVector()

{

this(10); // default size is 10

}

public StringVector(int initialSize)

{

data = new String[initialSize];

}

public void add(String str)

{

// ignore null strings

if(str == null) { return; }

ensureCapacity(count + 1);

data[count++] = str;

}

private void ensureCapacity(int minCapacity)

{

int oldCapacity = data.length;

if (minCapacity oldCapacity)

{

String oldData[] = data;

int newCapacity = oldCapacity * 2;

data = new String[newCapacity];

System.arraycopy(oldData, 0, data, 0, count);

}

}

public void remove(String str)

{

if(str == null) { return; // ignore null str }

for(int i = 0; i count; i++)

{

// check for a match

if(data[i].equals(str))

{

System.arraycopy(data,i+1,data,i,count-1); // copy data

// allow previously valid array element be gc′d

data[–count] = null;

return;

}

}

}

public final String getStringAt(int index)

{

if(index 0) { return null; }

else if(index count) { return null; // index is # strings }

else { return data[index]; // index is good }

}

}

因此，代碼：

Vector Strings=new Vector();

Strings.add(“One”);

Strings.add(“Two”);

String Second=(String)Strings.elementAt(1);

可以用如下的代碼替換：

StringVector Strings=new StringVector();

Strings.add(“One”);

Strings.add(“Two”);

String Second=Strings.getStringAt(1);

這樣就可以通過優化線程來提高JAVA程序的性能。用於測試的程序如下（TestCollection.java）:

import java.util.Vector;

public class TestCollection

{

public static void main(String args [])

{

TestCollection collect = new TestCollection();

if(args.length == 0)

{

System.out.println(“Usage: java TestCollection [ vector | stringvector ]”);

System.exit(1);

}

if(args[0].equals(“vector”))

{

Vector store = new Vector();

long start = System.currentTimeMillis();

for(int i = 0; i 1000000; i++)

{

store.addElement(“string”);

}

long finish = System.currentTimeMillis();

System.out.println((finish-start));

start = System.currentTimeMillis();

for(int i = 0; i 1000000; i++)

{

String result = (String)store.elementAt(i);

}

finish = System.currentTimeMillis();

System.out.println((finish-start));

}

else if(args[0].equals(“stringvector”))

{

StringVector store = new StringVector();

long start = System.currentTimeMillis();

for(int i = 0; i 1000000; i++) { store.add(“string”); }

long finish = System.currentTimeMillis();

System.out.println((finish-start));

start = System.currentTimeMillis();

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

String result = store.getStringAt(i);

}

finish = System.currentTimeMillis();

System.out.println((finish-start));

}

}

}

關於線程的操作，要注意如下幾個方面：

(1) 防止過多的同步

如上所示，不必要的同步常常會造成程序性能的下降。因此，如果程序是單線程，則一定不要使用同步。

(2) 同步方法而不要同步整個代碼段

對某個方法或函數進行同步比對整個代碼段進行同步的性能要好。

(3) 對每個對象使用多」鎖」的機制來增大並發。

一般每個對象都只有一個」鎖」，這就表明如果兩個線程執行一個對象的兩個不同的同步方法時，會發生」死鎖」。即使這兩個方法並不共享任何資源。為了避免這個問題，可以對一個對象實行」多鎖」的機制。如下所示：

class foo

{

private static int var1;

private static Object lock1=new Object();

private static int var2;

private static Object lock2=new Object();

public static void increment1()

{

synchronized(lock1)

{

var1++;

}

}

public static void increment2()

{

synchronized(lock2)

{

var2++;

}

}

}

4．輸入和輸出(I/O)

輸入和輸出包括很多方面，但涉及最多的是對硬碟，網路或資料庫的讀寫操作。對於讀寫操作，又分為有緩存和沒有緩存的；對於資料庫的操作，又可以有多種類型的JDBC驅動器可以選擇。但無論怎樣，都會給程序的性能帶來影響。因此，需要注意如下幾點：

(1) 使用輸入輸出緩衝

儘可能的多使用緩存。但如果要經常對緩存進行刷新（flush）,則建議不要使用緩存。

(2) 輸出流(Output Stream)和Unicode字元串

當時用Output Stream和Unicode字元串時，Write類的開銷比較大。因為它要實現Unicode到位元組(byte)的轉換.因此，如果可能的話,在使用Write類之前就實現轉換或用OutputStream類代替Writer類來使用。

(3) 當需序列化時使用transient

當序列化一個類或對象時，對於那些原子類型（atomic）或可以重建的原素要表識為transient類型。這樣就不用每一次都進行序列化。如果這些序列化的對象要在網路上傳輸，這一小小的改變對性能會有很大的提高。

(4) 使用高速緩存（Cache）

對於那些經常要使用而又不大變化的對象或數據，可以把它存儲在高速緩存中。這樣就可以提高訪問的速度。這一點對於從資料庫中返回的結果集尤其重要。

(5) 使用速度快的JDBC驅動器（Driver）

JAVA對訪問資料庫提供了四種方法。這其中有兩種是JDBC驅動器。一種是用JAVA外包的本地驅動器；另一種是完全的JAVA驅動器。具體要使用哪一種得根據JAVA布署的環境和應用程序本身來定。

5.一些其他的經驗和技巧

(1) 使用局部變數。

(2) 避免在同一個類中動過調用函數或方法(get或set)來設置或調用變數。

(3) 避免在循環中生成同一個變數或調用同一個函數（參數變數也一樣）。

(4) 儘可能的使用static,final,private等關鍵字。

(5) 當複製大量數據時，使用System.arraycopy()命令。

java程序設計有哪些設計原則

內聚性

類應該描述一個單一的實體，而所有的類操作應該在邏輯上相互配合，支持一個一致的目的。例如：可以設計一個類用於學生，但不應該將學生與教職工組合在一個類中，因為學生和教職工是不同的實體。

如果一個實體擔負太多的職責，就應該按各自的職責分成幾個類。例如：String類、StringBuffer類和 StringBuilder類用於處理字元串，但是他們的職責不同。String類處理不變的字元串，StringBuilder類創建可變字元串， StringBuffer()

與 StringBuffer() 類還包含更新字元串的同步方法。

一致性

遵循標準java程序設計風格和命名習慣。為類、數據域和方法選取具有信息的名字。通常的風格是將數據聲明置於構造方法之前，並且將構造方法置於方法之前。

選擇名字要保持一致。給類似的操作選擇不同的名字並非良好的實踐。例如：Length() 方法返回String、StringBuilder 和 StringBuffer 的大小。如果在這些類中給這個方法用不同的名字就不一致了。

一般來說，應該具有一致性地提供一個公共無參的構造函數，用於構建默認實例。如果一個類不支持無參的構造函數，要用文檔寫出原因。如果沒有顯示定義構造方法，即假定有一個空方法體的公共默認無參構造方法。

如果不想讓用戶創建類的對象，可以在類中聲明一個私有的構造方法，Math類就是如此。

封裝性

一個類應該使用private修飾符隱藏其數據，以免用戶直接訪問它。這使得類更易於維護。只在希望數據域可讀的情況下，才提供get方法；也只在希望數據域可更新的情況下，才提供set方法。例如：Rational類為numerator和denominator提供了get方法，但是沒有提供set方法，因為Rational對象是不可改變的。

清晰性

為使設計清晰，內聚性、一致性和封裝性都是很好的設計原則。除此之外，類應該有一個很清晰的合約，從而易於解釋和理解。

用戶可以以各種不同的組合、順序，以及在各種環境中結合使用多個類。因此，在設計一個類時，這個類不應該限制用戶如何以及何時使用該類；以一種方式設計屬性，以允許用戶按值的任何順序和任何組合來設置；設計方法應該使得實現的功能與他們出現的順序無關。例如：Loan類包含屬性loanAmount、numberOfYears和annualIntereRate，這些屬性的值，可以按任何順序來設置。

方法應在不生產混淆的情況下進行直觀定義。例如：String類中的substring（int beginIndex， int endIndex）方法就有一點混亂。這個方法返回從beginIndex到endIndex-1而不是endIndex的子串。該方法應該返回從beginIndex到endIndex的子字元串，從而更加直觀。

不應該聲明一個來自其他數據域的數據域。例如，下面的Person類有兩個數據域：birthDate和age。由於age可以從birthDate導出，所以age不應該聲明為數據域。

在進行Java程序設計時，B/S結構和C/S結構之間有什麼區別？

BS：瀏覽器\伺服器。CS：客戶端\伺服器。 BS結構的應用也就是一般的網站不用下載客戶端直接互聯網就可以體驗。 CS結構的應用你必須把客戶端下載到本機才可以用。