任务1阶段总结

程序代码：
FileOperation类：

package com.school1.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.io.Writer;


public class FileOperation {
		int a;
		File file;
		
		public String ReadIt() {
			Reader reader = null;
			char[]flush = new char[1024];
			int len = -1;
			String file1= null;
			try {
				reader = new FileReader(file);
				
				while((len=reader.read(flush))!=-1) {
					 file1 = new String(flush,0,len);
					System.out.println("目前文件中包含以下内容"+file1);
					return file1;
				}
			} catch (IOException e) {
				e.printStackTrace();
			}finally {
				if(null!=reader) {
					try {
						reader.close();
						
					} catch (IOException e) {
						e.printStackTrace();
						
				}
				}
				}
			return file1;
				}

		public FileOperation() throws IOException {
			super();
		this.file = new  File("user.db");
			
			//System.out.println(file.exists());
			file.createNewFile();
			
			//System.out.println(file.exists());
		}
	public  String getMSg() {
		BufferedReader buf= new BufferedReader(new InputStreamReader(System.in));
	        String str = null;
	        //从控制台获取字符串
			try {
				str = buf.readLine();
				//获取字符串
			} catch (IOException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}
		return str;
	}	
	public boolean writeMsg(String msg1) {
		 boolean judge = true;
		 Writer writer = null;
			try {
				writer = new FileWriter(this.file,true);
				//第二个参数加上true就表示在文件结尾追加
				writer.append(msg1);
				writer.flush();
				
			} catch (IOException e) {
				// TODO 自动生成的 catch 块
				e.printStackTrace();
			}finally {
				if(null!=writer) {
					try {
						writer.close();
						judge = false;
						return judge;
					} catch (IOException e) {
						// TODO 自动生成的 catch 块
						e.printStackTrace();
					}
					}
				}
				return judge;
			}
			
		 

		public void deletefile(){
			this.file.delete();
		}
		
		
	/*	public static void main(String[] args) throws IOException {
			FileOperation File1 = new FileOperation();
			String string = File1.getMSg();
			File1.writeMsg(string);
			
			}*/
}

Test类

package com.school1.test;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.IOException;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTextField;

	

public class Test {
	
	
	public static void doingFileOperation( FileOperation file) {
	
			JFrame jf = new JFrame("输入程序");
			jf.setSize(900,900);
			jf.setLocationRelativeTo(null);//设置大小后才居中，居中改位置会偏移
			jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
			JPanel panel = new JPanel();//默认流式布局
			JLabel lbl01 = new JLabel();
			lbl01.setForeground(Color.white);//一般习惯lbl开头，按钮btn开头
			lbl01.setFont(new Font("楷体",Font.PLAIN,20));
			lbl01.setBounds(200,200,100,35);
			JLabel lbl02 = new JLabel();
			lbl02.setIcon(new ImageIcon("image/1.jpg"));
			lbl02.setBounds(200,600,600,200);
			JLabel lbl03 = new JLabel();
			lbl03.setForeground(Color.white);//一般习惯lbl开头，按钮btn开头
			lbl03.setFont(new Font("楷体",Font.PLAIN,20));
			lbl03.setBounds(300,400,100,35);
			
			
			
			JLabel lbl = new JLabel("输入框");
			lbl.setFont(new Font ("楷体",Font.PLAIN,30));
			lbl.setForeground(Color.white);
			
			
			final JTextField txt = new JTextField();
			lbl01.setText("文件已存在");
			txt.setPreferredSize(new Dimension(100,35));
			txt.setFont(new Font ("楷体",Font.PLAIN,15));
			
			
			JButton btn = new JButton("完成");
			JButton btn2 = new JButton("删除文件");
			
			ActionListener listener = new ActionListener() {
				@Override
				public void actionPerformed(ActionEvent e) {
					Object obj = e.getSource();
					if(obj==btn2) {
					file.deletefile();
					}else if(obj==btn) {
						file.writeMsg(txt.getText());
						lbl01.setText("向文件中继续输入内容");
						lbl03.setText("文件中的内容有:"+file.ReadIt());
					}
				}
			};
	
			btn.addActionListener(listener);
			btn2.addActionListener(listener);
			
			
			
			
			
			
			
			
			
			
			
			
		
			//将所有控件添加在面板上
			panel.add(lbl);
			panel.add(txt);
			panel.add(btn);
			panel.add(btn2);
			panel.add(lbl01);
			panel.add(lbl02);
			panel.add(lbl03);
			jf.setVisible(true);
			jf.setContentPane(panel);
			jf.getContentPane().setBackground(Color.black);
		
			return;
		}
	
		

	public static void main(String[] args) {
		FileOperation File1 = null;
		try {
			File1 = new FileOperation();
		} catch (IOException e) {
			e.printStackTrace();
		}
	doingFileOperation(File1);
	
	}
	
	
	

	
	
	
	
	
}

窗口，背景以及输入操作效果

相关知识点的总结与复习：
对程序进行输出的方式：

1. 在控制栏输出
   system.out.println()//自动换行操作
   system.out.print()//无换行操作
   同时，在jdk1.5后收录了类似c语言的预设型控制输出
   system.out.printf("%d",a);//以int格式输出变量a的内容
2. 在窗口界面下输出
   （ JLabel） label.setText可以设置文本（swing ui）

对程序进行输入的方式：

