108學年01學期，四筒老師在課堂上課講解、立即上機實作練習。開始來點進階方法！
package com.fout.bots.heirs;
import java.io.*;
/**
* 計算某年某月某日的星期幾
*/
public class Example41 {
public static void main(String[] args) throws Exception {
int year, month, day;
int i, temp_year, days, last;
// 一個星期
char[] week = { '日', '一', '二', '三', '四', '五', '六' };
// 月份的天數
int[] temp_month = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, };
String getbr;
InputStream is = System.in;
Reader read = new InputStreamReader(is);
BufferedReader br = new BufferedReader(read);
/* ========== 請使用者輸入選項 ========== */
System.out.print("請輸入西元年：");
getbr = br.readLine();
year = Integer.parseInt(getbr);
System.out.print("請輸入月：");
getbr = br.readLine();
month = Integer.parseInt(getbr);
System.out.print("請輸入日：");
getbr = br.readLine();
day = Integer.parseInt(getbr);
/* ========== 是否為閏年及計算總天數 ========== */
temp_year = year - 1;
days = (365 * temp_year + temp_year / 4 - temp_year / 100 + temp_year / 400);
// 若是閏年則將該年2月的日期改為29天
if ((year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0))) {
temp_month[1] = 29;
}
// 算總天數
for (i = 0; i < (month - 1); i++) {
days = days + temp_month[i];
}
days = days + day;
last = days % 7;
String message = (year + "年" + month + "月" + day + "日是禮拜" + week[last]);
System.out.println(message);
}
}
package com.fout.bots.heirs;
import java.io.*;
/**
* 標準的階乘計算class
*/
class frac {
static int y;
// 算階乘
public static int fraction() {
int ans, i;
ans = 1;
for (i = 1; i <= y; i = i + 1)
ans = ans * i;
return (ans);
}
}
public class Example42 extends frac {
// 實數階乘，這個就是擴充的方法
private static int relfraction(double yy) {
int ans;
int newy, i;
// 轉換整數
newy = (int) yy;
String message = "哪有人輸入實數的，下次請輸入整數：" + newy;
System.out.println(message);
ans = 1;
for (i = 1; i <= newy; i = i + 1) {
ans = ans * i;
}
return (ans);
}
@SuppressWarnings("static-access")
public static void main(String[] args) throws Exception {
String getbr;
InputStream is = System.in;
Reader read = new InputStreamReader(is);
BufferedReader br = new BufferedReader(read);
int x, pt;
double fx;
x = 5;
// 將 Example42 物件實體化
Example42 target = new Example42();
while (x >= 0) {
/* ========== 請使用者輸入選項 ========== */
System.out.print("請輸入要計算階乘的數字：");
getbr = br.readLine();
/* ========== 是否為整數 ========== */
// 輸入字串如果有小數點就是實數
pt = getbr.indexOf(".");
// 整數
if (pt < 0) {
x = Integer.parseInt(getbr);
if (x < 0) {
System.out.println("謝謝！再見！");
continue;
}
target.y = x;
String message = (x + "!=" + target.fraction());
System.out.println(message);
} else {
fx = Double.parseDouble(getbr);
if (fx < 0) {
System.out.println("謝謝！再見！");
continue;
}
String message = (fx + "!=" + target.relfraction(fx));
System.out.println(message);
}
}
}
}
package com.fout.bots.heirs;
import java.util.*;
/**
* 繼承方式來擴充發牌運算，玩21 點
*/
public class Example43 {
public static void main(String[] args) {
int i, j, x;
int num = 5;
final int defaultCnt = 52;
// 記錄該位牌是否已被發出
int[] card = new int[defaultCnt];
Random ran = new Random();
p21[] p = new p21[4];// 定義四家玩家,配置空間給陣列
for (i = 0; i < 4; i = i + 1) {
p[i] = new p21();
player.show_cnt();
}
/* ---------- 起始值設定 ---------- */
for (i = 0; i < defaultCnt; i = i + 1) {
card[i] = 0;
}
/* ---------- 亂數產生發牌 ---------- */
// 最多發5張就可以過5關
for (j = 0; j < num; j = j + 1) {
// 發下一家
for (i = 0; i < p.length; i = i + 1) {
x = ran.nextInt(defaultCnt);
while (card[x] != 0) {
x = ran.nextInt(52);
}
if (p[i].isgo()) {
p[i].set_card(x);
card[x] = 1;
System.out.print("第 " + (i + 1) + " 家要牌得到：");
System.out.println(p[i].show(j) + " 目前" + p[i].count_value() + "點");
} else {
System.out.println("第 " + (i + 1) + " 家不要牌了");
}
}
}
// 顯示最後結果
System.out.println("======================== 最後結果 ====================");
for (i = 0; i < p.length; i = i + 1) {
num = p[i].card_num();// 取得真正的牌數
System.out.print("第 " + (i + 1) + " 家的牌：");
for (j = 0; j < num; j = j + 1) {
System.out.print(p[i].show(j) + " ");
}
if (p[i].count_value() > 21) {
System.out.println("積點是" + p[i].count_value() + "點!爆了！");
} else {
if (num >= 5) {
System.out.print("喔！過五關囉！ ");
}
System.out.println("積點是" + p[i].count_value() + "點");
}
}
}
}
class player {
int card_cnt;
// 記錄手上的牌
protected int[] card = new int[13];
// 共用的對照表可以用static
protected static String[] cname = { "梅花", "方塊", "紅心", "黑桃" };
// 共用的物件技術器
protected static int obj_cnt = 0;
// 一副牌52張，固定數值。
protected static final int defaultCnt = 52;
/**
* 建構子，首先把牌清乾淨
*/
public player() {
int i;
for (i = 0; i < 13; i = i + 1) {
this.card[i] = -1;
}
obj_cnt = obj_cnt + 1;// 登記多了一家
}
/**
* method 用來show出共有幾個物件
*/
public static void show_cnt() {
String message = ("目前共有" + obj_cnt + "家");
System.out.println(message);
}
/**
* method 用來show出第幾張牌
*/
public String show(int id) {
int A, B;
if (card[id] == -1) {
return ("沒有這張牌");
} else {
A = card[id] % 4;
B = card[id] / 4;
B = B + 2;
switch (B) {
case 14:
return (cname[A] + "A");
case 13:
return (cname[A] + "K");
case 12:
return (cname[A] + "Q");
case 11:
return (cname[A] + "J");
default:
return (cname[A] + B);
}
}
}
/**
* method 用來發牌給本玩家
*/
public void set_card(int id, int x) {
if (id < 13 && x < defaultCnt) {
card[id] = x;
} else {
String message = ("錯誤 id=" + id + " x=" + x);
System.out.println(message);
}
}
/**
* method 用來發牌給本玩家， 使用overload 來處理沒有設定第幾張的時機
*/
public void set_card(int x) {
int i, flag;
if (x > defaultCnt || x < 0) {
System.out.println("錯誤 x=" + x);
return;
}
// flag用來看看有沒有發到牌
flag = 0;
for (i = 0; i < 13; i = i + 1) {
// 那個位置沒有牌
if (card[i] == -1) {
card[i] = x;
flag = 1;
break; // 發完牌即可跳出
}
}
if (flag == 0) {
System.out.println("錯誤!本家發超過13張牌" + x);
}
}
}
// p21 類別繼承player 類別
class p21 extends player {
int card_value;
int status;// 0:繼續收牌 1:停止發牌
/**
* 建構子，參數初始化
*/
public p21() {
status = 0;// 預設值：收牌
card_value = 0;// 預設值：牌計數。
}
/**
* 確認是否再要牌
*/
public boolean isgo() {
boolean rc = false;
if (status == 1) {
rc = false;
}
if (count_value() < 17) {
// 大於17點則不要牌
rc = true;
}
return rc;
}
/**
* 回傳，目前牌數目
*/
public int card_num() {
return card_cnt;
}
public int count_value() {
int i;
int B, A;
A = 0;
card_value = 0;
for (i = 0; i < 13; i = i + 1) {
// 指定位置沒有牌
if (card[i] == -1) {
break; // 發完牌，即可跳出
} // if card
B = card[i] / 4 + 2;
if (B > 10 && B < 14) {
B = 10;// JQK都算10
}
if (B == 14) {
// 算有幾張A
A = A + 1;
} else {
card_value = card_value + B;
}
} // for
card_value = card_value + A;// 先把A算1
// 把A算成11試試看
while (card_value < 21 && A > 0) {
card_value = card_value + 10;
if (card_value <= 21) {
// 如果不爆就算11
A = A - 1;
} else {
// 如果會爆就算回A
card_value = card_value - 10;
break;
}
}
return card_value;
}
}
package com.fout.bots.heirs.much;
import java.util.*;
/**
* 繼承方式來擴充發牌運算，玩21 點
* 包含super()
*/
public class Example44 {
public static void main(String[] args) {
final int defaultCnt = 52;
int num = 5;
int i, j, x;
String message = null;
// 用來記錄該位牌是否已被發出
int[] card = new int[defaultCnt];
Random ran = new Random();
p21[] p = new p21[4];// 定義四家玩家,配置空間給陣列
for (i = 0; i < 4; i = i + 1) {
p[i] = new p21(i);
player.show_cnt();
}
/* ---------- 起始值設定 ---------- */
for (i = 0; i < defaultCnt; i = i + 1) {
card[i] = 0;
}
/* ---------- 亂數產生發牌 ---------- */
// 最多發5張就可以過5關了
for (j = 0; j < num; j = j + 1) {
// 發下一家
for (i = 0; i < 4; i = i + 1) {
x = ran.nextInt(defaultCnt);
while (card[x] != 0)
x = ran.nextInt(defaultCnt);
if (p[i].isgo()) {
p[i].set_card(x);
card[x] = 1;
message = ("第 " + (i + 1) + " 家要牌得到：");
System.out.print(message);
message = (p[i].show(j) + " 目前" + p[i].count_value() + "點");
System.out.println(message);
} else {
message = ("第 " + (i + 1) + " 家不要牌了");
System.out.println(message);
}
}
}
// 顯示最後結果
System.out.println("========================最後的結果====================");
for (i = 0; i < 4; i = i + 1) {
// 取得真正的牌數
num = p[i].card_num();
message = ("第 " + (i + 1) + " 家的牌：");
System.out.print(message);
for (j = 0; j < num; j = j + 1) {
System.out.print(p[i].show(j) + " ");
}
if (p[i].count_value() > 21) {
message = ("積點是" + p[i].count_value() + "點!爆了！");
System.out.println(message);
} else {
if (num >= 5) {
System.out.print("喔！過五關囉！ ");
}
message = ("積點是" + p[i].count_value() + "點");
System.out.println(message);
}
}
}
}
class p21 extends player {
// 0:繼續收牌 1:停止發牌
int status;
int card_value;
p21() {
// 清理牌計數
card_value = 0;
// 設定收牌
status = 0;
}
p21(int cpt) {
super(cpt);
// 清理牌計數
card_value = 0;
// 設定收牌
status = 0;
}
// 決定要不要再要牌
public boolean isgo() {
if (status == 1) {
return false;
}
// 大於17點就不要牌
if (count_value() < 17) {
return true;
}
return false;
}
// 傳回現在的牌數目
public int card_num() {
return card_cnt;
}
public int count_value() {
int i;
int B, A;
A = 0;
card_value = 0;
for (i = 0; i < 13; i = i + 1) {
// 那個位置沒有牌
if (card[i] == -1) {
break; // 發完牌即可跳出
}
B = card[i] / 4 + 2;
if (B > 10 && B < 14) {
B = 10;// JKQ都算10
}
if (B == 14) {
A = A + 1;// 算有幾張A
} else {
card_value = card_value + B;
}
}
// 先把A算1
card_value = card_value + A;
// 把A算成11試試看
while (card_value <= 21 && A > 0) {
card_value = card_value + 10;
// 如果不爆就算11
if (card_value < 21) {
A = A - 1;
} else {
// 如果會爆就算回A
card_value = card_value - 10;
break;
}
}
return card_value;
}
}
class player {
// 記錄手上的牌
int[] card = new int[13];
// 共用的對照表可以用static
private static String[][] cname = {
{ "梅花", "方塊", "紅心", "黑桃" },
{ "Club", "Diamond", "Hearts", "Spades" },
{ "花", "塊", "心", "桃" },
{ "C", "D", "H", "S" }
};
int card_cnt;
// 共用的物件技術器
private static int obj_cnt = 0;
// 記錄選定哪一組牌名
private int card_pt;
// 一副牌52張，固定數值。
protected static final int defaultCnt = 52;
/**
* 建構子，首先把牌清乾淨
*/
public player() {
int i;
card_cnt = 0;
// 預設選用中文全名
card_pt = 0;
for (i = 0; i < 13; i = i + 1) {
this.card[i] = -1;
}
obj_cnt = obj_cnt + 1;// 登記多了一家
}
public player(int cpt) {
int i;
// 可以設定選用不同牌名
card_pt = cpt;
// 預設選用中文全名
card_cnt = 0;
for (i = 0; i < 13; i = i + 1) {
this.card[i] = -1;
}
obj_cnt = obj_cnt + 1;// 登記多了一家
}
/**
* method 用來show出共有幾個物件
*/
public static void show_cnt() {
String message = ("目前共有" + obj_cnt + "家");
System.out.println(message);
}
/**
* method 用來show出第幾張牌
*/
public String show(int id) {
int A, B;
if (card[id] == -1) {
return ("沒有這張牌");
} else {
A = card[id] % 4;
B = card[id] / 4;
B = B + 2;
switch (B) {
case 14:
return (cname[card_pt][A] + "A");
case 13:
return (cname[card_pt][A] + "K");
case 12:
return (cname[card_pt][A] + "Q");
case 11:
return (cname[card_pt][A] + "J");
default:
return (cname[card_pt][A] + B);
}
}
}
/**
* method 用來發牌給本玩家
*/
public void set_card(int id, int x) {
if (id < 13 && x < defaultCnt) {
card[id] = x;
card_cnt = card_cnt + 1;
} else {
String message = ("錯誤 id=" + id + " x=" + x);
System.out.println(message);
}
}
/**
* method 用來發牌給本玩家，
* 使用overload 來處理沒有設定第幾張的時機
*/
public void set_card(int x) {
int i, flag;
if (x > defaultCnt || x < 0) {
System.out.println("錯誤 x=" + x);
return;
}
// flag用來看看有沒有發到牌
flag = 0;
for (i = 0; i < 13; i = i + 1) {
// 那個位置沒有牌
if (card[i] == -1) {
card[i] = x;
flag = 1;
card_cnt = card_cnt + 1;
break; // 發完牌即可跳出
}
}
if (flag == 0) {
System.out.println("錯誤!本家發超過13張牌" + x);
}
}
}
package com.fout.bots.heirs.its;
import java.util.*;
/**
* 繼承方式來擴充發牌運算，玩21 點
* 包含this()呼叫建構子方式，及protected的使用方法
*/
public class Example45 {
public static void main(String[] args) {
final int defaultCnt = 52;
int num = 5;
int i, j, x;
String message = null;
// 用來記錄該位牌是否已被發出
int[] card = new int[defaultCnt];
Random ran = new Random();
p21[] p = new p21[4];// 定義四家玩家,配置空間給陣列
for (i = 0; i < 4; i = i + 1) {
p[i] = new p21();
player.show_cnt();
}
/* ---------- 起始值設定 ---------- */
for (i = 0; i < defaultCnt; i = i + 1) {
card[i] = 0;
}
/* ---------- 亂數產生發牌 ---------- */
// 最多發5張就可以過5關了
for (j = 0; j < num; j = j + 1) {
// 發下一家
for (i = 0; i < 4; i = i + 1) {
x = ran.nextInt(defaultCnt);
while (card[x] != 0) {
x = ran.nextInt(defaultCnt);
}
if (p[i].isgo()) {
p[i].set_card(x);
card[x] = 1;
message = ("第 " + (i + 1) + " 家要牌得到：");
System.out.print(message);
message = (p[i].show(j) + " 目前" + p[i].count_value() + "點");
System.out.println(message);
} else {
message = ("第 " + (i + 1) + " 家不要牌了");
System.out.println(message);
}
}
}
// 顯示最後結果
System.out.println("========================最後的結果====================");
for (i = 0; i < 4; i = i + 1) {
// 取得真正的牌數
num = p[i].card_num();
message = ("第 " + (i + 1) + " 家的牌：");
System.out.print(message);
for (j = 0; j < num; j = j + 1) {
System.out.print(p[i].show(j) + " ");
}
if (p[i].count_value() > 21) {
message = ("積點是" + p[i].count_value() + "點!爆了！");
System.out.println(message);
} else {
if (num >= 5) {
System.out.print("喔！過五關囉！ ");
}
message = ("積點是" + p[i].count_value() + "點");
System.out.println(message);
}
}
}
}
class p21 extends player {
// 0:繼續收牌 1:停止發牌
private int status;
private int card_value;
p21() {
// 清理牌計數
card_value = 0;
// 設定收牌
status = 0;
}
p21(int cpt) {
super(cpt);
// 清理牌計數
card_value = 0;
// 設定收牌
status = 0;
}
// 決定要不要再要牌
public boolean isgo() {
if (status == 1) {
return false;
}
// 大於17點就不要牌
if (count_value() < 17) {
return true;
}
return false;
}
// 傳回現在的牌數目
public int card_num() {
return card_cnt;
}
public int count_value() {
int i;
int B, A;
A = 0;
card_value = 0;
for (i = 0; i < 13; i = i + 1) {
// 那個位置沒有牌
if (card[i] == -1) {
break; // 發完牌即可跳出
}
B = card[i] / 4 + 2;
if (B > 10 && B < 14) {
B = 10;// JKQ都算10
}
if (B == 14) {
A = A + 1;// 算有幾張A
} else {
card_value = card_value + B;
}
}
// 先把A算1
card_value = card_value + A;
// 把A算成11試試看
while (card_value <= 21 && A > 0) {
card_value = card_value + 10;
// 如果不爆就算11
if (card_value < 21) {
A = A - 1;
} else {
// 如果會爆就算回A
card_value = card_value - 10;
break;
}
}
return card_value;
}
}
class player {
// 記錄手上的牌
int[] card = new int[13];
// 共用的對照表可以用static
private static String[][] cname = {
{ "梅花", "方塊", "紅心", "黑桃" },
{ "Club", "Diamond", "Hearts", "Spades" },
{ "花", "塊", "心", "桃" },
{ "C", "D", "H", "S" }
};
int card_cnt;
// 共用的物件技術器
private static int obj_cnt = 0;
// 記錄選定哪一組牌名
private int card_pt;
// 一副牌52張，固定數值。
protected static final int defaultCnt = 52;
/**
* 建構子，首先把牌清乾淨
*/
public player() {
// 預設選用中文全名，呼叫player(0)
this(0);
}
public player(int cpt) {
int i;
// 可以設定選用不同牌名
card_pt = cpt;
// 預設選用中文全名
card_cnt = 0;
for (i = 0; i < 13; i = i + 1) {
this.card[i] = -1;
}
obj_cnt = obj_cnt + 1;// 登記多了一家
}
/**
* method 用來show出共有幾個物件
*/
public static void show_cnt() {
String message = ("目前共有" + obj_cnt + "家");
System.out.println(message);
}
/**
* method 用來show出第幾張牌
*/
public String show(int id) {
int A, B;
if (card[id] == -1) {
return ("沒有這張牌");
} else {
A = card[id] % 4;
B = card[id] / 4;
B = B + 2;
switch (B) {
case 14:
return (cname[card_pt][A] + "A");
case 13:
return (cname[card_pt][A] + "K");
case 12:
return (cname[card_pt][A] + "Q");
case 11:
return (cname[card_pt][A] + "J");
default:
return (cname[card_pt][A] + B);
}
}
}
/**
* method 用來發牌給本玩家
*/
public void set_card(int id, int x) {
if (id < 13 && x < defaultCnt) {
card[id] = x;
card_cnt = card_cnt + 1;
} else {
String message = ("錯誤 id=" + id + " x=" + x);
System.out.println(message);
}
}
/**
* method 用來發牌給本玩家，
* 使用overload 來處理沒有設定第幾張的時機
*/
public void set_card(int x) {
int i, flag;
if (x > defaultCnt || x < 0) {
System.out.println("錯誤 x=" + x);
return;
}
// flag用來看看有沒有發到牌
flag = 0;
for (i = 0; i < 13; i = i + 1) {
// 那個位置沒有牌
if (card[i] == -1) {
card[i] = x;
flag = 1;
card_cnt = card_cnt + 1;
break; // 發完牌即可跳出
}
}
if (flag == 0) {
System.out.println("錯誤!本家發超過13張牌" + x);
}
}
}
package com.fout.bots.heirs.loading;
import java.util.*;
/**
* 繼承方式來擴充發牌運算，玩21 點
* 包含this()呼叫建構子方式，及protected的使用方法
* overriding 來擴充發牌運算
*/
public class Example46 {
public static void main(String[] args) {
final int defaultCnt = 52;
int num = 5;
int i, j, x;
String message = null;
// 用來記錄該位牌是否已被發出
int[] card = new int[defaultCnt];
Random ran = new Random();
p21[] p = new p21[4];// 定義四家玩家,配置空間給陣列
for (i = 0; i < p.length; i = i + 1) {
p[i] = new p21();
player.show_cnt();
}
/* ---------- 起始值設定 ---------- */
for (i = 0; i < defaultCnt; i = i + 1) {
card[i] = 0;
}
/* ---------- 亂數產生發牌 ---------- */
// 最多發5張就可以過5關了
for (j = 0; j < num; j = j + 1) {
// 發下一家
for (i = 0; i < 4; i = i + 1) {
x = ran.nextInt(defaultCnt);
while (card[x] != 0) {
x = ran.nextInt(defaultCnt);
}
if (p[i].isgo()) {
p[i].set_card(x);
card[x] = 1;
message = ("第 " + (i + 1) + " 家要牌得到：");
System.out.print(message);
message = (p[i].show(j) + " 目前" + p[i].get_card_value() + "點");
System.out.println(message);
} else {
message = ("第 " + (i + 1) + " 家不要牌了");
System.out.println(message);
}
}
}
// 顯示最後結果
System.out.println("========================最後的結果====================");
for (i = 0; i < 4; i = i + 1) {
// 取得真正的牌數
num = p[i].card_num();
message = ("第 " + (i + 1) + " 家的牌：");
System.out.print(message);
for (j = 0; j < num; j = j + 1) {
System.out.print(p[i].show(j) + " ");
}
if (p[i].get_card_value() > 21) {
message = ("積點是" + p[i].get_card_value() + "點!爆了！");
System.out.println(message);
} else {
if (num >= 5) {
System.out.print("喔！過五關囉！ ");
}
message = ("積點是" + p[i].get_card_value() + "點");
System.out.println(message);
}
}
}
}
class p21 extends player {
// 0:繼續收牌 1:停止發牌
private int status;
private int card_value;
public p21() {
// 清理牌計數
card_value = 0;
// 設定收牌
status = 0;
}
public p21(int cpt) {
super(cpt);
// 清理牌計數
card_value = 0;
// 設定收牌
status = 0;
}
// 決定要不要再要牌
public boolean isgo() {
if (status == 1) {
return false;
}
/*
* 以下改用發牌就算好的card_value
* 大於17點就不要牌了
* */
if (card_value < 17) {
return true;
}
return false;
}
// 傳回現在的牌數目
public int card_num() {
return card_cnt;
}
// 傳回現在的點數
public int get_card_value() {
return card_value;
}
// overriding palyer的method，順便計算點數
public void set_card(int x)
{
int i, flag;
int A, B;
if (x > defaultCnt || x < 0) {
System.out.println("錯誤 x=" + x);
return;
}
// flag用來看看有沒有發到牌
flag = 0;
A = 0;
for (i = 0; i < 13; i = i + 1) {
// 那個位置沒有牌，發牌順便算牌
if (card[i] == -1) {
card[i] = x;
flag = 1;
card_cnt = card_cnt + 1;
B = x / 4 + 2;
if (B > 10 && B < 14) {
// JKQ都算10
B = 10;
}
if (B == 14) {
// 算有幾張A
A = A + 1;
} else {
card_value = card_value + B;
}
break; // 發完牌即可跳出
}
}
card_value = card_value + A;// 先把A算1
// 把A算成11試試看
while (card_value < 21 && A > 0) {
card_value = card_value + 10;
// 如果不爆就算11
if (card_value <= 21) {
A = A - 1;
} else {
// 如果會爆就算回A
card_value = card_value - 10;
break;
}
}
if (flag == 0) {
System.out.println("錯誤!本家發超過13張牌" + x);
}
}
}
class player {
// 記錄手上的牌
protected int[] card = new int[13];
/*
* 設定final就不可以改
* 共用的對照表可以用static
* */
private final static String[][] cname = {
{ "梅花", "方塊", "紅心", "黑桃" },
{ "Club", "Diamond", "Hearts", "Spades" },
{ "花", "塊", "心", "桃" },
{ "C", "D", "H", "S" } };
// 記錄選定哪一組牌名
private int card_pt;
// 共用的物件技術器
private static int obj_cnt = 0;
protected int card_cnt;
// 一副牌52張，固定數值。
protected static final int defaultCnt = 52;
/**
* 建構子，首先把牌清乾淨
*/
public player() {
// 預設選用中文全名，呼叫player(0)
this(0);
}
public player(int cpt) {
int i;
// 可以設定選用不同牌名
card_pt = cpt;
// 預設選用中文全名
card_cnt = 0;
for (i = 0; i < 13; i = i + 1) {
this.card[i] = -1;
}
obj_cnt = obj_cnt + 1;// 登記多了一家
}
/**
* method 用來show出共有幾個物件
*/
public final static void show_cnt() {
String message = ("目前共有" + obj_cnt + "家");
System.out.println(message);
}
/**
* method 用來show出第幾張牌
*/
public String show(int id) {
int A, B;
if (card[id] == -1) {
return ("沒有這張牌");
} else {
A = card[id] % 4;
B = card[id] / 4;
B = B + 2;
switch (B) {
case 14:
return (cname[card_pt][A] + "A");
case 13:
return (cname[card_pt][A] + "K");
case 12:
return (cname[card_pt][A] + "Q");
case 11:
return (cname[card_pt][A] + "J");
default:
return (cname[card_pt][A] + B);
}
}
}
/**
* method 用來發牌給本玩家
*/
public void set_card(int id, int x) {
if (id < 13 && x < defaultCnt) {
card[id] = x;
card_cnt = card_cnt + 1;
} else {
String message = ("錯誤 id=" + id + " x=" + x);
System.out.println(message);
}
}
/**
* method 用來發牌給本玩家，
* 使用overload 來處理沒有設定第幾張的時機
*/
public void set_card(int x) {
int i, flag;
if (x > defaultCnt || x < 0) {
System.out.println("錯誤 x=" + x);
return;
}
// flag用來看看有沒有發到牌
flag = 0;
for (i = 0; i < 13; i = i + 1) {
// 那個位置沒有牌
if (card[i] == -1) {
card[i] = x;
flag = 1;
card_cnt = card_cnt + 1;
break; // 發完牌即可跳出
}
}
if (flag == 0) {
System.out.println("錯誤!本家發超過13張牌" + x);
}
}
}
package com.fout.bots.heirs.digest;
import java.util.*;
/**
* 繼承方式來擴充發牌運算，玩21 點
* 包含this()呼叫建構子方式，及protected的使用方法
* 抽象類別(abstract)來擴充發牌運算
*/
public class Example47 {
public static void main(String[] args)
{
final int defaultCnt = 52;
int num = 5;
int i, j, x;
String message = null;
// 用來記錄該位牌是否已被發出
int[] card = new int[defaultCnt];
Random ran = new Random();
player p[];
// 定義四家玩家,配置空間給陣列
p=new player[4];
p[0]=new p21a();
p[1]=new p21b();
p[2]=new p21a();
p[3]=new p21b();
player.show_cnt();
/* ---------- 起始值設定 ---------- */
for (i = 0; i < defaultCnt; i = i + 1) {
card[i] = 0;
}
/* ---------- 亂數產生發牌 ---------- */
// 最多發5張就可以過5關了
for (j = 0; j < num; j = j + 1) {
// 發下一家
for (i = 0; i < 4; i = i + 1) {
x = ran.nextInt(defaultCnt);
while (card[x] != 0) {
x = ran.nextInt(defaultCnt);
}
if (p[i].isgo()) {
p[i].set_card(x);
card[x] = 1;
message = ("第 " + (i + 1) + " 家要牌得到：");
System.out.print(message);
message = (p[i].show(j) + " 目前" + p[i].get_card_value() + "點");
System.out.println(message);
} else {
message = ("第 " + (i + 1) + " 家不要牌了");
System.out.println(message);
}
}
}
// 顯示最後結果
System.out.println("========================最後的結果====================");
for (i = 0; i < 4; i = i + 1) {
num = p[i].card_num();// 取得真正的牌數
message = ("第 " + (i + 1) + " 家的牌：");
System.out.print(message);
for (j = 0; j < num; j = j + 1) {
System.out.print(p[i].show(j) + " ");
}
if (p[i].get_card_value() > 21) {
message = ("積點是" + p[i].get_card_value() + "點!爆了！");
System.out.println(message);
} else {
if (num >= 5) {
System.out.print("喔！過五關囉！ ");
}
message = ("積點是" + p[i].get_card_value() + "點");
System.out.println(message);
}
}
}
}
class p21b extends player{
// 0:繼續收牌 1:停止發牌
private int status;
private int card_value;
public p21b() {
this(0);
}
public p21b(int cpt) {
int i;
// 可以設定選用不同牌名
card_pt = cpt;
// 預設選用中文全名
card_cnt = 0;
for (i = 0; i < 13; i = i + 1) {
this.card[i] = -1;
}
// 登記多了一家
obj_cnt = obj_cnt + 1;
// 清理牌計數
card_value = 0;
// 設定收牌
status = 0;
}
// 決定要不要再要牌
public boolean isgo() {
if (status == 1)
return false;
//
/*
* 以下改用發牌就算好的card_value
* 大於18點才不要牌了
* */
if (card_value < 18) {
return true;
}
return false;
}
// 傳回現在的點數
public int get_card_value() {
return card_value;
}
// overriding palyer的method，順便計算點數
public void set_card(int x) {
int i, flag;
int A, B;
if (x > defaultCnt || x < 0) {
System.out.println("錯誤 x=" + x);
return;
}
// flag用來看看有沒有發到牌
flag = 0;
A = 0;
for (i = 0; i < 13; i = i + 1) {
// 那個位置沒有牌，發牌順便算牌
if (card[i] == -1) {
card[i] = x;
flag = 1;
card_cnt = card_cnt + 1;
B = x / 4 + 2;
if (B > 10 && B < 14) {
B = 10;// JKQ都算10
}
if (B == 14) {
A = A + 1;// 算有幾張A
} else {
card_value = card_value + B;
}
break; // 發完牌就可以跳出去了
}
}
// 先把A算1
card_value = card_value + A;
// 把A算成11試試看
while (card_value < 21 && A > 0) {
card_value = card_value + 10;
// 如果不爆就算11
if (card_value <= 21) {
A = A - 1;
} else {
// 如果會爆就算回A
card_value = card_value - 10;
break;
}
}
if (flag == 0) {
System.out.println("錯誤!本家發超過13張牌" + x);
}
}
}
class p21a extends player{
// 0:繼續收牌 1:停止發牌
private int status;
private int card_value;
public p21a() {
this(0);
}
public p21a(int cpt) {
int i;
// 可以設定選用不同牌名
card_pt = cpt;
// 預設選用中文全名
card_cnt = 0;
for (i = 0; i < 13; i = i + 1) {
this.card[i] = -1;
}
// 登記多了一家
obj_cnt = obj_cnt + 1;
// 清理牌計數
card_value = 0;
// 設定收牌
status = 0;
}
// 決定要不要再要牌
public boolean isgo() {
if (status == 1)
return false;
/*
* 以下改用發牌就算好的card_value
* 大於17點就不要牌了
* */
if (card_value < 17)
return true;
return false;
}
// 傳回現在的點數
public int get_card_value() {
return card_value;
}
// overriding palyer的method，順便計算點數
public void set_card(int x) {
int i, flag;
int A, B;
if (x > defaultCnt || x < 0) {
System.out.println("錯誤 x=" + x);
return;
}
// flag用來看看有沒有發到牌
flag = 0;
A = 0;
for (i = 0; i < 13; i = i + 1) {
if (card[i] == -1) // 那個位置沒有牌，發牌順便算牌
{
card[i] = x;
flag = 1;
card_cnt = card_cnt + 1;
B = x / 4 + 2;
if (B > 10 && B < 14) {
B = 10;// JKQ都算10
}
if (B == 14) {
A = A + 1;// 算有幾張A
} else {
card_value = card_value + B;
}
break; // 發完牌就可以跳出去了
}
}
// 先把A算1
card_value = card_value + A;
// 把A算成11試試看
while (card_value < 21 && A > 0) {
card_value = card_value + 10;
// 如果不爆就算11
if (card_value <= 21) {
A = A - 1;
} else {
// 如果會爆就算回A
card_value = card_value - 10;
break;
}
}
if (flag == 0) {
System.out.println("錯誤!本家發超過13張牌" + x);
}
}
}
abstract class player{
//記錄手上的牌
protected int[] card=new int[13];
/*
* 設定final就不可以改
* 共用的對照表可以用static
* */
protected final static String[][] cname={
{"梅花","方塊","紅心","黑桃"},
{"Club","Diamond","Hearts","Spades"},
{"花","塊","心","桃"},
{"C","D","H","S"}};
//共用的物件技術器
protected static int obj_cnt = 0;
//記錄選定哪一組牌名
protected int card_pt;
protected int card_cnt;
// 一副牌52張，固定數值。
protected static final int defaultCnt = 52;
/**
* method 用來show出共有幾個物件
* 設定為final
*/
public final static void show_cnt() {
String message = ("目前共有" + obj_cnt + "家");
System.out.println(message);
}
/**
* method 用來show出第幾張牌
*/
public String show(int id) {
int A,B;
if (card[id]==-1) {
return ("沒有這張牌");
} else {
A=card[id]%4;
B=card[id]/4;
B=B+2;
switch (B) {
case 14:
return (cname[card_pt][A] + "A");
case 13:
return (cname[card_pt][A] + "K");
case 12:
return (cname[card_pt][A] + "Q");
case 11:
return (cname[card_pt][A] + "J");
default:
return (cname[card_pt][A] + B);
}
}
}
//傳回現在的牌數目
public int card_num() {
return card_cnt;
}
/**
* 發牌的方法設定為abstract
* */
abstract public void set_card(int x);
/**
* 要不要再發牌的方法設定為 abstract
* */
abstract public boolean isgo();
abstract public int get_card_value();
}
package com.fout.bots.heirs.port;
import java.util.*;
/**
* 繼承方式來擴充發牌運算，玩21 點
* 包含this()呼叫建構子方式，及protected的使用方法
* 介面(interface)型態來擴充發牌運算
*/
public class Example48 {
public static void main(String[] args) {
final int defaultCnt = 52;
int num = 5;
int i, j, x;
String message = null;
// 用來記錄該位牌是否已被發出
int[] card = new int[defaultCnt];
Random ran = new Random();
player p[];
// 定義四家玩家,配置空間給陣列
p = new player[4];
p[0] = new p21a();
p[1] = new p21b();
p[2] = new p21a();
p[3] = new p21b();
/* ---------- 起始值設定 ---------- */
for (i = 0; i < defaultCnt; i = i + 1) {
card[i] = 0;
}
/* ---------- 亂數產生發牌 ---------- */
// 最多發5張就可以過5關了
for (j = 0; j < num; j = j + 1) {
// 發下一家
for (i = 0; i < 4; i = i + 1) {
x = ran.nextInt(defaultCnt);
while (card[x] != 0)
x = ran.nextInt(defaultCnt);
if (p[i].isgo()) {
p[i].set_card(x);
card[x] = 1;
message = ("第 " + (i + 1) + " 家要牌得到：");
System.out.print(message);
message = (p[i].show(j) + " 目前" + p[i].get_card_value() + "點");
System.out.println(message);
} else {
message = ("第 " + (i + 1) + " 家不要牌了");
System.out.println(message);
}
}
}
// 顯示最後結果
System.out.println("========================最後的結果====================");
for (i = 0; i < 4; i = i + 1) {
// 取得真正的牌數
num = p[i].card_num();
System.out.print("第 " + (i + 1) + " 家的牌：");
for (j = 0; j < num; j = j + 1) {
System.out.print(p[i].show(j) + " ");
}
if (p[i].get_card_value() > 21) {
message = ("積點是" + p[i].get_card_value() + "點!爆了！");
System.out.println(message);
} else {
if (num >= 5) {
System.out.print("喔！過五關囉！ ");
}
message = ("積點是" + p[i].get_card_value() + "點");
System.out.println(message);
}
}
}
}
class p21b implements player {
// 記錄手上的牌
private int[] card = new int[13];
// 記錄選定哪一組牌名
private int card_pt = 0;
private int card_value;
private int card_cnt = 0;
// 0:繼續收牌 1:停止發牌
private int status;
public p21b() {
this(0);
}
public p21b(int cpt) {
int i;
// 可以設定選用不同牌名
card_pt = cpt;
// 預設選用中文全名
card_cnt = 0;
for (i = 0; i < 13; i = i + 1) {
this.card[i] = -2;// -2代表空牌
}
// 清理牌計數
card_value = 0;
// 設定收牌
status = 0;
}
public String show(int id) {
int A, B;
if (card[id] == -2) {
return ("沒有這張牌");
} else {
A = card[id] % 4;
B = card[id] / 4;
B = B + 2;
switch (B) {
case 14:
return (cname[card_pt][A] + "A");
case 13:
return (cname[card_pt][A] + "K");
case 12:
return (cname[card_pt][A] + "Q");
case 11:
return (cname[card_pt][A] + "J");
default:
return (cname[card_pt][A] + B);
}
}
}
// 傳回現在的牌數目
public int card_num() {
return card_cnt;
}
// 決定要不要再要牌
public boolean isgo() {
if (status == 1)
return false;
/*
* 以下改用發牌就算好的card_value
* 大於18點才不要牌
*/
if (card_value < 18)
return true;
return false;
}
// 傳回現在的點數
public int get_card_value() {
return card_value;
}
// overriding palyer的method，順便計算點數
public void set_card(int x) {
int i, flag;
int A, B;
if (x > defaultCnt || x < 0) {
System.out.println("錯誤 x=" + x);
return;
}
// flag用來看看有沒有發到牌
flag = 0;
A = 0;
for (i = 0; i < 13; i = i + 1) {
// 那個位置沒有牌，發牌順便算牌
if (card[i] == -2) {
card[i] = x;
flag = 1;
card_cnt = card_cnt + 1;
B = x / 4 + 2;
if (B > 10 && B < 14) {
B = 10;// JKQ都算10
}
if (B == 14) {
A = A + 1;// 算有幾張A
} else {
card_value = card_value + B;
}
break; // 發完牌就可以跳出去了
}
}
// 先把A算1
card_value = card_value + A;
// 把A算成11試試看
while (card_value < 21 && A > 0)
{
card_value = card_value + 10;
if (card_value <= 21) {
// 如果不爆就算11
A = A - 1;
} else {
// 如果會爆就算回A
card_value = card_value - 10;
break;
}
}
if (flag == 0) {
System.out.println("錯誤!本家發超過13張牌" + x);
}
}
}
class p21a implements player {
// 記錄手上的牌
private int[] card = new int[13];
// 記錄選定哪一組牌名
private int card_pt = 0;
private int card_value;
private int card_cnt = 0;
// 0:繼續收牌 1:停止發牌
private int status;
public p21a() {
this(0);
}
public p21a(int cpt) {
int i;
card_pt = cpt;// 可以設定選用不同牌名
card_cnt = 0;// 預設選用中文全名
for (i = 0; i < 13; i = i + 1) {
this.card[i] = -1;
}
// 清理牌計數
card_value = 0;
// 設定收牌
status = 0;
}
public String show(int id) {
int A, B;
if (card[id] == -1) {
return ("沒有這張牌，搞什麼？！");
} else {
A = card[id] % 4;
B = card[id] / 4;
B = B + 2;
switch (B) {
case 14:
return ("拿到" + cname[card_pt][A] + "A，爽！");
case 13:
return (cname[card_pt][A] + "K");
case 12:
return (cname[card_pt][A] + "Q");
case 11:
return (cname[card_pt][A] + "J");
default:
return (cname[card_pt][A] + B);
}
}
}
// 傳回現在的牌數目
public int card_num() {
return card_cnt;
}
// 決定要不要再要牌
public boolean isgo() {
if (status == 1)
return false;
/*
* 以下改用發牌就算好的card_value
* 大於17點就不要牌了
* */
if (card_value < 17) {
return true;
}
return false;
}
// 傳回現在的點數
public int get_card_value() {
return card_value;
}
// overriding palyer的method，順便計算點數
public void set_card(int x)
{
int i, flag;
int A, B;
if (x > defaultCnt || x < 0) {
System.out.println("錯誤 x=" + x);
return;
}
// flag用來看看有沒有發到牌
flag = 0;
A = 0;
for (i = 0; i < 13; i = i + 1) {
// 那個位置沒有牌，發牌順便算牌
if (card[i] == -1) {
card[i] = x;
flag = 1;
card_cnt = card_cnt + 1;
B = x / 4 + 2;
if (B > 10 && B < 14) {
B = 10;// JKQ都算10
}
if (B == 14) {
A = A + 1;// 算有幾張A
} else {
card_value = card_value + B;
}
break; // 發完牌就可以跳出去了
}
}
// 先把A算1
card_value = card_value + A;
// 把A算成11試試看
while (card_value < 21 && A > 0) {
card_value = card_value + 10;
if (card_value <= 21) {
// 如果不爆就算11
A = A - 1;
} else {
// 如果會爆就算回A
card_value = card_value - 10;
break;
}
}
if (flag == 0) {
System.out.println("錯誤!本家發超過13張牌" + x);
}
}
}
interface player {
// 一副牌52張，固定數值。
final static int defaultCnt = 52;
/*
* 共用的對照表可以用static
* 設定final就不可以改
* */
final static String[][] cname = {
{ "梅花", "方塊", "紅心", "黑桃" },
{ "Club", "Diamond", "Hearts", "Spades" },
{ "花", "塊", "心", "桃" },
{ "C", "D", "H", "S" } };
/**
* method 用來show出第幾張牌
* */
abstract public String show(int id);
abstract public int card_num();
/**
* 發牌的方法設定為abstract
* */
abstract public void set_card(int x);
/**
* 要不要再發牌的方法設定為 abstract
* */
abstract public boolean isgo();
abstract public int get_card_value();
}
package com.fout.bots.gui;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
/**
* Paint String 畫圖物件是JFrame 的擴充
*/
@SuppressWarnings("serial")
public class Example49 extends JFrame {
// 全域變數
Container c;
// 建構子
public Example49() {
// 視窗標題
super("Example49 : 測試畫圖");
c = getContentPane();
setSize(640, 480);
setVisible(true);
}
// 真正的畫圖設定
public void paint(Graphics g) {
g.setFont(new Font("Serif", Font.PLAIN, 20));
g.drawString("我在畫圖，你在看嗎？", 10, 100);
g.drawString("This is a test", 10, 200);
g.drawString("你羨慕嗎？", 300, 200);
}
public static void main(String[] args) {
// 畫圖類別
Example49 app = new Example49();
app.addWindowListener(new WindowAdapter() { // 匿名內部類別
public void windowClosing(WindowEvent e) {
System.exit(0);// 處理視窗關閉要求
}
});
}
}
package com.fout.bots.gui;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
/**
* JFrame來建構UI的基礎
*/
public class Example50 {
public static void main(String[] args) {
// 順便設定標題
JFrame frm = new JFrame("JFrame 是基礎！");
JLabel lab1 = new JLabel("測試UI介面");
Container c;
frm.setSize(400, 400); // 設定視窗大小
frm.setLocation(100, 100);// 設定視窗位置
// 取得JFrame的內容容器，元件都放這裡
c = frm.getContentPane();
c.add(lab1); // 加入UI元件
frm.setVisible(true);// 將frame 顯示出來
frm.addWindowListener(new WindowAdapter() { // 匿名內部類別
public void windowClosing(WindowEvent e) {
System.exit(0);// 處理視窗關閉要求
}
});
}
}
package com.fout.bots.gui;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
/**
* 繼承JFrame 來處理UI
*/
@SuppressWarnings("serial")
public class Example51 extends JFrame {
Container c;
JLabel lab1 = new JLabel("測試UI介面");
public Example51() {
super("用繼承的比較簡單啦！");
// 取得JFrame的內容容器，元件都放這裡
c = getContentPane();
// 設定視窗大小
setSize(200, 200);
// 設定視窗位置
setLocation(100, 100);
c.add(lab1); // 加入UI元件
setVisible(true);// 將frame 顯示出來
}
public static void main(String[] args) {
Example51 app = new Example51();
app.addWindowListener(new WindowAdapter() { // 匿名內部類別
public void windowClosing(WindowEvent e) {
System.exit(0);// 處理視窗關閉要求
}
});
}
}
package com.fout.bots.gui;
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
/**
* Paint COS function
*/
@SuppressWarnings("serial")
public class Example52 extends JFrame {
Container c;
public Example52() {
super("Mydraw:畫函式圖");
c = getContentPane();
setSize(640, 480);
setVisible(true);
}
// 真正的畫圖設定
public void paint(Graphics g) {
double y, x;
int DY, DX;
Color blue = Color.blue; // 設定紅色
g.setColor(blue);
g.drawLine(320, 0, 320, 479);
g.drawLine(0, 240, 639, 240);// 座標軸
g.drawString("函數圖形", 10, 100);
Color red = Color.red; // 設定紅色
g.setColor(red);
/* ---------- 算 y=x ---------- */
for (DX = 0; DX <= 639; DX = DX + 1) {
x = (double) (DX - 320) / 50.0;
y = Math.cos(x);
DY = (int) (y * 100.0 + 240);
DY = 479 - DY;
g.drawLine(DX, DY, DX, DY);
// System.out.println(DX+" "+DY+" "+x+" "+y);
}
}
public static void main(String[] args) {
Example52 app = new Example52();
app.addWindowListener(new WindowAdapter() { // 匿名內部類別
public void windowClosing(WindowEvent e) {
System.exit(0);// 處理視窗關閉要求
}
});
}
}
package com.fout.bots.troll;
import java.io.*;
/**
* 圓形面積計算，含例外處理
*/
public class Example53 {
@SuppressWarnings("resource")
public static void main(String[] args) {
String getbr;
int flag = 0;
String message;
double radius, area;
final double pi = 3.14159;
radius = 0;
Reader reader;
BufferedReader br = null;
InputStream is = System.in;
reader = new InputStreamReader(is);
br = new BufferedReader(reader);
while (flag == 0) {
message = ("請輸入圓形半徑（輸入0結束）：");
System.out.print(message);
try {
getbr = br.readLine();
radius = Double.parseDouble(getbr);
// 輸入0 則結束
if (radius == 0) break;
flag = 0;
} catch (NumberFormatException e) {
// 處理輸入文字
e.printStackTrace();
System.out.println("請輸入正確數字！");
flag = 0;
continue;// 此次非正確數字跳出程序
} catch (IOException e) {
// 處理鍵盤遇到錯誤
e.printStackTrace();
System.out.println("程式停止，謝謝使用！");
return; // 停止下來，不繼續以下程序
}
area = pi * radius * radius;
message = ("圓形面積等於：" + area);
System.out.println(message); // 顯示字串
}
// 釋放資源
if(br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
package com.fout.bots.troll;
import java.io.*;
/**
* 階乘計算，主動拋出例外
*/
public class Example54 {
@SuppressWarnings("resource")
public static void main(String[] args) {
int x;
String getbr;
String message;
fra fr = new fra(); // class來計算階乘
Reader reader;
BufferedReader br = null;
InputStream is = System.in;
reader = new InputStreamReader(is);
br = new BufferedReader(reader);
/*========== 請使用者輸入選項 ==========*/
x = 5;
while (x > 0) {
message = ("請輸入要計算階乘的數字(輸入0結束)：");
System.out.print(message);
try {
getbr = br.readLine();
x = Integer.parseInt(getbr);
// 輸入0 則結束
if (x == 0) {
System.out.println("謝謝！再見！");
break;
}
if (x < 0) {
// 主動拋出錯誤訊息類別
throw new ArithmeticException();
}
} catch (ArithmeticException e) {
System.out.println("請輸入正整數！");
x = 100; // 使while 繼續執行
continue;
} catch (NumberFormatException e) { // 處理輸入文字
System.out.println("請輸入數字！");
x = 100; // 使while 繼續執行
continue;
} catch (IOException e) {// 處理鍵盤遇到錯誤
System.out.println("程式停止，謝謝使用！");
return;
}
System.out.println(x + "!=" + fr.fraction(x));
}
// 釋放資源
if(br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
class fra {
int fraction(int y) {
int i, ans;
ans = 1;
for (i = 1; i <= y; i = i + 1) {
ans = ans * i;
}
return (ans);
}
}
package com.fout.bots.troll;
import java.io.*;
/**
* 階乘計算，自己定義例外類別
*/
public class Example55 {
@SuppressWarnings("resource")
public static void main(String[] args) {
int x;
String getbr;
String message;
// class來計算階乘
fra2 fr = new fra2();
Reader reader;
BufferedReader br = null;
InputStream is = System.in;
reader = new InputStreamReader(is);
br = new BufferedReader(reader);
/* ========== 請使用者輸入選項 ========== */
x = 5;
while (x > 0) {
message = ("請輸入要計算階乘的數字(輸入0結束)：");
System.out.print(message);
try {
getbr = br.readLine();
x = Integer.parseInt(getbr);
} catch (NumberFormatException e) { // 處理輸入文字
System.out.println("請輸入數字！");
x = 100; // 使while 繼續執行
continue;
} catch (IOException e) {// 處理鍵盤遇到錯誤
System.out.println("程式停止，謝謝使用！");
return;
}
if (x == 0) {
System.out.println("謝謝！再見！");
break;
}
try {
message = (x + "!=" + fr.fraction(x));
System.out.println(message);
} catch (FracError e) {
System.out.println("請輸入正整！");
x = 100; // 使while 繼續執行
continue;
}
}
}
}
//定義階乘錯誤的例外類別
@SuppressWarnings("serial")
class FracError extends Exception {
}
class fra2 {
int fraction(int y) throws FracError {
int i, ans;
if (y < 0) {
// 主動拋出自訂錯誤類別
throw new FracError();
}
ans = 1;
for (i = 1; i <= y; i = i + 1) {
ans = ans * i;
}
return (ans);
}
}
package com.fout.bots.troll;
import java.io.*;
/**
* 用FileInputStream 讀入一個bmp檔，將圖片轉180度，另外新檔案 t.bmp 300*300 bmp檔
*/
public class Example56 {
public static void main(String[] args) {
String getbr;
Reader reader;
BufferedReader br = null;
InputStream is = System.in;
reader = new InputStreamReader(is);
br = new BufferedReader(reader);
int i, j;
int x, y, k;
byte data[][][] = new byte[300][300][3];// 300*300*3 byte 放輸入圖形
byte ndata[][][] = new byte[300][300][3];// 300*300*3 byte 放轉過的圖形
byte header[] = new byte[54];// 54位元表頭
/* ========== 請使用者輸入選項 ========== */
System.out.print("請輸入來源bmp檔案名稱：");
FileInputStream fr = null;
FileOutputStream fw = null;
try {
getbr = br.readLine();// 取得input file
fr = new FileInputStream(getbr);// 讀取檔案
// 讀取54 byte表頭，由0開始，填入54byte
fr.read(header, 0, 54);
for (i = 0; i < 300; i = i + 1) {
for (j = 0; j < 300; j = j + 1) {
// 讀取每一點，每一點三個byte
fr.read(data[i][j], 0, 3);
}
}
fr.close();// 關閉檔案
/* ========== 圖檔轉180度 ========== */
for (x = 0; x < 300; x = x + 1) {
for (y = 0; y < 300; y = y + 1) {
for (k = 0; k < 3; k = k + 1) {
ndata[y][x][k] = data[299 - y][x][k];
}
}
}
/* ========== open input file ========== */
System.out.print("請輸入目標檔案名稱：");
getbr = br.readLine(); // 取得output file
/* ========== open output file ========== */
fw = new FileOutputStream(getbr);// 讀取檔案
// 寫入表頭，由0開始，寫出54byte
fw.write(header, 0, 54);
for (i = 0; i < 300; i = i + 1) {
for (j = 0; j < 300; j = j + 1) {
// 寫入每一點，每點3 byte
fw.write(ndata[i][j], 0, 3);
}
}
fw.close();// 關閉檔案
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
// 釋放資源
if(fw != null) {
try {
fw.close();
} catch (IOException e) {
}
}
if(fr != null) {
try {
fr.close();
} catch (IOException e) {
}
}
if(br != null) {
try {
br.close();
} catch (IOException e) {
}
}
}
}
}
package com.fout.bots.troll;
import java.io.*;
import java.util.*;
/**
* 用StringTokenizer 算成績
*/
public class Example57 {
public static void main(String[] args) {
String getbr, getfr;
String message;
Reader reader;
BufferedReader br = null;
InputStream is = System.in;
reader = new InputStreamReader(is);
br = new BufferedReader(reader);
int i, j;
double sum;
double total;
StringTokenizer stk;
String name[] = new String[200];
// 最多兩百個學生
double score[][] = new double[200][7];
BufferedReader fr = null;
try {
/* ========== 請使用者輸入選項 ========== */
System.out.print("請輸入檔案名稱：");
getbr = br.readLine();// 取得input file
/* ========== open file ========== */
fr = new BufferedReader(new FileReader(getbr));
i = 0;
sum = 0;
// 檔案未到檔尾，則繼續執行
while (fr.ready())
{
getfr = fr.readLine(); // 取得一行輸入
// System.out.println(getfr);
// 取得token
stk = new StringTokenizer(getfr, " \n\t");
try {
name[i] = stk.nextToken();
for (j = 0; j < 7; j = j + 1) {
score[i][j] = Double.parseDouble(stk.nextToken());
// System.out.print(score[i][j]+" ");
}
total = (score[i][0] * 2 + score[i][1]);
total += (score[i][2] + score[i][3] * 0.2);
total += (score[i][4] * 2 + score[i][5]);
total += (score[i][6] * 0.3);
i = i + 1;
} catch (NumberFormatException ex) { // 處理輸入文字
message = (getfr + " 這個成績格式有問題！");
System.out.println(message);
continue;
}
message = ("第 " + name[i - 1] + "號 " + total + " 分");
System.out.println(message);
sum = sum + total;
}
fr.close(); // close file
sum = sum / (double) i;
message = ("全班總平均： " + sum + " 分");
System.out.println(message);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
// 釋放資源
if(fr != null) {
try {
fr.close();
} catch (IOException e) {
}
}
if(br != null) {
try {
br.close();
} catch (IOException e) {
}
}
}
}
}
package com.fout.bots.troll;
import java.io.*;
/**
* 用RandomAccessFile 與readUnsignedByte() 處理圖形
*/
public class Example58 {
public static void main(String[] args) {
String getbr;
String message;
Reader reader;
BufferedReader br = null;
InputStream is = System.in;
reader = new InputStreamReader(is);
br = new BufferedReader(reader);
int i;
int r, g, b;
long cnt = 0;
int his[] = new int[256];
// 54位元表頭
byte header[] = new byte[54];
for (i = 0; i < 256; i = i + 1) {
his[i] = 0;
}
/* ========== 請使用者輸入選項 ========== */
RandomAccessFile fp = null;
try {
System.out.print("請輸入來源bmp檔案名稱：");
getbr = br.readLine();// 取得input file
fp = new RandomAccessFile(getbr, "r");
// 跳過表頭
fp.read(header, 0, 54);
try {
while (true) {
// 讀取三元色
r = fp.readUnsignedByte();
g = fp.readUnsignedByte();
b = fp.readUnsignedByte();
i = (r + g + b) / 3;
his[i] = his[i] + 1;
cnt = cnt + 1;
}
} catch (EOFException ex) {
}
// 檔案結尾
message = ("總共算了 " + cnt + " 點");
System.out.println(message);
for (i = 0; i < 256; i = i + 1) {
message = (i + "有 " + his[i] + " 圖素");
System.out.println(message);
}
fp.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
if(fp != null) {
try {
fp.close();
} catch (IOException e) {
}
}
}
}
}
package com.fout.bots.kill;
/**
* Thread 示範
*/
public class Example59 {
public static void main(String[] args) {
myThread t1 = new myThread("第一號!");
myThread t2 = new myThread("第十號!");
t1.start();// 啟動執行緒
t2.start();// 啟動執行緒
}
}
// 繼承Thread 類別
class myThread extends Thread {
private String msg;
public myThread(String inp) {
msg = inp;
}
public myThread() {
this("Thread Test!");
}
// 執行緒執行處理端點
public void run() {
int i, j;
for (i = 0; i < 10; i++) {
for (j = 0; j < 1000000; j++)
;// 空跑的迴圈
System.out.println(msg + "回應!");
}
}
}
package com.fout.bots.kill;
public class Example60 {
public static void main(String[] args) {
myRunnable r1 = new myRunnable("第一號!");
myRunnable r2 = new myRunnable("第十號!");
// 用Thread 類別的執行緒
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();// 啟動執行緒
t2.start();// 啟動執行緒
}
}
//繼承Runnable 類別
class myRunnable implements Runnable {
private String msg;
public myRunnable(String inp) {
msg = inp;
}
public myRunnable() {
this("Thread Test!");
}
// 執行緒執行處理端點
public void run() {
int i, j;
for (i = 0; i < 10; i++) {
for (j = 0; j < 1000000; j++)
;// 空跑的迴圈
System.out.println(msg + "回答!");
}
}
}