课程总结

Posted 2021-03-23 cxnkkk

一.认识java

1.JAVA语言特点

简洁有效、可移植性、面向对象、解释性、适合分布式计算、拥有较好的性能、健壮防患于未然、具有多线程处理能力、具有较高的安全性、是一种动态语言、是一种中性结构

2.JVM、JRE和JDK的区别：

JVM(Java Virtual Machine):java虚拟机，用于保证java的跨平台的特性。

java语言是跨平台，jvm不是跨平台的。

JRE(Java Runtime Environment):java的运行环境,包括jvm+java的核心类库。

JDK(Java Development Kit):java的开发工具,包括jre+开发工具

3.数据类型：

(1)基本数据类型(4类8种)：

整数类型：byte、short、int、long

浮点数类型：float、double

字符类型：char

布尔类型：boolean(ture false)

(2)引用数据类型：

类

接口

数组

4.类型转换

精度从高到低 double float long int short(char) byte
(1)自动类型转换 将一个低精度---?高精度
(2)强制类型转换 将一个高精度---?低精度(精度会下降)

5.重载：

概念：在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可。
特点：与返回值类型无关，只看参数列表(参数类型以及参数个数)。
好处：方便于阅读，优化了程序设计。

二.面向对象

1.类和对象：

类：对现实世界中某类事物的描述,是抽象的，概念上的定义。
对象：事物具体存在的个体。

3.成员变量和局部变量的区别

(1)作用域
成员变量：针对整个类有效。
局部变量：只在某个范围内有效。(一般指的就是方法,语句体内)
(2)存储位置
成员变量：随着对象的创建而存在，随着对象的消失而消失，存储在堆内存中。
局部变量：在方法被调用，或者语句被执行的时候存在，存储在栈内存中。
当方法调用完，或者语句结束后，就自动释放。

4.封装：

指隐藏对象的属性和实现细节，仅对外提供公共访问方式

5.构造方法：

(1)特点：
方法名与类名相同
没有返回类型
没有返回值
(2)作用：构造函数是用于创建对象，并对其进行初始化赋值，对象一建立就自动调用相对应的构造函数

6.构造代码块：

(1)作用：给对象进行初始化，对象一建立就执行，而且优先于构造函数执行
(2)构造代码块和构造函数的区别：
构造代码块是给所有不同对象的共性进行统一初始化
构造函数是给对应的对象进行初始化

7.this关键字

作用（1）表示类中的属性
（2）可以使用this调用本类的构造方法
（3）this表示当前对象

8.static关键字：

(1)静态的意思，用来修饰成员变量和成员函数
(2)静态的特点:
随着类的加载而加载
优先于对象存在
对所有对象共享
可以被类名直接调用
注意：静态方法中不能使用this,super关键字

三.面向对象（高级篇）

1.继承

(1)把很多类的相同特征和行为进行抽取，用一个类来描述。让多个类和这个类产生一个关系。
这样的话，多个类就可以省略很多代码。这个关系就是继承。java中用extends关键字表示。
（2）继承的特点:
java中只能单继承，没有多继承。
java可以有多重(层)继承。
（3）继承的好处：
继承的出现提高了代码的复用性。
继承的出现让类与类之间产生了关系，提供了多态的前提。

2.重写和重载的区别

重载：在同一类中。方法名相同，参数列表不同。重载可以改变返回类型。
重写：在不同类中(子父类中)。

3.this和super的区别

this:代表本类对象的引用。
super:代表父类的存储空间。

4.final关键字

(1)最终的意思，可以用于修饰类，方法，变量。
(2)final修饰的类不能被继承。
final修饰的方法不能被重写。
final修饰的变量是一个常量。只能被赋值一次。
内部类只能访问被final修饰的局部变量。

5.抽象类

特点：

A:抽象类和抽象方法都要用abstract进行修饰
B:抽象类不能被实例化
C:抽象类中不一定有抽象方法，但是，有抽象方法的类一定是抽象类。

6.接口interface

(1)关系
A:类与类的关系
是继承关系。类与类只能单继承，可以多重继承。
B:类和接口的关系
是实现关系。类可以多实现接口。
类在继承一个类的同时，可以实现多个接口。
C:接口和接口的关系
是继承关系。接口可以多继承接口。
(2)接口的特点
A:是对外暴露的规则
B:是功能的扩展
C:接口的出现降低耦合性。
耦合(类与类之间的关系)
内聚(类完成功能的能力)
编程规范：低耦合，高内聚。

