上面 wuzhikun12同學(xué)寫的不錯(cuò)，但我想還不能運(yùn)行，并且還不太完善。我給個(gè)能運(yùn)行的：（注意：文件名為：Test.java)
讓客戶滿意是我們工作的目標(biāo)，不斷超越客戶的期望值來自于我們對這個(gè)行業(yè)的熱愛。我們立志把好的技術(shù)通過有效、簡單的方式提供給客戶，將通過不懈努力成為客戶在信息化領(lǐng)域值得信任、有價(jià)值的長期合作伙伴，公司提供的服務(wù)項(xiàng)目有：域名注冊、雅安服務(wù)器托管、營銷軟件、網(wǎng)站建設(shè)、新洲網(wǎng)站維護(hù)、網(wǎng)站推廣。
//要實(shí)現(xiàn)對象間的比較，就必須實(shí)現(xiàn)Comparable接口，它里面有個(gè)compareTo方法
//Comparable最好使用泛型，這樣，無論是速度還是代碼量都會(huì)減少
@SuppressWarnings("unchecked")
class Student implements ComparableStudent{
private String studentNo; //學(xué)號(hào)
private String studentName; //姓名
private double englishScore; //英語成績
private double computerScore; //計(jì)算機(jī)成績
private double mathScore; //數(shù)學(xué)成績
private double totalScore; //總成績
//空構(gòu)造函數(shù)
public Student() {}
//構(gòu)造函數(shù)
public Student(String studentNo,String studentName,double englishSocre,double computerScore,double mathScore) {
this.studentNo = studentNo;
this.studentName = studentName;
this.englishScore = englishSocre;
this.computerScore = computerScore;
this.mathScore = mathScore;
}
//計(jì)算總成績
public double sum() {
this.totalScore = englishScore+computerScore+mathScore;
return totalScore;
}
//計(jì)算評測成績
public double testScore() {
return sum()/3;
}
//實(shí)現(xiàn)compareTO方法
@Override
public int compareTo(Student student) {
double studentTotal = student.getTotalScore();
return totalScore==studentTotal?0:(totalScorestudentTotal?1:-1);
}
//重寫toString方法
public String toString(){
return "學(xué)號(hào)："+this.getStudentNo()+" 姓名："+this.getStudentName()+" 英語成績："+this.getEnglishScore()+" 數(shù)學(xué)成績："+this.getMathScore()+" 計(jì)算機(jī)成績："+this.getComputerScore()+" 總成績："+this.getTotalScore();
}
//重寫equals方法
public boolean equals(Object obj) {
if(obj == null){
return false;
}
if(!(obj instanceof Student)){
return false;
}
Student student = (Student)obj;
if(this.studentNo.equals(student.getStudentName())) { //照現(xiàn)實(shí)來說，比較是不是同一個(gè)學(xué)生，應(yīng)該只是看他的學(xué)號(hào)是不是相同
return true;
} else {
return false;
}
}
/*以下為get和set方法，我個(gè)人認(rèn)為，totalScore的set的方法沒必要要，因?yàn)樗怯善渌煽冇?jì)算出來的
在set方法中，沒設(shè)置一次值，調(diào)用一次sum方法，即重新計(jì)算總成績
*/
public String getStudentNo() {
return studentNo;
}
public void setStudentNo(String studentNo) {
this.studentNo = studentNo;
sum();
}
public String getStudentName() {
return studentName;
}
public void setStudentName(String studentName) {
this.studentName = studentName;
sum();
}
public double getEnglishScore() {
return englishScore;
}
public void setEnglishScore(double englishScore) {
this.englishScore = englishScore;
sum();
}
public double getComputerScore() {
return computerScore;
}
public void setComputerScore(double computerScore) {
this.computerScore = computerScore;
sum();
}
public double getMathScore() {
return mathScore;
}
public void setMathScore(double mathScore) {
this.mathScore = mathScore;
sum();
}
public double getTotalScore() {
return totalScore;
}
}
//Student子類學(xué)習(xí)委員類的實(shí)現(xiàn)
class StudentXW extends Student {
//重寫父類Student的testScore()方法
@Override
public double testScore() {
return sum()/3+3;
}
public StudentXW() {}
//StudentXW的構(gòu)造函數(shù)
public StudentXW(String studentNo,String studentName,double englishSocre,double computerScore,double mathScore) {
super(studentNo,studentName,englishSocre,computerScore,mathScore);
}
}
//Student子類班長類的實(shí)現(xiàn)
class StudentBZ extends Student {
//重寫父類Student的testScore()方法
@Override
public double testScore() {
return sum()/3+5;
}
public StudentBZ() {}
//StudentXW的構(gòu)造函數(shù)
public StudentBZ(String studentNo,String studentName,double englishSocre,double computerScore,double mathScore) {
super(studentNo,studentName,englishSocre,computerScore,mathScore);
}
}
//測試類
public class Test {
public static void main(String[] args) {
//生成若干個(gè)student類、StudentXW類、StudentBZ類
Student student1 = new Student("s001","張三",70.5,50,88.5);
Student student2 = new Student("s002","李四",88,65,88.5);
Student student3 = new Student("s003","王五",67,77,90);
StudentXW student4 = new StudentXW("s004","李六",99,88,99.5);
StudentBZ student5 = new StudentBZ("s005","朱漆",56,65.6,43.5);
Student[] students = {student1,student2,student3,student4,student5};
for(int i = 0 ; istudents.length; i++){
double avgScore = students[i].testScore();
System.out.println(students[i].getStudentName()+"學(xué)生的評測成績?yōu)椋?+ avgScore+"分");
}
}
}
運(yùn)行結(jié)果為：
張三學(xué)生的評測成績?yōu)椋?9.66666666666667分
李四學(xué)生的評測成績?yōu)椋?0.5分
王五學(xué)生的評測成績?yōu)椋?8.0分
李六學(xué)生的評測成績?yōu)椋?8.5分
朱漆學(xué)生的評測成績?yōu)椋?0.03333333333333分
下面給你提供一些在JAVA程序的設(shè)計(jì)和編碼中，經(jīng)常采用的一些方法和技巧，可以提高JAVA程序的性能：
1．對象的生成和大小的調(diào)整。
JAVA程序設(shè)計(jì)中一個(gè)普遍的問題就是沒有好好的利用JAVA語言本身提供的函數(shù)，從而常常會(huì)生成大量的對象（或?qū)嵗Ｓ捎谙到y(tǒng)不僅要花時(shí)間生成對象，以后可能還需花時(shí)間對這些對象進(jìn)行垃圾回收和處理。因此，生成過多的對象將會(huì)給程序的性能帶來很大的影響。
例1：關(guān)于String ,StringBuffer，+和append
JAVA語言提供了對于String類型變量的操作。但如果使用不當(dāng)，會(huì)給程序的性能帶來影響。如下面的語句：
String name=new String("HuangWeiFeng");
System.out.println(name+"is my name");
看似已經(jīng)很精簡了，其實(shí)并非如此。為了生成二進(jìn)制的代碼，要進(jìn)行如下的步驟和操作：
(1) 生成新的字符串 new String（STR_1);
(2) 復(fù)制該字符串;
(3) 加載字符串常量"HuangWeiFeng"（STR_2);
(4) 調(diào)用字符串的構(gòu)架器（Constructor）;
(5) 保存該字符串到數(shù)組中（從位置0開始）;
(6) 從java.io.PrintStream類中得到靜態(tài)的out變量;
(7) 生成新的字符串緩沖變量new StringBuffer(STR_BUF_1);
(8) 復(fù)制該字符串緩沖變量;
(9) 調(diào)用字符串緩沖的構(gòu)架器（Constructor）;
(10) 保存該字符串緩沖到數(shù)組中（從位置1開始）;
(11) 以STR_1為參數(shù)，調(diào)用字符串緩沖(StringBuffer)類中的append方法;
(12) 加載字符串常量"is my name"(STR_3);
(13) 以STR_3為參數(shù)，調(diào)用字符串緩沖(StringBuffer)類中的append方法;
(14) 對于STR_BUF_1執(zhí)行toString命令;
(15) 調(diào)用out變量中的println方法，輸出結(jié)果。
由此可以看出，這兩行簡單的代碼，就生成了STR_1,STR_2,STR_3,STR_4和STR_BUF_1五個(gè)對象變量。這些生成的類的實(shí)例一般都存放在堆中。堆要對所有類的超類，類的實(shí)例進(jìn)行初始化，同時(shí)還要調(diào)用類極其每個(gè)超類的構(gòu)架器。而這些操作都是非常消耗系統(tǒng)資源的。因此，對對象的生成進(jìn)行限制，是完全有必要的。
經(jīng)修改，上面的代碼可以用如下的代碼來替換。
StringBuffer name=new StringBuffer("HuangWeiFeng");
System.out.println(name.append("is my name.").toString());
系統(tǒng)將進(jìn)行如下的操作：
(1) 生成新的字符串緩沖變量new StringBuffer(STR_BUF_1);
(2) 復(fù)制該字符串緩沖變量;
(3) 加載字符串常量"HuangWeiFeng"(STR_1);
(4) 調(diào)用字符串緩沖的構(gòu)架器（Constructor）;
(5) 保存該字符串緩沖到數(shù)組中（從位置1開始）;
(6) 從java.io.PrintStream類中得到靜態(tài)的out變量;
(7) 加載STR_BUF_1;
(8) 加載字符串常量"is my name"(STR_2);
(9) 以STR_2為參數(shù)，調(diào)用字符串緩沖(StringBuffer)實(shí)例中的append方法;
(10) 對于STR_BUF_1執(zhí)行toString命令(STR_3);
(11)調(diào)用out變量中的println方法，輸出結(jié)果。
由此可以看出，經(jīng)過改進(jìn)后的代碼只生成了四個(gè)對象變量：STR_1,STR_2,STR_3和STR_BUF_1.你可能覺得少生成一個(gè)對象不會(huì)對程序的性能有很大的提高。但下面的代碼段2的執(zhí)行速度將是代碼段1的2倍。因?yàn)榇a段1生成了八個(gè)對象，而代碼段2只生成了四個(gè)對象。
代碼段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提供的庫函數(shù)來優(yōu)化程序，對提高JAVA程序的性能時(shí)非常重要的.其注意點(diǎn)主要有如下幾方面；
(1) 盡可能的使用靜態(tài)變量（Static Class Variables）
如果類中的變量不會(huì)隨他的實(shí)例而變化，就可以定義為靜態(tài)變量，從而使他所有的實(shí)例都共享這個(gè)變量。
例：
public class foo
{
SomeObject so=new SomeObject();
}
就可以定義為：
public class foo
{
static SomeObject so=new SomeObject();
}
(2) 不要對已生成的對象作過多的改變。
對于一些類(如：String類)來講，寧愿在重新生成一個(gè)新的對象實(shí)例，而不應(yīng)該修改已經(jīng)生成的對象實(shí)例。
例：
String name="Huang";
name="Wei";
name="Feng";
上述代碼生成了三個(gè)String類型的對象實(shí)例。而前兩個(gè)馬上就需要系統(tǒng)進(jìn)行垃圾回收處理。如果要對字符串進(jìn)行連接的操作，性能將得更差，因?yàn)橄到y(tǒng)將不得為此生成更多得臨時(shí)變量，如上例1所示。
(3) 生成對象時(shí)，要分配給它合理的空間和大小JAVA中的很多類都有它的默認(rèn)的空間分配大小。對于StringBuffer類來講，默認(rèn)的分配空間大小是16個(gè)字符。如果在程序中使用StringBuffer的空間大小不是16個(gè)字符，那么就必須進(jìn)行正確的初始化。
(4) 避免生成不太使用或生命周期短的對象或變量。對于這種情況，因該定義一個(gè)對象緩沖池。以為管理一個(gè)對象緩沖池的開銷要比頻繁的生成和回收對象的開銷小的多。
(5) 只在對象作用范圍內(nèi)進(jìn)行初始化。JAVA允許在代碼的任何地方定義和初始化對象。這樣，就可以只在對象作用的范圍內(nèi)進(jìn)行初始化。從而節(jié)約系統(tǒng)的開銷。
例：
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來發(fā)方便用戶捕捉異常，進(jìn)行異常的處理。但是如果使用不當(dāng)，也會(huì)給JAVA程序的性能帶來影響。因此，要注意以下兩點(diǎn)：
(1) 避免對應(yīng)用程序的邏輯使用try/catch
如果可以用if,while等邏輯語句來處理，那么就盡可能的不用try/catch語句。
(2) 重用異常
在必須要進(jìn)行異常的處理時(shí)，要盡可能的重用已經(jīng)存在的異常對象。以為在異常的處理中，生成一個(gè)異常對象要消耗掉大部分的時(shí)間。
3. 線程(Threading)
一個(gè)高性能的應(yīng)用程序中一般都會(huì)用到線程。因?yàn)榫€程能充分利用系統(tǒng)的資源。在其他線程因?yàn)榈却脖P或網(wǎng)絡(luò)讀寫而 時(shí)，程序能繼續(xù)處理和運(yùn)行。但是對線程運(yùn)用不當(dāng)，也會(huì)影響程序的性能。
例2：正確使用Vector類
Vector主要用來保存各種類型的對象（包括相同類型和不同類型的對象）。但是在一些情況下使用會(huì)給程序帶來性能上的影響。這主要是由Vector類的兩個(gè)特點(diǎn)所決定的。第一，Vector提供了線程的安全保護(hù)功能。即使Vector類中的許多方法同步。但是如果你已經(jīng)確認(rèn)你的應(yīng)用程序是單線程，這些方法的同步就完全不必要了。第二，在Vector查找存儲(chǔ)的各種對象時(shí)，常常要花很多的時(shí)間進(jìn)行類型的匹配。而當(dāng)這些對象都是同一類型時(shí)，這些匹配就完全不必要了。因此，有必要設(shè)計(jì)一個(gè)單線程的，保存特定類型對象的類或集合來替代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);
這樣就可以通過優(yōu)化線程來提高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));
}
}
}
關(guān)于線程的操作，要注意如下幾個(gè)方面：
(1) 防止過多的同步
如上所示，不必要的同步常常會(huì)造成程序性能的下降。因此，如果程序是單線程，則一定不要使用同步。
(2) 同步方法而不要同步整個(gè)代碼段
對某個(gè)方法或函數(shù)進(jìn)行同步比對整個(gè)代碼段進(jìn)行同步的性能要好。
(3) 對每個(gè)對象使用多”鎖”的機(jī)制來增大并發(fā)。
一般每個(gè)對象都只有一個(gè)”鎖”，這就表明如果兩個(gè)線程執(zhí)行一個(gè)對象的兩個(gè)不同的同步方法時(shí)，會(huì)發(fā)生”死鎖”。即使這兩個(gè)方法并不共享任何資源。為了避免這個(gè)問題，可以對一個(gè)對象實(shí)行”多鎖”的機(jī)制。如下所示：
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)
輸入和輸出包括很多方面，但涉及最多的是對硬盤，網(wǎng)絡(luò)或數(shù)據(jù)庫的讀寫操作。對于讀寫操作，又分為有緩存和沒有緩存的；對于數(shù)據(jù)庫的操作，又可以有多種類型的JDBC驅(qū)動(dòng)器可以選擇。但無論怎樣，都會(huì)給程序的性能帶來影響。因此，需要注意如下幾點(diǎn)：
(1) 使用輸入輸出緩沖
盡可能的多使用緩存。但如果要經(jīng)常對緩存進(jìn)行刷新（flush）,則建議不要使用緩存。
(2) 輸出流(Output Stream)和Unicode字符串
當(dāng)時(shí)用Output Stream和Unicode字符串時(shí)，Write類的開銷比較大。因?yàn)樗獙?shí)現(xiàn)Unicode到字節(jié)(byte)的轉(zhuǎn)換.因此，如果可能的話,在使用Write類之前就實(shí)現(xiàn)轉(zhuǎn)換或用OutputStream類代替Writer類來使用。
(3) 當(dāng)需序列化時(shí)使用transient
當(dāng)序列化一個(gè)類或?qū)ο髸r(shí)，對于那些原子類型（atomic）或可以重建的原素要表識(shí)為transient類型。這樣就不用每一次都進(jìn)行序列化。如果這些序列化的對象要在網(wǎng)絡(luò)上傳輸，這一小小的改變對性能會(huì)有很大的提高。
(4) 使用高速緩存（Cache）
對于那些經(jīng)常要使用而又不大變化的對象或數(shù)據(jù)，可以把它存儲(chǔ)在高速緩存中。這樣就可以提高訪問的速度。這一點(diǎn)對于從數(shù)據(jù)庫中返回的結(jié)果集尤其重要。
(5) 使用速度快的JDBC驅(qū)動(dòng)器（Driver）
JAVA對訪問數(shù)據(jù)庫提供了四種方法。這其中有兩種是JDBC驅(qū)動(dòng)器。一種是用JAVA外包的本地驅(qū)動(dòng)器；另一種是完全的JAVA驅(qū)動(dòng)器。具體要使用哪一種得根據(jù)JAVA布署的環(huán)境和應(yīng)用程序本身來定。
5.一些其他的經(jīng)驗(yàn)和技巧
(1) 使用局部變量。
(2) 避免在同一個(gè)類中動(dòng)過調(diào)用函數(shù)或方法(get或set)來設(shè)置或調(diào)用變量。
(3) 避免在循環(huán)中生成同一個(gè)變量或調(diào)用同一個(gè)函數(shù)（參數(shù)變量也一樣）。
(4) 盡可能的使用static,final,private等關(guān)鍵字。
(5) 當(dāng)復(fù)制大量數(shù)據(jù)時(shí)，使用System.arraycopy()命令。
class?Student{
private?String?name;
private?int?age;
public?Student(){
this.name?=?"nobody";
this.age?=20;
}
public?void?setName(String?name){
this.name?=?name;
}
public?String?getName(){
return?name;
}
public?void?setAge(int?age){
this.age?=?age;
}
public?int?getAge(){
return?age;
}
public?boolean?isSameAge(Student?s){
return?age?==?s.age;
}????
}
import java.awt.*;//計(jì)算器實(shí)例
import java.awt.event.*;
public class calculator
{
public static void main(String args[])
{
MyWindow my=new MyWindow("計(jì)算器");
}
}
class MyWindow extends Frame implements ActionListener
{ StringBuffer m=new StringBuffer();
int p;
TextField tex;
Button b0,b1,b2,b3,b4,b5,b6,b7,b8,b9,jia,jian,cheng,chu,deng,dian,qingling,kaifang;
MyWindow(String s)
{
super(s);
//StringBuffer s2=new StringBuffer();
//String s;
tex=new TextField(18);
b0=new Button(" 0 ");
b1=new Button(" 1 ");
b2=new Button(" 2 ");
b3=new Button(" 3 ");
b4=new Button(" 4 ");
b5=new Button(" 5 ");
b6=new Button(" 6 ");
b7=new Button(" 7 ");
b8=new Button(" 8 ");
b9=new Button(" 9 ");
dian=new Button(" . ");
jia=new Button(" + ");
jian=new Button(" - ");
cheng=new Button(" × ");
chu=new Button(" / ");
deng=new Button(" = ");
qingling=new Button(" 清零 ");
kaifang=new Button(" √ ");
setLayout(new FlowLayout());
add(tex);
add(b0);
add(b1);
add(b2);
add(b3);
add(b4);
add(b5);
add(b6);
add(b7);
add(b8);
add(b9);
add(dian);
add(jia);
add(jian);
add(cheng);
add(chu);
add(kaifang);
add(qingling);
add(deng);
b0.addActionListener(this);
b1.addActionListener(this);
b2.addActionListener(this);
b3.addActionListener(this);
b4.addActionListener(this);
b5.addActionListener(this);
b6.addActionListener(this);
b7.addActionListener(this);
b8.addActionListener(this);
b9.addActionListener(this);
jia.addActionListener(this);
jian.addActionListener(this);
cheng.addActionListener(this);
chu.addActionListener(this);
dian.addActionListener(this);
deng.addActionListener(this);
qingling.addActionListener(this);
kaifang.addActionListener(this);
setBounds(200,200,160,280);
setResizable(false);//不可改變大小
setVisible(true);
validate();
addWindowListener(new WindowAdapter()
{ public void windowClosing(WindowEvent ee)
{ System.exit(0);
}
});
}
public void actionPerformed(ActionEvent e)
{
if(e.getSource()==b0)
{
m=m.append("0");
tex.setText(String.valueOf(m));
}
if(e.getSource()==b1)
{
m=m.append("1"); tex.setText(String.valueOf(m));
}
if(e.getSource()==b2)
{
m=m.append("2"); tex.setText(String.valueOf(m));
}
if(e.getSource()==b3)
{
m=m.append("3"); tex.setText(String.valueOf(m));
}
if(e.getSource()==b4)
{
m=m.append("4"); tex.setText(String.valueOf(m));
}
if(e.getSource()==b5)
{
m=m.append("5"); tex.setText(String.valueOf(m));
}
if(e.getSource()==b6)
{
m=m.append("6"); tex.setText(String.valueOf(m));
}
if(e.getSource()==b7)
{
m=m.append("7"); tex.setText(String.valueOf(m));
}
if(e.getSource()==b8)
{
m=m.append("8"); tex.setText(String.valueOf(m));
}
if(e.getSource()==b9)
{
m=m.append("9"); tex.setText(String.valueOf(m));
}
if(e.getSource()==jia)
{
m=m.append("+"); tex.setText(String.valueOf(m));
}
if(e.getSource()==jian)
{
m=m.append("-"); tex.setText(String.valueOf(m));
}
if(e.getSource()==cheng)
{
m=m.append("*"); tex.setText(String.valueOf(m));
}
if(e.getSource()==chu)
{
m=m.append("/"); tex.setText(String.valueOf(m));
}
if(e.getSource()==dian)
{
m=m.append("."); tex.setText(String.valueOf(m));
}
String mm=String.valueOf(m);
int p1=mm.indexOf("+");
int p2=mm.indexOf("-");
int p3=mm.indexOf("*");
int p4=mm.indexOf("/");
if(p1!=-1)
{
p=p1;
}
else if(p3!=-1)
{
p=p3;
}
else if(p2!=-1)
{
p=p2;
}
else if(p4!=-1)
{
p=p4;
}
if(e.getSource()==deng)
{
String m1=mm.substring(0,p);
String m2=mm.substring(p+1);
String ch=mm.substring(p,p+1);
//System.out.println(m1);
//System.out.println(m2);
//System.out.println(ch);
if(ch.equals("+"))
{
float n1=Float.parseFloat(m1);
float n2=Float.parseFloat(m2);
float sum=n1+n2;
String su=String.valueOf(sum);
tex.setText(su);
}
if(ch.equals("-"))
{
float n1=Float.parseFloat(m1);
float n2=Float.parseFloat(m2);
float sum=n1-n2;
String su=String.valueOf(sum);
tex.setText(su);
}
if(ch.equals("*"))
{
float n1=Float.parseFloat(m1);
float n2=Float.parseFloat(m2);
float sum=n1*n2;
String su=String.valueOf(sum);
tex.setText(su);
}
if(ch.equals("/"))
{
float n1=Float.parseFloat(m1);
float n2=Float.parseFloat(m2);
float sum=n1/n2;
String su=String.valueOf(sum);
tex.setText(su);
}
}
if(e.getSource()==qingling)
{StringBuffer kk=new StringBuffer();
m=kk;
tex.setText("0");
// System.out.println(mm);
}
if(e.getSource()==kaifang)
{
String t=tex.getText();
float num=Float.parseFloat(t);
double nub=Math.sqrt(num);
tex.setText(String.valueOf(nub));
}
}
}
java課程設(shè)計(jì)題目及代碼分別是：
1、題目：計(jì)算器。設(shè)計(jì)內(nèi)容是設(shè)計(jì)一個(gè)圖形界面（GUI）的計(jì)算器應(yīng)用程序，完成簡單的算術(shù)運(yùn)算。
設(shè)計(jì)要求是設(shè)計(jì)的計(jì)算器應(yīng)用程序可以完成家法、減法、乘法、除法和取余運(yùn)算。且有小數(shù)點(diǎn)、正負(fù)號(hào)、求倒數(shù)、退格和清零功能。
2、代碼：
數(shù)字按鈕NumberButton類如下：
import java.awt.
import java.awt.event.
import javax.swing.
public class NumberButton extends Button.
{
int number.
public NumberButton(int number).
{
super(""+number).
this.number=number.
setForeground(Color.blue).
}
public int getNumber().
{
return number;
}
}
其它java課程設(shè)計(jì)題目及代碼是：
題目：華容道。編寫一個(gè)按鈕的子類，使用該子類創(chuàng)建的對象代表華容道中的人物。通過焦點(diǎn)事件控制人物顏色，當(dāng)人物獲得焦點(diǎn)時(shí)顏色為藍(lán)色，當(dāng)失去焦點(diǎn)時(shí)顏色為灰色。
通過鍵盤事件和鼠標(biāo)事件來實(shí)現(xiàn)曹操、關(guān)羽等人物的移動(dòng)。當(dāng)人物上發(fā)生鼠標(biāo)事件或鍵盤事件時(shí)，如果鼠標(biāo)指針的位置是在人物的下方（也就是組件的下半部分）或按下鍵盤的“↓“鍵，該人物向下移動(dòng)。向左、向右和向上的移動(dòng)原理類似。
代碼是：
String name[]={"曹操","關(guān)羽","張","劉","馬","許","兵","兵","兵","兵"}.
for(int i=0;iname.length;i++).
{
person[i]=new Person(i,name[i]).
person[i].addKeyListener(this).
person[i].addMouseListener(this).
//? ? ?person[i].addFocusListener(new Person).
add(person[i]).
}
person[0].setBounds(104,54,100,100).
person[1].setBounds(104,154,100,50).
person[2].setBounds(54,154,50,100).
person[3].setBounds(204,154,50,100).
person[4].setBounds(54,54,50,100).
person[5].setBounds(204,54,50,100);
person[6].setBounds(54,254,50,50);
person[7].setBounds(204,254,50,50);
person[8].setBounds(104,204,50,50);
person[9].setBounds(154,204,50,50);
重慶分公司
重慶分公司
