这周的学习报告分两份，第一份是将过往偷懒的，没整理全的知识点进行补充，顺带复习，第二份则针对Java网络编程、绘图以及泛型与集合框架这三个大的点进行整理（可能写不完拖到第十三周吧(#^.^#)）
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
一、Java入门
（一）每种语言之所以至今仍然被使用，其原因是因为它不可以被完全替代，或者说它的优势足以让它继续被使用。而Java最大的优势应当是它的可移植性，同时它是一种多线程、稳定、面向对象的语言。顺带一提，C语言和C++没有被替代的原因是因为他们的运行速度非常快，是最能提高硬件运行效率的语言，非常适合底层开发。
（二）Java程序开发步骤
1、编写源文件 2、编译（得到字节码文件）（字节码文件可以被反编译得到源文件） 3、运行（用Java解释器解释字节码文件）
（三）程序编写风格
1、Allmans风格（独行风格）左右大括号各占一行
2、Kernighan风格（行尾风格）左括号在上一行行尾，右大括号独占一行
注释不提
二、基本数据类型及数组（写过的部分不再重新提起）
（一）标识符
用来标识类名、变量名、方法名、类型名、数组名及文件名的有效字符序列，标识符由字母、下划线、美元符号和数字组成，长度不限。标识符首字母不为数字，不能是其余关键字，也不能为true、false和null。
（二）Unicode字符集
Java使用Unicode标准字符集，其前128个字符为ascll码。因此Java所使用的字母不仅包括通常的拉丁字母，也包括汉字、日文片假名、朝鲜文、俄文等等。
三、运算符、表达式和语句
（一）算术运算符
加减运算符优先级是4级，乘除和求余运算符优先级是3级，他们都是二目运算符，操作元都是整型或浮点型数据，结合方向都是从左到右。顺便一提，自增自减运算符的操作元也只能是整型或者浮点型变量。
（二）逻辑运算符
&&、||表示逻辑与、逻辑或，是二目运算符；！表示逻辑非，是单目运算符。逻辑运算符操作元必须是boolean型数据，但是可以连接关系表达式。
（三）位运算符
(1)按位与运算符 & 是二目运算符，对两个整型数据a、b按位进行运算，先将数据化为32位二进制数据，若两个数据对应位都是1，则和的对应位为1，否则是0，如果b的精度高于a，则结果和精度与b相同。
(2)按位或运算符 | 是二目运算符，前面过程一致，若两个数据对应位都是0，则和的对应位是0，否则为1。
(3)按位非运算符 ~ 是单目运算符，前面过程一致，若a对应位是0，则结果对应位是1，否则是0。
(4)按位异或运算 ^ 是二目运算符，前面过程一致，若两个数据对应位相同，则结果对应位是0，否则是1
所以有a^a=0,a^0=a. a^b^b=a
位运算符也可以操作逻辑型数据，当a、b都是true，a&b是true，否则a&b为false；当a、b都是false，a|b是false，否则a&b为true；~就不提了，类似于！。
（四）语句概述（这部分不提，C语音与C++的学习已经了解）
四、类与对象
（1） 参数传值
在Java中，方法的所有参数都是“传值”的
class Computer{
int add(int x,int y){
return x+y;
}
}
public class Example4_6 {
public static void main(String args[]){
Computer com = new Computer();
int m = 100;
int n = 200;
int result = com.add(m,n); //将m、n的值“传值”给参数x、y
System.out.println(result);
result = com.add(120+m,n*10+8); //将表达式120+m，n*10+8的值“传值”给参数x、y
System.out.println(result);
}
}
（2）对于引用
一个类声明的两个对象如果具有相同的引用，两者就具有完全相同的变量
此处提及一下饿汉式单例模式
//对象是方法被调用时，才初始化，也叫做对象的延时加载。成为：懒汉式。
//Single类进内存，对象还没有存在，只有调用了getInstance方法时，才建立对象。
class Single
{
private static Single s = null;//创建对象
private Single(){}//防止被其他类对该类进行实例化，避免被调用
public static Single getInstance()
{
//A B
if(s==null)//如果A，B为空则进入
{
synchronized(Single.class)//A 进入后 此处功能是防止B进入，加入同步锁 只允许一个实例进入
{
if(s==null)//A为null
//对A进行实例化 再返回同步快12行，此时只有一个对象B,可以进入同步锁，到14行此时对象不为空因为实例化了A ，直接返回S
s = new Single();
}
}
return s;
}
五、子类与继承（之前第六周学习报告写的非常完善，这里跳过）
六、接口与实现（跳过）
七、内部类与异常类（当时因为不理解就暂时略过了，此处整理就从头开始吧）
（1）类可以有两种重要成员：成员变量和方法，而Java还允许类可以有一种成员：内部类。 Java支持在一个类中定义另一个类，这样的类称内部类，包含内部类的类成为内部类的外嵌类
内部类和外嵌类之间的重要关系有 1、内部类的外嵌类的成员变量在内部类有效，内部类的方法可以调用外嵌类的方法 2、内部类的类体不可以声明类变量和类方法，外嵌类的类体可以用内部类声明对象作为外嵌类的成员 3、内部类仅供它的外嵌类使用
举例
public class RedCowForm {
static String formName;
RedCow cow; //内部类声明对象
RedCowForm() {
}
RedCowForm(String s) {
cow = new RedCow(150,112,5000);
formName = s;
}
public void showCowMess() {
cow.speak();
}
class RedCow { //内部类的声明
String cowName = "红牛";
int height,weight,price;
RedCow(int h,int w,int p){
height = h;
weight = w;
price = p;
}
void speak() {
System.out.println("偶是"+cowName+",身高:"+height+"cm 体重:"+weight+"kg,生活在"+formName);
}
} //内部类结束
}
（2）关于匿名类作用不理解......跳过
（3）异常类
1、所谓异常就是程序运行时可能出现的一些错误，异常处理将会改变程序的控制流程，让程序有机会对错误做出处理。
Java使用throw关键字抛出一个Exception子类的实例表示异常发生，允许方法调用过程中抛出异常对象，终止当前方法的继续执行。
2、Java使用try-catch处理异常，将可能出现的异常操作放在try部分，一但try抛出异常对象，那么try部分立刻结束执行，转向执行相应的catch部分。
3、编写程序时，可以扩展Exception类定义自己的异常类。throw是关键字，与throws是不同的关键字
4、断言
断言语句一般用于程序不准备通过捕获异常来处理的错误，要求程序必须立即停止执行。在调试代码阶段，可以让断言语句发挥作用，正式运行是可以关闭断言语句但仍把断言语句保留在源代码中，以后可以重新启用断言语句。
用Java解释器直接运行时默认关闭断言语句，可以使用-ea启用断言，如Java -ea mainClass
八、常用实用类
（1）String类
String类在Java.lang包中，因为Java.lang包被默认引入，因此可以直接使用String类，因为String类是final类，因此用户不能扩展，即String类没有子类。
String常量也是对象，有String s = new String("hello world");但凡是new运算符构造出的对象都不在常量池中。
（2）字符串的并置 String对象可以用“+”进行并置运算，首尾相接得到一个新的String对象。
（3）String类的常用方法
1、String对象调用equals(String s)方法比较当前String对象的字符序列是否与参数s指定的String对象的字符序列相同，如
String a = new String("nihao");
String b = new String("nihao");
String c = new String("hello world");那么a.equals(b)的值是true，a.equals(c)是false。
2、String对象调用startsWith(String s)方法,判断当前String对象的字符序列前缀是否与参与参数指定的String对象的字符序列，如
String a = "你好" ,b = "不好"那么a.startsWith("你")的值就是true，b.startsWith("你")的值就是false.
3、那么endsWith(String s)就是判断后缀是否是参数s的字符序列。
4、compareTo(String s)按字典序与参数指定的String对象s的字符序列比较大小
5、contains(String s)比较当前String对象的字符序列是否包含参数s的字符序列，如，a="nihao",那么a.contains("bu")的值就是false
6、idnexOf(String s)和lastIndexOf(String s) 对于String a = "ABC",索引位置0、1、2上的字符分别是A、B、C。 idnexOf(String s)从当前String对象的字符序列的0索引位置开始检索首次出现s的字符序列的位置，并返回该位置；lastIndexOf(String s)从当前String对象的字符序列的0索引位置开始检索最后一次出现s的字符序列的位置。idnexOf(String s,int startpoint)方法是一个重载方法，参数startpoint的值用来指定检索开始的位置。
7、substring(int startpoint)获得一个新的String对象，新的String对象字符序列赋值当前String对象的字符序列中的startpoint位置到最后位置上的字符所得到的字符序列。调用substring(int start,int end)得到的新的String对象的字符序列赋值当前String对象的字符序列中的start位置至end-1位置上的字符。
（4）字符串可以与基本数据相互转化
使用public static int parseInt(String s)可以将“数字”字符组成的字符序列转化成int型数据，同样的也有public static int parseByte(String s)，public static int parseLong(String s)，public static int parseFloat(String s)等等
也可以用如public static String valueOf(int n),public static String valueOf(byte n),public static String valueOf(float n)等方法将如123、1232.98等数值转化为String对象。
（5）正则表达式（元字符不一一列举，详情看书或者仔细上网查阅资料）
在正则表达式中可以用限定修饰符，如对于限定修饰符？，如果X表达正则表达式中的一个元字符或普通字符，那么X？表示X出现了0次或1次。 如String a = "nihao[2468]？";那么“nihao2” “nihao4”....都是与正则表达式a匹配的字符串。 又例如a = "@\\w{4}",那么“@abcd” ，“Java” ，“世界和平”都是与正则表达式a匹配的字符串。
（6）StringTokenizer类和Scanner类都可以用于分解String对象的字符序列，StringTokenizer(String s)为s构造一个分析器，使用默认的分隔标记。StringTokenizer(String s，String delim)为s构造一个分析器，参数delim的字符序列中的字符任意排列被作为分隔标记。
（7）StringBuffer类
（8）日期 format方法 format(格式化模式，日期列表)
（9）Math类,BigInteger类和Random类
Random类用于获得随机数，如Random random = new Random(); random.nextInt(100)可以返回一个0~99之间的某个整数
（10）
1、format方法也可以用于对数字格式化。如String s = String.format("%.2f",3.1415926535)，那么s的字符序列就是3.14 String s = String.format("%d元%0.3f公斤%d台",888,999.777666,123); s就是“888元999.778公斤123台”
2、%d:将值格式化为十进制整数，%o：将值格式化为八进制整数，%x将值格式化为小写的十六进制整数，%X：将值格式化为大写的十六进制整数。
（11）Class类 帮助程序创建其他类的实例。
（12）console类,可以用于在键盘输入一行文本，又不在命令行显示，可以用System类调用console（）方法返回console()方法返回Console类的一个对象，如 Console cons = System.console();然后用cons调用readPassword()方法读取用户在键盘输入一行文本，并将文本以一个char数组返回： char []passwd = cons.readPassword();
九、组件及事件处理（跳过）
十、输入、输出流
程序在运行期间，可能需要从外部的存储媒介或其他程序读入所需要的数据，这就需要使用输入流，程序通过输入流读取源中的数据，使用read（）方法读入。同样的，也有必要使用输出流，用write（）方法把数据写入目的地。 多有输入流都是抽象类InputStream（字节输入流）或抽象类Reader（字符输入流）的子类，而所有输出流都是抽象类OutputStream或者Writer的子类
（1）File类
file类对象主要用来获取文件本身的一些信息如文件所在目录、文件长度或者读写权限，不涉及对文件的读写。构造方法有三个 File(String filename);File(String directoryPath,String filename);File(File dir,String filename)directoryPath指文件路径dir是目录，使用File(String filename)，该文件被认为与当前应用程序在同一目录中。
使用file类的方法获取文件本身信息 getName(); canRead()能否读取; canWrite()能否写入; exists()是否存在; length()获取文件长度，单位是字节; getAbsolutePath()获取文件绝对路径; getParent()获取文件父目录;等等
（2）文件字节输入流
使用输入流有四个步骤 1、设定输入流的源 2、创建指向源的输入流 3、让输入流读取源中的数据 4、关闭输入流。
构造方法
FileInputStream(String name);
FileInputStream(File file);第一个构造方法使用给定的文件名创建输入流，第二个使用File对象创建书瑞路，参数name和file指定的文件称为输入流的源。
创建输入流，可能会出现错误（或者称为异常），如文件不存在。当出现I/O错误，Java生成一个出错信号，它使用IOException（IO异常）对象表示这个出错信号。程序必须在try-catch语句中try块创建输入流，在catch块检测并处理这个异常
字节输入流的read方法以字节为单位读取源中数据 输入流提供了关闭方法close()。例子如下
import java.io.*;
public class Example10_4 {
public static void main(String args[]) {
int n=-1;
byte [] a=new byte[100];
try{ File f=new File("Example10_4.java");
InputStream in = new FileInputStream(f);
while((n=in.read(a,0,100))!=-1) {
String s=new String (a,0,n);
System.out.print(s);
}
in.close();
}
catch(IOException e) {
System.out.println("File read Error"+e);
}
}
}
（3）文件字节输出流类似输入流，不再赘述。
（4）文件字符输入、输出流
与FileInputStream、FileOutputStream字节流对应的是FileReader、FileWriter字符流，不赘述
（5）缓冲流
BufferedReader和BufferedWriter类创建的对象称为缓冲输入、输出流，这加强读写文件的能力。例如student.txt是一个学生名单，每个姓名占一行，如果我们要读取名字，那么每次必须读取一行，使用FileReader流很难完成这样的任务，因为我们不清楚一行有多少字符，因此Java提供更高级的流BufferedReader和BufferedWriter，二者的源和目的地必须是字符输入、输出流。 BufferedReader和BufferedWriter的构造方法
BufferedReader(Reader in);
BufferedWriter(Writer out);BufferedReader流通过方法readLine()读取文本行，具体操作如下
FileReader one = new FileReader("a.txt");
BufferedReader two = BufferedReader(one);String Line = two.readLine();这样就读取了a.txt文件，类似的将FileWriter、BufferedWriter连接起来，然后使用BufferedWriter将数据写到目的地。
（6）随机流
RandomAccessFile类创建的流称作随机流，它既可以作为流的指向，也可以作为流的源，即既可以从这个流中读取文件中的数据，也可以通过这个流写入数据到文件。构造方法如下
RandomAccessFile(String name,String mode) RandomAccessFile(File file,String mode)
file是一个File对象，给出创建的流的源，也是流目的地，name用于确定文件名，给出创建的流的源，也是流目的地。mode取r（只读）或rw（可读写）权限
（7）数组流
流的源和目的地除了可以是文件，也可以是计算机内存
因此有字节数组流和字符数组流，给出例子，不细说
import java.io.*;
public class Example10_10 {
public static void main(String args[]) {
try {
ByteArrayOutputStream outByte=new ByteArrayOutputStream();
byte [] byteContent="mid-autumn festival".getBytes();
outByte.write(byteContent);
ByteArrayInputStream inByte=new ByteArrayInputStream(outByte.toByteArray());
byte backByte []=new byte[outByte.toByteArray().length];
inByte.read(backByte);
System.out.println(new String(backByte));
CharArrayWriter outChar=new CharArrayWriter();
char [] charContent="中秋快乐".toCharArray();
outChar.write(charContent);
CharArrayReader inChar=new CharArrayReader(outChar.toCharArray());
char backChar []=new char[outChar.toCharArray().length];
inChar.read(backChar);
System.out.println(new String(backChar));
}
catch(IOException exp){}
}
}
（8）数据流
DataInputStream和DataOutputStream类创建的对象称为数据输入、输出流，他们允许程序按着机器无关的风格读取Java原始数据，即读取一个数值时不再关心这个数值是多少字节。构造方法如下
DataInputStream（InputStream in）创建的数据输入流流向有参数in指定的底层输入流，同样的有
DataOutputStream（OutputStream out）创建的数据输出流流向有参数out指定的底层输出流，这两个类的方法不一一赘述。
（9）对象流
ObjectInputStream和ObjectOutputStream类分别是InputStream和OutputStream类的子类，创建的对象称为对象输入、输出流。对象输出流使用writeObject（Object obj）方法将一个对象obj写入一个文件，同样的有readObject(Object obj)读取一个对象到程序中，构造方法如下
ObjectInputStream（InputStream in）和ObjectOutputStream（OutputStream out）
使用对象流写入或者读入对象时，要保证对象是序列化，这是为了保证能把对象写入到文件并能再把对象正确读回到程序中。 一个类如果实现了Serializable接口（java.io包中的接口）那么这个类创建的对象就是所谓的序列化对象
（10）序列化与对象克隆
已知一个类的两个对象如果具有相同的引用，那么他们具有相同的实体和功能，所以如果我们想得到对象的一个复制，而复制的变化不会引起对象实体发生变化，这样的复制称为原对象的一个克隆对象
我们可以将要克隆的对象写入对象输出流指向的目的地，然后将该目的地作为一个对象输入流的源，那么该对象输入流从源中读回的对象一定是原对象的一个克隆。即 对象输入流通过对象的序列化信息来得到当前对象的一个克隆。
（11）使用Scanner解析文件
与前面第八章使用Scanner解析字符串中数据类似，不赘述。
（12）带进度条的输入流
可以使用javax.swing包提供的输入流类ProgressMonitorInputStream.构造方法是 ProgressMonitorInputStream(compunent c,String s,InputStream)
进度条在参数c指定的组件正前方显示，若c=null，则在屏幕正前方显示。
（13）文件锁
经常会出现几个程序处理同一个文件的情景，比如同时更新或读取文件，这样可能发生混乱，文件锁可以帮助解决这样的问题。比如RandomAccessFile创建的流在读写文件是可以使用文件锁，只要不解除该锁，其他程序无法操作被锁定文件。具体如何实现给出例子
import java.io.*;
public class Example10_19 {
public static void main(String args[]) {
File file=new File("Example12_15.java");
WindowFileLock win=new WindowFileLock(file);
win.setTitle("使用文件锁");
}
}
import java.io.*;
import java.nio.*;
import java.nio.channels.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class WindowFileLock extends JFrame implements ActionListener {
JTextArea text;
JButton button;
File file;
RandomAccessFile input;
FileChannel channel;
FileLock lock;
WindowFileLock(File f) {
file=f;
try {
input=new RandomAccessFile(file,"rw");
channel=input.getChannel();
lock=channel.tryLock();
}
catch(Exception exp){}
text=new JTextArea();
button=new JButton("读取一行");
button.addActionListener(this);
add(new JScrollPane(text),BorderLayout.CENTER);
add(button,BorderLayout.SOUTH);
setSize(300,400);
setVisible(true);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void actionPerformed(ActionEvent e) {
try{
lock.release();
String lineString=input.readLine();
text.append("\n"+lineString);
lock=channel.tryLock();
if(lineString==null)
input.close();
}
catch(Exception ee){}
}
}
从前整理到此为止。
参考资料 Java2实用教程（第五版）耿祥义 张跃平编著