7.接口和抽象类的区别

抽象类只能被单继承
接口可以多实现,接口的出现避免了多继承的局限性。

8.多态：

(1)同一个对象，在程序不同时刻的多种运行状态。举例：动物，狗是狗，狗是动物。水(气态，液态，固态)

(2)多态前提

A:存在着继承或者实现关系

B:有方法的重写

C:父类(接口)引用指向子类(实现)对象

9.Object类：

(1)是所有类的根类，超类。
java中提供的类以及我们自定义的类都直接或者间接的继承自Object类。
(2)Object类中的方法
A:void finalize()
当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。
B:Class getClass()
获取对象的字节码文件的描述类，后面再讲反射的时候还会在说这个类。
String name = s.getClass().getName();

三.异常

1.程序运行过程中的不正常现象就叫异常。

2.导致程序运行不正常的现象有很多，所以，就有很多的异常对象。

而这些异常对象存在着共性的内容，所以，可以不断的进行抽取。最终形成了异常的体系结构。
异常体系的根类是:Throwable

3.Throwable：

Error:重大的问题，我们处理不了。也不需要编写代码处理。比如说内存溢出。
Exception:一般性的错误，是需要我们编写代码进行处理的。
RuntimeException:运行时异常，这个我们也不需要处理。

4.

异常的分类
异常有两种：
编译时被检测异常：
该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。
该异常被标识，代表这可以被处理。
运行时异常(编译时不检测)
在编译时，不需要处理，编译器不检查。
该异常的发生，建议不处理，让程序停止。需要对代码进行修正。

5.异常体系的特点：

异常体系中的所有类及其子类对象都具备可抛性。也就是说可以被throw和throws关键字所操作。

6.main方法是如何处理异常的。

A:在main里面编写代码进行处理
B:交给jvm自己进行处理。采用的是jvm的默认处理方式。
其实就是相当于调用了异常对象的printStackTrace()方法。

7.Throwable类的学习

getMessage():获取异常信息，返回字符串。
toString():获取异常类名和异常信息，返回字符串。
printStackTrace():获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。

8.异常的处理·

try...catch...finally

try
{
可能出现异常的代码
}
catch(异常对象)
{    
异常处理代码
}
finally
{
释放资源
}

9.throws和throw的区别

A：有throws的时候可以没有throw。
有throw的时候，如果throw抛的异常是Exception体系，那么必须有throws在方法上声明。
B：throws用于方法的声明上，其后跟的是异常类名，后面可以跟多个异常类，之间用逗号隔开
throw用于方法体中，其后跟的是一个异常对象名

四、多线程：

1、进程和线程：

进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。
线程：进程内部的一条执行路径或者一个控制单元。
两者的区别：
一个进程至少有一个线程
进程在执行过程中拥有独立的内存单元，而多个线程共享内存；

2、多线程的优势：

解决了多部分同时运行的问题，提高效率

3、线程的弊端：

线程太多会导致效率的降低，因为线程的执行依靠的是CPU的来回切换。

4、什么叫多线程：

一个进程中有多个线程，称为多线程。

5、实现多线程的方法：

实现多线程可以通过继承Thread类和实现Runnable接口。
(1)继承Thread
定义一个类继承Thread类
复写Thread类中的public void run()方法，将线程的任务代码封装到run方法中
直接创建Thread的子类对象，创建线程
调用start()方法，开启线程(调用线程的任务run方法)
//另外可以通过Thread的getName()获取线程的名称。

(2)实现Runnable接口；
定义一个类，实现Runnable接口；
覆盖接口的public void run()的方法，将线程的任务代码封装到run方法中；
创建Runnable接口的子类对象
将Runnabl接口的子类对象作为参数传递给Thread类的构造函数，创建Thread类对象
（原因：线程的任务都封装在Runnable接口子类对象的run方法中。
所以要在线程对象创建时就必须明确要运行的任务）。
调用start()方法，启动线程。

两种方法区别：

