經典的java程序

4. java軟體有哪些經典的

貪食蛇，俄羅斯方塊，五子棋。
常用的就不知道了。

5. 跪求JAVA經典小項目代碼或者教程

http://www.pudn.com/downloads52/sourcecode/game/detail181556.html

俄羅斯方塊

6. 經典java

Private 語句 在模塊級別中使用，用於聲明私有變數及分配存儲空間。語法Private [WithEvents] varname[([subscripts])] [As [New] type] [,[WithEvents] varname[([subscripts])] [As [New] type]] . . .Private 語句的語法包含下面部分：部分描述WithEvents可選的。關鍵字，說明 varname 是用來響應由 ActiveX 對象所觸發的事件的對象變數。只有在類模塊中才是合法的。使用 WithEvents，可以定義任意個所需的單變數，但不能用 WithEvents 創建數組。New 和 WithEvents 不能一起使用。varname必需的。變數的名稱；遵循標準的變數命名約定。subscripts可選的。數組變數的維數；最多可以定義 60 維的多維數組。subscripts 參數的使用語法如下： [lower To] upper [,[lower To] upper] . . . 如果不顯式指定 lower，則數組的下界由 Option Base 語句控制。如果沒有 Option Base 語句則下界為 0。New可選的。使其可以隱式地創建對象的關鍵字。如果使用 New 聲明對象變數，則在第一次引用該變數時創建該對象的新實例，因此不必使用 Set 語句來對該對象引用賦值。New 關鍵字不能聲明任何內部數據類型的變數以及從屬對象的實例，也不能與 WithEvents 一起使用。type可選的。變數的數據類型；可以是 Byte、Boolean、Integer、Long、Currency、Single、Double、Decimal（目前尚不支持）、Date、String（對可變長的字元串）、String * length（對定長的字元串）、Object、Variant、用戶定義類型或對象類型。所聲明的每個變數都要一個單獨的 As type 子句。說明Private 變數只能在包含其聲明的模塊中使用。可以使用 Private 語句聲明變數的數據類型。例如，下面的語句聲明了一個 Integer 類型的變數。Private NumberOfEmployees As Integer也可以使用 Private 語句來聲明變數的對象類型。下面的語句為工作表的新實例聲明了一個變數。Private X As New Worksheet如果在定義對象變數時沒有使用 New 關鍵字，則在使用該變數之前，必須使用 Set 語句將一個已有的對象賦給該引用對象的變數。在賦值之前，所聲明的這個對象變數有一個特定值 Nothing，這個值表示該變數沒有指向任何對象的實例。如果不指定數據類型或對象類型，且在模塊中沒有使用 Deftype 語句，則按預設情況該變數為 Variant 類型。可以用帶空圓括弧的 Private 語句來聲明動態數組，然後可以在過程內用 ReDim 語句來定義該數組的維數和元素。如果試圖在 Private，Public 或 Dim 語句中重新定義一個已顯式定義了大小的數組的維數，就會發生錯誤。當初始化變數時，數值變數被初始化為 0，變長的字元串被初始化為一個零長度的字元串 ("")，而定長的字元串則用 0 填充。Variant 變數被初始化為 Empty。用戶自定義類型的變數的每個元素作為各自獨立的變數進行初始化。注意 當在過程中使用 Private 語句時，通常將 Private 語句放在過程的開始。
private，空，protected，public 許可權
使用private修飾符可以完全隱藏類的成員，使得不能從類外直接訪問它們。
不使用修飾符允許同一個包里的任何類直接訪問類的成員，但是其他包中的類不可以。
使用protected修飾符允許任何包中的子類或同一包的類的成員。
使用public修飾符允許任何類訪問類的成員。

public在程序語言中基本都表示全局變數或者全局函數，他的本意是「公共的」的意思，他表示某個變數或者函數是全局函數，例如:public int a 表示a這個整形變數是全局變數，再例如，聲明一個全局函數：public function checked()
........
end function
表示checked這個函數是全局函數

