java程序實例

① 用java編寫一個簡單例子，題目如下

package test;

public class Student {
private String name;
private String id;
private String clazz;
private int age;
private String address;

/**
* sayHello方法
*/
public void sayHello() {
System.out.println("學號為" + this.id + "的同學的具體信息如下：");
System.out.println("姓名：" + this.name);
System.out.println("班級：" + this.clazz);
System.out.println("年齡：" + this.age);
System.out.println("家庭住址：" + this.address);
}

/**
* 測試方法
*
* @param args
*/
public static void main(String[] args) {
// 第一問
Student student = new Student();
student.setAddress("網路知道");
student.setAge(1);
student.setClazz("一班");
student.setId("071251000");
student.setName("lsy605604013");
student.sayHello();

// 第二問
Student studentNew = new Student();
studentNew.setAddress("搜搜知道");
studentNew.setAge(2);
studentNew.setClazz("二班");
studentNew.setId("071251001");
studentNew.setName("lady");
if (student.getAge() < studentNew.getAge())
studentNew.sayHello();
else if (student.getAge() > studentNew.getAge())
student.sayHello();
else
System.out.println("兩人一樣大");

}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getId() {
return id;
}

public void setId(String id) {
this.id = id;
}

public String getClazz() {
return clazz;
}

public void setClazz(String clazz) {
this.clazz = clazz;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}

public String getAddress() {
return address;
}

public void setAddress(String address) {
this.address = address;
}

}

② 一個簡單的Java程序代碼

public double GetCost(int minutes)
{
//整數時間所花的費用
int aa = minutes / 60; //未滿1小時處理
if (minutes < 60)
return 2;

//超出小時部分
int bb = minutes % 60; //其實你還有必要做一些其他處理。比如說超過30分鍾了該怎麼樣算等等...... return aa * 2 + bb * 0.01d;
}

③ JAVA繼承實例

繼承是面向對象編程技術的一塊基石，因為它允許創建分等級層次的類。運用繼承，你能夠創建一個通用類，它定義了一系列相關項目的一般特性。該類可以被更具體的類繼承，每個具體的類都增加一些自己特有的東西。在Java 術語學中，被繼承的類叫超類（superclass ），繼承超類的類叫子類（subclass ）。因此，子類是超類的一個專門用途的版本，它繼承了超類定義的所有實例變數和方法，並且為它自己增添了獨特的元素。

繼承一個類，只要用extends 關鍵字把一個類的定義合並到另一個中就可以了。為了理解怎樣繼承，讓我們從簡短的程序開始。下面的例子創建了一個超類A和一個名為B的子類。注意怎樣用關鍵字extends 來創建A的一個子類。

// A simple example of inheritance.
// Create a superclass.
class A {
int i, j;
void showij() {
System.out.println("i and j: " + i + " " + j);
}
}
class B extends A {
int k;
void showk() {
System.out.println("k: " + k);
}
void sum() {
System.out.println("i+j+k: " + (i+j+k));
}
}
class SimpleInheritance {
public static void main(String args[]) {
A superOb = new A();
B subOb = new B();
System.out.println("Contents of superOb: ");
superOb.showij();
System.out.println();
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");
subOb.showij();
subOb.showk();
System.out.println();
System.out.println("Sum of i, j and k in subOb:");
subOb.sum();
}
}

該程序的輸出如下：

Contents of superOb:
i and j: 10 20

Contents of subOb:
i and j: 7 8
k: 9

Sum of i, j and k in subOb:
i+j+k: 24

像你所看到的，子類B包括它的超類A中的所有成員。這是為什麼subOb 可以獲取i和j 以及調用showij( ) 方法的原因。同樣，sum( ) 內部，i和j可以被直接引用，就像它們是B的一部分。

盡管A是B的超類，它也是一個完全獨立的類。作為一個子類的超類並不意味著超類不能被自己使用。而且，一個子類可以是另一個類的超類。聲明一個繼承超類的類的通常形式如下：

class subclass-name extends superclass-name {
// body of class
}

你只能給你所創建的每個子類定義一個超類。Java 不支持多超類的繼承（這與C++ 不同，在C++中，你可以繼承多個基礎類）。你可以按照規定創建一個繼承的層次。該層次中，一個子類成為另一個子類的超類。然而，沒有類可以成為它自己的超類。