(1)实现Runnable接口避免了单继承的局限性
(2)继承Thread类线程代码存放在Thread子类的run方法中
实现Runnable接口线程代码存放在接口的子类的run方法中；
在定义线程时，建议使用实现Runnable接口，因为几乎所有多线程都可以使用这种方式实现

6、创建线程是为什么要复写run方法？

Thread类用于描述线程。Thread类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。

7、start()和run方法有什么区别？

调用start方法方可启动线程，而run方法只是thread的一个普通方法，调用run方法不能实现多线程；

Start()方法:

start方法用来启动线程,实现了多线程运行,这时无需等待run方法体代码执行完毕而直接继续执行下面的
代码。通过调用Thread类的start()方法来启动一个线程,这时此线程处于就绪(可运行)状态，并没有运行，
一旦得到cpu时间片(执行权),就开始执行run()方法,这里方法run()称为线程体，
它包含了要执行的这个线程的内容，Run方法运行结束,此线程随即终止。

Run()方法:

run()方法只是Thread类的一个普通方法,如果直接调用Run方法,程序中依然只有主线程这一个线程,
其程序执行路径还是只有一条，还是要等待run方法体执行完毕后才可继续执行下面的代码，
这样就没有达到多线程的目的。

8、线程的几种状态：

新建：new一个Thread对象或者其子类对象就是创建一个线程，当一个线程对象被创建，但是没有开启，这个时候，
只是对象线程对象开辟了内存空间和初始化数据。
就绪：新建的对象调用start方法，就开启了线程，线程就到了就绪状态。
在这个状态的线程对象，具有执行资格，没有执行权。
运行：当线程对象获取到了CPU的资源。
在这个状态的线程对象，既有执行资格，也有执行权。
冻结：运行过程中的线程由于某些原因(比如wait,sleep)，释放了执行资格和执行权。
当然，他们可以回到运行状态。只不过，不是直接回到。
而是先回到就绪状态。
死亡：当线程对象调用的run方法结束，或者直接调用stop方法，就让线程对象死亡，在内存中变成了垃圾。
9、sleep()和wait()的区别：
(1)这两个方法来自不同的类，sleep()来自Thread类，和wait()来自Object类。
(2)sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用了b的sleep方法，实际上还是a去睡觉，
要让b线程睡觉要在b的代码中调用sleep。而wait()是Object类的非静态方法
(3)sleep()释放资源不释放锁，而wait()释放资源释放锁；
(4)使用范围：wait,notify和notifyAll只能在同步控制方法或者同步控制块里面使用,而sleep可以在任何地方使用
10、多线程安全问题：
(1)原因:当程序的多条语句在操作线程共享数据时(如买票例子中的票就是共享资源)，由于线程的随机性导致
一个线程对多条语句，执行了一部分还没执行完，另一个线程抢夺到cpu执行权参与进来执行，
此时就导致共享数据发生错误。比如买票例子中打印重票和错票的情况。
(2)解决方法:对多条操作共享数据的语句进行同步，一个线程在执行过程中其他线程不可以参与进来
11、Java中多线程同步是什么？
同步是用来解决多线程的安全问题的，在多线程中，同步能控制对共享数据的访问。如果没有同步，当一个线程在
修改一个共享数据时，而另外一个线程正在使用或者更新同一个共享数据，这样容易导致程序出现错误的结果。
12、什么是锁?锁的作用是什么?
锁就是对象
锁的作用是保证线程同步，解决线程安全问题。
持有锁的线程可以在同步中执行，没有锁的线程即使获得cpu执行权，也进不去。
13、同步的前提:
(1)必须保证有两个以上线程
(2)必须是多个线程使用同一个锁，即多条语句在操作线程共享数据
(3)必须保证同步中只有一个线程在运行
14、同步的好处和弊端
好处：同步解决了多线程的安全问题
弊端：多线程都需要判断锁，比较消耗资源
15、同步的两种表现形式：
(1)同步代码块:
可以指定需要获取哪个对象的同步锁,使用synchronized的代码块同样需要锁,但他的锁可以是任意对象
考虑到安全问题，一般还是使用同一个对象，相对来说效率较高。

注意：
虽然同步代码快的锁可以使任何对象，但是在进行多线程通信使用同步代码快时，
必须保证同步代码快的锁的对象和，否则会报错。
同步函数的锁是this，也要保证同步函数的锁的对象和调用wait、notify和notifyAll的对象是
同一个对象，也就是都是this锁代表的对象。
格式：

