1 数字大小比较
编写Java程序，输入3个整数，并求出3个整数的最大值和最小值。
如果要想进行数字输入的处理，那么应该保证输入错误的时候可以重新输入，为了可以达到的重用的设计，那么应该准备一个可以重用的输入类。
1、定义一个输入工具类
package org.lks.util;
import java.util.Scanner;
public class InputUtil {
private InputUtil() {}
private static final Scanner INPUT = new Scanner(System.in);
public static int getInt(String prompt) {
System.out.print(prompt);
boolean flag = true;
int num = 0;
while(flag) {
if(INPUT.hasNextInt()) {
num = INPUT.nextInt();
break;
}else {
INPUT.next(); //当输入错误的时候，需要接收错误的输入，否则这个输入会一直等待接收，就会一直循环，当然也可以使用BufferedReader类来接收输入。
System.out.println("输入有误！");
System.out.print(prompt);
}
}
return num;
}
}
2、定义数据的输入处理
package org.lks.service;
public interface INumberService {
int[] stat(int count);
}
3、定义接口的实现子类
package org.lks.service.impl;
import org.lks.service.INumberService;
import org.lks.util.InputUtil;
public class NumberServiceImpl implements INumberService {
@Override
public int[] stat(int count) {
int[] result = new int[2];
int[] data = new int[count];
for(int i = 0; i < count; i++) {
data[i] = InputUtil.getInt("please input the " + (i+1) + " Integer: ");
}
result[0] = data[0];
result[1] = data[0];
for(int i = 0; i < count; i++) {
if(data[i] > result[0]) {
result[0] = data[i];
}
if(data[i] < result[1]) {
result[1] = data[i];
}
}
return result;
}
}
4、定义工厂类获取接口对象
package org.lks.factory;
import org.lks.service.impl.NumberServiceImpl;
public class NumberServiceFactory {
private NumberServiceFactory() {}
public static NumberServiceImpl getNumberService() {
return new NumberServiceImpl();
}
}
5、编写测试程序类
package cn.victor.demo;
import org.lks.factory.NumberServiceFactory;
import org.lks.service.impl.NumberServiceImpl;
public class IOCaseDemo {
public static void main(String[] args) {
NumberServiceImpl sni = NumberServiceFactory.getNumberService();
int[] result = sni.stat(5);
System.out.println("max: " + result[0] + " min: " + result[1]);
}
}
2 文件保存
从键盘输入文件的内容和要保存的文件名称，然后根据输入的名称创建文件，并将内容保存到文件之中。
在本程序里面只要求开发者保存的是文件名称而并没有设置文件路径，那么对于文件的就应该在程序启动之前就准备好。
1、定义一个文件服务的接口
package org.lks.service;
import java.io.File;
public interface IFileSave {
public static final String SAVE_DIRECTORY = "D:" + File.separator + "hy" + File.separator;
boolean save();
}
2、在InputUtil追加字符串处理方法
public static String getString(String prompt) {
String str = null;
boolean flag = true;
while(flag) {
System.out.println(prompt);
if(INPUT.hasNext()) {
str = INPUT.nextLine().trim();
flag = false;
}else {
INPUT.next();
System.out.println("输入有误！");
}
}
return str;
}
3、定义接口的实现子类
package org.lks.service.impl;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import org.lks.service.IFileSave;
import org.lks.util.InputUtil;
public class FileSaveImpl implements IFileSave {
private String name;
private String content;
static {
File file = new File(SAVE_DIRECTORY);
if(!file.exists()) {
file.mkdirs();
}
}
public FileSaveImpl() {
this.name = InputUtil.getString("please input the file name: ");
this.content = InputUtil.getString("please the content: ");
}
@Override
public boolean save() {
File file = new File(SAVE_DIRECTORY + this.name);
PrintWriter output = null;
try {
output = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file)));
output.print(this.content);
return true;
} catch (IOException e) {
return false;
}finally {
if(output != null) {
output.close();
}
}
}
}
4、定义工厂类获取接口对象
package org.lks.factory;
import org.lks.service.impl.FileSaveImpl;
public class FileSaveFactory {
private FileSaveFactory() {}
public static FileSaveImpl getFileSave() {
return new FileSaveImpl();
}
}
5、编写测试程序类
package cn.victor.demo;
import org.lks.factory.FileSaveFactory;
public class IOCaseDemo {
public static void main(String[] args) {
boolean save = FileSaveFactory.getFileSave().save();
System.out.println(save);
}
}
3 字符串逆序显示
从键盘传入多个字符串到程序，并将它们按逆序输出在屏幕上。
本程序之中应该考虑到如下几种设计：
（1）既然字符串的内容可以随时修改，那么最好建立一个StringBuffer做保存；
（2）在进行数据处理的时候应该由用户自己来决定是否继续输入；
1、定义字符串操作标准
package org.lks.service;
public interface IStringService {
boolean append(String str);
String[] reverse();
}
2、实现子类里面就使用StringBuffer来操作
package org.lks.service.impl;
import org.lks.service.IStringService;
public class StringServiceImpl implements IStringService {
private StringBuffer sbf = new StringBuffer();
@Override
public boolean append(String str) {
this.sbf.append(str).append("|");
return true;
}
@Override
public String[] reverse() {
String[] results = this.sbf.toString().split("\\|");
int center = results.length / 2;
int head = 0;
int tail = results.length - 1;
for( int i = 0; i < center; i++) {
String temp = results[head];
results[head++] = results[tail];
results[tail--] = temp;
}
return results;
}
}
3、定义工厂类
package org.lks.factory;
import org.lks.service.impl.StringServiceImpl;
public class StringServiceFactory {
private StringServiceFactory() {}
public static StringServiceImpl getStringService() {
return new StringServiceImpl();
}
}
4、定义一个Menu处理类，采用交互式的界面形式完成处理。
package org.lks.menu;
import java.util.Arrays;
import org.lks.factory.StringServiceFactory;
import org.lks.service.IStringService;
import org.lks.util.InputUtil;
public class StringMenu {
private static IStringService iss = StringServiceFactory.getStringService();
public StringMenu() {
this.choose();
}
public void choose() {
this.show();
String str = InputUtil.getString("please input the command: ");
switch(str) {
case "1":{
String content = InputUtil.getString("please input the string: ");
StringMenu.iss.append(content);
this.choose();
}
case "2":{
System.out.println(Arrays.toString(StringMenu.iss.reverse()));
this.choose();
}
case "0":{
System.out.println("bye!");
System.exit(1);
}
default:{
System.out.println("Error!Please input again!");
this.choose();
}
}
}
public void show() {
System.out.println("[1] add string");
System.out.println("[2] reverse string");
System.out.println("[0] exit");
}
}
5、编写测试类
package cn.victor.demo;
import org.lks.menu.StringMenu;
public class IOCaseDemo {
public static void main(String[] args) {
new StringMenu();
}
}
4 数据排序处理
从键盘输入以下数据：“TOM:89|JERRY:90|TONY:95”，数据格式为“姓名:成绩|姓名:成绩|姓名:成绩，对输入的内容按成绩进行排序，并将排序结果按照成绩由高到低排序。
对于排序的处理肯定使用Comparable接口完成，同时利用Arrays类来处理，这里面唯一不同的地方就在于此时的数据要通过键盘输入。
1、建立Student的程序类，并且进行排序规则的配置。
package org.lks.model;
public class Student implements Comparable<Student>{
private String name;
private double score;
public Student() {}
public Student(String name, double score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "[Student]name: " + this.name + "; score: " + this.score;
}
@Override
public int compareTo(Student o) {
if(this.score > o.score) {
return -1;
}else if(this.score < o.score) {
return 1;
}else {
return 0;
}
}
}
2、建立数据的输入处理操作，因为牵扯到拆分问题
package org.lks.service;
public interface IStudentSservice {
String getData();
}
3、建立IStudentService的子类
package org.lks.service.impl;
import java.util.Arrays;
import org.lks.model.Student;
import org.lks.service.IStudentSservice;
public class StudentServiceImpl implements IStudentSservice {
private String contents;
private Student[] students;
public StudentServiceImpl() {}
public StudentServiceImpl(String contents) {
this.contents = contents;
String[] temp = contents.split("\\|");
this.students = new Student[temp.length];
for(int i = 0; i < temp.length; i++) {
String[] infos = temp[i].split(":");
this.students[i] = new Student(infos[0], Double.parseDouble(infos[1]));
}
}
public void sort() {
if(students != null) {
Arrays.sort(this.students);
}
}
@Override
public String getData() {
this.sort();
return Arrays.toString(this.students);
}
}
4、定义Factory工厂类
package org.lks.factory;
import org.lks.service.impl.StudentServiceImpl;
import org.lks.util.InputUtil;
public class StudentServiceFactory {
private StudentServiceFactory() {}
public static StudentServiceImpl getStudentService() {
return new StudentServiceImpl(InputUtil.getString("please input the info: "));
}
}
5、编写测试类
package cn.victor.demo;
import org.lks.factory.StudentServiceFactory;
import org.lks.menu.StringMenu;
public class IOCaseDemo {
public static void main(String[] args) {
System.out.println(StudentServiceFactory.getStudentService().getData());
}
}
5 数据排序处理深入
将上一题中的内容进行拓展，可以将全部输入的信息保存在文件中，还可以添加信息，并可以显示全部的数据。
如果此要进行内容的保存，那么首先一定要确认好所有输出数据的保存位置，所有的数据之间如果要想沿用之前的设计的结构，则数据文件里面的保存应该做到格式统一，即：“姓名:成绩|”进行存储，而在进行数据添加的时候可以添加两类数据：“单独的内容”、“一组内容”。还有一个前提：暂时不去考虑数据过大的问题。
1、设置一个文件的处理类，该类之中只是提供有数据的追加以及读取
package org.lks.util;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;
public class FileUtil {
private FileUtil() {}
public static String fileRead(File file) {
if(!file.exists()) {
return null;
}
String result = null;
Scanner scan = null;
StringBuffer sbf = new StringBuffer();
try {
scan = new Scanner(file);
while(scan.hasNext()) {
sbf.append(scan.next());
}
result = sbf.toString();
} catch (FileNotFoundException e) {
System.err.println("File Read Error!");
return null;
} finally {
if(scan != null) {
scan.close();
}
}
return result;
}
public static boolean fileAppend(File file, String content) {
boolean result = false;
if(!file.getParentFile().exists()) {
file.getParentFile().mkdirs();
}
PrintWriter printWriter = null;
try {
printWriter = new PrintWriter(new FileOutputStream(file, true));
printWriter.print(content);
result = true;
}catch(IOException e) {
System.err.println("File append error!");
return result;
}finally {
if(printWriter != null) {
printWriter.close();
}
}
return result;
}
}
2、扩充IStudentService的操作方法
package org.lks.service;
public interface IStudentService {
boolean studentAppend(String content);
String getData();
}
3、修改StudentServiceImpl中的功能
package org.lks.service.impl;
import java.io.File;
import java.util.Arrays;
import org.lks.model.Student;
import org.lks.service.IStudentService;
import org.lks.util.FileUtil;
public class StudentServiceImpl implements IStudentService {
private static final String SAVE_PATH = "D:" + File.separator + "hy" + File.separator + "info";
private Student[] students;
public StudentServiceImpl() {}
@Override
public boolean studentAppend(String content) {
if("".equals(content)) {
return false;
}
boolean result = false;
File file = new File(SAVE_PATH);
if(content.startsWith("|")) {
content = content.substring(1);
}
if(!content.endsWith("|")) {
content = content + "|";
}
FileUtil.fileAppend(file, content);
return result;
}
private void sort() {
if(students != null) {
Arrays.sort(this.students);
}
}
@Override
public String getData() {
File file = new File(SAVE_PATH);
String[] infos = FileUtil.fileRead(file).split("\\|");
if(infos != null) {
students = new Student[infos.length];
for(int i = 0; i < infos.length; i++) {
String[] info = infos[i].split(":");
students[i] = new Student(info[0], Double.parseDouble(info[1]));
}
}else {
return null;
}
this.sort();
return Arrays.toString(this.students);
}
}
4、此时工厂类
package org.lks.factory;
import org.lks.service.impl.StudentServiceImpl;
import org.lks.util.InputUtil;
public class StudentServiceFactory {
private StudentServiceFactory() {}
public static StudentServiceImpl getStudentService() {
return new StudentServiceImpl();
}
}
5、定义一个菜单处理
package org.lks.menu;
import org.lks.factory.StudentServiceFactory;
import org.lks.service.IStudentService;
import org.lks.util.InputUtil;
public class StudentServiceMenu {
private IStudentService iss;
public StudentServiceMenu() {
this.iss = StudentServiceFactory.getStudentService();
this.choose();
}
public void choose() {
this.show();
String str = InputUtil.getString("please input the command: ");
switch(str) {
case "1":{
String info = InputUtil.getString("please input the student info");
this.iss.studentAppend(info);
this.choose();
}
case "2":{
System.out.println(this.iss.getData());
this.choose();
}
case "0":{
System.out.println("bye!");
System.exit(1);
}
default:{
System.out.println("input syntax error!");
this.choose();
}
}
}
public void show() {
System.out.println("[1] append student data");
System.out.println("[2] display student data");
System.out.println("[3] exit");
}
}
6、编写测试类
package cn.victor.demo;
import org.lks.menu.StudentServiceMenu;
public class IOCaseDemo {
public static void main(String[] args) {
new StudentServiceMenu();
}
}
6 奇偶数统计
编写程序，当程序运行后，根据屏幕提示输入一个数字字符串，输入后统计有多少个偶数数字和奇数数字。
本质的流程就是进行每一个字符串的拆分，而后进行数字的转换处理。
1、定义INumberService的接口，进行数字处理服务
package org.lks.service;
public interface INumberService {
int[] stat(int count); //最大值和最小值
int[] statb(String num); //奇偶数个数统计
}
2、定义NumberServiceImpl接口子类
@Override
public int[] statb(String num) {
if("".equals(num)) {
return null;
}
if(!num.matches("\\d+")) {
return null;
}
int[] result = new int[] {0, 0};
String[] nums = num.split("");
for(int i = 0; i < nums.length; i++) {
if(Integer.parseInt(nums[i]) % 2 == 0) {
result[1] ++;
}else {
result[0] ++;
}
}
return result;
}
3、建立工厂类
package org.lks.factory;
import org.lks.service.impl.NumberServiceImpl;
public class NumberServiceFactory {
private NumberServiceFactory() {}
public static NumberServiceImpl getNumberService() {
return new NumberServiceImpl();
}
}
4、定义主类调用程序
package cn.victor.demo;
import java.util.Arrays;
import org.lks.factory.NumberServiceFactory;
import org.lks.util.InputUtil;
public class IOCaseDemo {
public static void main(String[] args) {
System.out.println(Arrays.toString(NumberServiceFactory.getNumberService().statb(InputUtil.getString("please input integer stream: "))));
}
}
7 用户登录
完成系统登录程序，从命令行输入用户名和密码，如果没有输入用户名和密码，则提示输入用户名和密码；如果输入了用户名但是没有输入密码，则提示用户输入密码，然后判断用户名是否是lks，密码是否是19990821，如果正确，则提示登录成功；如果错误，显示登录失败的信息，用户再次输入用户名和密码，连续3次输入错误后系统退出。
对于此时的程序发现可以将用户名和密码同时输入，也可以先输入用户名，而后输入密码，如果超过了3次，就表示登录结束，对于用户名和密码的使用可以采用“用户名/密码”的形式完成，如果发现没有“/”表示没有输入密码。
1、定义用户的操作接口
package org.lks.service;
public interface IUserService {
boolean isExit();
boolean login(String name, String password);
}
2、定义操作接口的子类
package org.lks.service.impl;
import org.lks.service.IUserService;
public class UserServiceImpl implements IUserService {
private static int count;
public UserServiceImpl() {
UserServiceImpl.count = 0;
}
@Override
public boolean isExit() {
return UserServiceImpl.count >= 3;
}
@Override
public boolean login(String name, String password) {
this.count ++;
if("lks".equals(name) && "19990821".equals(password)) {
return true;
}else {
return false;
}
}
}
3、对于登陆失败的检测处理操作，应该单独定义一个用户的代理操作类
package org.lks.service.proxy;
import org.lks.service.IUserService;
import org.lks.util.InputUtil;
public class UserServiceProxy implements IUserService {
private IUserService userService;
public UserServiceProxy(IUserService userService) {
this.userService = userService;
}
@Override
public boolean isExit() {
return this.userService.isExit();
}
@Override
public boolean login(String name, String password) {
while(!this.userService.isExit()) {
String str = InputUtil.getString("please input your username and password that is divide by '/': ");
if(str.contains("/")) {
String[] temp = str.split("/");
boolean login = this.userService.login(temp[0], temp[1]);
if(login) {
System.out.println("success!");
return true;
}else {
System.out.println("username or password is wrong, please input again!");
}
}else {
String strA = InputUtil.getString("please input your password: ");
boolean login = this.userService.login(str, strA);
if(login) {
System.out.println("success!");
return true;
}else {
System.out.println("username or password is wrong, please input again!");
}
}
}
if(this.userService.isExit()) {
System.out.println("输入错误次数超过三次，程序自动终止!");
}
return false;
}
}
4、定义工厂类
package org.lks.factory;
import org.lks.service.IUserService;
import org.lks.service.impl.UserServiceImpl;
import org.lks.service.proxy.UserServiceProxy;
public class UserServiceFactory {
private UserServiceFactory() {}
public static IUserService getUserService() {
return new UserServiceProxy(new UserServiceImpl());
}
}
5、定义测试处理
package cn.victor.demo;
import org.lks.factory.UserServiceFactory;
public class IOCaseDemo {
public static void main(String[] args) {
UserServiceFactory.getUserService().login(null, null);
}
}
真实业务只实现核心功能，辅助逻辑处理交给代理控制。
8 投票选举
1、功能描述
有一个版采用民主投票方法推选班长，班长候选人共四位，每个人姓名及代号分别为“张三 1;李四 2;王五 3;赵六 4”。程序操作员将每张选票上所填写的代号（1、2、3或4）循环输入电脑，输入数字0结束输入，然后将所有候选人的得票情况显示出来，并显示最终当选者得信息。
2、具体要求
（1）要求用面向对象方法，编写学生类Student，将候选人姓名、代号和票数保存到类Student中，并实现相应的getXXX方法和setXXX方法。
（2）输入数据前，显示出各位候选人得代号及姓名（提示，建立一个候选人类型数组）。
（3）循环执行接收键盘输入的班长候选人代号，直到输入的数字为0，结束选票的输入工作。
（4）在接收每次输入的选票后要求验证该选票是否有效，即如果输入的数不是0、1、2、3、4这5个数字之一，或者输入的是一串字母，应显示出错误提示信息“此选票无效，请输入正确的候选人代号！”，并继续等待输入。
（5）输入结束后显示所有候选人的得票情况，如参考样例所示。
（6）输入最终当选者得相关信息，如参考样例所示。
3、参考样例
编程实现
1、建立学生类，这个类里面需要保存有编号、姓名、票数。
package org.lks.model;
public class Student implements Comparable<Student>{
private long sid;
private String name;
private int vote;
private double score;
public Student() {}
public Student(long sid, String name, int vote) {
this.sid = sid;
this.name = name;
this.vote = vote;
}
public Student(String name, double score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "Student [sid=" + sid + ", name=" + name + ", vote=" + vote + "]\n";
}
@Override
public int compareTo(Student o) {
return o.vote - this.vote;
}
public long getSid() {
return sid;
}
public void setSid(long sid) {
this.sid = sid;
}
public int getVote() {
return vote;
}
public void setVote(int vote) {
this.vote = vote;
}
}
2、定义投票处理得业务接口
package org.lks.service;
public interface IVoteService {
boolean vote(long sid);
String getData();
String getResult();
}
3、定义VoteServiceImpl子类
package org.lks.service.impl;
import java.util.Arrays;
import org.lks.model.Student;
import org.lks.service.IVoteService;
public class VoteServiceImpl implements IVoteService {
private Student[] students = new Student[] {
new Student(1L, "张三", 0), new Student(2L, "李四", 0),
new Student(3L, "王五", 0), new Student(4L, "赵六", 0)
};
@Override
public boolean vote(long sid) {
for(int i = 0; i < students.length; i++) {
if(this.students[i].getSid() == sid) {
this.students[i].setVote(this.students[i].getVote() + 1);
return true;
}
}
return false;
}
@Override
public String getData() {
return Arrays.toString(this.students);
}
@Override
public String getResult() {
Arrays.sort(this.students);
return this.getData();
}
}
4、定义工厂类
package org.lks.factory;
import org.lks.service.IVoteService;
import org.lks.service.impl.VoteServiceImpl;
public class VoteServiceFactory {
private VoteServiceFactory() {}
public static IVoteService getVoteService() {
return new VoteServiceImpl();
}
}
5、定义一个菜单的信息显示类
package org.lks.menu;
import org.lks.factory.VoteServiceFactory;
import org.lks.service.IVoteService;
import org.lks.util.InputUtil;
public class VoteMenu {
private IVoteService iss;
public VoteMenu() {
this.iss = VoteServiceFactory.getVoteService();
this.vote();
}
public void vote() {
System.out.println(iss.getData());
while(true) {
int code = InputUtil.getInt("please input the sid(1,2,3,4) to vote or 0 to close input: ");
if(code != 0) {
if(this.iss.vote(code)) {
System.out.println("success!");
}else {
System.out.println("fail!");
}
}else {
break;
}
}
System.out.println("the result: ");
System.out.println(iss.getResult());
}
}
6、定义测试类
package cn.victor.demo;
import org.lks.menu.VoteMenu;
public class IOCaseDemo {
public static void main(String[] args) {
new VoteMenu();
}
}
