java超强学习笔记(三)

2008-10-7 11:02

java超强学习笔记(三) 
多线程：  进程与线程：   进程：同一个操作系统中执行的一个子程序，包含了三部分虚拟CPU、代码、数据   多进程：同一个操作系统中执行的多个并行的子程序。可以提高cpu的使用率   线程：在同一个进程当中执行的子程序流   多线程：同一个进程当中并发执行的多个子程序流。可以提高cpu的使用率   进程与线程的区别：    进程有独立的进程空间，进程中的数据存放空间（堆空间和栈空间）是独立的。    线程的堆空间是共享的，栈空间是独立的，线程消耗的资源也比进程小，相互之间可以影响的。   java中如何调进程：    调用本地程序的两个类     Runtime      Runtime.getRuntime.exec(...); //执行一个程序       其返回值就是Process类型     Process     注意：    只有运行状态的线程才有机会执行代码，主线程的中止不会影响其他的正在运行中的线程，主线程中止也就是main()方法退出了。只有进程中的所有线程都中止时，进程（JVM进程）才会退出，只要有线程没有中止，进程就不会退出。    操作系统决定线程是否有优先级，独占式的操作系统中系统会有优先级的概念，共享式的操作系统则不会有优先级的。    在线程的内部，程序依然顺序执行    线程编程的两种方法：   写一个类，继承Thread类，覆盖Thread类中继承来的run()方法，这样就写好了自定义的线程类。    继承java.lang.Thread类：     class MyThread extends Thread{         public void run(){  //覆盖run()，线程体方法，自身其实就是普通的方法          .......      }     }     启动线程：     public class TestThread{        public static void main(){         Thread t1=new Mythread();         T1.start();  //调用start()来启动线程，线程启动方法，向线程调度器说明当前线程已经准备好了，是一种可运行状态        }     }        写一个类，实现Runable接口，实现其中的run()方法。这种方法写好的类的对象需要作为线程类创建对象时构造方法的参数。    实现java.lang.Runnable接口：     Class MyThread  implements Runnable{        public void run(){             }     }     启动线程：     public class TestThread{      public static void main(){       Runnable myThread = new MyThread();       Thread t = new Thread(myThread);       t.start();      }     }       Thread中的一些方法：   currentThread()             返回对当前正在执行的线程对象的引用(实现接口方式时使用)   sleep(long millis)             在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)。    本线程不会去抢，除非sleep结束。    多个线程之间都会去抢执行权限，不会考虑优先级。   yield()             暂停当前正在执行的线程对象，并执行其他线程。             只给本类或者优先级大于本类优先级的线程去抢。            join()             等待该线程终止。              放在start()前面则没有用处。            setDaemon(boolean on)             将该线程标记为守护线程，守护线程需要依赖其他线程，会在虚拟机停止的时候停止。                 线程的生命周期：   1）初始状态：此时线程只是处于JVM进程中，只是创建了一个线程对象，并没有真正开始运行。   2）可动行状态：调用线程对象的start()方法，此时线程才真正的被创建，进入可运行状态，等待CPU的调度。“万事俱备，只欠CPU”。   3）运行状态：正在运行的线程，此时它拥有CPU的执行权。   4）阻塞状态：运行状态中的线程，如果正在等待用户输入或调用了sleep()和join()等方法都会导致线程进入阻塞状态，注意从阻塞状态出来的线程不一定马上回到运行状态，而是重新回到可运行状态，等待CPU的再次调度。   5）等待队列状态：一个线程调用一个对象的wait()会自动放弃该对象的锁标记，进入等待队列状态，只有当有另外一线程调用临界资源的notIFy()或notifyAll()方法，建议多使用notifyAll()，才会将等待队列中的线程释放，此线程进入锁池状态。   6）锁池状态：每个对象都有互斥锁标记，以防止对临界资源的访问造成数据的不一致，和数据的不完整性。一个线程拥有一个对象的锁标记后，另一线程想访问该对象，必须在锁池中等待。由系统决定哪个线程拿到锁标记并运行。注意从锁池状态出来的线程不是马上回到运行状态，而是重新回到可运行状态，等待CPU的再次调度。   7）终止状态：一个线程运行结束后称为终止状态，一个进程中只有所有的线程退出后才会终止。 
多线程：  多线程的同步：    多线程并发访问同一个对象（临界资源），如果不对线程进行同步控制，破坏了原子操作(不可再分的操作)，则会造成临界资源(两个线程同时访问的资源)的数据不一致。   
  每一个对象都有一个互斥的锁标记和一个锁池。当线程拥有这个对象的锁标记时才能访问这个资源，没有锁标记便进入锁池，保证在同步代码块中只有一个线程，解决了多线程同步控制的问题。      关键字：synchronized //线程在同步代码中必须采用串行访问    synchronized修饰代码块：对括号内的对象object加锁，只有拿到对象锁标记的线程才能进入该代码块。        public void push(char c){             synchronized(object){  //object只要是对象就可以，但必须保证是同一对象              ……              同步代码              ……             }        }            synchronized修饰方法：在整个方法范围内对当前对象的加锁，只有拿到对象锁标记的线程才能执行该方法。尽可能的少用        public synchronized void push(char c) {      ……      同步代码      ……      }              一个线程可以同时拥有多个对象的锁标记，锁标记如果过多，就会出现线程等待其他线程释放锁标记，而又都不释放自己的锁标记供其他线程运行的状况，造成死锁。    
  静态方法可以是同步方法：但是它所锁的并不是当前对象，是类对象。   抽象方法不能是synchronized同步的方法。   构造方法不能是synchronized同步的方法。       线程因为未拿到锁标记而发生阻塞进入锁池（lock pool）。每个对象都有自己的一个锁池的空间，用于放置等待运行的线程。由系统决定哪个线程拿到锁标记并运行      利用Collections类中的synchronizedXxxx(Xxxx ss)方法可以得到相应集合的线程安全的集合      注意：    在同步语句块中不能直接操作对象锁正在使用的对象。    对象与锁一一对应。    同步依赖对象锁，锁对象相同，同步语句串行，锁对象不同，同步语句并行。    顺序锁，不要回调，反向打开。    能不用同步就不用同步，有数据共享冲突时才使用同步。     等待通知机制：   线程间通信使用的空间称之为对象的等待对列（wait pool），该队列也是属于对象的空间的。      使用Object类中wait()的方法，在运行状态中，线程调用wait()，此时表示线程将释放自己所有的锁标记和CPU的占用，同时进入这个对象的等待池。等待池的状态也是阻塞状态，只不过线程释放自己的锁标记。只有在对该对象加锁的同步代码块里，才能掉用该对象的wait()，表示线程将会释放所有锁标记，进入等待队列，线程将进入等待队列状态。      一个线程进入了一个对对象加锁的同步代码块，并对该对象调用了wait()方法，释放自己拥有的所有锁标记，进入该对象等待队列，另一个线程获得了该对象的锁标记，进入代码块对该对象调用了notify()方法，就会从等待队列里释放出一线程，释放出的这个线程要继续运行就还要进入那个同步代码块，因为得不到要访问代码块对象的锁标记，而进入该对象的锁池，等待锁标记释放。      什么情况下释放锁：    同类代码执行完毕。    异常未处理，错误退出。    调用wait()。      相关方法：    1) wait()：交出锁和CPU的占用;    2) notify()：将从对象的等待池中移走一个任意的线程，并放到锁池中，那里的对象一直在等待，直到可以获得对象的锁标记。    3) notifyAll(): 将从等待池中移走所有等待那个对象的线程并放到锁池中，只有锁池中的线程能获取对象的锁标记，锁标记允许线程从上次因调用wait()而中断的地方开始继续运行       注意：    用notifyAll()取代notify()，因为在调用notify()方法时，是由系统决定释放出哪个线程。    只能对加锁的资源进行wait()和notify()。    判断是否进行等待wait()时，用while代替if来进行判断。     I/O流  字节输入流：InputStream类为所有字节输入流的父类   三个基本的read()方法：          int read()           从流里读出的一个字节。不推荐使用          int read(byte[] b)           将数据读入到字节数组中，并返回所读的字节数          int read(byte[] b, int off, int len)           off  从哪里开始读。           len  读取多少。           将输入流中最多 len 个数据字节读入字节数组。   其它方法：          void close()           关闭此输入流并释放与该流关联的所有系统资源。          int available()           返回不受阻塞地从此输入流读取的字节数。          long skip(long n)           跳过和放弃此输入流中的n个数据字节，该方法有可能失效。          boolean markSupported()           测试此输入流是否支持 mark 和 reset 方法。          void mark(int n)           在此输入流中标记当前的位置          void reset()           将此流重新定位到对此输入流最后调用 mark 方法时的位置。    字节输出流：OutputStream类是所有字节输入流的父类   三个基本的write()方法：    void write(int n)     将指定的字节写入此输出流。    void write(byte[] b)     将 b.length 个字节从指定的字节数组写入此输出流。    void write(byte[] b, int off, int len)     将指定字节数组中从偏移量off开始的len个字节写入此输出流。   其它方法：    void close()           关闭此输出流并释放与此流有关的所有系统资源。    void flush()           刷新此输出流并强制写出所有缓冲的输出字节。             文件输入输出流：FileInputStream和FileOutputStream   要构造一个FileInputStream，所关联的文件必须存在而且是可读的。    如：     FileInputStream fis = new FileInputStream("myfile.dat");   要构造一个FileOutputStream，而输出文件已经存在，则它将被覆盖。        如：           FIleOutputStream fos = new FileOutputStream("results.dat");       要想以追加的方式写，则需要一个额外的参数，如：     FileOutputStream outfile = new FileOutputStream("results.dat" ,true); //参数为true时输出为追加，为false时为覆盖。  
  
