Java基础-22总结登录注册IO版,数据操作流,内存操作流,打印流,标准输入输出流,

 cn.itcast.pojo User
 cn.itcast.dao UserDao
 cn.itcast.dao.impl UserDaoImpl(实现我不管)
 cn.itcast.game GuessNumber
 cn.itcast.test UserTest
package cn.itcast.pojo;(1)
/**
 * 这是用户基本描述类
 * 
 * @author 风清扬
 * @version V1.1
 * 
 */
public class User {
 // 用户名
 private String username;
 // 密码
 private String password;
 public User() {
 }
 public String getUsername() {
 return username;
 }
 public void setUsername(String username) {
 this.username = username;
 }
 public String getPassword() {
 return password;
 }
 public void setPassword(String password) {
 this.password = password;
 }
}
package cn.itcast.dao;(2)
import cn.itcast.pojo.User;
/**
 * 这是针对用户进行操作的接口
 * 
 * @author 风清扬
 * @version V1.1
 * 
 */
public interface UserDao {
 /**
  * 这是用户登录功能
  * 
  * @param username
  *            用户名
  * @param password
  *            密码
  * @return 返回登录是否成功
  */
 public abstract boolean isLogin(String username, String password);
 /**
  * 这是用户注册功能
  * 
  * @param user
  *            要注册的用户信息
  */
 public abstract void regist(User user);
}
package cn.itcast.dao.impl;(3)
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import cn.itcast.dao.UserDao;
import cn.itcast.pojo.User;
/**
 * 这是用户操作的具体实现类(IO版)
 * 
 * @author 风清扬
 * @version V1.1
 * 
 */
public class UserDaoImpl implements UserDao {
 // 为了保证文件一加载就创建
 private static File file = new File("user.txt");
 static {
 try {
 file.createNewFile();
 } catch (IOException e) {
 System.out.println("创建文件失败");
 // e.printStackTrace();
 }
 }
 @Override
 public boolean isLogin(String username, String password) {
 boolean flag = false;
 BufferedReader br = null;
 try {
 // br = new BufferedReader(new FileReader("user.txt"));
 br = new BufferedReader(new FileReader(file));
 String line = null;
 while ((line = br.readLine()) != null) {
 // 用户名=密码
 String[] datas = line.split("=");
 if (datas[0].equals(username) && datas[1].equals(password)) {
 flag = true;
 break;
 }
 }
 } catch (FileNotFoundException e) {
 System.out.println("用户登录找不到信息所在的文件");
 // e.printStackTrace();
 } catch (IOException e) {
 System.out.println("用户登录失败");
 // e.printStackTrace();
 } finally {
 if (br != null) {
 try {
 br.close();
 } catch (IOException e) {
 System.out.println("用户登录释放资源失败");
 // e.printStackTrace();
 }
 }
 }
 return flag;
 }
 @Override
 public void regist(User user) {
 /*
  * 为了让注册的数据能够有一定的规则，我就自己定义了一个规则： 用户名=密码
  */
 BufferedWriter bw = null;
 try {
 // bw = new BufferedWriter(new FileWriter("user.txt"));
 // bw = new BufferedWriter(new FileWriter(file));
 // 为了保证数据是追加写入，必须加true
 bw = new BufferedWriter(new FileWriter(file, true));
 bw.write(user.getUsername() + "=" + user.getPassword());
 bw.newLine();
 bw.flush();
 } catch (IOException e) {
 System.out.println("用户注册失败");
 // e.printStackTrace();
 } finally {
 if (bw != null) {
 try {
 bw.close();
 } catch (IOException e) {
 System.out.println("用户注册释放资源失败");
 // e.printStackTrace();
 }
 }
 }
 }
}
package cn.itcast.game;(4)
import java.util.Scanner;
/**
 * 这是猜数字小游戏
 * 
 * @author 风清扬
 * @version V1.1
 * 
 */
