工程一：记事本的实现

以下是本人设计的java记事本，功能比较简单粗暴，纯粹是为了巩固java IO和GUI的内容不足之处，欢迎各路大神指正！

以下是UI层的代码

//记事本界面层
	
	import java.awt.*;
	import java.awt.datatransfer.*;
	import java.awt.event.*;//问题：(此处注释掉变编译不通过)
	import javax.swing.*;
	import java.awt.datatransfer.*;
	import javax.swing.undo.*;
	import javax.swing.text.Document;
	import java.awt.event.ActionEvent;
	import java.awt.event.ActionListener;
	import javax.swing.event.UndoableEditEvent;
	import javax.swing.event.UndoableEditListener;
	import javax.swing.event.*;
	public class noteBookUI{
		
		//定义一个全局变量用于存储当前打开文件的路径
		String nowFileSrc = null;
		
		//执行入口
		
		public static void main(String args[]){
			noteBookUI nui = null;
			nui = new noteBookUI();
			nui.initBO();
			
		}
		
		noteBookBO nbo = null;
		//初始化业务对象
		public void initBO(){
			nbo = new noteBookBO();
			
		}
		
		/**
		*以下实现ui界面
		*/
		
		JFrame jFrame;
		JMenu jm1,jm2,jm3;
		JMenuBar jmb;
		JMenuItem jmt1,jmt2,jmt3,jmt4,jmt5,jmt6,jmt7,jmt8,jmt9,jmt10,
		jmt11,jmt12,jmt13,jmt14,jmt15,jmt16,jmt17;
		//文本输入区域
		final JTextArea text;JScrollPane jp;
		public noteBookUI(){    
			//主窗口
			jFrame = new JFrame("记事本");
			//菜单条
			jmb=new JMenuBar();
			
			//主菜单
			//创建统一字体
			Font font_jm=new Font("微软雅黑",Font.PLAIN,20);
			jm1=new JMenu("文件");
			jm1.setFont(font_jm);
			jm2=new JMenu("编辑");
			jm2.setFont(font_jm);
			jm3=new JMenu("格式");
			jm3.setFont(font_jm);
			//设置按钮的大小
			jm1.setPreferredSize(new Dimension(50,20));
			jm2.setPreferredSize(new Dimension(50,20));
			jm3.setPreferredSize(new Dimension(50,20));
			
			//定义两个常量，设置按钮的长宽
			int WIDTH = 200;  //宽度
			int HEIGH = 30; //高度
			//创建文件菜单下的菜单按钮
			//创建字体对象
			Font font_jmt=new Font("微软雅黑",Font.PLAIN,20);
			jmt1 = new JMenuItem("  新建(N)      Ctrl+N");
			jmt1.setFont(font_jmt);
			jmt2 = new JMenuItem("  打开(O)      Ctrl+O");
			jmt2.setFont(font_jmt);
			jmt3 = new JMenuItem("  保存(S)       Ctrl+S");
			jmt3.setFont(font_jmt);
			jmt4 = new JMenuItem("  另存为(A)");
			jmt4.setFont(font_jmt);
			jmt5 = new JMenuItem("  退出(X)");
			jmt5.setFont(font_jmt);
			//设置按钮大小
			jmt1.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt2.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt3.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt4.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt5.setPreferredSize(new Dimension(WIDTH,HEIGH));
			
			//将相关按钮添加到相关菜单
			jm1.add(jmt1);
			jm1.add(jmt2);
			jm1.add(jmt3);
			jm1.add(jmt4);
			
			//创建编辑菜单下的按钮
			jmt6 = new JMenuItem("  撤销(U)      Ctrl+Z");
			jmt6.setFont(font_jmt);
			jmt7 = new JMenuItem("  剪切(T)      Ctrl+X");
			jmt7.setFont(font_jmt);
			jmt8 = new JMenuItem("  复制(C)      Ctrl+C");
			jmt8.setFont(font_jmt);
			jmt9 = new JMenuItem("  粘贴(P)      Ctrl+V");
			jmt9.setFont(font_jmt);
			jmt10 = new JMenuItem("  删除(L)        Del");
			jmt10.setFont(font_jmt);
			jmt11 = new JMenuItem("  查找(F)      Ctrl+F");
			jmt11.setFont(font_jmt);
			jmt12 = new JMenuItem("  查找下一个(N)  F3");
			jmt12.setFont(font_jmt);
			jmt13 = new JMenuItem("  替换(R)      Ctrl+H");
			jmt13.setFont(font_jmt);
			jmt14 = new JMenuItem("  替换(A)      Ctrl+A");
			jmt14.setFont(font_jmt);
			
			//设置按钮大小
			jmt6.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt7.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt8.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt9.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt10.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt11.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt12.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt13.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt14.setPreferredSize(new Dimension(WIDTH,HEIGH));
			//添加相关按钮到编辑下拉菜单中
			jm2.add(jmt6);
			jm2.add(jmt7);
			jm2.add(jmt8);
			jm2.add(jmt9);
			jm2.add(jmt10);
			jm2.add(jmt11);
			jm2.add(jmt12);
			jm2.add(jmt13);
			jm2.add(jmt14);
			
			//创建格式下拉菜单下的菜单
			jmt15 = new JMenuItem("  自动换行(W)");
			jmt15.setFont(font_jmt);
			jmt16 = new JMenuItem("  字体(F)");
			jmt16.setFont(font_jmt);
			jmt15.setPreferredSize(new Dimension(WIDTH,HEIGH));
			jmt16.setPreferredSize(new Dimension(WIDTH,HEIGH));
			//添加
			jm3.add(jmt15);
			jm3.add(jmt16);
			
			jmb.add(jm1);
			jmb.add(Box.createHorizontalStrut(50));
			jmb.add(jm2);
			jmb.add(Box.createHorizontalStrut(50));
			jmb.add(jm3);
			jFrame.add(jmb);
			//添加位置大小属性
			jFrame.add(jmb,"North");
			
			//创建滚动输入窗体
			text = new JTextArea();
			//设置输入框的默认字体
			Font font_write = new Font("微软雅黑",Font.PLAIN,20);
			text.setFont(font_write);
			jp = new JScrollPane(text);
			//显示水平(垂直)滚动条
			jp.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
			jp.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS );
			jFrame.add(jp);
			
			
			//往编辑区域添加撤销相关组件
			final UndoManager undo = new UndoManager();
			Document doc = text.getDocument();
			//注册给定的观察者以便开始接收文档发生不可撤消的编辑的通知
			doc.addUndoableEditListener(new UndoableEditListener() {
				public void undoableEditHappened(UndoableEditEvent evt) {
					undo.addEdit(evt.getEdit());
				}
			});
			
			//快捷键实现
			//新建
			text.getActionMap().put("NewFile",new AbstractAction("NewFile") {
				public void actionPerformed(ActionEvent evt) {
					//新建文件之前弹出是否保存当前文件数据窗口
					//beforeCreatFile();
					String srcFile = null;
					//选择存储路径,弹出路径选择窗口
					//srcFile = srcSelect("新建");
					srcFile = showSelectSrc_newFile();
					//如果用户没有选择路径直接取消操作，则退出该按钮操作
					if(srcFile==null){
						return ;
					}else{
						//路径选择好后，弹出文件名字输入框
						//String fileName = showGetName();
						//调用业务类中的方法创建文件，成功后初始化当前文件路径并弹出提示窗口
						nowFileSrc = nbo.doCreateFile(srcFile);
						//更改窗体标题为当前文件名
						jFrame.setTitle(srcFile);
						//创建成功后弹出提示窗口
						JOptionPane.showMessageDialog(null, "创建文件成功");
					}
				}
			});
			
			//打开
			text.getActionMap().put("Open",new AbstractAction("Open") {
				public void actionPerformed(ActionEvent evt) {
					String srcFile = null;
					srcFile = showSelectSrc_openFile();
					//判断是否选择了路径，如果路径选择成功，执行打开操作
					if(srcFile!=null){
						nowFileSrc = srcFile;
						String fileInfo = nbo.doOpen(srcFile);
						//将文件的信息传递给文本框
						text.setText(fileInfo);
					}else{
						JOptionPane.showMessageDialog(null, "文件打开失败，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}
			});
			
			//保存
			text.getActionMap().put("Conserver",new AbstractAction("Conserver") {
				public void actionPerformed(ActionEvent evt) {
					//获取输入文本区域的值
					String a = text.getText();
					System.out.println(a);
					//当前已打开文件，执行保存操作，否则提示创建或打开文件
					if(nowFileSrc!=null){
						int rtn = nbo.doConserve(nowFileSrc,a);
						if(rtn==1){
							JOptionPane.showMessageDialog(null, "保存成功！", "提示", JOptionPane.ERROR_MESSAGE);
						}else{
							JOptionPane.showMessageDialog(null, "保存失败，请重新操作！", "提示", JOptionPane.ERROR_MESSAGE);
						}
					}else{
						String src = showSelectSrc_saveOther();
						int rtn = nbo.doConserve(src,a);
						if(rtn==1){
							JOptionPane.showMessageDialog(null, "保存成功！", "提示", JOptionPane.ERROR_MESSAGE);
						}else{
							JOptionPane.showMessageDialog(null, "保存失败，请重新操作！", "提示", JOptionPane.ERROR_MESSAGE);
						}
					}
				}
			});
			
			//另存为
			text.getActionMap().put("SaveAs",new AbstractAction("SaveAs") {
				public void actionPerformed(ActionEvent evt) {
					//进行所有操作之前先判断用户是否已经打开文件
					if(nowFileSrc==null){
						showNotOpenFileInfo();
						return ;
					}else{
						//获取输入文本区域的值
						String a = text.getText();
						//跳转至路径选择界面
						String srcFile4 = null;
						srcFile4 = showSelectSrc_saveOther();
						//判断路径选择操作是否成功
						if(srcFile4==null){
							return ;
						}else{
							nbo.doConserve(srcFile4,a);
						}
					}
				}
			});
			
			//撤销
			text.getActionMap().put("Undo",new AbstractAction("Undo") {
				public void actionPerformed(ActionEvent evt) {
					try{
						if(undo.canUndo()){
							undo.undo();
						}else{
							JOptionPane.showMessageDialog(null, "当前不能进行撤销操作！", "提示", JOptionPane.ERROR_MESSAGE);
						}
					}catch(CannotUndoException e){
						//不可撤销后弹出提示信息
						JOptionPane.showMessageDialog(null, "操作错误，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}
			});
			//剪切
			text.getActionMap().put("JianQie",new AbstractAction("JianQie") {
				public void actionPerformed(ActionEvent evt) {
					//判断当前编辑区域有无文本
					if(text.getText().equals("")){
						JOptionPane.showMessageDialog(null, "当前文本编辑区域为空，不能进行剪切操作", "提示", JOptionPane.ERROR_MESSAGE);
					}else{
						int rtn = nbo.doJianQie(text);
						if(rtn == 1){
							JOptionPane.showMessageDialog(null, "剪切成功！", "提示", JOptionPane.ERROR_MESSAGE);
						}else{
							JOptionPane.showMessageDialog(null, "剪切操作失败，请重新操作！", "提示", JOptionPane.ERROR_MESSAGE);
						}
					}
				}
			});
			
			//复制
			text.getActionMap().put("Copy",new AbstractAction("Copy") {
				public void actionPerformed(ActionEvent evt) {
					int rtn = nbo.doCopy(text);
					 if(rtn == -1){
						JOptionPane.showMessageDialog(null, "复制操作失败，请重新操作！", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}
			});
			
			//粘贴
			text.getActionMap().put("Paste",new AbstractAction("Paste") {
				public void actionPerformed(ActionEvent evt) {
					try{
						int rtn = nbo.doPaste(text);
						if(rtn==-1){
							//剪切板内容不是文本内容
							JOptionPane.showMessageDialog(null, "当前内容是非文本，无法粘贴！", "提示", JOptionPane.ERROR_MESSAGE);
						}
						if(rtn==1){
							//剪切板为空
							JOptionPane.showMessageDialog(null, "当前剪切板无内容，请先进行复制操作！", "提示", JOptionPane.ERROR_MESSAGE);
						}
					}catch(Exception e){
						//有操作异常，弹出异常消息
						JOptionPane.showMessageDialog(null, "操作错误，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}
			});
			
			//删除
			text.getActionMap().put("Delete",new AbstractAction("Delete") {
				public void actionPerformed(ActionEvent evt) {
					int rtn = nbo.doDelete(text);
					if(rtn == -1){
						 JOptionPane.showMessageDialog(null, "删除操作失败，请选择您要删除的区域！", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}
			});
			
			//查找
			text.getActionMap().put("Search",new AbstractAction("Search") {
				public void actionPerformed(ActionEvent evt) {
					try{
						if("".equals(text.getText())){
							//文本编辑区域为空，提示无法查找
							JOptionPane.showMessageDialog(null, "当前编辑区域没有内容，无法查找！", "提示", JOptionPane.ERROR_MESSAGE);
						}else{
							showSearch();
						}	
					}catch(Exception e){
						//有操作异常，弹出异常消息
						JOptionPane.showMessageDialog(null, "操作错误，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}
			});
			
			//查找下一个
			text.getActionMap().put("SearchNext",new AbstractAction("SearchNext") {
				public void actionPerformed(ActionEvent evt) {
					//这里和查找操作一样
					try{
						if("".equals(text.getText())){
							//文本编辑区域为空，提示无法查找
							JOptionPane.showMessageDialog(null, "当前编辑区域没有内容，无法查找！", "提示", JOptionPane.ERROR_MESSAGE);
						}else{
							showSearch();
						}	
					}catch(Exception e){
						//有操作异常，弹出异常消息
						JOptionPane.showMessageDialog(null, "操作错误，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}
			});
			
			//替换
			text.getActionMap().put("Replace",new AbstractAction("Replace") {
				//这里和查找操作一样
				public void actionPerformed(ActionEvent evt) {
					try{
						if("".equals(text.getText())){
							//文本编辑区域为空，提示无法查找
							JOptionPane.showMessageDialog(null, "当前编辑区域没有内容，无法查找！", "提示", JOptionPane.ERROR_MESSAGE);
						}else{
							showSearch();
						}	
					}catch(Exception e){
						//有操作异常，弹出异常消息
						JOptionPane.showMessageDialog(null, "操作错误，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}
			});
			//全选
			text.getActionMap().put("SelectAll",new AbstractAction("SelectAll") {
				public void actionPerformed(ActionEvent evt) {
					try{
						if("".equals(text.getText())){
							//若文本区域没有文本内容，弹出提示框
							JOptionPane.showMessageDialog(null, "当前编辑区域没有内容，无法全选！", "提示", JOptionPane.ERROR_MESSAGE);
						}else{
							nbo.chooseAll(text);
						}
					}catch(Exception e){
						//有异常弹出提示信息
						JOptionPane.showMessageDialog(null, "操作出错，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
					}//标记
				}
			});
			//添加相关事件
			text.getInputMap().put(KeyStroke.getKeyStroke("control N"), "NewFile");
			text.getInputMap().put(KeyStroke.getKeyStroke("control O"), "Open");
			text.getInputMap().put(KeyStroke.getKeyStroke("control S"), "Conserver");
			text.getInputMap().put(KeyStroke.getKeyStroke("control Z"), "Undo");
			text.getInputMap().put(KeyStroke.getKeyStroke("control X"), "JianQie");
			text.getInputMap().put(KeyStroke.getKeyStroke("control C"), "Copy");
			text.getInputMap().put(KeyStroke.getKeyStroke("Del"), "Delete");
			text.getInputMap().put(KeyStroke.getKeyStroke("control F"), "Search");
			text.getInputMap().put(KeyStroke.getKeyStroke("F3"), "SearchNext");
			text.getInputMap().put(KeyStroke.getKeyStroke("control A"), "SelectAll");
		
			
			//设置窗口属性
			jFrame.setVisible(true);
			jFrame.setSize(1000, 1000);
			jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
			
			
			//监听相关事件
			
			//监听主菜单按钮
			//监听编辑按钮事件，每次单击菜单按钮都需要更新各个按钮是否可操作
			jm2.addMenuListener(new MenuListener(){
				
				//由于MenuListener是抽象类，所以实现另外两个方法
				 public void menuDeselected(MenuEvent e){
                    return ;
                }
				public void menuCanceled(MenuEvent e){
                    return ;
                }
                public void menuSelected(MenuEvent e){
                    //更新各个按钮可操作状态
					//判断撤销是否可用（为什么不用变成final的？）
					System.out.println("Test jm2ActionListen");
					jmt6.setEnabled(undo.canUndo());
					//判断剪切是否可用
					if((text.getText()==null)||(text.getSelectedText()==null)){
						jmt7.setEnabled(false);
					}
					//判断复制是否可用
					if((text.getText()==null)||(text.getSelectedText()==null)){
						jmt8.setEnabled(false);
					}
					//判断粘贴是否可用
					String value = null;
					try{
						Clipboard c1 = Toolkit.getDefaultToolkit().getSystemClipboard();
						Transferable clipT = c1.getContents(null);
						value = (String)clipT.getTransferData(DataFlavor.stringFlavor);
					}catch(Exception ex){
						value = "";
					}
					if(value.equals("")){
						System.out.println("Test jm2ActionListen zhanTie");
						jmt9.setEnabled(false);
					}
					//判断删除是否可用
					if(nbo.doDelete(text)!=1){
						jmt10.setEnabled(false);
					}
                }
				
			});
			
			//监听新建按钮事件
			jmt1.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent ae){
					//新建文件之前弹出是否保存当前文件数据窗口
					//beforeCreatFile();
					String srcFile = null;
					//选择存储路径,弹出路径选择窗口
					//srcFile = srcSelect("新建");
					srcFile = showSelectSrc_newFile();
					//如果用户没有选择路径直接取消操作，则退出该按钮操作
					if(srcFile==null){
						return ;
					}else{
						//路径选择好后，弹出文件名字输入框
						//String fileName = showGetName();
						//调用业务类中的方法创建文件，成功后初始化当前文件路径并弹出提示窗口
						nowFileSrc = nbo.doCreateFile(srcFile);
						//创建成功后弹出提示窗口
						JOptionPane.showMessageDialog(null, "创建文件成功");
					}
				}
			});
			
			//类似地监听其他按钮
			//监听打开按钮
			jmt2.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent ae){
					String srcFile = null;
					srcFile = showSelectSrc_openFile();
					//判断是否选择了路径，如果路径选择成功，执行打开操作
					if(srcFile!=null){
						nowFileSrc = srcFile;
						String fileInfo = nbo.doOpen(srcFile);
						//将文件的信息传递给文本框
						text.setText(fileInfo);
					}else{
						JOptionPane.showMessageDialog(null, "文件打开失败，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}
			});
			//监听保存
			jmt3.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent ae){
					//获取输入文本区域的值
					String a = text.getText();
					System.out.println(a);
					//当前已打开文件，执行保存操作，否则提示创建或打开文件
					if(nowFileSrc!=null){
						int rtn = nbo.doConserve(nowFileSrc,a);
						if(rtn==1){
							JOptionPane.showMessageDialog(null, "保存成功！", "提示", JOptionPane.ERROR_MESSAGE);
						}else{
							JOptionPane.showMessageDialog(null, "保存失败，请重新操作！", "提示", JOptionPane.ERROR_MESSAGE);
						}
					}else{
						String src = showSelectSrc_saveOther();
						int rtn = nbo.doConserve(src,a);
						if(rtn==1){
							JOptionPane.showMessageDialog(null, "保存成功！", "提示", JOptionPane.ERROR_MESSAGE);
						}else{
							JOptionPane.showMessageDialog(null, "保存失败，请重新操作！", "提示", JOptionPane.ERROR_MESSAGE);
						}
					}
					
				}
			});

		//监听另存为按钮
		jmt4.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				//进行所有操作之前先判断用户是否已经打开文件
				if(nowFileSrc==null){
					showNotOpenFileInfo();
					return ;
				}else{
					//获取输入文本区域的值
					String a = text.getText();
					//跳转至路径选择界面
					String srcFile4 = null;
					srcFile4 = showSelectSrc_saveOther();
					//判断路径选择操作是否成功
					if(srcFile4==null){
						return ;
					}else{
						nbo.doConserve(srcFile4,a);
					}
				}	
			}
		});
		
		/**
		*编辑菜单下的按钮监听
		*/
		//监听撤销按钮
		jmt6.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                try{
                    undo.undo();
                }catch(CannotRedoException cre){
					JOptionPane.showMessageDialog(null, "当前不能进行撤销操作！", "提示", JOptionPane.ERROR_MESSAGE);
                    
                }
				//更新按钮是否可用
                jmt6.setEnabled(undo.canUndo());
            }
        });
		
		//监听剪切按钮
		jmt7.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				//判断当前编辑区域有无文本
				if(text.getText().equals("")){
					JOptionPane.showMessageDialog(null, "当前文本编辑区域为空，不能进行剪切操作", "提示", JOptionPane.ERROR_MESSAGE);
				}else{
					int rtn = nbo.doJianQie(text);
					if(rtn == 1){
						JOptionPane.showMessageDialog(null, "剪切成功！", "提示", JOptionPane.ERROR_MESSAGE);
					}else{
						JOptionPane.showMessageDialog(null, "剪切操作失败，请重新操作！", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}
				 
			}
		});
		//监听复制按钮
		jmt8.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				 int rtn = nbo.doCopy(text);
				 if(rtn == -1){
					 JOptionPane.showMessageDialog(null, "复制操作失败，请重新操作！", "提示", JOptionPane.ERROR_MESSAGE);
				 }
			}
		});
		//监听粘贴按钮
		jmt9.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				 try{
					int rtn = nbo.doPaste(text);
					if(rtn==-1){
						//剪切板内容不是文本内容
						JOptionPane.showMessageDialog(null, "当前内容是非文本，无法粘贴！", "提示", JOptionPane.ERROR_MESSAGE);
					}
					if(rtn==1){
						//剪切板为空
						JOptionPane.showMessageDialog(null, "当前剪切板无内容，请先进行复制操作！", "提示", JOptionPane.ERROR_MESSAGE);
					}
				}catch(Exception e){
					 //有操作异常，弹出异常消息
					 JOptionPane.showMessageDialog(null, "操作错误，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
				}
			}
		});
		//监听删除按钮
		jmt10.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				 int rtn = nbo.doDelete(text);
				 if(rtn == -1){
					 JOptionPane.showMessageDialog(null, "删除操作失败，请选择您要删除的区域！", "提示", JOptionPane.ERROR_MESSAGE);
				 }
			}
			
		});
		//监听查找按钮
		jmt11.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				try{
					if("".equals(text.getText())){
						//文本编辑区域为空，提示无法查找
						JOptionPane.showMessageDialog(null, "当前编辑区域没有内容，无法查找！", "提示", JOptionPane.ERROR_MESSAGE);
					}else{
						showSearch();
					}	
				}catch(Exception e){
					//有操作异常，弹出异常消息
					JOptionPane.showMessageDialog(null, "操作错误，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
				}
			}
		});
		//监听查找下一个
		jmt12.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				try{
					if("".equals(text.getText())){
						//文本编辑区域为空，提示无法查找
						JOptionPane.showMessageDialog(null, "当前编辑区域没有内容，无法查找！", "提示", JOptionPane.ERROR_MESSAGE);
					}else{
						showSearch();
					}	
				}catch(Exception e){
					//有操作异常，弹出异常消息
					JOptionPane.showMessageDialog(null, "操作错误，请重新操作", "提示", JOptionPane.ERROR_MESSAGE);
				}
			}
		});
		//监听替换
		jmt13.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				//首先弹出查找/查找下一个/替换窗口
				 showReplace();
			}
		});
		//监听全选
		jmt14.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				//首先弹出查找/查找下一个/替换窗口
				 nbo.chooseAll(text);
			}
		});
			
		}
		
		//新建路径选择界面
		public String showSelectSrc_newFile(){
			 FileDialog fd=new FileDialog(new Frame(),"新建",FileDialog.SAVE);
			 //System.out.println("000");
			 fd.setVisible(true);
			 if(fd.getFile()==null||fd.getDirectory()==null){
				 return null;
			 }else{
				 return fd.getDirectory()+fd.getFile();
			 }
		}
		//另存为路径选择界面
		public String showSelectSrc_saveOther(){
			 FileDialog fd=new FileDialog(new Frame(),"另存为",FileDialog.SAVE);
			 //System.out.println("000");
			 fd.setVisible(true);
			 if(fd.getFile()==null||fd.getDirectory()==null){
				 return null;
			 }else{
				 return fd.getDirectory()+fd.getFile();
			 }
			 
		}
		
		//打开路径选择界面
		public String showSelectSrc_openFile(){
			FileDialog fd=new FileDialog(new Frame(),"打开",FileDialog.LOAD);
			 fd.setVisible(true);
			 if(fd.getFile()==null||fd.getDirectory()==null){
				 return null;
			 }else{
				 return fd.getDirectory()+fd.getFile();
			 }
		}
		
		//确定提示界面
		public void showDoSuccess(String doWhat){
			JOptionPane.showConfirmDialog(null, "确定"+doWhat+"?", doWhat, JOptionPane.YES_NO_OPTION); 
		}
		
		//当前未打开文件时的提示界面
		public void showNotOpenFileInfo(){
			JOptionPane.showMessageDialog(null, "当前未打开文件，请先打开或者创建相关文件再进行其它操作");
		}
		
		/*
		//文件名字输入界面,返回相关文件名字（用于重命名和新建功能）
		public String showGetName(){
			String name = JOptionPane.showInputDialog(null,"请输入文件名字：
","输入文件名",JOptionPane.PLAIN_MESSAGE); 
			return name;
		}
		*/
		
		//进行新操作前（新建文件和关闭窗口）询问是否保存当前数据显示界面
		public void beforeCreatFile(){
			//弹出该窗口的前提是已经打开了相关文件
			if(nowFileSrc!=null){
				final JFrame frame_remindSave = new JFrame("记事本");
				//创建一个垂直box
				Box remindSaveBox = Box.createVerticalBox();
				
				//文字提示信息
				JPanel jpanel_remindLabel = new JPanel();
				JLabel jlabel_tiShi = new JLabel("是否将更改保存到"+nowFileSrc+"?");
				jpanel_remindLabel.add(jlabel_tiShi);
				remindSaveBox.add(jpanel_remindLabel);
				remindSaveBox.add(Box.createVerticalStrut(5));
				
				//确定和取消按钮
				JPanel jpanel_remindButton = new JPanel();
				JButton baoCun_btn = new JButton("保存");
				JButton fangQi_btn = new JButton("放弃");
				jpanel_remindButton.add(baoCun_btn);
				jpanel_remindButton.add(fangQi_btn);
				remindSaveBox.add(jpanel_remindButton);
				
				frame_remindSave.add(remindSaveBox);
				
				//设置窗口属性
				frame_remindSave.setVisible(true);
				frame_remindSave.setSize(1000, 200);
				frame_remindSave.setResizable(false);
				frame_remindSave.setLocation(500,500);
				frame_remindSave.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
				
				
				//监听相关按钮
				//监听保存按钮
				baoCun_btn.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent ae){
					nbo.doConserve(nowFileSrc,text.getText());
					System.out.println("000");
					frame_remindSave.dispose();
				}
				
				});
				
				//监听放弃按钮
				fangQi_btn.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent ae){
					System.out.println("001");
					frame_remindSave.dispose();
				}
				
				});
				
			}else{
				//当前没有打开文件则直接退出该方法
				return ;
			}
		}
			
		
		//查找显示界面
		//JFrame frame1;
		public void showSearch(){
			final String [] selectInfo = new String[2];
			//默认状态查找是向下查找,查找方框内信息是空
			selectInfo[0] = "向下";
			selectInfo[1] = "";
			JFrame frame1 = new JFrame("查找");
			
			//创建一个垂直box
			Box findInfoBox = Box.createVerticalBox();
			
			JPanel jpanel_danXuan = new JPanel();
			
			//文本输入框
			JLabel label_fingInfo = new JLabel("查找内容");
			final JTextField jtext_findInfo = new JTextField(10);
			JPanel findInfo_panel = new JPanel();
			findInfo_panel.add(label_fingInfo);
			findInfo_panel.add(jtext_findInfo);
			findInfoBox.add(findInfo_panel);
			findInfoBox.add(Box.createVerticalStrut(10));
			
			//单选按钮
			JRadioButton jrb1 = new JRadioButton("向下");
			JRadioButton jrb2 = new JRadioButton("向上");
			//默认选中的是向下按钮
			jrb1.setSelected(true);
			ButtonGroup group = new ButtonGroup();
			group.add(jrb1);
			group.add(jrb2);
			jpanel_danXuan.add(jrb1);
			jpanel_danXuan.add(jrb2);
			findInfoBox.add(jpanel_danXuan);
			findInfoBox.add(Box.createVerticalStrut(10));
			
			//确定和取消按钮
			JPanel jpanel_queDingQuXiao = new JPanel();
			JButton queDing_btn = new JButton("确定");
			JButton quXiao_btn = new JButton("取消");
			jpanel_queDingQuXiao.add(queDing_btn);
			jpanel_queDingQuXiao.add(quXiao_btn);
			findInfoBox.add(jpanel_queDingQuXiao);
			findInfoBox.add(Box.createVerticalStrut(5));
			
			//提示信息
			JPanel jpanel_tiShi = new JPanel();
			final JLabel jlabel_tiShi = new JLabel("请输入您要查找的信息");
			jlabel_tiShi.setForeground(new Color(238,32,32));
			jpanel_tiShi.add(jlabel_tiShi);
			findInfoBox.add(jpanel_tiShi);
			
			
			frame1.add(findInfoBox);
			
			
			//设置窗口属性
			frame1.setVisible(true);
			frame1.setSize(1000, 200);
			frame1.setResizable(false);
			frame1.setLocation(500,500);
			frame1.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
			
			
			//添加按钮事件
			//监听单选按钮事件
			jrb1.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent e){
					//将相应的选取的信息赋值给数组selectInfo
					selectInfo[0] = "向下";
				}
			});
			
			jrb2.addActionListener(new ActionListener(){
				public void actionPerformed(ActionEvent e){
					//将相应的选取的信息赋值给数组selectInfo
					selectInfo[0] = "向上";
				}
			});
			
			//监听确定、取消按钮事件
			queDing_btn.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				//确定按钮，执行查找操作
				selectInfo[1] = jtext_findInfo.getText();
				int rtn = nbo.doFindString(text,selectInfo);
				/**
				*根据返回值，弹出相应的提示信息
				*/
				if(rtn==0){
					//如果输入字符串为空，提示输入为空
					jlabel_tiShi.setText("您输入的查找内容为空，请重新输入");
				}else if(rtn==1){
					//返回1，查找成功
					jlabel_tiShi.setText("查找成功");
				}else{
					//找不到内容
					jlabel_tiShi.setText(selectInfo[0]+"查找"+"找不到该内容");
				}
			}
			});
			quXiao_btn.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				//返回null
				return ;
			}
			});	
		}
		
	//替换窗口
	public void showReplace(){
		JFrame frame2 = new JFrame("替换");
		//创建一个垂直box
		Box replaceBox = Box.createVerticalBox();
		
		//创建查找内容板块
		JPanel jpanel_search = new JPanel();
		JLabel jlabel_search = new JLabel("查找内容  ");
		final JTextField jtext_search = new JTextField(15);
		JButton jbutton_search = new JButton("查找下一个");
		jpanel_search.add(jlabel_search);
		jpanel_search.add(jtext_search);
		jpanel_search.add(jbutton_search);
		replaceBox.add(jpanel_search);
		replaceBox.add(Box.createVerticalStrut(10));
		
		//创建替换内容板块
		JPanel jpanel_replace = new JPanel();
		JLabel jlabel_replace = new JLabel("  替换  ");
		final JTextField jtext_replace = new JTextField(15);
		JButton jbutton_replace = new JButton("替换");
		JButton jbutton_replaceall = new JButton("全部替换");
		jpanel_replace.add(jlabel_replace);
		jpanel_replace.add(jtext_replace);
		jpanel_replace.add(jbutton_replace);
		jpanel_replace.add(jbutton_replaceall);
		replaceBox.add(jpanel_replace);
		
		//创建取消板块以及信息提示板块
		JPanel jpanel_cancel = new JPanel();
		JButton jbutton_cancel = new JButton("取消");
		final JLabel jlabel_tiShi = new JLabel("显示提示信息");
		jlabel_tiShi.setForeground(new Color(238,32,32));
		jpanel_cancel.add(jbutton_cancel);
		replaceBox.add(jpanel_cancel);
		replaceBox.add(jlabel_tiShi);
		
		frame2.add(replaceBox);
		//设置窗口属性
		frame2.setVisible(true);
		frame2.setSize(1000, 200);
		frame2.setResizable(false);
		frame2.setLocation(500,500);
		frame2.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
		
		//监听按钮事件
		//监听查找下一个按钮
		//获取查找输入框中的内容
		final JTextArea jtext_search1 = text;
		jbutton_search.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				//由于查找方法传递的参数是字符串数组，所以先创建一个字符串数组用于传递信息
				String [] info = new String[2];
				info[0] = "向下";
				info[1] = jtext_search.getText();
				int rtn = nbo.doFindString(text,info);
				System.out.println(rtn);
				//根据返回值相应显示提示信息
				if(rtn==0){
					//如果输入字符串为空，提示输入为空
					jlabel_tiShi.setText("您输入的查找内容为空，请重新输入");
				}else if(rtn==1){
					//返回1，查找成功
					jlabel_tiShi.setText("查找成功,您可以选择替换");
				}else{
					//找不到内容
					jlabel_tiShi.setText("找不到该内容,该字符可能不存在或者您已将光标移到最后");
				}
			}
		});
		
		//监听替换按钮
		jbutton_replace.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				int rtn  = nbo.doReplace(jtext_search1,jtext_replace.getText());
				if(rtn==0){
					jlabel_tiShi.setText("您还没有选中文字，无法执行替换");
				}else{
					jlabel_tiShi.setText("替换成功");
				}
			}
		});
		
		
		//监听全部替换按钮
		jbutton_replaceall.addActionListener(new ActionListener(){
			public void actionPerformed(ActionEvent ae){
				int rtn  = nbo.doReplaceAll(text,jtext_search.getText(),jtext_replace.getText());
				if(rtn==0){
					jlabel_tiShi.setText("请输入替换内容和查找内容");
				}else if(rtn==-1){
					jlabel_tiShi.setText("找不到内容，请重新输入");
				}else{
					jlabel_tiShi.setText("全部替换成功");
				}
			}
		});
		
	}
	
	/*
	//添加关闭窗口触发时间
	addWindowListener(new WindowAdapter(){  
		public void windowClosing(WindowEvent e) {  
			super.windowClosing(e);  
			//弹出询问是否保存修改后的文件
			
			 
		 }  
		  
	});  
	*/		
	
	}

　