static C++的static有兩種用法：面向過程程序設計中的static和面向對象程序設計中的static。前者應用於普通變數和函數，不涉及類；後者主要說明static在類中的作用。
一、面向過程設計中的static
1、靜態全局變數
在全局變數前，加上關鍵字static，該變數就被定義成為一個靜態全局變數。我們先舉一個靜態全局變數的例子，如下：
//Example 1#include <iostream.h>void fn();static int n; //定義靜態全局變數void main(){ n=20; cout<<n<<endl; fn();}void fn(){ n++; cout<<n<<endl;}
靜態全局變數有以下特點：
該變數在全局數據區分配內存；
未經初始化的靜態全局變數會被程序自動初始化為0（自動變數的值是隨機的，除非它被顯式初始化）；
靜態全局變數在聲明它的整個文件都是可見的，而在文件之外是不可見的；
靜態變數都在全局數據區分配內存，包括後面將要提到的靜態局部變數。對於一個完整的程序，在內存中的分布情況如下圖：
代碼區
全局數據區
堆區
棧區
一般程序的由new產生的動態數據存放在堆區，函數內部的自動變數存放在棧區。自動變數一般會隨著函數的退出而釋放空間，靜態數據（即使是函數內部的靜 態局部變數）也存放在全局數據區。全局數據區的數據並不會因為函數的退出而釋放空間。細心的讀者可能會發現，Example 1中的代碼中將
static int n; //定義靜態全局變數
改為
int n; //定義全局變數
程序照樣正常運行。
的確，定義全局變數就可以實現變數在文件中的共享，但定義靜態全局變數還有以下好處：
靜態全局變數不能被其它文件所用；
其它文件中可以定義相同名字的變數，不會發生沖突；
您可以將上述示例代碼改為如下：
//Example 2//File1#include <iostream.h>void fn();static int n; //定義靜態全局變數void main(){ n=20; cout<<n<<endl; fn();}//File2#include <iostream.h>extern int n;void fn(){ n++; cout<<n<<endl;}
編譯並運行Example 2，您就會發現上述代碼可以分別通過編譯，但運行時出現錯誤。 試著將
static int n; //定義靜態全局變數
改為
int n; //定義全局變數
再次編譯運行程序，細心體會全局變數和靜態全局變數的區別。
2、靜態局部變數
在局部變數前，加上關鍵字static，該變數就被定義成為一個靜態局部變數。
我們先舉一個靜態局部變數的例子，如下：
//Example 3#include <iostream.h>void fn();void main(){ fn(); fn(); fn();}void fn(){ static n=10; cout<<n<<endl; n++;}
通常，在函數體內定義了一個變數，每當程序運行到該語句時都會給該局部變數分配棧內存。但隨著程序退出函數體，系統就會收回棧內存，局部變數也相應失效。
但有時候我們需要在兩次調用之間對變數的值進行保存。通常的想法是定義一個全局變數來實現。但這樣一來，變數已經不再屬於函數本身了，不再僅受函數的控制，給程序的維護帶來不便。
靜態局部變數正好可以解決這個問題。靜態局部變數保存在全局數據區，而不是保存在棧中，每次的值保持到下一次調用，直到下次賦新值。
靜態局部變數有以下特點：
該變數在全局數據區分配內存；
靜態局部變數在程序執行到該對象的聲明處時被首次初始化，即以後的函數調用不再進行初始化；
靜態局部變數一般在聲明處初始化，如果沒有顯式初始化，會被程序自動初始化為0；
它始終駐留在全局數據區，直到程序運行結束。但其作用域為局部作用域，當定義它的函數或語句塊結束時，其作用域隨之結束；
3、靜態函數
在函數的返回類型前加上static關鍵字,函數即被定義為靜態函數。靜態函數與普通函數不同，它只能在聲明它的文件當中可見，不能被其它文件使用。
靜態函數的例子：
//Example 4#include <iostream.h>static void fn();//聲明靜態函數void main(){ fn();}void fn()//定義靜態函數{ int n=10; cout<<n<<endl;}
定義靜態函數的好處：
靜態函數不能被其它文件所用；
其它文件中可以定義相同名字的函數，不會發生沖突；
二、面向對象的static關鍵字（類中的static關鍵字）
1、靜態數據成員
在類內數據成員的聲明前加上關鍵字static，該數據成員就是類內的靜態數據成員。先舉一個靜態數據成員的例子。
//Example 5#include <iostream.h>class Myclass{public: Myclass(int a,int b,int c); void GetSum();private: int a,b,c; static int Sum;//聲明靜態數據成員};int Myclass::Sum=0;//定義並初始化靜態數據成員Myclass::Myclass(int a,int b,int c){ this->a=a; this->b=b; this->c=c; Sum+=a+b+c;}void Myclass::GetSum(){ cout<<"Sum="<<Sum<<endl;}void main(){ Myclass M(1,2,3); M.GetSum(); Myclass N(4,5,6); N.GetSum(); M.GetSum();}
可以看出，靜態數據成員有以下特點：
對於非靜態數據成員，每個類對象都有自己的拷貝。而靜態數據成員被當作是類的成員。無論這個類的對象被定義了多少個，靜態數據成員在程序中也只有一份拷 貝，由該類型的所有對象共享訪問。也就是說，靜態數據成員是該類的所有對象所共有的。對該類的多個對象來說，靜態數據成員只分配一次內存，供所有對象共 用。所以，靜態數據成員的值對每個對象都是一樣的，它的值可以更新；
靜態數據成員存儲在全局數據區。靜態數據成員定義時要分配空間，所以不能在類聲明中定義。在Example 5中，語句int Myclass::Sum=0;是定義靜態數據成員；
靜態數據成員和普通數據成員一樣遵從public,protected,private訪問規則；
因為靜態數據成員在全局數據區分配內存，屬於本類的所有對象共享，所以，它不屬於特定的類對象，在沒有產生類對象時其作用域就可見，即在沒有產生類的實例時，我們就可以操作它；
靜態數據成員初始化與一般數據成員初始化不同。靜態數據成員初始化的格式為：
＜數據類型＞＜類名＞::＜靜態數據成員名＞=＜值＞
類的靜態數據成員有兩種訪問形式：
＜類對象名＞.＜靜態數據成員名＞ 或 ＜類類型名＞::＜靜態數據成員名＞
如果靜態數據成員的訪問許可權允許的話（即public的成員），可在程序中，按上述格式來引用靜態數據成員 ；
靜態數據成員主要用在各個對象都有相同的某項屬性的時候。比如對於一個存款類，每個實例的利息都是相同的。所以，應該把利息設為存款類的靜態數據成員。這 有兩個好處，第一，不管定義多少個存款類對象，利息數據成員都共享分配在全局數據區的內存，所以節省存儲空間。第二，一旦利息需要改變時，只要改變一次， 則所有存款類對象的利息全改變過來了；
同全局變數相比，使用靜態數據成員有兩個優勢：
靜態數據成員沒有進入程序的全局名字空間，因此不存在與程序中其它全局名字沖突的可能性；
可以實現信息隱藏。靜態數據成員可以是private成員，而全局變數不能；
2、靜態成員函數
與靜態數據成員一樣，我們也可以創建一個靜態成員函數，它為類的全部服務而不是為某一個類的具體對象服務。靜態成員函數與靜態數據成員一樣，都是類的內部 實現，屬於類定義的一部分。 普通的成員函數一般都隱含了一個this指針，this指針指向類的對象本身，因為普通成員函數總是具體的屬於某個類的具體對象的。通常情況下，this 是預設的。如函數fn()實際上是this->fn()。但是與普通函數相比，靜態成員函數由於不是與任何的對象相聯系，因此它不具有this指 針。從這個意義上講，它無法訪問屬於類對象的非靜態數據成員，也無法訪問非靜態成員函數，它只能調用其餘的靜態成員函數。 下面舉個靜態成員函數的例子。
//Example 6#include <iostream.h>class Myclass{public: Myclass(int a,int b,int c); static void GetSum();/聲明靜態成員函數private: int a,b,c; static int Sum;//聲明靜態數據成員};int Myclass::Sum=0;//定義並初始化靜態數據成員Myclass::Myclass(int a,int b,int c){ this->a=a; this->b=b; this->c=c; Sum+=a+b+c; //非靜態成員函數可以訪問靜態數據成員}void Myclass::GetSum() //靜態成員函數的實現{// cout<<a<<endl; //錯誤代碼，a是非靜態數據成員 cout<<"Sum="<<Sum<<endl;}void main(){ Myclass M(1,2,3); M.GetSum(); Myclass N(4,5,6); N.GetSum(); Myclass::GetSum();}
關於靜態成員函數，可以總結為以下幾點：
出現在類體外的函數定義不能指定關鍵字static；
靜態成員之間可以相互訪問，包括靜態成員函數訪問靜態數據成員和訪問靜態成員函數；
非靜態成員函數可以任意地訪問靜態成員函數和靜態數據成員；
靜態成員函數不能訪問非靜態成員函數和非靜態數據成員；
由於沒有this指針的額外開銷，因此靜態成員函數與類的全局函數相比速度上會有少許的增長；
調用靜態成員函數，可以用成員訪問操作符(.)和(->)為一個類的對象或指向類對象的指針調用靜態成員函數，也可以直接使用如下格式：
＜類名＞::＜靜態成員函數名＞（＜參數表＞）
調用類的靜態成員函數。
===============================================================================================
static靜態變數聲明符。 在聲明它的程序塊，子程序塊或函數內部有效，值保持，在整個程序期間分配存儲器空間，編譯器默認值0。
是C++中很常用的修飾符，它被用來控制變數的存儲方式和可見性。
2、為什麼要引入static?
函數內部定義的變數，在程序執行到它的定義處時，編譯器為它在棧上分配空間，大家知道，函數在棧上分配的空間在此函數執行結束時會釋放掉，這樣就產生了一個問題: 如果想將函數中此變數的值保存至下一次調用時，如何實現？ 最容易想到的方法是定義一個全局的變數，但定義為一個全局變數有許多缺點，最明顯的缺點是破壞了此變數的訪問范圍（使得在此函數中定義的變數，不僅僅受此函數控制）。
3、什麼時候用static?
需要一個數據對象為整個類而非某個對象服務,同時又力求不破壞類的封裝性,即要求此成員隱藏在類的內部，對外不可見。
4、static的內部機制：
靜態數據成員要在程序一開始運行時就必須存在。因為函數在程序運行中被調用，所以靜態數據成員不能在任何函數內分配空間和初始化。
這樣，它的空間分配有三個可能的地方，一是作為類的外部介面的頭文件，那裡有類聲明；二是類定義的內部實現，那裡有類的成員函數定義；三是應用程序的main（）函數前的全局數據聲明和定義處。
靜態數據成員要實際地分配空間，故不能在類的聲明中定義（只能聲明數據成員）。類聲明只聲明一個類的「尺寸和規格」，並不進行實際的內存分配，所以在類聲明中寫成定義是錯誤的。它也不能在頭文件中類聲明的外部定義，因為那會造成在多個使用該類的源文件中，對其重復定義。
static被引入以告知編譯器，將變數存儲在程序的靜態存儲區而非棧上空間，靜態
數據成員按定義出現的先後順序依次初始化，注意靜態成員嵌套時，要保證所嵌套的成員已經初始化了。消除時的順序是初始化的反順序。
5、static的優勢：
可以節省內存，因為它是所有對象所公有的，因此，對多個對象來說，靜態數據成員只存儲一處，供所有對象共用。靜態數據成員的值對每個對象都是一樣，但它的值是可以更新的。只要對靜態數據成員的值更新一次，保證所有對象存取更新後的相同的值，這樣可以提高時間效率。
6、引用靜態數據成員時，採用如下格式：
<類名>::<靜態成員名>
如果靜態數據成員的訪問許可權允許的話(即public的成員)，可在程序中，按上述格式
來引用靜態數據成員。
7、注意事項：
(1)類的靜態成員函數是屬於整個類而非類的對象，所以它沒有this指針，這就導致
了它僅能訪問類的靜態數據和靜態成員函數。
(2)不能將靜態成員函數定義為虛函數。
(3)由於靜態成員聲明於類中，操作於其外，所以對其取地址操作，就多少有些特殊
，變數地址是指向其數據類型的指針 ，函數地址類型是一個「nonmember函數指針」。
(4)由於靜態成員函數沒有this指針，所以就差不多等同於nonmember函數，結果就
產生了一個意想不到的好處：成為一個callback函數，使得我們得以將C++和C-based X W
indow系統結合，同時也成功的應用於線程函數身上。
(5)static並沒有增加程序的時空開銷，相反她還縮短了子類對父類靜態成員的訪問
時間，節省了子類的內存空間。
(6)靜態數據成員在<定義或說明>時前面加關鍵字static。
(7)靜態數據成員是靜態存儲的，所以必須對它進行初始化。
(8)靜態成員初始化與一般數據成員初始化不同:
初始化在類體外進行，而前面不加static，以免與一般靜態變數或對象相混淆；
初始化時不加該成員的訪問許可權控制符private，public等；
初始化時使用作用域運算符來標明它所屬類；
所以我們得出靜態數據成員初始化的格式：
<數據類型><類名>::<靜態數據成員名>=<值>
(9)為了防止父類的影響，可以在子類定義一個與父類相同的靜態變數，以屏蔽父類的影響。這里有一點需要注意：我們說靜態成員為父類和子類共享，但我們有重復定義了靜態成員，這會不會引起錯誤呢？不會，我們的編譯器採用了一種絕妙的手法：name-mangling 用以生成唯一的標志。
[編輯本段]static 函數
內部函數和外部函數
當一個源程序由多個源文件組成時，C語言根據函數能否被其它源文件中的函數調用，將函數分為內部函數和外部函數。
1 內部函數（又稱靜態函數）
如果在一個源文件中定義的函數，只能被本文件中的函數調用，而不能被同一程序其它文件中的函數調用，這種函數稱為內部函數。
定義一個內部函數，只需在函數類型前再加一個「static」關鍵字即可，如下所示：
static 函數類型 函數名(函數參數表)
{……}
關鍵字「static」，譯成中文就是「靜態的」，所以內部函數又稱靜態函數。但此處「static」的含義不是指存儲方式，而是指對函數的作用域僅局限於本文件。
使用內部函數的好處是：不同的人編寫不同的函數時，不用擔心自己定義的函數，是否會與其它文件中的函數同名，因為同名也沒有關系。
2 外部函數
外部函數的定義：在定義函數時，如果沒有加關鍵字「static」，或冠以關鍵字「extern」，表示此函數是外部函數：
[extern] 函數類型 函數名(函數參數表)
{……}
調用外部函數時，需要對其進行說明：
[extern] 函數類型 函數名(參數類型表)[，函數名2(參數類型表2)……]；
[案例]外部函數應用。
（1）文件mainf.c
main()
{ extern void input(…),process(…),output(…);
input(…); process(…); output(…);
}
（2）文件subf1.c
……
extern void input(……) /*定義外部函數*/
{……}
（3）文件subf2.c
……
extern void process(……) /*定義外部 函數*/
{……}
（4）文件subf3.c
……
extern void output(……) /*定義外部函數*/
{……}