public class GuessNumber {
 private GuessNumber() {
 }
 public static void start() {
 // 产生一个随机数
 int number = (int) (Math.random() * 100) + 1;
 // 定义一个统计变量
 int count = 0;
 while (true) {
 // 键盘录入一个数据
 Scanner sc = new Scanner(System.in);
 System.out.println("请输入数据(1-100)：");
 int guessNumber = sc.nextInt();
 count++;
 // 判断
 if (guessNumber > number) {
 System.out.println("你猜的数据" + guessNumber + "大了");
 } else if (guessNumber < number) {
 System.out.println("你猜的数据" + guessNumber + "小了");
 } else {
 System.out.println("恭喜你，" + count + "次就猜中了");
 break;
 }
 }
 }
}
package cn.itcast.test;(5)
import java.util.Scanner;
import cn.itcast.dao.UserDao;
import cn.itcast.dao.impl.UserDaoImpl;
import cn.itcast.game.GuessNumber;
import cn.itcast.pojo.User;
/**
 * 用户测试类
 * 
 * @author 风清扬
 * @version V1.1
 * 
 */
public class UserTest {
 public static void main(String[] args) {
 // 为了能够回来
 while (true) {
 // 欢迎界面，给出选择项
 System.out.println("--------------欢迎光临--------------");
 System.out.println("1 登录");
 System.out.println("2 注册");
 System.out.println("3 退出");
 System.out.println("请输入你的选择:");
 // 键盘录入选择，根据选择做不同的操作
 Scanner sc = new Scanner(System.in);
 // 为了后面的录入信息的方便，我所有的数据录入全部用字符接收
 String choiceString = sc.nextLine();
 // switch语句的多个地方要使用，我就定义到外面
 UserDao ud = new UserDaoImpl();
 // 经过简单的思考，我选择了switch
 switch (choiceString) {
 case "1":
 // 登录界面，请输入用户名和密码
 System.out.println("--------------登录界面--------------");
 System.out.println("请输入用户名：");
 String username = sc.nextLine();
 System.out.println("请输入密码：");
 String password = sc.nextLine();
 // 调用登录功能
 // UserDao ud = new UserDaomImpl();
 boolean flag = ud.isLogin(username, password);
 if (flag) {
 System.out.println("登录成功,可以开始玩游戏了");
 System.out.println("你玩吗?y/n");
 while (true) {
 String resultString = sc.nextLine();
 if (resultString.equalsIgnoreCase("y")) {
 // 玩游戏
 GuessNumber.start();
 System.out.println("你还玩吗?y/n");
 } else {
 break;
 }
 }
 System.out.println("谢谢使用，欢迎下次再来");
 System.exit(0);
 // break; //这里写break，结束的是switch
 } else {
 System.out.println("用户名或者密码有误,登录失败");
 }
 break;
 case "2":
 // 欢迎界面，请输入用户名和密码
 System.out.println("--------------注册界面--------------");
 System.out.println("请输入用户名：");
 String newUsername = sc.nextLine();
 System.out.println("请输入密码：");
 String newPassword = sc.nextLine();
 // 把用户名和密码封装到一个对象中
 User user = new User();
 user.setUsername(newUsername);
 user.setPassword(newPassword);
 // 调用注册功能
 // 多态
 // UserDao ud = new UserDaoImpl();
 // 具体类使用
 // UserDaoImpl udi = new UserDaoImpl();
 ud.regist(user);
 System.out.println("注册成功");
 break;
 case "3":
 default:
 System.out.println("谢谢使用，欢迎下次再来");
 System.exit(0);
 break;
 }
 }
 }
}

package cn.itcast_01;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/*
 * 可以读写基本数据类型的数据
 * 数据输入流：DataInputStream
 *  DataInputStream(InputStream in)
 * 数据输出流：DataOutputStream
 *  DataOutputStream(OutputStream out) 
 */