I/O流  流的概念：程序与数据来源之间的桥梁    流的分类：   按数据方向分：输入流和输出流     输入流：InputStream/Reader     OutputStream/Writer   按数据类型分：字节流和字符流    字节流：InputStream/OutputStream    字符流：Reader/Writer   按流的功能分：节点流和处理流    节点流用操作数据的来源。    处理流用来封装节点流，从而给节点流增加一个功能，不能独立存在，在关闭流时如果使用了处理流，只需关闭最外层的流就可以了。    区分节点流和处理流的小方法：     看构造器，节点流参数为数据来源，而处理流参数为其他流。    选择流的思路：   先考虑是输入流还是输出流，   再考虑是字节流还是字符流，   最后考虑是节点流还是处理流。     字符流：Reader和Writer所有字符流的父类型   java技术使用Unicode来表示字符串和字符，而且提供16位版本的流，以便用类似的方法处理字符。   如果构造了一个连接到流的Reader和Writer，转换规则会在使用缺省平台所定义的字节编码和Unicode之间切换。     桥梁流：InputStreamReader和OutputStreamWriter（字节流转化成字符流的桥转换器）   这两个类不是用于直接输入输出的，他是将字节流转换成字符流的桥转换器，并可以指定编解码方式。      逐行读写流：BufferedReader/BufferedWriter   以上两个都是过滤流，需要用其他的节点流来作参数构造对象。   BufferedReader的方法：readLine():String ，当他的返回值是null时，就表示读取完毕了。要注意，再写入时要注意写换行符，否则会出现阻塞。   BufferedWriter的方法：newLine() ，这个方法会写出一个换行符。     管道流：线程交互的时候使用   PipedInputStream/PipedOutputStream    传送输出流可以连接到传送输入流，以创建通信管道。传送输出流是管道的发送端。通常，数据由某个线程写入 PipedOutputStream 对象，并由其他线程从连接的 PipedInputStream 读取。   注意：管道输出流和管道输入流需要对接。      数据流：DataInputStream和DataOutputStream   通过流来读写Java基本类，注意DataInputStream和DataOutputStream的方法是成对的。   支持直接输出输入各种数据类型。   注意：使用DataOutputStream/DataInputStream时，要注意写入顺序和读取顺序相同，否则会将没有分割写入的信息分割不正确而读取出错误的数据。     Properties类：针对属性文件(*.properties，内容是name=value)进行操作，在java.util包下    load(InputStream inStream)             从输入流中读取属性列表（键和元素对）。            getProperty(String key)             用指定的键在此属性列表中搜索属性。    java编码方式：   编码：把字符转换成数字存储到计算机中，按ASCII将字母映射为整数。   解码：把数字从计算机转换成相应的字符的过程。       不同的国家有不同的编码，当编码方式和解码方式不统一时，产生乱码。   因为美国最早发展软件，所以每种的编码都向上兼容ASCII 所以英文没有乱码。    ASCII（英文）                 1个字符占一个字节（所有的编码集都兼容ASCII）    ISO8859-1（拉丁文）     1个字符占一个字节    GB-2312/GBK            1个字符占两个字节（多用于中文）    Unicode                1个字符占两个字节（网络传输速度慢）    UTF-8                  变长字节，对于英文一个字节，对于汉字两个或三个字节。       中文编码时出现乱码的情况：    用流操作文件。    网页（动态静态）。    网络传递消息。       解决乱码的方式：    String temp = 乱码的字符串    temp = new String(temp.getBytes("ISO8859-1") , "GBK")       将temp按照ISO8859-1的方式进行解码生成一个字节序列，然后在按照GBK的方式解码字节序列生成字符串。     File类：可表示文件或者目录   File下的方法是对磁盘上的文件进行磁盘操作，但是无法读写文件的内容。
  构造器：    File(String pathname) //以文件的路径做参数       File类的方法：    boolean createNewFile()     创建一个新文件    File createTempFile(String prefix, String suffix, File directory)               在指定目录中创建一个新的空文件，使用给定的前缀和后缀字符串生成其名称。会在前缀和后缀之间加一个随机数    boolean mkdir()     创建一个新目录    boolean delete()     删除文件，删除的是创建File对象时指定与之关联创建的那个文件。    String[] List()     返回当前File对象下所有显文件和目录名（相对路径）    File[] ListFiles()     返回当前File对象（必须是目录）下的所有File对象，可以用getName()来访问到文件名。    boolean isDirectory()和boolean isFile()     判断究竟是目录还是文件。    boolean exists()     判断文件或文件夹是否存在。    String getPath()     获得相对路径。    String getAbsolutePath()     获得文件的绝对路径      注意：    File类的对象实施表示一个文件并不是真正的文件，只是一个代理而已，通过这个代理来操作文件    创建一个文件对象和创建一个文件在java中是两个不同的概念。前者是在虚拟机中创建了一个文件，但却并没有将它真正地创建到OS的文件系统中，随着虚拟机的关闭，这个创建的对象也就消失了。而创建一个文件才是在系统中真正地建立一个文件。    例如：     File f=new File(“11.txt”); //创建一个名为11.txt的文件对象     f.CreateNewFile();      //真正地创建文件
 RandomAccessFile：   允许随机访问文件，类支持直接输出输入各种数据类型。      构造器：    RandomAccessFile(File file, String mode)              创建从中读取和向其中写入（可选）的随机存取文件流，该文件由 File 参数指定。    RandomAccessFile(String name, String mode)              创建从中读取和向其中写入（可选）的随机存取文件流，该文件具有指定名称。     mode( r：以只读方式打开      rw：可读可写，不存在则创建)
  相关方法：    long getFilePointer()     返回文件指针的当前位置。    void seek(long pos)     设置文件指针到给定的绝对位置。    long length()     返回文件的长度。          对象流：ObjectInputStream和ObjectOutputStream（实现对象序列化）   对象流是过滤流，需要节点流作参数来构造对象，用于直接把对象写入文件和从文件中读取对象。   只有实现了Serializable接口的类型的对象才可以被读写，Serializable接口是个标记接口，其中没有定义方法。   对象会序列化成一个二进制代码，文件中保存对象的属性。      writeObject(o)、readObject()这两个是对象读写操作时用的方法。    Object o = new Object();     FileOutputStream fos=new FileOutputStream("Object.txt");    ObjectOutputStream oos=new ObjectOutputStream(fos);    oos.writeObject(o);    oos.close();
   FileInputStream fis =new FileInputStream(“Object.txt”);    ObjectInputStream ois =new ObjectInputStream(fis);    Object o = (Object)Ois.readObject();    ois.close();
  一个类中有其他类型的对象，那么，这个类实现了Serializable接口，在对象序列化时，也同样要求这个类中属性都能够对象序列化（基本类型除外）。      注意：    对于对象流的操作，在写对象时要一次写入完毕，如果使用追加模式写入，只会读取到上一次写入的对象，使用对象流写入时，会先写入一个头部，然后写入数据，最后加上结束符号，如果使用追加方式写入的话，那就会在结束符号继续向下写入，但是在读取时只会读到结束符为止，以后再次写入的数据就会丢失。
         