以下是BO业务层代码

//记事本
import java.io.*;
import java.awt.*;
import java.awt.datatransfer.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.datatransfer.*;
import javax.swing.undo.UndoManager;
import java.lang.StringBuffer.*;
public  class noteBookBO{
	
	/**
	*定义文件菜单下的业务方法
	*/
	//做到打开文件新建文件将窗口标题改为对应文件路劲，关闭窗口触发时间没有实现
	noteBookDA nda = new noteBookDA();
	//定义新建方法
	public  String doCreateFile(String srcFile){
		String src = null;
		System.out.println("test doCreatFile"+srcFile);
		try{
			File f = nda.creatFile(srcFile);
			src = f.getAbsolutePath();
			System.out.println(src);
		}catch(IOException ie){
			System.out.println(ie);
		}
		//获取当前文件的路径并返回
		return src;
	}
	
	//定义打开方法
	public String doOpen(String srcFile){
		String rtn = null;
		try{
			 rtn = nda.dataRead(srcFile);
		}catch(IOException ie){
			System.out.println(ie);
		}
		return rtn;
	}
	//定义保存方法,如果所传递的文件路径所指文件不存在，则对应返回-1，如果保存成功，返回1
	public int doConserve(String srcFile,String data){
		int rtn;		
		try{
			nda.dataWrite(srcFile,data);
			rtn = 1;
		}catch(Exception ie){
			rtn = -1;
		}
		return rtn;
	}
	//定义另存为方法
	public  void doNewConserve(String srcFile,String data) {
		try{
			nda.dataWrite(srcFile,data);
		}catch(IOException ie){
			System.out.println(ie);
		}
	}
	//定义退出方法
	public void quit(){
		System.exit(0);
	}
	
	
	/**
	*定义编辑菜单下的业务方法
	*/
	//定义撤销的方法,返回1表示撤销成功，返回0表示撤销失败
	public int doCeXiao(JTextArea text){
		System.out.println("000");
		UndoManager undoManager = new UndoManager();
		text.getDocument().addUndoableEditListener(undoManager);
		if(undoManager.canUndo()){
			System.out.println("001");
			undoManager.undo();
			return 1;
		}else{
			System.out.println("002");
			return 0;
		}
	}
	//定义剪切方法,成功返回1，失败返回-1
	public int doJianQie(JTextArea text){
		//先copy
		int rtn_copy = doCopy(text);
		//后delete
		int rtn_delete = doDelete(text);
		if((rtn_copy) ==1&&(rtn_delete==1)){
			return 1;
		}else{
			return -1;
		}
	}
	