synchronized(对象)
{
需同步的代码;
}

(2)同步函数
同步方法是指进入该方法时需要获取this对象的同步锁，在方法上使用synchronized关键字，
使用this对象作为锁，也就是使用了当前对象，因为锁住了方法，所以相对于代码块来说效率相对较低。
注:静态同步函数的锁是该方法所在的类的字节码文件对象，即类名.class文件
格式：-
修饰词 synchronized 返回值类型 函数名(参数列表)
{
需同步的代码;
}

16.死锁

两个线程对两个同步对象具有循环依赖时，就会发生死锁。即同步嵌套同步，而锁却不同。

17.wait()、sleep()、notify()、notifyAll()

wait():使一个线程处于等待状态，并且释放所持有的对象的lock。
sleep():使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要捕捉InterruptedException异常。
notify():唤醒一个处于等待状态的线程，注意的是在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，
而是由JVM确定唤醒哪个线程(一般是最先开始等待的线程)，而且不是按优先级。
Allnotity():唤醒所有处入等待状态的线程，注意并不是给所有唤醒线程一个对象的锁，而是让它们竞争。

18.多线程join方法：

void join() 等待该线程终止。
void join(long millis) 等待该线程终止的时间最长为 millis 毫秒。
throws InterruptedException
特点：当A线程执行到B线程的join方法时，A就会等待B线程都执行完，A才会执行
作用: join可以用来临时加入线程执行；

19.多线程优先级：yield()方法

yield():暂停当前正在执行的线程对象，并执行其他线程
setPriority(int newPriority):更改线程优先级
int getPriority() 返回线程的优先级。
String toString() 返回该线程的字符串表示形式，包括线程名称、优先级和线程组

五.java IO

1、IO流概述

(1)用来处理设备(硬盘，控制台，内存)间的数据。
(2)java中对数据的操作都是通过流的方式。
(3)java用于操作流的类都在io包中。
(4)按照流操作的数据的类型不同：分为字节流和字符流。字符流是为了方便中文的操作而来的。
(5)按照流的流向不同分为：输入流，输出流

2.字节流

输出字节流：OutputStream：字节写入流抽象类
输入字节流：InputStream：字节读取流抽象类

3.字符流

输出字符流：Writer：字符写入流的抽象
输入字符流：Reader: 字符读取流的抽象类

4.转换流

OutputStreamWriter：是Writer的子类，将输出的字符流变为字节流，即将一个字符流的输出对象变为字节流的输出对象
InputStreamReader：是Reader的子类，将输入的字节流变成字符流，即将一个字节流的输入对象变为字符流的输入对象。

5.内存操作流

字节内存流：ByteArrayInputStream（内存字节输入流）、ByteArrayOutputStream（内存字节输出流）。
字符内存流：CharArrayReader（内存字符输入流）、CharArrayWriter（内存字符输出流）。

6.管道流:进行两个线程间的通信

分为管道输出流（PipedOutputStream）、管道输入流（PipedInputStream）。
如果想进行管道输出，则必须把输出流连接在输入流上，在PipedOutputSream类上有如下方法用于连接管道。

7.打印流

打印流提供了非常方便的打印功能，可以打印任何的数据类型，如小数、整数、字符串等。
包含字节打印流（PrintStream）和字符打印流（PrintWriter）

六.图形界面

1.AWT（重量级组件）

主要包括以下三种工具类
1）组件：Component
2）容器：Container
3）布局管理器：LayoutManager

2.Swing（轻量级组件）

（1）基本容器JFrame
（2）标签组件JLabel
（3）按钮组件JButton
（4）布局管理器
（6）文本框和文本区框和密码输入框：JTextField和JTextArea和JPasswordField。

3.实现简单窗口

实现简单记事本

package demo;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.KeyEvent;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.KeyStroke;

public class TextPad implements ActionListener{
    JFrame frame;
    JMenuBar bar;
    JMenu fileMenu,editMenu,formatMenu,lookMenu;
    JMenuItem newItem,openItem,saveItem,saveAnotherItem,closeItem;
    ImageIcon newIcon,openIcon,saveIcon,saveAnotherIcon,closeIcon;
    JMenuItem revocationItem,cutItem,copyItem,stickItem,deleteItem,allItem,timeDateItem;
    JMenuItem lineItem,typeFaceItem,zoomItem,statusItem;
    JScrollPane scroll;
    JTextArea area;
    JFileChooser chooser;             //文件选择框
    File file;
    