I/O流  对象流：ObjectInputStream和ObjectOutputStream   对象流是过滤流，需要节点流作参数来构造对象，用于直接把对象写入文件和从文件中读取对象。   只有实现了Serializable接口的类型的对象才可以被读写，Serializable接口是个标记接口，其中没有定义方法。   对象会序列化成一个二进制代码。      writeObject(o)、readObject()这两个是对象读写操作时用的方法。    Object o = new Object();     FileOutputStream fos=new FileOutputStream("Object.txt");    ObjectOutputStream oos=new ObjectOutputStream(fos);    oos.writeObject(o);    oos.close();
   FileInputStream fis =new FileInputStream("Object.txt");    ObjectInputStream ois =new ObjectInputStream(fis);    Object o = (Object)ois.readObject();    ois.close();      transient只能用来修饰属性。表示这个属性在对象序列化时将被忽略。    transient int num;    表示当我们进行序列化时忽略这个属性。
  注意：    对于对象流的操作，在写对象时要一次写入完毕，如果使用追加模式写入，只会读取到上一次写入的对象。使用对象流写入时，会先写入一个头部，然后写入数据，最后加上结束符号，如果使用追加方式写入的话，那就会在结束符号继续向下写入，但是在读取时只会读到结束符为止，以后再次写入的数据就会丢失。    包名、类名和属性可以被序列化，方法和构造器不会被序列化的。    静态属性不会被序列化的。    属性会被递归序列化的，也就是一个类中有引用类型的属性，如果这个属性对应的类实现了Serializable接口，在对象序列化时，也同样会对这个类中的属性进行对象序列化，如果没有实现Serializable接口，则会抛出异常。    所有属性必须都是可序列化的，特别是当有些属性本身也是对象的时候，要尤其注意这一点。    网络中传递对象必须实现序列化。    nio无阻塞的I/O（优化的I/O）   java.nio   定义块   Buffer类：一种用于特定的基本类型数据的容器    缓冲：就是块，用来存储内容。    容量：内存开辟的大小，根据类型的不同，有不同的空间。    界限：可用部分，即不应读取或写入的第一个元素的索引。    位置：当前指针的位置，从0开始。     容量>=界限>=位置         相关方法：     int capacity()               返回此缓冲区的容量。              int limit()               返回此缓冲区的界限。              int position()               返回此缓冲区的位置。              Buffer flip()               相当于截断没有用的空间，然后把指针移向开头，使limit=position,position=0              Buffer position(int newPosition)               设置此缓冲区的位置。                   当有大的文件需要处理的时候，为了不影响性能建议用直接缓冲。    Buffer有直接缓冲和间接缓冲两种。    只有ByteBuffer类提供了直接缓冲。使用直接缓冲，不影响程序。其它类想用直接缓冲需要进行转换。     java.nio.channels    对块进行读写的通道，类似于以前的流   Channel接口：用于 I/O 操作的连接      编程步骤：    a. 先创建一个I/O流，    b. 使用I/O流.getChannel()方法，获得通道，    c. 创建大小合适的ByteBUffer，    d. 通道的对象.read(buffer)/write(buffer)进行读写，    e. 关闭所有的流和通道，    f. 如果有多线程并发，可以使用"通道.lock()"获得FileLock对象，用FileLock.release() 释放此锁定。    g. 当遇到编码问题，使用CharSet、CharsetDecoder、CharsetEncoder三个类去解决       注意：    在读之前需要调用一下clear()方法，帮助读操作清理缓冲；写之前需要调用flip()方法，帮助写操作清理缓冲。    java.nio.charset    字符集，进行编码解码     Charset类：编码类，编码的信息    forName(String charsetName)     生成一个CharSet实例。    decode(ByteBuffer bb)              将此 charset 中的字节解码成 Unicode 字符的便捷方法。             encode(CharBuffer cb)              将此 charset 中的 Unicode 字符编码成字节的便捷方法。                 CharsetDecoder类：解码器    能够把特定 charset 中的字节序列转换成 16 位 Unicode 字符序列的引擎。       CharsetEncoder类：编码器，编码的行为    能够把 16 位 Unicode 字符序列转换成特定 charset 中字节序列的引擎。
