JavaIO编程案例
数字大小比较
题目:输入三个整数,求最大值和最小值
若想进行数字输入处理,应可以保证输入错误时可以重新输入,为了可以达到重用的设计,应该准备一个单独的输入数据类。
- 定义一个输入工具类
import java.util.Scanner;
public class InputUtil {
private InputUtil() {
}
/**
* 实现键盘接收数字
* @param promot 提示信息
* @return 可以使用的数字
*/
public static int getInt(String promot) {
int num = 0;
boolean flag = true;
while(flag){
Scanner Input = new Scanner(System.in);
System.out.println(promot);
if(Input.hasNext("\\d+")) {
flag = false;
num = Integer.parseInt(Input.next());
} else {
System.out.println("输入错误!");
}
}
return num;
}
}
- 定义接口
interface INumberService{
/**
* 输入数据并且返回数据最大/最小值
* @param count 输入数据个数
* @return 最大/最小值
*/
public int[] stat(int count);
}
- 接口实现子类
class NumberServiceImpl implements INumberService{
@Override
public int[] stat(int count) {
int result[] = new int[2]; //返回结果数组
int data[] = new int[count]; //存放输入数据
for(int x=0;x<data.length;x++) {
data[x] = InputUtil.getInt("请输入第"+ (x+1)+"个数字!");
}
result[0] = data[0]; //最大值
result[1] = data[0]; //最小值
for(int x=0; x<data.length;x++) {
if(data[x]>result[0]) {
result[0] = data[x];
}
if(data[x]< result[1]) {
result[1] = data[x];
}
}
return result;
}
}
- 定义工厂类获取接口对象
class Factory{
private Factory() {
}
public static INumberService getInstance() {
return new NumberServiceImpl();
}
}
- 编写测试程序
public static void main(String[] args) {
INumberService numberService = Factory.getInstance();
int result[] = numberService.stat(3);
System.out.println("max:"+ result[0] + " min:"+ result[1]);
}
文件保存
题目:从键盘输入文件的内容和要保存的文件名称,根据名称创建文件并保存内容
本程序中只要求开发者保存文件名称并没有设置文件路径,则应准备好文件路径。
- 定义文件服务接口
interface IFileService{
/**
* 定义文件保存处理方法
* @return 保存成功返回true
*/
public boolean save();
}
- 输入字符串处理方法类
public static String getString(String prompt) {
String str = null;
boolean flag = true;
while(flag) {
System.out.println(prompt);
try {
str = INPUT.readLine();
if(!"".equals(str)) {
flag = false;
} else {
System.out.println("输入不得为空!");
}
} catch (IOException e) {
// TODO: handle exception
e.printStackTrace();
System.out.println("输入不得为空!");
}
}
return str;
}
- 整体代码
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.PrintWriter;
import IO_Example.InputUtil; //见NumberComparable
@SuppressWarnings("unused")
interface IFileService{
public static final String SAVE_DIR = "C:"+File.separator+ "Project"+File.separator+"Java_study"+File.separator+"src"+File.separator+"文件";
/**
* 定义文件保存处理方法
* @return 保存成功返回true
*/
public boolean save();
}
class FileServiceImpl implements IFileService{
private String title;
private String content;
public FileServiceImpl() {
this.title = InputUtil.getString("请输入文件名称!");
this.content = InputUtil.getString("请输入文件内容!");
}
@Override
public boolean save(){
File file = new File(IFileService.SAVE_DIR + this.title);
PrintWriter out = null;
try {
out = new PrintWriter(new FileOutputStream(file));
out.print(this.content);
out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
return false;
} finally {
out.close();
}
return true;
}
}
class Factory_File{
public static IFileService getInstance() {
return new FileServiceImpl();
}
}
public class File_Save {
static {
//项目启动时该路径应首先创建
File file = new File(IFileService.SAVE_DIR);
if(!file.exists()) {
file.mkdirs();
}
}
public static void main(String[] args) {
IFileService fileService = Factory_File.getInstance();
System.out.println(fileService.save());
}
}
字符串逆序显示
题目:从键盘传入多个字符串到程序中,并将他们按逆序输出到屏幕上。
本程序之中考虑到如下几种设计:
- 既然字符串的内容可以随时修改,最好建立一个StringBuffer做保存;
- 在进行数据处理的时候应该由用户自己决定是否继续输入;
- 定义字符串操作接口
interface IStringService{
public void append(String str); //追加数据
public String[] reverse(); //翻转
}
- 实现子类里面使用StringBuffer
class StringServiceImple implements IStringService{
public StringBuffer data = new StringBuffer();
@Override
public void append(String str) {
this.data.append(str).append("|");
}
@Override
public String[] reverse() {
String result[] = this.data.toString().split("\\|");
int center = result.length/2;
int head = 0;
int tail = result.length - 1;
for(int x=0; x<center; x++) {
String temp = result[head];
result[head] = result[tail];
result[tail] = temp;
}
return result;
}
}
- 定义工厂类
class Factory_String{
private Factory_String() {
};
public static IStringService getInstance() {
return new StringServiceImple();
}
}
- 定义一个Menu处理类,采用交互式界面形式完成处理。
class Menu{
private IStringService stringService;
public Menu() {
this.stringService = Factory_String.getInstance();
this.choose();
}
public void choose() {
this.show();
String choose = InputUtil.getString("请进行选择");
switch (choose) {
case "1":{
//接收输入数据
String str = InputUtil.getString("请输入字符串数据");
this.stringService.append(str);
choose(); //重复出现
}
case "2":{
//String str = InputUtil.getString("请输入字符串数据");
String result[] = this.stringService.reverse();
System.out.println(Arrays.toString(result));
choose();
}
case "0":{
System.out.println("bye");
System.exit(1);
}
default :{
System.out.println("非法选项!");
choose();
}
}
}
public void show() {
System.out.println("[1]追加字符串数据");
System.out.println("[2]逆序显示所有字符串数据");
System.out.println("[0]结束程序执行");
System.out.println("\n\n");
}
}
- 编写测试
public static void main(String[] args) {
new Menu();
}
数据排序处理
题目:从键盘输入以下数据:TOM:89|JERRY:90|TONY:95,数据格式为:姓名:成绩,对输入内容按成绩排序(高-低)
对于排序处理肯定使用Comparable接口完成,同时利用Arrays类来完成处理,此时数据显示需要键盘输入。
- 建立Student程序类并且进行排序规则配置
class Student implements Comparable<Student>{
private String name;
private double score;
public Student(String name, double score) {
super();
this.name = name;
this.score = 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;
}
}
@Override
public String toString() {
return "Student [name=" + name + ", score=" + score + "]";
}
}
- 建立数据输入处理(牵扯到拆分操作)
interface IStudentService{
public Student[] getData();
}
class StudentServiceImpl implements IStudentService{
private String content;
private Student[] students;
public StudentServiceImpl(String content) {
this.content = content;
this.handle(); //进行数据处理
}
private void handle() {
//进行字符串数据处理
String result[] = this.content.split("\\|");
this.students = new Student[result.length];
for(int x=0; x< result.length; x++) {
String temp[] = result[x].split(":");
this.students[x] = new Student(temp[0] , Double.parseDouble(temp[1]));
}
}
@Override
public Student[] getData() {
Arrays.sort(this.students);
return this.students;
}
}
class Factory_Student{
private Factory_Student() {
};
public static IStudentService getInstance() {
return new StudentServiceImpl(InputUtil.getString("请输入数据信息。"));
}
}
- 编写测试类
public class Data_Comparable {
public static void main(String[] args) {
System.out.println(Arrays.toString(Factory_Student.getInstance().getData()));
}
}
数据排序处理深入(有问题)
题目:将上一题中内容进行扩展,将全部输入信息保存在文件中且还可以添加信息,并可以显示全部的数据
- 如果此时要进行内容的保存,首先一定要确认好所有输入数据的保存位置;
- 所有数据之间要想沿用之前的设计结构,则数据文件里面的保存应做到格式统一,即:姓名|成绩 的形式进行存储,而在数据添加时可添加两个数据:“单独的内容”,“一组数据”;
- 暂时不考虑数据过大的问题。
- 设置文件处理类,该类提供数据追加以及读取
class FileUtil{
public static String load(File file) {
Scanner scan = null;
try {
scan = new Scanner(file); //文件加载
if(scan.hasNext()) {
String str = scan.next(); //获取数据
return str;
}
return null;
} catch(Exception e) {
e.printStackTrace();
return null;
} finally {
if(scan != null) {
scan.close();
}
}
}
public static boolean append(File file,String content) {
PrintStream out = null;
try {
out = new PrintStream(new FileOutputStream(file, true));
out.print(content); //内容追加
return true;
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return false;
} finally {
if(out != null) {
out.close();
}
}
}
}
- 扩充IStudentService操作方法;
class StudentServiceImpl implements IStudentService{
private static final File SAVE_FILE = new File("C:\\Project\\Java_study\\src\\文件\\test_inner.txt");
private String content;
private Student[] students;
public StudentServiceImpl() {
this.content = FileUtil.load(SAVE_FILE); //读取已有数据内容
this.handle(); //进行数据处理
}
private void handle() {
//进行字符串数据处理
String result[] = this.content.split("\\|");
this.students = new Student[result.length];
for(int x=0; x<result.length; x++) {
String temp[] = result[x].split(":");
this.students[x] = new Student(temp[0] , Double.parseDouble(temp[1]));
}
}
@Override
public void append(String str) {
// TODO Auto-generated method stub
if(str.startsWith("|")) {
str.substring(1); //截取后面的部分
}
if(!str.endsWith("|")) {
str = str + "|"; //与后面数据进行分割
FileUtil.append(SAVE_FILE, str); //数据追加
}
}
@Override
public Student[] getData() {
Arrays.sort(this.students);
return this.students;
}
}
- 工厂类不再需要输入数据
public class Factory_Inner {
private Factory_Inner() {
}
public static IStudentService getInstance(){
return new StudentServiceImpl();
}
}
奇偶数统计
题目:编程程序运行后,根据提示输入一个数字字符串,统计奇偶数数量
本质流程就是每一个字符串的拆分,而后进行数字的转换处理。
- 定义INumberService_1接口,进行数字处理服务。
public interface INumberService_1 {
public int[] stat();
}
- 定义接口子类
public class INumberServiceImp implements INumberService_1 {
@Override
public int[] stat() {
int stat[] = new int[] {
0,0}; //第一个为偶数,第二个为基数
String str = InputUtil.getString("请输入数字信息!");
String result[] = str.split(""); //按照每个字符拆分
for(int x=0;x<result.length;x++) {
if(Integer.parseInt(result[x]) % 2 ==0 ) {
stat[0]++;
} else {
stat[1]++;
}
}
return stat;
}
}
- 建立工厂类
public class Factory_Inner {
private Factory_Inner() {
}
public static INumberService_1 getInstance(){
return new INumberServiceImp();
}
}
- 定义主类调用程序
import java.util.Arrays;
public class jiou {
public static void main(String[] args) {
System.out.println(Arrays.toString(Factory_Inner.getInstance().stat()));
}
}
用户登录
题目:完成登录程序,从命令行输入用户名和密码,如果没有输入用户名和密码,则提示输入用户名和密码;若仅输入了用户名提示用户输入密码。判断用户名为lyz,密码为hello,若正确提示成功,错误则显示登录失败,连续3次输入错误系统退出。
对于此事程序可以将用户名和密码同时输入,也可以先输入用户名后输入密码,超过此事则结束。用户名/密码的形式完成输入,若没有/表示没有输入密码。
- 定义用户操作接口
package IO_Example.User_log;
public interface IUserService {
public boolean isExit();
public boolean login(String name,String password);
}
- 定义操作接口子类
package IO_Example.User_log;
public class UserServiceImpl implements IUserService {
private int count = 0; //登录统计
@Override
public boolean isExit() {
return this.count >= 3; //执行登录退出的条件
}
@Override
public boolean login(String name, String password) {
return "lyz".equals(name) && "hello".equals(password);
}
}
- 对于登录失败检测处理应该单独定义一个用户代理操作类。
package IO_Example.User_log;
import IO_Example.*;
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.isExit()) {
//不进行退出
String inputData = InputUtil.getString("请输入登录信息");
if(inputData.contains("/")) {
String temp[] = inputData.split("/");
if(this.userService.login(temp[0], temp[1])) {
return true; //循环结束
} else {
System.out.println("登录失败,错误的用户名或密码!");
}
} else {
String pwd = InputUtil.getString("请输入密码");
if(this.userService.login(inputData, pwd)) {
return true;
} else {
System.out.println("登录失败,错误的用户名或密码!");
}
}
}
return false;
}
}
- 设计工厂类定义
package IO_Example.User_log;
public class Factory {
private Factory() {
};
public static IUserService getInstance() {
return new UserServiceProxy(new UserServiceImpl());
}
}
- 编写测试类
package IO_Example.User_log;
public class main {
public static void main(String[] args) {
System.out.println(Factory.getInstance().login(null, null));
}
}
*注:*真实业务只实现核心功能,辅助逻辑处理交给代理控制。
投票选举()
题目:**