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

原创 2016年07月31日 22:19:39

       到今天为止,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秒
胜者:兔子赢了!


LVS负载均衡集群服务搭建详解

一、LVS概述  1.LVS:Linux Virtual Server          四层交换(路由):根据请求报文的目标IP和目标PORT将其转发至后端主机集群中的某台服务器(根...

SVN各种错误提示产生原因及处理方法大全

SVN各种错误提示产生原因及处理方法大全 1.  svn: Server sent unexpected return value (500 Internal Server Error) in r...

Java 线程(龟兔赛跑游戏)

  • 2011年04月03日 08:27
  • 3KB
  • 下载

java程序设计中线程的方法回调(龟兔赛跑)

在线程中方法回调,就是在回调的地方实现interface接口下面案例(龟兔赛跑)mian方法类public class Test { public static void main(String...

JAVA多线程编程实现龟兔赛跑

Java的多线程建立在Thread类和Runnable接口上,可以通过继承Thread类和实现Runnable接口创建一个线程。 实现Runnable接口的类需要实例化run()方法。 实例化Th...
  • vas_sc
  • vas_sc
  • 2015年11月27日 18:46
  • 559

龟兔赛跑java实现

  • 2011年06月01日 14:45
  • 16KB
  • 下载

多线程实现——新龟兔赛跑

新龟兔赛跑: 规则:龟兔同时起步,每10毫秒秒跑1米,终点为100米,兔子跑步的能力强,乌龟跑步的能力弱 途中:1.兔子跑到10米的时候,谦让乌龟一下,接着跑 ...
  • Mus_Li
  • Mus_Li
  • 2017年04月23日 13:14
  • 577

线程休眠+内部类构建=龟兔赛跑

龟兔赛跑,线程休眠,内部类,鼠标事件,JButton,JPanel,JFrame
  • cjsxjm
  • cjsxjm
  • 2015年10月27日 21:25
  • 365

指针实现龟兔赛跑(随机数)

  • 2014年12月02日 23:12
  • 2KB
  • 下载
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:用面向对象实现支付功能、用线程实现龟兔赛跑、Java调用CMD运行adb命令并保存结果及归档
举报原因:
原因补充:

(最多只允许输入30个字)