网络编程：  网络基础知识   Mac地址：每个网卡专用地址，也是唯一的。   端口(port)：应用程序（进程）的标识（网络通信程序）    OS中可以有65536（2^16）个端口，进程通过端口交换数据。    端口是一种抽象的软件结构，与协议相关：TCP的23端口和UDT的23端口为两个不同的概念。    端口应该用1024以上的端口，以下的端口都已经设定功能。   协议：为了进行网络中的数据交换而建立的约定，协议是为了保证通信的安全，不同层的协议是完全不同的。    TCP协议：传输层的协议，重发一切错误的信息    IP协议：保证地址和主机一一对应（ip地址＋网卡地址）      TCP编程：   TCP是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建立连接，以便在TCP协议的基础上进行通信，当一个socket（通常都是server socket）等待建立连接时，另一个socket可以要求进行连接，一旦这两个socket连接起来，它们就可以进行双向数据传输，双方都可以进行发送或接收操作。    1) 服务器分配一个端口号，服务器使用accept()方法等待客户端的信号，信号一到打开socket连接，从socket中取得OutputStream和InputStream。       2) 客户端提供主机地址和端口号使用socket端口建立连接，得到OutputStream和InputStream。 
  Server端编码的步骤：    1、new ServerSocket 打开端口    2、调ServerSocket的accept()等待客户连接，当连接成功返回交互的Socket。    3、调用Socket.getInputStream,getOutputStream获得服务器端的IO流    4、用处理流封装后与客户端交互，记住你读我写，一读一写。    5、关闭单一客户端调用Socket的close(),关闭服务器调ServerSocket的close();
  Socket端编码步骤：    1、new Socket(Server ip,Server port)试图连接，如成功才有对象    2、调用Socket.getInputStream,getOutputStream获得服务器端的IO流    3、用处理流封装后与客户端交互，记住你读我写，一读一写。    4、关闭，只有Socket的close()方法。
 