	//定义复制方法
	//获取系统剪贴板,成功返回1，没有选中操作的文本区域，返回-1
	Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
	final Clipboard c1 = clipboard;
	public int doCopy(JTextArea text){
		String temp = text.getSelectedText(); 
		if(temp==null){
			return -1;
		}else{
			StringSelection textString = new StringSelection(temp);
			//Clipboard clipboard = new Clipboard(temp);
			c1.setContents(textString, null);
			return 1;
		}
		
	}
	
	/*定义粘贴方法,返回1表示操作成功，返回0表示剪切板空白
	*返回-1表示粘贴内容是非文本
	*出现相应的异常，相应地返回-2和-3
	*/
	public int doPaste(JTextArea text){
		// 获取剪切板中的内容
		try{
			Transferable clipT = c1.getContents(null);
			String value = null;
			if (clipT != null){   
				// 检查内容是否是文本类型   
				if (clipT.isDataFlavorSupported(DataFlavor.stringFlavor)){
					//获取剪切板中的数据
					value = (String)clipT.getTransferData(DataFlavor.stringFlavor);
					//执行替换操作
					int start = text.getSelectionStart();
					int end = text.getSelectionEnd();
					text.replaceRange(value, start, end);
					return 1;
				}else{
					//粘贴内容非文本返回-1
					return -1;
				}  
			}else{
				//剪切板为空返回0
				return 0;
			} 	 		
		}catch(UnsupportedFlavorException ufe){
			//捕获到此异常表示操作不支持该数据类型，返回-2
			return -2;
		}catch(IOException ie){
			//捕获到此异常表示IO操作有问题，返回-3
			return -3;
		}
		
	}
	