    public TextPad() {
        frame = new JFrame("记事本");
        bar=new JMenuBar();
        fileMenu=new JMenu("文件");
        editMenu=new JMenu("编辑");
        formatMenu=new JMenu("格式");
        lookMenu=new JMenu("查看");
        newIcon=new ImageIcon("e:"+File.separator+"Test"+File.separator+"小图标"+File.separator+"newIcon.png");
        openIcon=new ImageIcon("e:"+File.separator+"Test"+File.separator+"小图标"+File.separator+"openIcon.png");
        saveIcon=new ImageIcon("e:"+File.separator+"Test"+File.separator+"小图标"+File.separator+"saveIcon.png");
        saveAnotherIcon=new ImageIcon("e:"+File.separator+"Test"+File.separator+"小图标"+File.separator+"saveAnotherIcon.png");
        closeIcon=new ImageIcon("e:"+File.separator+"Test"+File.separator+"小图标"+File.separator+"closeIcon.png");    
        area=new JTextArea();
        scroll=new JScrollPane(area);

        
        newItem=new JMenuItem("新建（N）",newIcon);
        openItem=new JMenuItem("打开（O）",openIcon);
        saveItem=new JMenuItem("保存（S）",saveIcon);
        saveAnotherItem=new JMenuItem("另存为（D）",saveAnotherIcon);
        closeItem=new JMenuItem("关闭（X）",closeIcon);
        
        revocationItem=new JMenuItem("撤销（Z）");
        cutItem=new JMenuItem("剪切（T）");
        copyItem=new JMenuItem("复制（ C）");
        stickItem=new JMenuItem("粘贴（V）");
        deleteItem=new JMenuItem("删除（P）");
        allItem=new JMenuItem("全选（A）");
        timeDateItem=new JMenuItem("时间日期（Q）");
        
        lineItem=new JMenuItem("自动换行（W）");
        typeFaceItem=new JMenuItem("字体（F）");
        zoomItem=new JMenuItem("缩放（R）");
        statusItem=new JMenuItem("状态栏（S）");
        
        //加上监视器
        newItem.addActionListener(this);
        openItem.addActionListener(this);
        saveItem.addActionListener(this);
        saveAnotherItem.addActionListener(this);
        revocationItem.addActionListener(this);
        cutItem.addActionListener(this);
        copyItem.addActionListener(this);       
        stickItem.addActionListener(this);
        deleteItem.addActionListener(this);
        allItem.addActionListener(this);
        timeDateItem.addActionListener(this);
        lineItem.addActionListener(this);
        typeFaceItem.addActionListener(this);
        zoomItem.addActionListener(this);
        statusItem.addActionListener(this);
        
        
        fileMenu.add(newItem);
        fileMenu.add(openItem);
        fileMenu.add(saveItem);
        fileMenu.add(saveAnotherItem);
        fileMenu.addSeparator();
        fileMenu.add(closeItem);
        
        editMenu.add(revocationItem);
        editMenu.add(cutItem);
        editMenu.add(copyItem);
        editMenu.add(stickItem);
        editMenu.add(deleteItem);
        editMenu.add(allItem);
        editMenu.add(timeDateItem);
        
        formatMenu.add(lineItem);
        formatMenu.add(typeFaceItem);
        lookMenu.add(zoomItem);
        lookMenu.add(statusItem);
        
        newItem.setMnemonic(KeyEvent.VK_N);
        openItem.setMnemonic(KeyEvent.VK_O);
        saveItem.setMnemonic(KeyEvent.VK_S);
        saveAnotherItem.setMnemonic(KeyEvent.VK_D);
        closeItem.setMnemonic(KeyEvent.VK_X);
        revocationItem.setMnemonic(KeyEvent.VK_Z);
        cutItem.setMnemonic(KeyEvent.VK_T);
        copyItem.setMnemonic(KeyEvent.VK_C);
        stickItem.setMnemonic(KeyEvent.VK_V);
        deleteItem.setMnemonic(KeyEvent.VK_P);
        allItem.setMnemonic(KeyEvent.VK_A);
        timeDateItem.setMnemonic(KeyEvent.VK_Q);
        
        //快捷键
        newItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_N,InputEvent.CTRL_DOWN_MASK));
        openItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_O,InputEvent.CTRL_DOWN_MASK));
        saveItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_S,InputEvent.CTRL_DOWN_MASK));
        saveAnotherItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_D,InputEvent.CTRL_DOWN_MASK));
        closeItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_X,InputEvent.CTRL_DOWN_MASK));
        revocationItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_Z,InputEvent.CTRL_DOWN_MASK));
        cutItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_T,InputEvent.CTRL_DOWN_MASK));
        copyItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_C,InputEvent.CTRL_DOWN_MASK));  
        stickItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_V,InputEvent.CTRL_DOWN_MASK));
        deleteItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_P,InputEvent.CTRL_DOWN_MASK));
        allItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_A,InputEvent.CTRL_DOWN_MASK));
        timeDateItem.setAccelerator(KeyStroke.getKeyStroke( KeyEvent.VK_Q,InputEvent.CTRL_DOWN_MASK));

        
        bar.add(fileMenu);
        bar.add(editMenu);
        bar.add(formatMenu);
        bar.add(lookMenu);
        
        frame.setJMenuBar(bar);
        frame.add(scroll);
        frame.setSize(600,400);
        frame.setLocation(200, 100);
        frame.setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent event) {
        Object obj=event.getSource();
        if(obj instanceof JMenuItem) {
            JMenuItem item = (JMenuItem) obj;
            if(item==newItem) {                  //文件栏
                new TextPad();
            }else if(item==openItem) {
                chooser=new JFileChooser();
                chooser.showOpenDialog(null);
                file=chooser.getSelectedFile();
                try {
                    FileInputStream fis=new FileInputStream(file);
                    byte[] b = new byte[fis.available()];
                    fis.read(b);
                    area.append(new String(b));
                    fis.close();
                    
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }else if(item==saveItem) {
                
                file=chooser.getSelectedFile();
                FileOutputStream fos;
                try {
                    fos = new FileOutputStream(file);
                    byte[] b=area.getText().getBytes();
                    fos.write(b);
                    fos.close();
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                } catch (IOException e) {               
                }           
            }else if(item==saveAnotherItem) {
                chooser=new JFileChooser();
                chooser.showSaveDialog(null);
                file=chooser.getSelectedFile();
                try {
                    if(!file.exists()) {
                        file.createNewFile();
                    }
                    FileOutputStream fos=new FileOutputStream(file);
                    byte[] b=area.getText().getBytes();
                    fos.write(b);
                    fos.close();
                } catch (FileNotFoundException e) {                 
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                
            }else if(item==closeItem) {
                System.exit(1);
                
            }
            else if(item==cutItem) {                           //编辑栏
                area.cut();
            }else if(item==copyItem) {
                area.copy();
            }else if(item==stickItem) {
                area.paste();
            }else if(item==allItem) {
                area.selectAll();
            }else if(item==deleteItem) {
                String temp=area.getSelectedText();
                int start=area.getSelectionStart();
                int end=area.getSelectionEnd();
                area.replaceRange("", start, end);
            }else if(item==timeDateItem) {
                Date d = new Date();
                SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String dateNewStr=sdf.format(d);
                area.append(dateNewStr);
        }
        
    }
    }
}

总结

眨眼间，一个学期就过去了，这个学期学的语言是java，java和c有很多相似的又有很多不同。最初接触java时给我最大的不同便是语法，第一次看java代码时给我的感觉是一堆一堆很繁琐，不像c,很简洁很明了。后来经过一段时间的学习，也慢慢了解了java，慢慢发现java有很多还是和c很相象的，例如循环语句，条件语句这些，但也有很多不用，首先最大的不同便是语法上的。在这个学期开始时，对于java其实是没有跟上去的，可能与c的相差还是有点大，对于java的编程有点习惯用c的想法去想去思考，导致很多理解不来，所以最初一段时间是没跟上来，后来经过之后的学习以及自己再往前复习复习才慢慢跟上，现在也还是理解最基础的很多还是不知道，所以这个学期的java其实是没怎么学好的。之后再寒假还得多看看java。