用面向对象实现支付功能、用线程实现龟兔赛跑、Java调用CMD运行adb命令并保存结果及归档

本文链接：https://blog.csdn.net/jscly/article/details/52081299

到今天为止，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 {
					<span style="color:#ff0000;">if(tc.setTimeConsumed(timeConsumed)){//线程传回数据
						Thread.sleep(2000);
						flag = true;
					}</span>
				} 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 {
					<span style="color:#ff0000;">if (tc.setTimeConsumed(timeConsumed)) {//线程传回数据
						//睡眠1秒，让线程“缓一下”，以退出循环
						Thread.sleep(1000);
						flag = true;
						
					}</span>
				} 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<Object, Double> 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<Object, Double> hashMapOfAnimalsAndTcs = new HashMap<Object, Double>();
		
		//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秒
胜者：兔子赢了！