java烏龜

⑴ java 用多線程模擬龜兔賽跑：

public class TortoiseAndHareRace {
public static void main(String[] args) {
Runnable vs=new Race();
Thread hare=new Thread(vs,"Hare");
Thread tortoise =new Thread(vs,"Tortoise");
System.out.println("Ready!GO!");
hare.start();
tortoise.start();
}
}
class Race implements Runnable{
private static final int S=1000;
@Override
public void run() {
if(Thread.currentThread().getName().equals("Hare")){
int sHare=0;
while(sHare<=S){
sHare+=5;
if(sHare%20==0)
try {Thread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}
}
}else{
int sTortoise=0;
while(sTortoise<=S){
sTortoise++;
if(sTortoise%100==0)
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}

⑵ java龜兔賽跑求簡單多線程

publicclassCompetition{
	=false;//用來標記是否有人到達終點，到達終點後游戲結束
	//烏龜的實現方式
	{
		privatevolatileinttotal=0;//用來記錄當前已經前行了多少距離
		@Override
		publicvoidrun(){
			while(!gameOver){
				intstep=(int)(Math.random()*5+1);//產生1-5的隨機數
				total+=step;
				try{
					Thread.sleep(200);
				}catch(InterruptedExceptione){
					//TODOAuto-generatedcatchblock
					e.printStackTrace();
				}
			}
			
		}
		publicintgetTotal(){
			returntotal;
		}
	}
	//兔子的實現方式
	{
		privatevolatileinttotal=0;
		@Override
		publicvoidrun(){
			while(!gameOver){
				intstep=(int)(Math.random()*5+1);
				total+=step;
				try{
					Thread.sleep(200);
				}catch(InterruptedExceptione){
					//TODOAuto-generatedcatchblock
					e.printStackTrace();
				}
			}
		}
		publicintgetTotal(){
			returntotal;
		}
		
	}
	/**
	*@paramargs
	*/
	publicstaticvoidmain(String[]args){
		//TODOAuto-generatedmethodstub
		finalTortoisetortoise=newTortoise();
		finalRabbitrabbit=newRabbit();
		newThread(tortoise).start();
		newThread(rabbit).start();
		//下面多起了一個線程，相當於比賽的時候的裁判員，他每隔一段時間就看一下是否有人到達終點，若有人到達則宣判該人獲勝，游戲結束
		newThread(newRunnable(){

			@Override
			publicvoidrun(){
				//TODOAuto-generatedmethodstub
				while(!gameOver){
					inttorLen=tortoise.getTotal();//獲得烏龜前行的距離
					intrabLen=rabbit.getTotal();//獲得兔子前行的距離
					System.out.println("烏龜:"+torLen+",兔子"+rabLen);
					if(torLen>=100&&rabLen<100){
						System.out.println("烏龜獲勝!!!");
						gameOver=true;
					}elseif(rabLen>=100&&torLen<100){
						System.out.println("兔子獲勝!!!");
						gameOver=true;
					}elseif(rabLen>=100&&torLen>=100){//這里有可能兩人同時到達終點
						System.out.println("同時到達終點!!!");
						gameOver=true;
					}
					try{
						Thread.sleep(210);
					}catch(InterruptedExceptione){
						//TODOAuto-generatedcatchblock
						e.printStackTrace();
					}
				}
			}
			
		}).start();
		
	}

⑶ JAVA龜兔賽跑問題

先讓兔子進入阻塞狀態，然後等烏龜跑完終點後喚醒兔子線程就行；下面是各個方法的配套使用（網上的，總結的很不錯）1. sleep() 方法：sleep() 允許 指定以毫秒為單位的一段時間作為參數，它使得線程在指定的時間
內進入阻塞狀態，不能得到CPU 時間，指定的時間一過，線程重新進入可執行狀態。
典型地，sleep() 被用在等待某個資源就緒的情形：測試發現條件不滿足後，讓線程阻塞一段時間後
重新測試，直到條件滿足為止。
2. suspend() 和 resume() 方法：兩個方法配套使用，suspend()使得線程進入阻塞狀態，並且不會
自動恢復，必須其對應的resume() 被調用，才能使得線程重新進入可執行狀態。典型地，suspend() 和
resume() 被用在等待另一個線程產生的結果的情形：測試發現結果還沒有產生後，讓線程阻塞，另一個
線程產生了結果後，調用 resume() 使其恢復。
3. yield() 方法：yield() 使得線程放棄當前分得的 CPU 時間，但是不使線程阻塞，即線程仍處於
可執行狀態，隨時可能再次分得 CPU 時間。調用 yield() 的效果等價於調度程序認為該線程已執行了足
夠的時間從而轉到另一個線程。
4. wait() 和 notify() 方法：兩個方法配套使用，wait() 使得線程進入阻塞狀態，它有兩種形式
，一種允許指定以毫秒為單位的一段時間作為參數，另一種沒有參數，前者當對應的 notify() 被調用或
者超出指定時間時線程重新進入可執行狀態，後者則必須對應的 notify() 被調用。

詳情請見http://blog.csdn.net/small____fish/article/details/7726468

⑷ java畫烏龜

首先，手動畫一個小烏龜，如下：

/**
*功能：畫一個烏龜
*/

packagecom.test1;

importjava.awt.*;

importjavax.swing.*;
{
MyPanel2mp=null;
//構造函數
publicMyTortoise(){
mp=newMyPanel2();

this.add(mp);

this.setTitle("小烏龜，醜醜噠");
this.setSize(400,300);
this.setVisible(true);
this.setLocation(300,200);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}

publicstaticvoidmain(String[]args){
MyTortoisemtg=newMyTortoise();
}
}

//我的面板。只有JPanel有畫圖方法，JFrame沒有，故必須在JFrame中添加JPanel
classMyPanel2extendsJPanel{
//定義一個烏龜
Tortoiset=null;

//構造函數
publicMyPanel2(){
t=newTortoise(100,100);
}

//畫烏龜
publicvoiddrawTortoise(intx,inty,Graphicsg){
//1.畫臉
g.setColor(Color.green);
g.fillOval(x+60,y,30,15);
//2.畫左眼
g.setColor(Color.black);
g.fillOval(x+65,y+3,5,5);
//3.畫右眼
g.fillOval(x+78,y+3,5,5);
//4.畫脖子
g.setColor(Color.green);
g.fillOval(x+70,y,10,42);
//5.畫烏龜殼
g.setColor(Color.red);
g.fillOval(x+40,y+40,70,100);
//6.畫左上腳
g.setColor(Color.green);
g.fillOval(x+15,y+60,30,10);
//7.畫右上腳
g.fillOval(x+105,y+60,30,10);
//8.畫左下腳
g.fillOval(x+15,y+110,30,10);
//9.畫右下腳
g.fillOval(x+105,y+110,30,10);
//10.畫尾巴
g.setColor(Color.black);
g.drawLine(x+70,y+140,x+130,y+210);
g.drawOval(x+95,y+150,30,30);
}


//覆蓋JPanel的paint方法
//Graphics是繪圖的重要類。你可以把他理解成一隻畫筆
publicvoidpaint(Graphicsg){
//1.調用父類函數完成初始化任務
//這句話不能少
super.paint(g);
//2.畫烏龜，調用方法即可
this.drawTortoise(50,50,g);
}

}

//定義一個烏龜類
classTortoise{
//表示烏龜的橫坐標
intx=0;

//表示烏龜的縱坐標
inty=0;

publicintgetX(){
returnx;
}

publicvoidsetX(intx){
this.x=x;
}

publicintgetY(){
returny;
}

publicvoidsetY(inty){
this.y=y;
}
publicTortoise(intx,inty){
this.x=x;
this.y=y;
}
}

⑸ 如何用JAVA編一個抽烏龜的小游戲

import java.util.*;
public class A
{
public static void main(String[] args)
{
int count=5;
int[] num={1,2,3,4,5,6,7,8,9,10};
Scanner s=new Scanner(System.in);
int temp=(int)(Math.random()*10)+1;
System.out.println("您的烏龜年齡是:"+temp+"歲的.");
while(count>0)
{
Scanner ss=new Scanner(System.in);
System.out.println("請抽牌,您還有"+count+"次機會.");
System.out.println("開始抽牌--> y/n");
String sss=ss.nextLine();
if(sss.equals("y"))
{
int info=(int)(Math.random()*num.length);
if(num[info]==temp)
{
System.out.println("恭喜,您抽中了");
break;
}
else
{
System.out.println("沒抽中");
}
}
else
{
break;
}
--count;
}
}
}

⑹ java多線程龜兔雞賽跑

你可能是bw 的學生 吧 是不是表

⑺ 用java畫一個烏龜，能用鍵盤移動，並能翻身！

用畫布去話，跟畫驗證碼一樣。只不過你烏龜有點麻煩。
實現他移動很簡單，監聽鍵盤就好了，翻身的話，換張圖片，就到達效果了。

⑻ java基礎代碼，求問那句maria.doSth（jose）的影響，兩個烏龜分別怎麼動（藍色是jo

我認為答案應該是 B。

首先需要搞清楚題主提到的

voiddoSth(Turtleturtle);

方法，此方法接受一個 Turtle 類的對象 turtle 作為參數，但請注意這里傳遞進來的 turtle 參數並不是真正的對象 turtle，而是 turtle 對象所在的內存地址（類似於 C 語言的指針）。

舉個例子，此程序的 main 函數中使用

Turtlejose=newTurtle(150,50,world);

建立了一個新的 Turtle 類的對象，假設這個對象被存儲在內存地址 74 當中，則變數 jose 的值是這個 74 而不是新建的整個對象，也就是說，這個語句的意思是「在內存地址 74 中新建一個 Turtle 類的對象，並將其所在的內存地址 74 賦予一個叫 jose 的變數」。

Java 會在你調用 jose 的方法時，自動訪問 jose 指向的這個內存地址 74 中的實際的對象並調用其方法，而不必像 C 語言一樣需要手動進行解除引用的步驟。比如如果運行

jose.turn(90);

的話，實際上 Java 所進行的操作是「訪問變數 jose 內存儲的內存地址 74，找到地址 74 中存儲的 Turtle 類的對象，並調用此對象的 turn 方法。」

了解了這個原理後，就可以看

maria.doSth(jose);

這一句了。同前面所說，雖然 maria 存儲的只是真正的對象的內存地址，但在調用方法時 Java 會自動訪問這個地址並找到真正的對象，所以這一句會調用真正的 maria 對象的 doSth 方法，並將 jose 傳遞進去。同樣，請注意這里傳進來的 jose 是真正的 jose 對象所在的內存地址（延續上面的假設，內存地址 74）。

這一行，Java 首先會將 jose 內的內存地址（74）復制一份並賦予一個新的本地變數 turtle，這樣做是為了防止在方法中意外改變 jose 本身的值，從而造成指針指向的錯亂。所以這一行之後就多出了一個本地變數 turtle，它的值是 74，指向 jose 對象。

接下來就進了入 doSth 方法的執行。此方法的第一行

turtle=this;

將 this 所指向的對象（this 就是調用此方法的對象本身）所在的內存地址賦予 turtle。具體到這里就是將 maria 對象所在的內存地址的值賦予 turtle。假設 maria 對象所在的內存地址是 68，那麼這行之後 turtle 的值就從原來的 74 變成了 68。也就是說 turtle 變數現在不再指向 jose 對象，轉而指向了 maria 對象。

接下來的

this.forward(20);
turtle.turn(-90);
this.forward(20);

可以解釋為以下三個動作：

1. 將 this 所指向的內存地址中的對象找出並調用其 forward 方法。

2. 將 turtle 所指向的內存地址中的對象找出並調用其 turn 方法。

3. 將 this 所指向的內存地址中的對象找出並調用其 forward 方法。

   
   

因為 this 所指向的內存地址中的對象就是 maria 對象本身，而 turtle 由於 doSth 方法第一句的賦值也指向了 maria 對象本身，所以這三條指令實際上全部是作用於 maria 身上的，和 jose 沒有任何關系。也就是說，

maria.doSth(jose);

相當於

maria.forward(20);
maria.turn(-90);
maria.forward(20);

以上就是 doSth 方法運行的說明。了解這個之後就可以按照程序給出的順序走一遍然後確定兩只烏龜分別的路徑了。步驟為：

Worldworld=newWorld(200,200);

新建一個 200 * 200 的地圖：

可見最終的路徑是 B。

⑼ 如何用最基礎的JAVA語言編寫烏龜爬行代碼

很簡單，看文庫代碼即可：

http://wenku..com/view/a9213da9dd3383c4bb4cd24e?fr=prin