final類 假如說整個類都是final，就表明自己不希望從這個類繼續，或者不答應其他任何人採取這種操作。換言之，出於這樣或那樣的原因，我們的類肯定不需要進行任何改變；或者出於安全方面的理由，我們不希望進行子類化（子類處理）。
除此以外，我們或許還考慮到執行效率的問題，並想確保涉及這個類各對象的所有行動都要盡可能地有效。如下所示：
class SmallBrain {}
final class Dinosaur
{
int i = 7;
int j = 1;
SmallBrain x = new SmallBrain();
void f() {}
}
public class Jurassic
{
public static void main(String[] args)
{
Dinosaur n = new Dinosaur();
n.f();
n.i = 40;
n.j++;
}
}
注意數據成員既可以是final，也可以不是，取決於我們具體選擇。應用於final的規則同樣適用於數據成員，無論類是否被定義成final。將類定義成final後，結果只是禁止被繼承——沒有更多的限制。然而，由於它禁止被繼承，所以一個final類中的所有方法都默認為final。因為此時再也無法覆蓋它們。所以這與我們將一個方法明確聲明為final一樣。
可為final類內的一個方法添加final指示符，但這樣做沒有任何意義。

7. 請問誰有JAVA的經典程序求！！！～～

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.Ellipse2D;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
@SuppressWarnings("serial")
public class demo extends JFrame{
static double i=20,m=20,n=20,h=20,o=20,l=20;
static JLabel label;
static String string;
static int horse,p;
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
string = JOptionPane.showInputDialog(null,"1到6號馬，請輸入您的參賽馬的序號：");
horse = Integer.parseInt(string);
demo frame = new demo();
label = new JLabel("賽馬游戲");
frame.setTitle("賽馬游戲");
frame.setSize(810,250);
frame.setLocation(100, 100);
frame.setLayout(new BorderLayout());
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setResizable(false);
frame.add(label,BorderLayout.NORTH);
font ff = new font();
frame.add(ff);
frame.setVisible(true);
}
static public class font extends JComponent{
public font(){
task task = new task();
Timer t = new Timer();
t.schele(task, 1000,200);
}
@Override
public void paintComponent(Graphics g){
Graphics2D g1 = (Graphics2D) g;
g1.setPaint(Color.RED);
for(int f=1,i=40;i<=140;i+=20,f++){
g1.drawString(f+":", 10, i);
g1.drawLine(30, i, 800, i);
}
Ellipse2D e = new Ellipse2D.Double(i,20,20,20);
g1.setPaint(Color.RED);
g1.draw(e);
g1.fill(e);
Ellipse2D e1 = new Ellipse2D.Double(m,40,20,20);
g1.setPaint(Color.BLUE);
g1.draw(e1);
g1.fill(e1);
Ellipse2D e2 = new Ellipse2D.Double(n,60,20,20);
g1.setPaint(Color.GREEN);
g1.draw(e2);
g1.fill(e2);
Ellipse2D e3 = new Ellipse2D.Double(h,80,20,20);
g1.setPaint(Color.BLACK);
g1.draw(e3);
g1.fill(e3);
Ellipse2D e4 = new Ellipse2D.Double(o,100,20,20);
g1.setPaint(Color.YELLOW);
g1.draw(e4);
g1.fill(e4);
Ellipse2D e5 = new Ellipse2D.Double(l,120,20,20);
g1.setPaint(Color.CYAN);
g1.draw(e5);
g1.fill(e5);
g1.setPaint(Color.BLACK);
g1.drawLine(800, 20, 800, 200);
repaint();
}
class task extends TimerTask {
@Override
public void run() {
i+=Math.random()*10;
m+=Math.random()*10;
n+=Math.random()*10;
h+=Math.random()*10;
o+=Math.random()*10;
l+=Math.random()*10;
if((i>=780)||(m>=780)||(n>=780)||(h>=780)
||(o>=780)||(l>=780)){
if((i>=780)==true){
p=1;
}else{
if((m>=780)==true){
p=2;
}else{
if((n>=780)==true){
p=3;
}else{
if((h>=780)==true){
p=4;
}else{
if((o>=780)==true){
p=5;
}else{
if((l>=780)==true){
p=6;
}
}
}
}
}
}
if(p==horse){
JOptionPane.showMessageDialog(null, "恭喜您，您買的"+horse+"號馬贏了！");
}else{
JOptionPane.showMessageDialog(null, p+"號馬贏了！ 您選擇的 "+horse+"號馬輸了！");
}
System.exit(0);
}
}
}
}
}
這個是我自己寫賽馬游戲我感覺挺好玩的...反正就此猜唄...嘿嘿...