1. 对程序进行输入的方式
   Scanner类
   首先，导入java.util.包。
   import java.util.;
   然后，你需要新建一个读取标准输入（键盘）的扫描器对象。
   Scanner in = new Scanner(System.in);
   现在，你可以从键盘输入字符串了。
   String s = in.nextLine();
   以上这一行把键盘输入的一行字符串读取到变量 s 中。
   请看一个完整的简单示例：
   import java.util.*;
   public class Main
   {
   public static void main(String[] args)
   {
   Scanner in = new Scanner(System.in);
   String s = in.nextLine();
   System.out.println(s);

IO流文件操作：

处理文件的核心知识点

IO流

流，一端移动到另一端，流是一个抽象、动态的概念，是一连串连续动态的数据集合（IO，in&out）

数据流从数据源与程序间传输，以程序为中心，进为输入流，出为输出流
核心类

类	说明
File	文件类
InputStream	字节输入流
OutputStream	字节输出流
Reader	字符输入流
Writer	字符输出流
Closeable	关闭流接口
Flushable	刷新流接口
Serializable	序列化接口

三个接口在前四个输入输出流中都有实现，分别是为了关闭流，刷新流清除缓存，序列化？？？

import java.io.Serializable;

public class Admin implements Serializable { }
百度上是这么讲的：

Serializable接口是启用其序列化功能的接口。实现java.io.Serializable
接口的类是可序列化的。没有实现此接口的类将不能使它们的任意状态被序列化或逆序列化。

这个介绍非常的不接地气，于是我与去看了几篇博客，有一个小姐姐的博客引起了我的注意，她是这样理解的：

序列化的过程，就是一个“freeze”的过程，它将一个对象freeze（冷冻）住，然后进行存储，等到再次需要的时候，再将这个对象de-freeze就可以立即使用。

我们以为的没有进行序列化，其实是在声明的各个不同变量的时候，由具体的数据类型帮助我们实现了序列化操作。

如果有人打开过Serializable接口的源码，就会发现，这个接口其实是个空接口，那么这个序列化操作，到底是由谁去实现了呢？其实，看一下接口的注释说明就知道，当我们让实体类实现Serializable接口时，其实是在告诉JVM此类可被序列化，可被默认的序列化机制序列化。

为什么需要序列化 1，存储对象在存储介质中，以便在下次使用的时候，可以很快捷的重建一个副本。也就是When the resulting
series of bits is reread according to the serialization format, it can
be used to create a semantically identical clone of the original
object.

问题：我没有实现序列化的时候，我一样可以存入到我的sqlserver或者MySQL、Oracle数据库中啊，为什么一定要序列化才能存储呢？？？？

2，便于数据传输，尤其是在远程调用的时候！

其实说了这么多，想表达的意思就是：

Serializable接口是一个里面什么都没有的接口 它的源代码是public interface
Serializable{}，即什么都没有。

如果一个接口里面什么内容都没有，那么这个接口是一个标识接口，比如，一个学生遇到一个问题，排错排了几天也没解决，此时，她举手了（示意我去帮他解决），然后我过去，帮他解决了，那么这个举手其实就是一个标识，自己不能解决的问题标示我去帮他解决，在Java中的这个Serializable接口是给JVM看的，告诉JVM，我不做这个类的序列化了，你(JVM)给我序列化，序列化就是变成二进制流，比如云计算、Hadoop，特别是Hadoop完全就是分布式环境，那么就要涉及到对象要在网络中传输，里面的全是二进制流，当然你来做这个序列化操作也可以，但是这个类里面可能还有一个类，如果你把外面的类对象Person变成二进制，那么里面也要序列化（这要用到深度遍历，很麻烦），干脆告诉JVM，让他来帮你做。

serializable接口就是Java提供用来进行高效率的异地共享实例对象的机制，实现这个接口即可。

有关序列化的解释之后再做补全

每个流都有着对应的输入输出功能和附加功能，主要还是为了输出输入服务的
在设计程序中出现的问题

关于异常处理的问题
用try catch捕获时finally中的流close（）方法没必要嵌套，
当已经出现异常就没必要再去调用一次close了

关于设计问题
递归方法不能被静态调用，但很多时候都没必要使用，可以用循环，解析型的问题要化简可以用，多次操作则用循环比较好，实际使用还是要看情况

关于窗口界面添加图片更改背景色无效的问题：
对于一个顶层容器，直接将其修改为不可见或需要的颜色是错误的，以
JFrame为例，打开窗口看到的白色默认背景实际上是由它创建的容器
getContentPane()来显示效果的，故我们可将这个容器修改颜色：
jf.getContentPane().setBackground(Color.red);

关于转码的问题：在使用字节流操作汉字的时候可能会用到转码，为了正确的显示出效果，否则可能会出现乱码情况

关于路径：

相对路径和绝对路径
1）存在盘符：绝对路径
2）不存在盘符：相对路径，以工程为出发点
src = new File（“user.db”）；
相对路径的搜索与创建都在工程文件下

程序形成主要思想过程：

1.设计的文件操作方法主要在FileOperation上
2.Test负责调用，调用的方式是创建FileOperation的对象
3.要求中的限制：文件名和路径、文件末添加的输入方法、每次写入信息（满足多次输入）、在需要结束程序的时候有结束的表示并且调用delete（）删除
4.初次实现：使用文本输入流输出流，对于结束的表示在所有的输入后再添加一次提示结束的输入，输入指定的end结束，再输入delete删除，问题：多次循环操作输出都需要额外的输出过于繁琐，结束方式不够简便
5.添加swing ui相关的容器：使用JLabel组件进行文字表示和背景增添，增加文本输入框，新建JButton组件，添加监听事件来完成按钮效果，最终效果是按钮1获得了点击将文本输入框中的文字写入文件，按钮2直接调用delete删除文件，将不好操作的结束输出改为了窗口的自带关闭键，通过
jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);调整关闭键的行为为点击关闭键关闭程序，达到结束输出的目的