用面向对象实现支付功能、用线程实现龟兔赛跑、Java调用CMD运行adb命令并保存结果及归档
到今天为止，Java的基础知识已经告一段落了，以下是老师为检验我们的学习成果所设计的几个题目（希望对读者有所帮助）：
用面向对象实现支付功能
支付接口：
package com.mashen.pay;
/**
* 支付接口
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public interface IPay {
//鉴权
boolean authorizaton(String payStyle);
//订单生成
boolean generateBill(String payStyle);
//确认支付
boolean pay(String psw);
//支付超时
String timeOut();
}
支付抽象类：
package com.mashen.pay;
/**
* 支付抽象类
*
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public abstract class PayImpt implements IPay {
// 鉴权
@Override
public boolean authorizaton(String payStyle) {
// TODO Auto-generated method stub
return false;
}
// 生成订单
@Override
public boolean generateBill(String payStyle) {
// TODO Auto-generated method stub
return false;
}
// 验证支付密码
@Override
public boolean pay(String psw) {
// TODO Auto-generated method stub
return false;
}
// 支付超时
@Override
public String timeOut() {
return "支付超时";
}
}
支付宝实现类：
package com.mashen.pay;
/**
* 支付宝实现类
*
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public class ZhifubaoPayImpt extends PayImpt {
// 支付方式
private String payStyle;
// private String psw;
public ZhifubaoPayImpt(String payStyle) {
// 构造器里面鉴权和生成订单
this.payStyle = payStyle;
// this.psw = psw;
authorizaton(payStyle);
generateBill(payStyle);
// pay(psw);
}
// 鉴权
@Override
public boolean authorizaton(String payStyle) {
System.out.println("跳转到" + payStyle + "支付页面,进行鉴权步骤...");
return false;
}
// 生成订单
@Override
public boolean generateBill(String payStyle) {
System.out.println("--" + payStyle + "--\n正在生成订单...");
return false;
}
// 验证支付密码
@Override
public boolean pay(String psw) {
if (psw.equals(new String("123"))) {
System.out.println("支付密码正确,正在处理...");
return true;
}
return false;
}
// 支付超时
@Override
public String timeOut() {
// TODO Auto-generated method stub
return super.timeOut();
}
}
微信实现类：
package com.mashen.pay;
/**
* 微信实现类
*
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public class WeixinPayImpt extends PayImpt {
// 支付方式
private String payStyle;
// private String psw;
public WeixinPayImpt(String payStyle) {
this.payStyle = payStyle;
// this.psw = psw;
authorizaton(payStyle);
generateBill(payStyle);
// pay(psw);
}
// 鉴权
@Override
public boolean authorizaton(String payStyle) {
System.out.println("跳转到" + payStyle + "支付页面,进行鉴权步骤...");
return false;
}
// 生成订单
@Override
public boolean generateBill(String payStyle) {
System.out.println("--" + payStyle + "支付--\n正在生成订单...");
return false;
}
// 验证支付密码
@Override
public boolean pay(String psw) {
if (psw.equals(new String("123"))) {
System.out.println("支付密码正确,正在处理...");
return true;
}
return false;
}
// 支付超时
@Override
public String timeOut() {
// TODO Auto-generated method stub
return super.timeOut();
}
}
银联实现类：
package com.mashen.pay;
/**
* 银联实现类
*
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public class YinlianPayImpt extends PayImpt {
// 支付方式
private String payStyle;
// private String psw;
public YinlianPayImpt(String payStyle) {
this.payStyle = payStyle;
// this.psw = psw;
authorizaton(payStyle);
generateBill(payStyle);
// pay(psw);
}
// 鉴权
@Override
public boolean authorizaton(String payStyle) {
System.out.println("跳转到" + payStyle + "支付页面,进行鉴权步骤...");
return false;
}
// 生成订单
@Override
public boolean generateBill(String payStyle) {
System.out.println("--" + payStyle + "--\n正在生成订单...");
return false;
}
// 验证支付密码
@Override
public boolean pay(String psw) {
if (psw.equals(new String("123"))) {
System.out.println("支付密码正确,正在处理...");
return true;
}
return false;
}
// 支付超时
@Override
public String timeOut() {
// TODO Auto-generated method stub
return super.timeOut();
}
}
支付工厂类：
package com.mashen.pay;
import java.util.Scanner;
/**
* 支付工厂类 用户选择支付方式（微信、支付宝、银联），并输入密码确认支付（只是一个大概的思路）
*
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public class PayFactory {
private PayFactory() {
}
public static void main(String[] args) {
long startTime = System.currentTimeMillis();
PayImpt payStyle = null;
System.out.println("请选择支付方式:" + "\n1:微信" + "\n2:支付宝" + "\n3:银联");
Scanner scanner = new Scanner(System.in);
// 选择支付方式
int payRequestCode = scanner.nextInt();
String psw = null;
payStyle = PayFactory.choosePay(payRequestCode);
if (payStyle != null) {
System.out.println("请输入支付密码,以确认是否支付?");
psw = scanner.next();
long endTime = System.currentTimeMillis();
// 输入密码超时（超过30s）
if ((endTime - startTime) > 30000) {
System.out.println("支付超时！");
return;
}
if (payStyle instanceof WeixinPayImpt) {
if (((WeixinPayImpt) payStyle).pay(psw)) {
System.out.println("支付成功！");
}
} else if (payStyle instanceof ZhifubaoPayImpt) {
if (((ZhifubaoPayImpt) payStyle).pay(psw)) {
System.out.println("支付成功！");
}
} else if (payStyle instanceof YinlianPayImpt) {
if (((YinlianPayImpt) payStyle).pay(psw)) {
System.out.println("支付成功！");
}
}
}
}
/**
* 选择支付方式，实例化对应的实现类
*
* @param requestCode
* @return PayImpt
*/
public static PayImpt choosePay(int requestCode) {
PayImpt payStyle = null;
switch (requestCode) {
case 1:
payStyle = new WeixinPayImpt("微信");
return payStyle;
case 2:
payStyle = new ZhifubaoPayImpt("支付宝");
return payStyle;
case 3:
payStyle = new YinlianPayImpt("银联");
return payStyle;
default:
break;
}
return null;
}
}
运行结果：
请选择支付方式:
1:微信
2:支付宝
3:银联
1
跳转到微信支付页面,进行鉴权步骤...
--微信支付--
正在生成订单...
请输入支付密码,以确认是否支付?
123
支付密码正确,正在处理...
支付成功！
用线程实现龟兔赛跑
package com.mashen.execadbcmd;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
/**
* 在java代码中运行cmd，运行adb命令，把得到的结果保存到指定路径下的log.txt文件（所得到的结果的文件）
* 如果此文件大于200K则将其归档到指定路径下的log20xx-xx-xx.txt文件（归档文件）
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public class ExecAdbCmd {
private ExecAdbCmd() {
}
public static void main(String[] args) {
try {
// adb命令："cmd /c adb devices"
// 附：用android命令管理avd
ExecAdbCmd.saveAndGenerateArchiveFile("cmd /c android list avd",
"D:\\", "log.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
public static void saveAndGenerateArchiveFile(String cmd, String disk,
String saveFileName) throws IOException {
//Runtime的exec方法执行命令
Runtime rt = Runtime.getRuntime();
Process process = rt.exec(cmd);
if (process != null) {
//保存所得到的结果的文件
File file = new File(disk + saveFileName);
//文件不存在则创建一个新的
if (!file.exists()) {
file.createNewFile();
}
//Process对象中获取输入流
BufferedReader br = new BufferedReader(new InputStreamReader(
process.getInputStream()));
FileWriter fw = new FileWriter(file);
//获取当前格式化时间，用于记录当前操作的时间和归档文件的命名
Calendar calendar = Calendar.getInstance();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
"yyyy-MM-dd HH:mm");
String suffix = simpleDateFormat.format(calendar.getTime());
System.out.println(simpleDateFormat.format(calendar.getTime()));
//写入当前操作的时间
fw.write("****" + suffix + "****\r\n");
// 生成归档文件
// 文件后缀的日期信息：xxxx-xx-xx
String suffixForArFile = suffix.substring(0, 10);
//归档文件
File archiveFile = new File(disk + "log" + suffixForArFile + ".txt");
//归档文件不存在则创建一个新的
if (!archiveFile.exists()) {
archiveFile.createNewFile();
}
FileWriter fwForAr = new FileWriter(archiveFile);
//写入当前操作的时间
fwForAr.write("****" + suffix + "****\r\n");
String result = null;
while ((result = br.readLine()) != null) {
//所保存的文件大于200K则写入归档文件
if ((double) file.length() / 1024 >= 200.0) {
fwForAr.write(result + "\r\n");
}
System.out.println(result);
fw.write(result + "\r\n");
}
fw.close();
fwForAr.close();
br.close();
// 待实现：归档
// rt.exec("cmd /k d:");
// rt.exec("cmd /k tar -cf ccc.tar log.txt");
// System.out.println("size:" + (double) file.length() / 1024 +
// "K");
}
// Runtime.getRuntime().exec("C:\\Program Files\\Internet Explorer\\IEXPLORE.EXE "
// + "www.163.com");
}
}
Java调用CMD运行adb命令并保存结果及归档
兔子线程：
package com.mashen.threadexam;
import org.omg.CORBA.TCKind;
/**
* 兔子线程： 兔子每次跳一步，一步的距离是100厘米， 每走100步，需要休息0.001秒
* 在本代码中计算兔子线程和本包中的乌龟线程的50000厘米赛跑的胜利条件是：谁用时最少
*
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public class Rabbit extends Thread {
//声明并在构造器中初始化TimeConsumed类，以保存兔子的耗时数
public static volatile TimeConsumed tc;
public Rabbit(TimeConsumed tc) {
this.tc = tc;
}
// 步数，每一百步重置为0
int count = 0;
// 100步休息0.001秒，计算跳到50000厘米时，休息了多少个0.001秒
int countForTakeARest = 0;
// 步数，用来计算总步数，不重置
int distance = 0;
// 总距离
int totalDistance = 0;
// 开始时间
long startTime = 0L;
// 结束时间
long endTime = 0L;
// 总耗时
static double timeConsumed = 0;
private volatile boolean flag = false;
@Override
public void run() {
startTime = System.currentTimeMillis();
System.out.println("现在时间" + startTime);
while (!flag) {
// 总距离=步数*100厘米
totalDistance = distance * 100;
// 每一百步重置count
if (count == 100) {
countForTakeARest++;
// System.out.println("休息了多少个0.001秒--1--" + countForTakeARest);
System.out.println("休息一下吧！");
count = 0;
System.out.println("跑了" + totalDistance + "厘米");
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("兔子每步跳100厘米");
// 当总距离等于50000厘米时，计算总用时
if (totalDistance == 50000) {
endTime = System.currentTimeMillis();
// System.out.println("结束时间：" + endTime);
// System.out.println("休息了多少个0.001秒--2--" + countForTakeARest);
timeConsumed = (double) (endTime - startTime) / 1000 + 0.001
* countForTakeARest;
// System.out.println("耗时q ：" + (double)(endTime - startTime) /
// 1000 + "秒");
System.out.println("兔子耗时 ：" + timeConsumed + "秒");
try {
if(tc.setTimeConsumed(timeConsumed)){//线程传回数据
Thread.sleep(2000);
flag = true;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
// 每次走一步（100厘米），步数加1
distance++;
// 步数每次加1
count++;
}
}
/**
* 得到当前动物名，用于TimeConsumed类的getWinner()方法的相关操作
* @return String
*/
public String getAnimalName() {
return "兔子";
}
// public TimeConsumed getTcObj(){
// if (tc != null) {
// return tc;
// }
// System.out.println("tc为空");
// return null;
// }
public static void main(String[] args) throws InterruptedException {
TimeConsumed tc = new TimeConsumed();
Rabbit rabbit = new Rabbit(tc);
rabbit.start();
rabbit.join();
System.out.println("main方法中，兔子耗时:"+rabbit.tc.getTimeConsumed() + "秒");
}
}
乌龟线程：
package com.mashen.threadexam;
/**
* 乌龟线程： 乌龟每次跑一步，一步的距离是1厘米，
* 在本代码中计算兔子线程和本包中的乌龟线程的50000厘米赛跑的胜利条件是：谁用时最少
*
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public class Tortoise extends Thread {
//步数，乌龟每次走一步
int count = 0;
//总距离（单位：里面）
int distance = 0;
//开始时间
long startTime = 0L;
//结束时间
long endTime = 0L;
//总耗时
static double timeConsumed = 0;
//flag，while循环执行的条件，true表示退出循环，默认是false
public volatile boolean flag = false;
//TimeConsumed类，保存耗时数
public static volatile TimeConsumed tc;
public Tortoise(TimeConsumed tc) {
this.tc = tc;
}
@Override
public void run() {
//得到开始时间
startTime = System.currentTimeMillis();
while (!flag) {
//步数加1
count++;
//当前总距离
distance = count * 1;
System.out.println("乌龟每步跑1mm");
if (distance == 50000) {
//结束时间
endTime = System.currentTimeMillis();
//得到总耗时，x.xxx格式（用到double）
timeConsumed = (double) (endTime - startTime) / 1000;
System.out.println("乌龟耗时 ：" + timeConsumed + "秒");
try {
if (tc.setTimeConsumed(timeConsumed)) {//线程传回数据
//睡眠1秒，让线程“缓一下”，以退出循环
Thread.sleep(1000);
flag = true;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
* 得到当前动物名，用于TimeConsumed类的getWinner()方法的相关操作
* @return String
*/
public String getAnimalName() {
return "乌龟";
}
// public TimeConsumed getTcObj() {
//
// if (tc != null) {
// return tc;
// }
// System.out.println("tc为空");
// return null;
// }
public static void main(String[] args) throws InterruptedException {
Tortoise tortoise = new Tortoise(new TimeConsumed());
tortoise.start();
tortoise.join();
System.out.println("乌龟耗时" + tortoise.tc.getTimeConsumed() + "秒");
}
}
耗时类：
package com.mashen.threadexam;
import java.util.HashMap;
import java.util.List;
/**
* 耗时类
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public class TimeConsumed {
private double timeConsumed;
public TimeConsumed() {
this.timeConsumed = timeConsumed;
}
public double getTimeConsumed() {
return timeConsumed;
}
/**
* 当timeConsumed > 0才将timeConsumed赋值给当前对象的timeConsumed属性
* @param timeConsumed
* @return boolean
*/
public boolean setTimeConsumed(double timeConsumed) {
if (timeConsumed > 0) {
this.timeConsumed = timeConsumed;
return true;
}
return false;
}
/**
* 比较兔子和乌龟的耗时数，以得到胜者
* @param hashMap
* @return
*/
public String getWinner(HashMap hashMap) {
double tc1 = -1, tc2 = -1;
for (Object obj : hashMap.keySet()) {
if (obj instanceof Rabbit) {
// System.out.println(((Rabbit)obj).getAnimalName());
tc1 = hashMap.get((Rabbit) obj);
} else if (obj instanceof Tortoise) {
// System.out.println(((Tortoise)obj).getAnimalName());
tc2 = hashMap.get((Tortoise) obj);
}
}
if (tc1 != -1 && tc2 != -1) {
if (tc1 < tc2) {
return "兔子赢了！";
} else if (tc1 > tc2) {
return "乌龟赢了！";
} else if (tc1 == tc2) {
return "兔子和乌龟并列第一名";
}
}
return null;
}
} 龟兔赛跑类：
package com.mashen.threadexam;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
* 龟兔赛跑
* 一个兔子线程（Rabbit）和一个乌龟线程（Tortoise）
* 全程50000厘米
* 兔子每次跳一步，每步100厘米，每跳100步，休息0.001秒
* 乌龟每次跑一步，每步1厘米
* 问谁是赢家？
* @author Administrator
* @date 2016/07/31
* @version 1.0
*/
public class TortoiseRaceWithRabbit {
public static void main(String[] args) throws InterruptedException {
//利用构造器Tortoise(TimeConsumed)在运行线程的同时计算乌龟的总耗时数
Tortoise tortoise = new Tortoise(new TimeConsumed());
//利用构造器Rabbit(TimeConsumed)在运行线程的同时计算兔子的总耗时数
Rabbit rabbit = new Rabbit(new TimeConsumed());
//记录乌龟和兔子各自的耗时数，传人TimeConsumed类的getWinner()方法比较以得到胜者
HashMap hashMapOfAnimalsAndTcs = new HashMap();
//rabbit线程向运行，利用join（）方法先让rabbit线程运行完毕，接着得到兔子的耗时（在这里必须调用join()）
rabbit.start();
rabbit.join();
//得到兔子的耗时数
double timeConsumedOfRabbit = rabbit.tc.getTimeConsumed();
//加入hashmap中
hashMapOfAnimalsAndTcs.put(rabbit, Double.valueOf(timeConsumedOfRabbit));
//tortoise线程接着运行，利用join方法让tortoise线程运行完毕，（在这里必须调用join()），接着执行主线程的其他步骤
tortoise.start();
tortoise.join();
double timeConsumedOfTortoise = tortoise.tc.getTimeConsumed();
hashMapOfAnimalsAndTcs.put(tortoise, Double.valueOf(timeConsumedOfTortoise));
System.out.println("兔子用了" + timeConsumedOfRabbit + "秒");
System.out.println("乌龟用了" + timeConsumedOfTortoise + "秒");
TimeConsumed tc = new TimeConsumed();
if(tc.getWinner(hashMapOfAnimalsAndTcs) != null){
System.out.println("胜者：" + tc.getWinner(hashMapOfAnimalsAndTcs));
}
}
}
运行结果：
乌龟每步跑1mm
乌龟每步跑1mm
乌龟每步跑1mm
乌龟每步跑1mm
...
乌龟每步跑1mm
乌龟每步跑1mm
乌龟每步跑1mm
乌龟每步跑1mm
乌龟耗时 ：0.415秒
兔子用了0.021秒
乌龟用了0.415秒
胜者：兔子赢了！