网络编程：  多线程+网络：   1、服务器端的等待客户连接代码（ while(true) ），服务器端与单个客户端交互的代码放入线程体（ run ）   2、客户端如有其他要求，与服务器交互的代码也要放入线程体   3、ServerSocket和Socket编码基于TCP/IP协议，重发一切错误数据，当网络不好时会使性能很差   4、Server端    new ServerSocket启动等待连接线程    在accept后启动交互线程   注意：交互时注意对应产生，读写流对应和次数对应     URL：网址，统一资源定位器   常用的构造器：    URL(String spec)     spec  一个完整的网址（协议+网址）              根据 String 表示形式创建 URL 对象。                URLConnection：与网址进行连接   通过URL的openConnection()方法生成一个URLConnection实例，通过下面两个方法，进行流的操作    getInputStream()              返回从此打开的连接读取的输入流             getOutputStream()              返回写入到此连接的输出流。                UDP编程：这种信息传输方式相当于传真，信息打包，在接收端准备纸   特点：    1、一种无连接协议，速度快    2、不保证数据的完整，不会进行重发       DatagramSocket和DatagramPacket类：    DatagramSocket：此类表示用来发送和接收数据报包的套接字。    DatagramPacket：数据报包，是UDP下进行传输数据的单位，数据存放在字节数组中，其中包括了目标地址和端口以及传送的信息。     用于接收：       DatagramPacket(byte[] buf , int length)     用于发送：       DatagramPacket(byte[] buf , int length , InetAddress address , int port )         UDP发送端：    1、创建一个DatagramSocket，不需要参数    2、创建一个DatagramPacket，指明接收方的IP地址和端口号    3、发送数据send(DatagramPacket p)    4、关闭DatagramSocket
  UDP接收端：    1、创建一个DatagramSocket，指定接收方的IP地址和端口号    2、创建一个DatagramPacket，不需要IP地址和端口号    3、接收数据receive(DatagramPacket p)    4、关闭DatagramSocket     常用类库：  java.lang.*:   System 系统   Object 对象    clone()    equals()    hashCode()    toString()   Class  类      String/StringBuffer/StringBuilder  与字符串相关的   Thread 线程   所有的封装类
 java.util.*:   Set--->HashSet,TreeSet      List--->ArrayList    Map--->HashMap(线程安全，不支持空),HashTable(线程不安全，支持空)   Collections--->外同步   Properties   Date   观察者-->Observable,接口Observer   数据结构+工具类
 java.sql.*: 后面马上会讲到，JDBC    java.awt/swing.*：没什么机会用到     java.io.*:  流相当的多   File/FilenameFilter   Serializable 对象序列化接口
   注意：写一个类要考虑的事情：1、无参构造器，2、实现序列化接口，3、重写equals,hashCode      FileInputStream   FileOutputStream   InputStreamReader   PrintStream   BufferedReader   nio包    java.net.*:  以后JSP,Servlet用的时候这个包都已经写好了   InetAddress--->IP地址   URL----------->网址   URLConnection---->连接   ServerSocket,Socket----TCP/IP   DatagramSocket,DatagramPacket----UDP     一些零散的类：   Comparable（可比较的）,Comparator（比较器）
  java.math.*;数字在商业软件中应用时找这个包    BigDecimal      与反射相关的：java.lang.reflect:  用的机会比较少         Runtime（运行环境）,Process（进程），这两个在java.lang包里，用了这些就不能跨平台了，而且效率低
  
