课程总结
针对本学期学习的JAVA程序设计我做了以下总结：
1、本学期<Java程序设计>课程的主要内容
1）、基础语法：Java关键字，标识符，类型转换、直接量、变量、循环语句（if,for,switch）、方法、运算符、递归。
2）、面向对象编程（重中之重）：面向对象设计思想、对象与内存（重点）、方法重载、对象创建使用、abstrsct的使用、final的使用、super的使用、static的使用、
package和import的运用、对象 转型、多态、抽象类、接口等基本的知识点。其中重点掌握有封装、继承、多态、抽象类、接口。
3）、异常处理：try｛...｝catch（Exception e）｛...｝、异常的分类、方法异常的抛出、自定义异常。
4）、数组：基本的数组操作、二维数组的使用。
5）、常用类：String类、StringBuffer类、Math类、File类等等。
6）、文件与数据流：输入流 java.io.InputStream 、输出流 java.io.OutputStream，带缓存的输入流和输出流BufferedOutputStream、 BufferedOutputStream
带缓存的读写器BufferedWreter BufferReader
7）、线程：线程的两种实现方式，Synchronized关键字——同步，死锁等问题。
8）、JDBC，MySQL，记事本操作。
2. Java 继承
Java面对对象具有三大特性：
继承：继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的
封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口
多态：多态是指允许不同子类型的对象对同一消息作出不同的响应。要实现多态主要是做两件事：重写和重载。
2.1 方法重载和方法重写
重载：是在一个类里面，是多态在编译器的表现形式。判断方法：
方法名相同
形参列表不同
重写：是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。是多态的运行期间的表现形式。判断条件：
方法名和形参列表相同
重写方法的返回值或者抛出的异常类型要与被重写的方法的返回值和抛出的异常相同，或者为其子类
重写方法的访问修饰符大于等于被重写方法的访问修饰符
注意事项：
静态方法不存在重写，形式上的重写只能说是隐藏；
私有方法不存在重写，父类中的private方法，子类中即使定义了也相当于一个新的方法；
2.2 抽象类和接口
抽象类（abstract）和接口（interface）的区别：
抽象类中可以有构造方法，接口中不能；
抽象类中可以有普通成员变量，接口中不能；
抽象类中可以包含非抽象的普通方法，接口不能；
抽象类中的访问类型是：public、protected，接口中默认为：public abstract;
抽象类中可以包含静态方法，接口中不能；
抽象类中的静态成员变量类型任意，接口中仅为：public static final;
一个类只可以继承（extends）一个抽象类，但一个类可以继承（implements）多个接口；
3.3 super和this关键字
this关键字：是指向对象本身的一个指针。this只能在类中的非静态方法中使用，静态方法和静态的代码块中绝对不能出现this。
表示类中的属性和方法：函数参数或者参数中的局部变量和成员变量同名的情况下，成员变量被屏蔽，此时要访问成员变量则需要用"this.成员变量名"来访问成员变量。例如:
class B{
private int x = 1;
public void out(){
int x = 2;
System.out.print(x);//打印2
System.out.print(this.x);//打印1
}
}
表示当前对象：在函数中，需要引用该函数所属类的当前对象时候，直接使用this
class C{
public static void main(String[] args){
C c1 = new C();
c1.tell();
}
public static void tell(){
System.out.print(this);//打印当前对象的字符串表示
}
}
super关键字：
子类调用父类的构造方法：用super(参数列表)的方式调用，参数不是必须的。同时，还要注意super(参数列表)这条语句只能在子类构造方法中的第一行。例如：
class A{
public A(){
System.out.print("A");
}
}
class B extends A{
public B(){
super();//调用父类构造方法，打印A
System.out.print("B");
}
}
访问父类中被覆盖的同名变量或者方法：如果子类覆盖了父类的中某个方法的实现，可以通过使用 super 关键字来引用父类的方法实现。例如：
class A{
public int a = 1;//可以直接赋值，不用通过构造函数
public void say(){
System.out.print(a);
}
}
class B extends A{
private int a = 2;
public void say(){
System.out.print(super.a);//访问父类的a变量，前提是父类的a变量是公有的
}
public void tell(){
super.say();//调用父类的say()方法而不是子类的say()方法
}
}
2.4 Java构造器
在Java中，构造方法的主要作用是完后才能对象的初始化工作，把定义对象的参数传给对象的域。
注意事项：
构造方法的方法名必须与类名相同；
构造方法没有返回类型，也不能定义为void，在方法名前不声明方法类型；
一个类可以定义多个构造方法，如果类在定义时没有定义构造方法，编译器会自动插入一个无参数的默认构造器；
子类不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
3. Java 异常
Java把异常当作对象来处理，并定义一个基类java.lang.Throwable作为所有异常的超类。
3.1 Java异常分类
throwable又可以分为两类：
Error：内部错误或者资源耗尽错误，当出现这些异常时，Java虚拟机（JVM）一般会选择终止线程
Exception：通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
Exception又可分为：
UncheckedException：是程序运行时错误，常见的异常有：
ClassNotFoundException：应用程序试图加载类时，找不到相应的类，抛出该异常。
IllegalAccessException：拒绝访问一个类的时候，抛出该异常。
InterruptedException：一个线程被另一个线程中断，抛出该异常。
NoSuchMethodException：请求的方法不存在
NullPointerException：空指针异常
IndexOutOfBoundsException： 数组角标越界异常，常见于操作数组对象时发生。
ClassCastException： 数据类型转换异常
NumberFormatException： 字符串转换为数字异常；出现原因：字符型数据中包含非数字型字符。
CheckedException：需要用 try…catch… 语句捕获并进行处理，并且可以从异常中恢复，常见的有：
IOException
SQLException
3.2 异常处理机制
Java的异常处理机制可分为：
异常捕获：try、catch 和 finally
异常抛出：throws、throw
对于异常捕获，我们需要注意的是一下几点：
try语句在返回前，将其他所有的操作执行完，保留好要返回的值，而后转入执行finally中的语句，而后分为以下三种情况：
情况一：如果finally中有return语句，则会将try中的return语句”覆盖“掉，直接执行finally中的return语句，得到返回值，这样便无法得到try之前保留好的返回值。
情况二：如果finally中没有return语句，也没有改变要返回值，则执行完finally中的语句后，会接着执行try中的return语句，返回之前保留的值。
情况三：如果finally中没有return语句，但是改变了要返回的值，这里有点类似与引用传递和值传递的区别，分以下两种情况：
如果return的数据是基本数据类型或文本字符串，则在finally中对该基本数据的改变不起作用，try中的return语句依然会返回进入finally块之前保留的值。
如果return的数据是引用数据类型，而在finally中对该引用数据类型的属性值的改变起作用，try中的return语句返回的就是在finally中改变后的该属性的值
对于异常的抛出，需要注意的是：throws和throw的区别，
throw：
throw 语句用在方法体内，表示抛出异常，由方法体内的语句处理。
throw 是具体向外抛出异常的动作，所以它抛出的是一个异常实例，执行 throw 一定是抛出了某种异常
throws：
throws 语句是用在方法声明后面，表示如果抛出异常，由该方法的调用者来进行异常的处理。
throws 主要是声明这个方法会抛出某种类型的异常，让它的使用者要知道需要捕获的异常的类型。
throws 表示出现异常的一种可能性，并不一定会发生这种异常。
4. Java Object
4.1 Object方法概述
Java中的Object类是所有类的父类，它提供了以下11个方法：
public final native Class<?> getClass()：返回当前运行时对象的Class对象，getClass方法是一个final方法，不允许子类重写，并且也是一个native方法。
public native int hashCode()： 返回散列值，而 equals() 是用来判断两个实例是否等价。等价的两个实例散列值一定要相同，但是散列值相同的两个实例不一定等价。
public boolean equals(Object obj)：在非空对象引用上equlas具有以下特性：
（一）自反性
x.equals(x); // true
1
（二）对称性
x.equals(y) == y.equals(x) // true
1
（三）传递性
if(x.equals(y) && y.equals(z)) {
x.equals(z); // true;
}
（四）一致性：多次调用 equals() 方法结果不变
x.equals(y) == x.equals(y); // true
（五）与 null 的比较：对任何不是 null 的对象 x 调用 x.equals(null) 结果都为 false
x.euqals(null); // false;
protected native Object clone() throws CloneNotSupportedException：是一个protected的native方法。由于Object本身没有实现Cloneable接口，所以不重写clone方法并且进行调用的话会抛出异常。且clone函数具有以下特性：
x.clone()!=x：x.clone()返回的对象为新建的对象，与原来的对象地址不同。
x.clone().getClass() == x.getClass(）：克隆出的对象与原对象都是同一个类生成的。
x.clone().equals(x)：新的对象与原来的对象相同（在equals()函数下是相同的,所以通常需要覆盖equals()方法）
public String toString()：Object对象的默认实现，即输出类的名字@实例的哈希码的16进制
public final native void notify()：是一个native方法，并且也是final的，不允许子类重写。唤醒一个在此对象监视器上等待的线程(监视器相当于就是锁的概念)。如果所有的线程都在此对象上等待，那么只会选择一个线程。选择是任意性的，并在对实现做出决定时发生。
public final native void notifyAll()：跟notify一样，唯一的区别就是会唤醒在此对象监视器上等待的所有线程，而不是一个线程。
public final native void wait(long timeout) throws InterruptedException：是一个native方法，并且也是final的，不允许子类重写。wait方法会让当前线程等待直到另外一个线程调用对象的notify或notifyAll方法，或者超过参数设置的timeout超时时间。
public final void wait(long timeout, int nanos) throws InterruptedException：跟wait(long timeout)方法类似，多了一个nanos参数，这个参数表示额外时间（以毫微秒为单位，范围是 0-999999）
public final void wait() throws InterruptedException：跟之前的2个wait方法一样，只不过该方法一直等待，没有超时时间。
protected void finalize() throws Throwable { }：该方法的作用是实例被垃圾回收器回收的时候触发的操作finalize方法是一个protected方法，Object类的默认实现是不进行任何操作。
4.2 “==”和equals的区别：
==：如果比较的对象是基本数据类型，则比较的是数值是否相等；如果比较的是引用数据类型，则比较的是对象的地址值是否相等。在不遇到算术运算的情况下，不会自动拆箱。
equals()：用来比较方法两个对象的内容是否相等。
注意：equals 方法不能用于基本数据类型的变量，如果没有对 equals 方法进行重写，则比较的是引用类型的变量所指向的对象的地址。
本学期的JAVA学习使我感到很艰难，因为没有真正弄懂JAVA的真正含义，使自己的思维跟不上，学习还不够努力，从而在学习的过程中出现了很多状况，
这使我认识到学习java应该是循环渐进,有始有终。基础掌握的不好，如果没有真正弄懂JAVA各种语法的真正含义，在学习的过程中就会不断地翻书去看前面的知识，
从而导致学的不够好和浪费时间 ，java是一门有着阶梯性的语言,我们应该按照java的学习体系,从最简单最基础的开始学，只有这样，我们在学习中才会遇到更少的麻烦.
java是一门更倾向于网络的语言，只有学好基础，才能够研究更高级的知识，因为没有基础.在以后的学习中很可能遇到很多的麻烦。在本学期过后我会继续努力，在复习旧的知识的同时。
学习新的知识，提高自己。