	//定义删除方法,成功返回1，如果没有选定操作的文本区域，返回-1
	public int doDelete(JTextArea text){
		int start = text.getSelectionStart();
		int end = text.getSelectionEnd();
		// 删除被选取的文本
		if(start==end){
			return -1;
		}else{
			text.replaceRange("", start, end);
			return 1;
		}
		
	}
	//定义查找方法,查找成功返回1，查找内容为空返回0，找不到该字符串返回-1
	int start ;
	int end ;
	public int doFindString(JTextArea text,String [] searchValue ){
		if("".equals(searchValue[1])){
			//为空，返回0
			return 0;
		}else{
			//判断是向下还是向上搜索,如果是向上，将字符串反转
			//获取当前光标的位置
			int caretPosition;
			if(searchValue[0].equals("向上")){
				if((text.getSelectedText()!=null)&&(text.getSelectedText().equals(searchValue[1]))){
					//如果文本选中了要查找的值，说明已经进行过查找操作，此时光标位置应该移动到start处
					caretPosition = start;
				}else{
					//如果还没有进行查找操作，应该获取当前光标的位置
					caretPosition = text.getCaretPosition();
				}
				//先将字符串反转
				 String text1 = text.getText();
				 StringBuffer StringBuffer1 = new StringBuffer(text1);
				 String textReverse = StringBuffer1.reverse().toString();
				//同时当前光标对应的位置也应该对应改变
				caretPosition = text1.length() - caretPosition;
				//查找前，查找的信息也需要反转
				StringBuffer StringBuffer2 = new StringBuffer(searchValue[1]);
				String infoReverse = StringBuffer2.reverse().toString();
				/**
				*执行查找操作,在操作中，由于字符串被反转
				*所以将字符串长度减去得出来的索引对应的是原字符串
				*的end的值
				*/
				end = textReverse.length() - textReverse.indexOf(infoReverse, caretPosition);
				start = end - infoReverse.length();
				//选中文本
				if(end>textReverse.length()){
					//end值大于文本长度，表示该文本不存在
					return -1;
				}else{
					//查找成功，选中文本
					text.select(start,end);
					return 1;
				}
			}else{
				String getInfo = text.getText();
				caretPosition = text.getCaretPosition();
				//查找对应的字符
				start = getInfo.indexOf(searchValue[1], caretPosition);
				end = getInfo.indexOf(searchValue[1], caretPosition) + searchValue[1].length();
				//选中文本
				if(start==-1){
					//文本不存在
					return -1;
				}else{
					//查找成功
					text.select(start,end);
					return 1;
				}
			}
		}
		
		
	}
	