8. 有誰知道Java里比較經典的一些小程序（我是剛學Java）

//列印抄素數....

public class Primer {

public static boolean check(int n){
//1既不是素數也不是合數
if(n == 1){
return false;
}
for(int i = 2; i <= n / 2; i ++){
if(n % i == 0) {
return false;
}
}
return true;
}

public static void main(String[] args) {
int len = 1000;
System.out.println("列印" + len + "以內的所有素數");
//2是最小的素數
int num = 0;
for(int i = 2; i <= len; i ++) {
if(Primer.check(i)){
System.out.print(i + "\t");
num ++;
if(num == 10) {
System.out.println();
num = 0;
}
}

}

}

}

9. java經典編程案例有哪些

1. java編程的記事本：

   import java.util.*;
   public class JieChengExample
   {
   public static void main(String args[])
   {
   Scanner input=new Scanner(System.in);
   int n,sum;
   Jiecheng jie=new Jiecheng();
   System.out.print("輸入n的值：");//輸入有幾個階乘相加
   n=input.nextInt();
   sum=0;
   for(int i=1;i<=n;i++)
   {
   sum=sum+jie.jiecheng(i);//這是n個階乘相加
   }
   System.out.println("1!+2!+3!+....+n!的和是："+sum);
   }
   }
   class Jiecheng
   {
   public int jiecheng(int temp)//算階乘的方法
   {
   int sum=1;
   for(int i=1;i<=temp;i++)
   {
   sum=sum*i; //計算階乘
   }
   return sum;//將一個階乘返回
   }
   }