public class DataStreamDemo {
 public static void main(String[] args) throws IOException {
 // 写
 // write();
 // 读
 read();
 }
 private static void read() throws IOException {
 // DataInputStream(InputStream in)
 // 创建数据输入流对象
 DataInputStream dis = new DataInputStream(
 new FileInputStream("dos.txt"));
 // 读数据
 byte b = dis.readByte();
 short s = dis.readShort();
 int i = dis.readInt();
 long l = dis.readLong();
 float f = dis.readFloat();
 double d = dis.readDouble();
 char c = dis.readChar();
 boolean bb = dis.readBoolean();
 // 释放资源
 dis.close();
 System.out.println(b);
 System.out.println(s);
 System.out.println(i);
 System.out.println(l);
 System.out.println(f);
 System.out.println(d);
 System.out.println(c);
 System.out.println(bb);
 }
 private static void write() throws IOException {
 // DataOutputStream(OutputStream out)
 // 创建数据输出流对象
 DataOutputStream dos = new DataOutputStream(new FileOutputStream(
 "dos.txt"));
 // 写数据了
 dos.writeByte(10);
 dos.writeShort(100);
 dos.writeInt(1000);
 dos.writeLong(10000);
 dos.writeFloat(12.34F);
 dos.writeDouble(12.56);
 dos.writeChar('a');
 dos.writeBoolean(true);
 // 释放资源
 dos.close();
 }
}

package cn.itcast_02;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
/*
 * 内存操作流：用于处理临时存储信息的，程序结束，数据就从内存中消失。
 * 字节数组：
 *  ByteArrayInputStream
 *  ByteArrayOutputStream
 * 字符数组：
 *  CharArrayReader
 *  CharArrayWriter
 * 字符串：
 *  StringReader
 *  StringWriter
 */
public class ByteArrayStreamDemo {
 public static void main(String[] args) throws IOException {
 // 写数据
 // ByteArrayOutputStream()
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 // 写数据
 for (int x = 0; x < 10; x++) {
 baos.write(("hello" + x).getBytes());
 }
 // 释放资源
 // 通过查看源码我们知道这里什么都没做，所以根本需要close()
 // baos.close();
 // public byte[] toByteArray()
 byte[] bys = baos.toByteArray();
 // 读数据
 // ByteArrayInputStream(byte[] buf)
 ByteArrayInputStream bais = new ByteArrayInputStream(bys);
 int by = 0;
 while ((by = bais.read()) != -1) {
 System.out.print((char) by);
 }
 // bais.close();
 }
}

 package cn.itcast_03;
import java.io.IOException;
import java.io.PrintWriter;
/*
 * 打印流
 * 字节流打印流 PrintStream
 * 字符打印流 PrintWriter
 * 
 * 打印流的特点：
 *  A:只有写数据的，没有读取数据。只能操作目的地，不能操作数据源。
 *  B:可以操作任意类型的数据。
 *  C:如果启动了自动刷新，能够自动刷新。
 *  D:该流是可以直接操作文本文件的。
 *  哪些流对象是可以直接操作文本文件的呢?
 *  FileInputStream
 *  FileOutputStream
 *  FileReader
 *  FileWriter
 *  PrintStream
 *  PrintWriter
 *  看API,查流对象的构造方法，如果同时有File类型和String类型的参数，一般来说就是可以直接操作文件的。
 * 
 *  流：
 *  基本流：就是能够直接读写文件的
 *  高级流：在基本流基础上提供了一些其他的功能
 */
public class PrintWriterDemo {
 public static void main(String[] args) throws IOException {
 // 作为Writer的子类使用
 PrintWriter pw = new PrintWriter("pw.txt");
 pw.write("hello");
 pw.write("world");
 pw.write("java");
 pw.close();
 }
}
package cn.itcast_03;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
 * 1:可以操作任意类型的数据。
 *  print()
 *  println()
 * 2:启动自动刷新
 *  PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
 *  还是应该调用println()的方法才可以
 *  这个时候不仅仅自动刷新了，还实现了数据的换行。
 * 
 *  println()
 * 其实等价于于：
 * bw.write();
 * bw.newLine(); 
 * bw.flush();
 */
public class PrintWriterDemo2 {
 public static void main(String[] args) throws IOException {
 // 创建打印流对象
 // PrintWriter pw = new PrintWriter("pw2.txt");
 PrintWriter pw = new PrintWriter(new FileWriter("pw2.txt"), true);
 // write()是搞不定的，怎么办呢?
 // 我们就应该看看它的新方法
 // pw.print(true);
 // pw.print(100);
 // pw.print("hello");
 pw.println("hello");
 pw.println(true);
 pw.println(100);
 pw.close();
 }
}

 BufferedReader br = new BufferedReader(new FileReader("a.txt"));
 PrintWriter pw = new PrintWriter(new FileWriter("b.txt"),true);
 String line = null;
 while((line=br.readLine())!=null) {
 pw.println(line);
 }
 pw.close();
 br.close();