国际化：让世界上每个人都能看懂。  Locale类（java.util包下）：包括所有国家、地区、语言   存在很多的静态属性，来表示国家、语言   三种构造方法：    Locale(String language)     根据语言代码构造一个语言环境。    Locale(String language, String country)     根据语言和国家构造一个语言环境。    Locale(String language, String country, String variant)     根据语言、国家和变量构造一个语言环境。   常用方法：    Locale getDefault()              获得此 Java 虚拟机实例的当前默认语言环境值。     String getdisplayCountry()              返回适合向用户显示的语言环境国家名。             void setDefault(Locale newLocale)              为此 Java 虚拟机实例设置默认语言环境。    String getLanguage()              返回此语言环境的语言代码。    String getCountry()              返回此语言环境的国家/地区代码。            注意：             国家会兼容语言，但语言不会兼容国家。            java.text.*：该包下存在许多格式化类            NumbeRFormat抽象类：             常用方法：              NumberFormat getInstance()               返回当前默认语言环境的通用数字格式。     NumberFormat getInstance(Locale inLocale)               返回指定语言环境的通用数字格式。              String format(double number)               根据国家，进行格式规范。              NumberFormat getCurrencyInstance(Locale inLocale)               返回指定语言环境的货币格式。                            SimpLEDateFormat类：             模式字母：     y  年      M  年中的月份      H  一天中的小时数（0-23）     h  am/pm 中的小时数（1-12）     m  小时中的分钟数     s  分钟中的秒数     构造器：     SimpleDateFormat(String pattern)               用给定的模式和默认语言环境的日期格式符号构造 SimpleDateFormat。    常用方法：     String format(Date date)               将一个 Date 格式化为日期/时间字符串。             注意：              看到相应的模式字母，就会进行转换。           实现国际化：   1、先写各个语言对应的文字类，使其extends ListResourceBundle，然后重写getContents()，返回一个二维数组。   2、在程序中按照Local和ListResourceBundle的baseName来选择对应的资源，调用getString()/getObject()取得value    ResourceBundle类：     ResourceBundle getBundle(String baseName, Locale locale)      baseName为对应的ListResourceBundle的类名(包名.类名)      使用指定的基本名称和语言环境，以及调用方的类加载器获取资源包。   注意：根据key去查找value时，当前没有会去查找默认的，默认的也没有则会抛出异常    5.0新特性：  1、自动装箱，自动解箱(简单类型->对象类型)   小于127的数值在自动装箱时只做一次装箱，做" == "时相等。   null无法自动解箱。   先装箱后赋值和先解箱后赋值时，需要注意是否能够匹配。     2、静态import   用于导入类中的静态属性和静态方法。   格式：import static 包名.类名.属性/方法/*   注意：    必须是静态的成员。    静态导入时，不允许导入同名方法/属性。    使用时，可省略" 类名. "就像使用本类方法一样      3、增强for循环：for(  :  )   方式统一，可以处理数组和集合。     不可以同时对两个以上的集合进行操作。   不支持删除元素。     4、可变长的参数：(...)   用于取代数组，实际上还是按数组进行处理，允许传递非数组的值（0到n个，中间用逗号分隔）。   可变长参数只能出现一次，且一定会放在参数列表的最后。   作参数时，可变长参数可以不传，但数组不可以。     5、格式化输入输出：Scanner类   了解下就可以，知道有这个类就OK。    6、枚举Enum：本质上也是一个类，具有类所有特性   格式：    enum 枚举名{     枚举值1,     枚举值2,     .....    }       特性：    显示一些同类型的清单。    一个枚举值就是一个枚举对象。    可以有构造器，但不能是public的。    具有一个私有的默认无参的构造器，显式构造后，默认的构造器会消失。    属性，方法和类一样。    枚举是final的(对于外部无法继承)，但在内部可以去实现。      注意：    清单里的类，会调用匹配的构造器，如无，则会报错。    在枚举中可以有抽象方法，但在清单中的所有子类都必须实现他。    如果要写属性和方法，则最后的一个枚举值要以分号结束。    枚举中的values()方法会返回枚举中的所有枚举值：  Color[] ss = Color.values();      7、泛型
 8、元数据（注释），项目中推广度一般     
5.0新特性：  泛型：   泛型的形式：    <E>    <E extends 类型>    <E extends Numner&comparator>  类名&接口，表示E继承Numner类实现comparator接口    <?>  泛型通配符表示任意类型，仅用于传参    <? extends 类型>  表示这个类型可以是该类或者该类的子类。    <? super 类型>  表示这个类型可以是该类或者该类的父类。          泛型的优点：    指定泛型后，取出数据时不需要进行强制类型转换，可以直接赋值给相应类型。    可以限定集合中的元素类型，保证集合中的元素是按照要求放入的。     可以增强多态(继承多个接口而无需写继承类)。    保证参数有效。
  泛型的局限性：       不能实例化泛型     T t = new T(); //error    数组不可用泛型限定     List<String>[] list = new List<String>[10]; //错误     E[] a = new E[10]; //错误    类的静态变量不能声明为类的泛型类型     public class GenClass<T> {        private static T t;   //编译错误     }    静态方法可以是泛型方法(在修饰符和返回值之间写泛型)，但是不可以使用类的泛型。     static void copyArrayToList(Object[] os,List<T> ls){       //错误，T为类的泛型     }          static <E> void copyArrayToList(E[] os,List<E> ls){       //泛型方法，正确的     }    泛型不能使用简单类型     GenList<int> nList = new GenList<int>(); //编译错误     泛型类不能是异常类，也就是该泛型类不能继承自Throwable以及其子类     public class MyExpection<T> extends Exception{ }   //编译错误    可以抛出（throws）泛型类，但catch的参数不能是泛型类。      注意：    编译时类型的泛型和运行时类型的泛型一定要一致，没有多态。    支持泛型的集合，只能存放指定的类型，或者是指定类型的子类型。 
 注释（元数据）：   描述代码的代码，作用是规范编译器的语法。
  三种内置注释：    @Deprecated 所标注的程序元素是不推荐使用的    @Override 检查是否为合法的覆盖父类的方法    @SuppressWarnings 注释类或方法，忽略其中的某些类型的警告信息       注释的三种类型：    标记注释：不需要任何参数     @Override     @Deprecated    单值注释：有一个值的注释     @注释名（值名=值）     值名一般为value，可以省略的，直接写值就可以     值的类型是有限制的，只能是以下几种：      8种基本数据类型      String      Class      Enum      Annotation      以及他们的数组    多值注释：每个值之间用逗号隔开       四种元注释：java.lang.annotation中的类    元注释：注释注释的注释，用来限定注释的特征    @Terget 用来限定某个注释的使用范围，可以对什么元素进行注释    @Retention  用来描述注释的有效范围    @Inherited  用来描述某注释是否有继承性    @Documented  用来限定注释的信息是否能够进行文档化       自定义注释：    在自定义注释时，要用元注释来进行描述。    如：     import java.lang.annotation.*;     @Target({ElementType.METHOD})     @Inherited     @Retention(RetentionPolicy.RUNTIME)     @Documented     public @interface InProgress {      String author(); //定义属性      String limited();     }        解析注释：利用反射    1、Class.forName()    2、getMethod    3、判断是否有注释    4、getAnnotation     并发线程：  三个多线程包：   java.util.concurrent    包含了常用的多线程工具，是新的多线程工具的主体。   java.util.concurrent.atomic    包含了不用加锁情况下就能改变值的原子变量。   java.util.concurrent.locks    包含锁定的工具。     Executor接口：   替代了Thread类，他可以创建定量的、动态的以及周期性的线程池。  ExecutorService接口：   线程池，用来存放线程来节省创建和销毁资源的消耗。     Callable和Future接口：   Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。Callable和Runnable有几点不同：    Callable规定的方法是call()，而Runnable规定的方法是run().    Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。    call()方法可抛出异常，而run()方法是不能抛出异常的。   运行Callable任务可拿到一个Future对象，通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
 软件开发流程：  1、可行性分析  2、需求分析->开发测试  3、概要设计->分隔模块，定义框架等  4、详细设计->类设计、接口设计  5、编码  6、测试  7、部署  8、维护   单元测试：  要求：   要有边界值的分析，主要针对分支语句的临界点   语句覆盖，保证写的任何语句都要运行到   判定覆盖，所有判断的地方都要覆盖掉   条件覆盖，保证所有条件都要覆盖掉   路径覆盖，所有分支都要测试到    步骤：   1、针对每个类写一个TestCase，在setUp方法中初始化要测试类，在tearDown方法中将测试类置为null   2、逐一编写以test开头的方法   3、新建一个套件类，再把所有的TestCase类加入套件类    Ant：用于对项目的整体构建、修改及部署等操作  Ant的下载：   去阿帕奇官方网站下载   在eclipse的eclipse3.2\plugins\org.apache.ant_1.6.5     建立ant的步骤：   1、写类：src和build.xml必须自己写，src中的源程序要按照包结构去构建好    projectName     classes     src     build.xml   2、写build.xml    <?xml version="1.0"  encoding="GB2312" ?>            <project default="main" basedir=".">            <property name="src" value="src\test" />                 <target name="main" description="begin build">               <mkdir dir="classes" />             <javac srcdir="${src};src" destdir=".\classes"/>              <java classname="test.Test">       <classpath>            <pathelement path=".\classes"/>       </classpath>      </java>       </target>              <target name="clean" description="begin clean">      <delete dir="classes" />     </target>               <target name="all" depends="clean,main" description="begin all">     </target>    </project>   3、ant配置环境变量    Path->org.apache.ant_1.6.5\bin    ClassPath->org.apache.ant_1.6.5\lib   4、运行     创建可运行的jar文件：  1、先建起一个空文件夹  2、把所有的源文件拷贝到该文件夹下  3、javac -d . *  编译此文件夹下各源文件  4、删除源文件  5、jar -cvf test.jar *  完成第一次打包  6、jar -xvf test.jar  解压  7、删除test.jar  8、改META_INF中的文件，加上Main-Class: MenuFrame （注意中间有空格），保存  9、jar -cvfM test.jar *   10、java -jar test.jar 可以运行   重构：  在不改变软件任何功能的前提下对代码进行修改，调整其结构，提高其可读性，降低其修改的成本。   重构的基本思想就是集中精力使设计简化，并且在新的需求出现时提供一个持续发展（而非扩展）的环境。  重构是一项功能强大的技术，但需以微小的步伐修改程序才行。     重构的优点：   重构可以改进软件的设计；   重构可以使你的代码看起来更易理解；   重构可以找出潜伏的Bug；   重构可以帮助你提高编程的速度――在一次次的迭代过程中阻止系统腐败变质，减少在调试中所花的时间；   重构可以使我们更快速的开发软件，甚至还可以提高我们的设计质量。    利用eclipse重构代码：   代码封装   方法移位(父类<->子类)   抽取方法   提炼接口

更多回帖

400万+工程师在用

400万+工程师在用

电子发烧友网工程师

java超强学习笔记(三)

相关帖子

TC275学习笔记第一篇之开发环境配置---Hightec+JAVA+UDE安装教程

如何学习Java

Java入门需要学习什么？

0基础可以学习JAVA吗？

Java学习经：提高Java培训效率的6个方法

谈谈如何学习java之路

给大家分享一个JAVA大牛的课程笔记

Java怎么学习!有什么重点吗

java学习大纲（初学java看看，有用）

[转帖]java学习心得总结

[原创]学习java的流程

java超强学习笔记(二)

java超强学习笔记(一)

java学习方法

java语言学习要点