	//定义替换,返回0表示没有选中文本，返回1表示替换成功
	public int doReplace(JTextArea text,String replaceInfo){
		if(text.getSelectedText()==null){
			return 0;
		}else{
			//执行替换操作
			text.replaceRange(replaceInfo, start, end);
			return 1;
		}
	}
	
	//定义全部替换方法,输入为空，返回0，成功替换全部返回1，找不到相应的字符返回-1
	public int doReplaceAll(JTextArea text,String regex,String replacement){
		String textInfo = text.getText();
		if("".equals(textInfo)||"".equals(regex)){
			return 0;
		}else{
			if(textInfo.indexOf(regex)!=-1){
				//如果替换的字符串存在,则执行替换操作
				String textDoneReplace = textInfo.replaceAll(regex,replacement);
				//替换完之后将数据写进输入区域
				text.setText(textDoneReplace);
				return 1;
			}else{
				return -1;
			}
		}
		
	}
	//定义全选
	public void chooseAll(JTextArea text){
		text.selectAll();
	}
}

　以下是DA数据层代码

//数据层面
import java .io.*;
public class noteBookDA{
	//主方法，测试用
	public static void main(String [] args){
		noteBookDA test = new noteBookDA();
		// try{
			// //String st = test.dataRead("text.txt");
			// //System.out.println(st);
			// //String st = new String("asldfkjlsdkfj");
			// //test.dataWrite("text.txt",st);
			// //test.creatFile("D:/HaiGe/mycode/L2-W4/代码练习/test","name1");
		// }catch(IOException ie){
			// System.out.println("IOException");
		// }
		
		
	}
	
	
	//定义数据操作方法
	