package cn.itcast_03;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
/*
 * 需求：DataStreamDemo.java复制到Copy.java中
 * 数据源：
 *  DataStreamDemo.java -- 读取数据 -- FileReader -- BufferedReader
 * 目的地：
 *  Copy.java -- 写出数据 -- FileWriter -- BufferedWriter -- PrintWriter
 */
public class CopyFileDemo {
 public static void main(String[] args) throws IOException {
 // 以前的版本
 // 封装数据源
 // BufferedReader br = new BufferedReader(new FileReader(
 // "DataStreamDemo.java"));
 // // 封装目的地
 // BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java"));
 //
 // String line = null;
 // while ((line = br.readLine()) != null) {
 // bw.write(line);
 // bw.newLine();
 // bw.flush();
 // }
 //
 // bw.close();
 // br.close();
 // 打印流的改进版
 // 封装数据源
 BufferedReader br = new BufferedReader(new FileReader(
 "DataStreamDemo.java"));
 // 封装目的地
 PrintWriter pw = new PrintWriter(new FileWriter("Copy.java"), true);
 String line = null;
 while((line=br.readLine())!=null){
 pw.println(line);
 }
 pw.close();
 br.close();
 }
}

package cn.itcast_04;
import java.io.PrintStream;
/*
 * 标准输入输出流
 * System类中的两个成员变量：
 * public static final InputStream in “标准”输入流。
 *  public static final PrintStream out “标准”输出流。
 * 
 *  InputStream is = System.in;
 *  PrintStream ps = System.out;
 */
public class SystemOutDemo {
 public static void main(String[] args) {
 // 有这里的讲解我们就知道了，这个输出语句其本质是IO流操作，把数据输出到控制台。
 System.out.println("helloworld");
 // 获取标准输出流对象
 PrintStream ps = System.out;
 ps.println("helloworld");
 ps.println();
 // ps.print();//这个方法不存在
 // System.out.println();
 // System.out.print();
 }
}

 Scanner sc = new Scanner(System.in);
package cn.itcast_04;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/*
 * System.in 标准输入流。是从键盘获取数据的
 * 
 * 键盘录入数据：
 *  A:main方法的args接收参数。
 *  java HelloWorld hello world java
 *  B:Scanner(JDK5以后的)
 *  Scanner sc = new Scanner(System.in);
 *  String s = sc.nextLine();
 *  int x = sc.nextInt()
 *  C:通过字符缓冲流包装标准输入流实现
 *  BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 */
public class SystemInDemo {
 public static void main(String[] args) throws IOException {
 // //获取标准输入流
 // InputStream is = System.in;
 // //我要一次获取一行行不行呢?
 // //行。
 // //怎么实现呢?
 // //要想实现，首先你得知道一次读取一行数据的方法是哪个呢?
 // //readLine()
 // //而这个方法在哪个类中呢?
 // //BufferedReader
 // //所以，你这次应该创建BufferedReader的对象，但是底层还是的使用标准输入流
 // // BufferedReader br = new BufferedReader(is);
 // //按照我们的推想，现在应该可以了，但是却报错了
 // //原因是：字符缓冲流只能针对字符流操作，而你现在是字节流，所以不能是用?
 // //那么，我还就想使用了，请大家给我一个解决方案?
 // //把字节流转换为字符流，然后在通过字符缓冲流操作
 // InputStreamReader isr = new InputStreamReader(is);
 // BufferedReader br= new BufferedReader(isr);
 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 System.out.println("请输入一个字符串：");
 String line = br.readLine();
 System.out.println("你输入的字符串是：" + line);
 System.out.println("请输入一个整数：");
 // int i = Integer.parseInt(br.readLine());
 line = br.readLine();
 int i = Integer.parseInt(line);
 System.out.println("你输入的整数是：" + i);
 }
}