成員的訪問和繼承
盡管子類包括超類的所有成員，它不能訪問超類中被聲明成private 的成員。例如，考慮下面簡單的類層次結構：

/* In a class hierarchy, private members remain private to their class.

This program contains an error and will not compile.
*/

// Create a superclass.

class A {
int i;
private int j; // private to A
void setij(int x, int y) {
i = x; j = y;
}
}
// A"s j is not accessible here.
class B extends A {
int total; void sum() {
total = i + j; // ERROR, j is not accessible here
}
}
class Access {
public static void main(String args[]) {
B subOb = new B();
subOb.setij(10, 12);
subOb.sum();
System.out.println("Total is " + subOb.total);
}
}

該程序不會編譯，因為B中sum( ) 方法內部對j的引用是不合法的。既然j被聲明成private，它只能被它自己類中的其他成員訪問。子類沒權訪問它。

注意：一個被定義成private 的類成員為此類私有，它不能被該類外的所有代碼訪問，包括子類。

更實際的例子
讓我們看一個更實際的例子，該例子有助於闡述繼承的作用。新的類將包含一個盒子的寬度、高度、深度。

// This program uses inheritance to extend Box.

class Box {
double width; double height; double depth;
// construct clone of an object
Box(Box ob) { // pass object to constructor
width = ob.width;
height = ob.height;
depth = ob.depth;
}
// constructor used when all dimensions specified
Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// constructor used when no dimensions specified
Box() {
width = -1; // use -1 to indicate
height = -1; // an uninitialized
depth = -1; // box
}
// constructor used when cube is created
Box(double len) {
width = height = depth = len;
}
// compute and return volume double
volume() {
return width * height * depth;
}
}

BoxWeight extends Box {
double weight; // weight of box
// constructor for BoxWeight
BoxWeight(double w, double h, double d, double m) {
width = w;
height = h;
depth = d;
weight = m;
}
}
class DemoBoxWeight {
public static void main(String args[]) {
BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);
BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);
double vol;
vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
System.out.println("Weight of mybox1 is " + mybox1.weight);
System.out.println();
vol = mybox2.volume();
System.out.println("Volume of mybox2 is " + vol);
System.out.println("Weight of mybox2 is " + mybox2.weight);
}
}

該程序的輸出顯示如下：

Volume of mybox1 is 3000.0
Weight of mybox1 is 34.3

Volume of mybox2 is 24.0
Weight of mybox2 is 0.076

BoxWeight 繼承了Box 的所有特徵並為自己增添了一個weight 成員。沒有必要讓BoxWeight 重新創建Box 中的所有特徵。為滿足需要我們只要擴展Box就可以了。

繼承的一個主要優勢在於一旦你已經創建了一個超類，而該超類定義了適用於一組對象的屬性，它可用來創建任何數量的說明更多細節的子類。每一個子類能夠正好製作它自己的分類。例如，下面的類繼承了Box並增加了一個顏色屬性：

// Here, Box is extended to include color.
class ColorBox extends Box {
int color; // color of box
ColorBox(double w, double h, double d, int c) {
width = w;
height = h;
depth = d;
color = c;
}
}

記住，一旦你已經創建了一個定義了對象一般屬性的超類，該超類可以被繼承以生成特殊用途的類。每一個子類只增添它自己獨特的屬性。這是繼承的本質。

超類變數可以引用子類對象
超類的一個引用變數可以被任何從該超類派生的子類的引用賦值。你將發現繼承的這個方面在很多條件下是很有用的。例如，考慮下面的程序：

class RefDemo {
public static void main(String args[]) {
BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);
Box plainbox = new Box(); double vol;
vol = weightbox.volume();
System.out.println("Volume of weightbox is " + vol);
System.out.println("Weight of weightbox is " + weightbox.weight);
System.out.println();
// assign BoxWeight reference to Box reference
plainbox = weightbox;
vol = plainbox.volume(); // OK, volume() defined in Box
System.out.println("Volume of plainbox is " + vol);
/* The following statement is invalid because plainbox does not define a weight member. */
// System.out.println("Weight of plainbox is " + plainbox.weight);
}
}

這里，weightbox 是BoxWeight 對象的一個引用，plainbox 是Box對象的一個引用。既然BoxWeight 是Box的一個子類，允許用一個weightbox 對象的引用給plainbox 賦值。