2.java賽馬游戲：

import java.util.Random;
public class Test {
public static void main(String[] args) {
Competition c = new Competition();
Thread T = new Thread(c);
T.start();
}
}
class Competition implements Runnable{
int red = 0;
int green = 0;
int Speed [] = new int [2];
Competition(){

}
public void run(){
Random r = new Random();
for(int a= 0;a<500;a++){
for(int j = 0;j<2;j++){
Speed[j] = r.nextInt(2);
red = red + Speed[j];
Speed[j] = r.nextInt(2);
green = green + Speed[j];
}
System.out.println("red的速度為"+red);
System.out.println("green的速度為"+green);
while(red >=500 || green>=500){
if(red >=500){
System.out.println("red先抵達終點線");
}
if(green >= 500){
System.out.println("green先抵達終點線");
}
if(green ==500 && red ==500 ){
System.out.println("兩個同時到達");
}
return;
}
}
/* if(red >green){
System.out.println("Redwin"+red);
}
if(red<green){
S...import java.util.Random;
public class Test {
public static void main(String[] args) {
Competition c = new Competition();
Thread T = new Thread(c);
T.start();
}
}
class Competition implements Runnable{
int red = 0;
int green = 0;
int Speed [] = new int [2];
Competition(){

}
public void run(){
Random r = new Random();
for(int a= 0;a<500;a++){
for(int j = 0;j<2;j++){
Speed[j] = r.nextInt(2);
red = red + Speed[j];
Speed[j] = r.nextInt(2);
green = green + Speed[j];
}
System.out.println("red的速度為"+red);
System.out.println("green的速度為"+green);
while(red >=500 || green>=500){
if(red >=500){
System.out.println("red先抵達終點線");
}
if(green >= 500){
System.out.println("green先抵達終點線");
}
if(green ==500 && red ==500 ){
System.out.println("兩個同時到達");
}
return;
}
}
/* if(red >green){
System.out.println("Redwin"+red);
}
if(red<green){
System.out.println("Greenwin"+green);
}
if(red == green){
System.out.println("equal");*/

JAVA的介紹：

Java是一種可以撰寫跨平台應用程序的面向對象的程序設計語言。Java技術具有卓越的通用性、高效性、平台移植性和安全性，廣泛應用於PC、數據中心、游戲控制台、科學超級計算機、行動電話和互聯網，同時擁有全球最大的開發者專業社群。