	//在指定目录创建新文件
	public File creatFile(String src) throws IOException{
		String fileSrc = src;
		File f = new File(fileSrc);
		if(f.exists()){
			return null;
		}else{
			try{
				// 创建新文件
				f.createNewFile();
            }catch (IOException e){
                System.out.println("创建新文件时出现了错误。。。");
                e.printStackTrace();
            }
			return f;
		}
	}
	
	//定义数据读取方法,返回读取到的数据的字符串
	public String dataRead(String srcFile) throws IOException{
		String dataString;
		File f = new File(srcFile);
		FileReader fr = new FileReader(f);
		char [] cbuf = new char[(int)f.length()];
		fr.read(cbuf);
		dataString = new String(cbuf);
		fr.close();
		return dataString;
	}
	//定义数据写入方法
	public void dataWrite(String srcFile,String writeData) throws IOException{
		String dataString;
		File f = new File(srcFile);
		FileWriter fw = new FileWriter(f);
		fw.write(writeData);
		fw.close();
	}
	//定义数据替换
	public void dataReplace(String srcFile,String oldData,String newData) throws IOException{
		//Fiel f= new File(srcFile);
		
	}
	//数据查找
	public void dataSearch(String allData,String tarData){
		
	}
	//定义数据删除
	public void dataDelete(String srcFile,String deleteData){
		//String da = dataRead(srcFile);
		
	}

}

　　该记事本只是实现了简单的输入编辑保存等基本操作，主要用于巩固IO和UI的知识，不足之处，恳请各位指出！