當一個子類對象的引用被賦給一個超類引用變數時，你只能訪問超類定義的對象的那一部分。這是為什麼plainbox 不能訪問weight 的原因，甚至是它引用了一個BoxWeight 對象也不行。仔細想一想，這是有道理的，因為超類不知道子類增加的屬性。這就是本程序中的最後一行被注釋掉的原因。Box的引用訪問weight 域是不可能的，因為它沒有定義。

④ 用java編寫一個統計投票結果程序

先定義一個學生的對象，裡面有名字，和票數兩個屬性，再定義一個排序函數，返回值為數組，就是取得三個數的數組，列印輸出，或者可以自己想一個更加面向對象的結構實現，在簡單問題上多用面向對象去思考問題 。

import java.util.Scanner;

public class Test {

public static void main(String args[]) {

Scanner in = new Scanner(System.in);

int cj, yxsum = 0, tgsum = 0, bjgsum = 0;

while ((cj = in.nextInt()) != 0) {

if (cj >= 85) {

yxsum++;

} else if (cj >= 60) {

tgsum++;

} else {

bjgsum++;

System.out.println(yxsum);

System.out.println(tgsum);

System.out.println(bjgsum);

}

(4)java程序實例擴展閱讀：

當編輯並運行一個Java程序時，需要同時涉及到這四種方面。使用文字編輯軟體（例如記事本、寫字板、UltraEdit等）或集成開發環境（Eclipse、MyEclipse等）在Java源文件中定義不同的類；

通過調用類（這些類實現了Java API）中的方法來訪問資源系統，把源文件編譯生成一種二進制中間碼，存儲在class文件中，再通過運行與操作系統平台環境相對應的Java虛擬機來運行class文件，執行編譯產生的位元組碼，調用class文件中實現的方法來滿足程序的Java API調用。

⑤ 用JAVA的do-while語句編寫程序例子

public class SimpleDoWhile {

public static void main(String[] args) {

int index = 1;

do {

System.out.println(index);

index = index + 1;

} while(index <= 10);

System.out.println("DONE.");

}

}

輸出結果為：

(5)java程序實例擴展閱讀：

do...while 和while循環非常相似，區別在於表達式的值是在每次循環結束時檢查而不是開始時。

和正規的 while 循環主要的區別是 do-while 的循環語句保證會執行一次（表達式的真值在每次循環結束後檢查），然而在正規的 while 循環中就不一定了（表達式真值在循環開始時檢查，如果一開始就為FALSE則整個循環立即終止）。

總結：while循環是先判斷後循環 ，而do–while循環是先循環後判斷。

⑥ 求助一個JAVA程序實例，「編製程序，列印出100—10000中所有的」水仙花數「」

public class shui {

/**
* @param args
*/
public static void main(String[] args) {
int b,s,g;
System.out.println("開始輸出");
for(int i=100;i<1000;i++){
b=i/100;
s=i%100/10;
g=i%10;
if(b*b*b+s*s*s+g*g*g==i)

System.out.println(b+"

"+s+" "+g+" "+i);
}

}

}

⑦ 一次，如何允許只運行一個Java程序實例

把自己編寫的java程序變成jar可執行文件的步驟如下： 1.最簡單直接的方法，選擇想打包的程序，右鍵export... 2.選擇Runnable Jar file。（即可執行的Jar包） 3.選擇程序的主類，就是還有Main函數的類。點Finish即可。

⑧ java編程實例

我是Java初學者，我看了你的問題後想了很久終於把它做出來了，你看看吧，方法不是很好，但能滿足你的要求：

import java.util.Scanner;
public class Check2{
int t;
char[] chs = new char[500]; //輸入的句子不能超過500個字元
Check2() {
String str;
Scanner sc = new Scanner(System.in);
System.out.println("請輸入字元串(輸入的字元串不能超過500個字元）：");
str = sc.nextLine();
t=str.length();
for (int i = 0; i < t; i ++) {
chs[i] = str.charAt(i); //將輸入的字元串裝入數組
}
}
}

class FuZhi{
char[] letter=new char[52]; //將52個字母（含大小寫）裝入數組
FuZhi(){
char p;
int i=0,j=26;
for(p='A';p<='Z';p++){
letter[i]=p; //這句剛才寫掉了，加上去後程序就完整了
i++; //將A-Z裝入數組
}
for(p='a';p<='z';p++){
letter[j]=p; //將a-z裝入數組，並且從數組的第26個開始裝入（letter[0]-letter[25]已被裝入了字母）
j++;
}
}
}

class display{
public static void main(String[] args){
char temp;
int t;
int[] n= new int [52]; //用於統計每個字元出現的次數

Check2 k =new Check2();
FuZhi m=new FuZhi();

for(int j=0;j<52;j++){
t=0; //令t為0，，並且使上一個字母統計完成後
//將其再次初始化（如A統計完成後，當程序統計B出現的次數時，使B的初始次數為0）
for(int i=0;i<k.t;i++){
if(m.letter[j]==k.chs[i]){ //比較字元是否相同，如相同，使t自加一
t++;
n[j]=t; //數組n來統計每個字母出現的次數，即其中的每一個元素代表一個字母在程序中出現的次數
}
}
}
System.out.println("總共輸入了"+k.t+"個字元:\n"+"其中");
for(int i=0;i<52;i++){
System.out.println("字母"+m.letter[i]+"出現的次數為："+n[i]+"次");
}
}
}

寫掉了一句「letter[i]=p;」，現在已經補上了，程序可以運行了，你試一下吧！！！

⑨ 編寫一個java程序，讀取系統時間，然後將時間用中文輸出

java程序讀取系統時間，可以使用Date時間類，使用格式化類simpleDateFormat類，實例如下：

packagecom.qiu.lin.he;

importjava.text.SimpleDateFormat;
importjava.util.Date;

publicclassCeShi{

	publicstaticvoidmain(String[]args){

		Datedate=newDate();//獲取此時的系統時間
		SimpleDateFormatsdf=newSimpleDateFormat("yyyy年MM月dd日HH點mm分ss秒");
		System.out.println("中文現實的時間是"+sdf.format(date));
	}
}

運行結果如下：

⑩ Java中實例是什麼意思

new 一個對象是實例嗎？
對，是實例，你說的沒錯。可以把這個new出來的對象叫做實例，說白了就是這個new出來的「東西」，叫它對象也可以，叫它實例也可以，對象和實例在這個角度上來講是等價的。
這樣：
Java中使用 new關鍵字 加上 構造方法，來創建一個對象，下面是一個名為Cat的類,
public class Cat {
public Cat() {
System.out.println("這是構造方法");
}
}
使用new + 構造方法 來創建一個對象，那麼也就是
Cat c = new Cat();
前半部分，Cat c 的意思是，在內存中分配一個變數，名字叫c，這個變數是Cat類型的，它的值是什麼？
一會兒在說；
後半部分，new Cat(); 這就是new關鍵字和構造方法來創建一個對象，Cat()是構造方法的名字沒錯吧？想造出一個對象來，就這么寫，語法規定的，沒有為什麼；
new Cat(); 說明 new這個Cat類的一個對象，程序運行的時候，會調用構造方法Cat()，等這個構造方法執行完了，這個Cat類型的對象也就造出來了，真正的出現在內存當中了；
使用new關鍵字造出來的對象，被分配在內存的堆區(heap)，而且等這個對象真正出來之後，還會做一件重要的事情：
我們這個對象是被分配在內存中的，那麼內存地方大了，這個對象在哪裡呢？怎麼找到它呢？new關鍵字創建出一個對象之後，會把這個對象在內存中的地址返回，通過這個地址就可以找到這個對象，那麼我們上面的寫法,
Cat c = new Cat();
意思就是說，把這個對象在內存中的地址 賦值 給變數c，這就是Java中引用概念，c就叫做引用，或者叫引用變數，或者直接叫變數，沒問題，都是它；
c的值就是一個內存地址，或者叫引用地址，通過這個地址，就可以准確的找到我們剛才創建出來的對象，以後我們要使用這個對象做一些事情，調用此對象的方法什麼的，都用過這個引用，ok？
----
注意，我再說一遍，好多人都搞不清楚，這個c到底是對象還是引用，好多人說c就是Cat類的一個實例，這是非常錯誤的，c就是引用，不是對象！我們new出來的這個東西，真正在內存中的這個東西叫做對象，叫做實例