1、java工作方式:
Head First Java Note
2、java发展:
     1>.java1.02:205个类
     2>.java1.1:500个类
     3>.java2:1.2~1.4,2300个类
     4>.java5.0:1.5以上,2500个类
3、程序结构:源文件包含类包含方法包含语句
4、primitive主数据类型:
Head First Java Note
5、命名规则:
     1>.字母、下划线(_)或$开头
     2>.后可跟数字、字母、下划线(_)或$
     3>.避开关键字
6、java保留字:
Head First Java Note
7、对象声明、创建与赋值步骤:
Head First Java Note
8、对象有状态行为两种属性,它们之间相互影响。
9、参数:数量、类型、顺序
     1>.形参:实参传入方法后
     2>.实参:传给方法的值
10、java通过值传递,即通过拷贝传递
11、引用对象的变量所传入的是远程控制的拷贝,而不是对象本身
12、方法只能声明单一的返回值,且返回值必须是声明的类型或能够隐式地转换成声明类型
13、实例变量:类中,默认值,integers—0、floating points—0.0、boolean—false、reference—null
       局部变量:方法中,使用前必须初始化
14、==:比较primitive主数据类型,或判断两个引用是否引用同一个对象
       equals:判断两个对象是否在意义上相等
15、null:代表“空”的字节组合,即没有操作对象的远程控制,是一个引用而不是对象
16、极限编程(XP)开发类步骤:
       1>.伪码:专注于逻辑,包含:实例变量的声明、方法的声明、方法的逻辑(重点)
       2>.测试码
       3>.真实码
17、ArrayList与数组的区别:
       1>.一般数组在创建时须指定大小
       2>.数组存放对象时须指定位置
       3>.一般数组使用特殊语法:name[index]
       4>.ArrayList是参数化的(范型)
18、短运算(&&、||):如果左边可确定结果则不执行右边
       长运算(&、|):两边都执行
19、覆盖:由子类重新定义继承的方法,以改变或延伸此方法的行为
       1>.参数一致(顺序、类型、个数),返回类型要兼容
       2>.不能降低方法的存取权限
20、IS-A测试:用来验证继承结构合理性,它的关系是单向的
21、如果类A继承类B,且类A是类C的父类,则C应该能通过IS-A B的测试
22、重载:方法名字相同,参数不同
       1>.返回类型可不同
       2>.不能只改变返回类型
       3>.不能更改存取权限
23、抽象类(abstract class):有构造函数,但不能被实例化,在子类new时执行
       1>.重点:可被子类继承共同的程序代码
       2>.好处:多态
       3>.抽象方法的意义:定义一组子型共同的协议
24、java.lang.Object的目的:多态、共同的方法实现
25、编译器根据引用类型判断方法的调用
26、接口:方法默认修饰符号为public abstract
27、JVM启动时,从系统中取得一块内存执行java程序
       1>.heap:对象的生存空间
       2>.stack:方法调用和变量(对象引用、primitive主数据)的生存空间,被执行方法在栈顶(方法状态、局部变量)
28、对象的实例变量的值存在该对象中,如果实例变量是private主数据类型,则JVM根据它的大小留下空间
29、类防止继承:
       1>.存取控制::非公有(非包中不能继承)
       2>.final class
       3>.private构造函数
30、构造函数:
       1>.新建类时执行
       2>.与类名相同,无返回类型
       3>.若无构造函数,编译器自动添加无参构造函数
       4>.多个构造函数,参数须不同
       5>.不能被继承
31、super(..):调用父类构造函数,默认在子类构造函数第一行添加
       this(...):调用本类构造函数,位于第一行,故不能同时与super()存在
32、完整的对象需要完整的父类核心
33、对象的生命周期随引用变量的生命周期而定:
       1>.局部变量:声明改变量的方法中
       2>.实例变量:与对象相同
34、释放对象方法:
       1>.引用永久性离开范围
       2>.引用被赋值其他对象
       3>.直接将引用赋null
35、java中没有全局(global)的概念
36、static:标记出不需要类实例的方法--不依靠实例变量和对象的行为
37、取得新对象的方法:
       1>.new
       2>.deserialization
       3>.reflection
       4>.clone():创建并返回对象的副本
38、实例变量:每个实例一个
       静态变量: 每个类一个,同一类所有实例共享,在类加载时初始化
39、JVM会在第一次创建该类的新实例,或使用该类的静态方法或变量时加载类
       1>.静态变量在该类的任何对象创建之前完成初始化
       2>.静态变量在该类的任何静态方法执行之前完成初始化
40、静态初始化块(static initializer):一段在加载类时会执行的程序代码
41、final:代表常数变量,即不能改变值,或方法、类不能被覆盖。须在声明或静态初始化中赋值
42、primitive及包装类:
boolean  Boolean
char Character 
byte Byte
short Short
int Integer
long Long 
float  Float
double Double
43、autoboxing应用:
       1>.方法的参数
       2>.返回值
       3>.bolean表达式
       4>.数值运算
       5>.赋值
44、操作日期:
       1>.Date:取得当前日期
       2>.Calendar:其余功能
45、异常处理规则:
       1>.catch与finally不能没有try
       2>.try与catch间不能有程序
       3>.try一定要有catch或finally
       4>.只带有finally的try必须声明异常
46、存储数据:
       1>.序列化(seriatization):将序列化对象写入到文件中,可通过读取该文本恢复对象状态
           <1>.易恢复
           <2>.难阅读
           <3>.安全
           <4>.仅适用于java程序
       2>.纯文本:可用于非java程序
47、serializable接口:marker或tag类的标记接口,声明实现它的类可以被序列化
48、序列化程序将对象上所有东西存储起来,被对象的实例变量所引用的所有对象都会被序列化
49、将序列化对象写入到文件步骤:
       1>.创建FileOutputStream:FileOutputStream fos=new FileOutputStream("test.seriazable");
       2>.创建ObjectOutputStream:ObjectOutputStream oos=new ObjectOutputStream(fos);
       3>.写入对象:oos.writeObject(...)
       4>.关闭ObjectOutputStream:oss.close()
Head First Java Note
50、对象序列化示例:
//Test Serialization
import java.io.Serializable;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;
import java.lang.Exception;

public class TestS implements Serializable{

    private int width;
    private int height;

    public void setWidth(int width){
         this.width = width;
    }
   
    public int getWidth(){
         return width;
    }

    public void setHeight(int height){
         this.height = height;
    }
 
    public int getHeight(){
         return height;
    }

    public static void main(String[] args){
  
         TestS t = new TestS();
         t.setWidth(99);
         t.setHeight(88); 
         FileOutputStream fos = null;
         ObjectOutputStream oos = null;

         try{
              fos = new FileOutputStream("tests.serializable");
              oos = new ObjectOutputStream(fos);
              oos.writeObject(t);    
         }catch(Exception e){
              e.printStackTrace();
         }finally{
              try{
                   oos.close();
              }catch(Exception es){
                   System.out.println("Exception: oos.close()"); 
              }    
         }
    }

}
51、transient:瞬时,修饰某实例变量不被序列化,反序列化时,重设为默认值:0、0.0、false、null
52、反序列化(deserializable):还原对象
       1>.创建FileInputStream:FileInputStream fis=new FileInputStream("tests.seriazable");
       2>.创建ObjectInputStream:ObjectInputStream ois=new ObjectInputStream(fis);
       3>.读取对象:Object o=ois.readObject();
       4>.转换对象:TestS t = (TestS)o;
       5>.关闭ObjectInputStream:ois.close();
Head First Java Note
53、反序列化过程:
       1>.对象从stream读出来
       2>.JVM通过存储的信息判断出对象的class类型
       3>.JVM尝试寻找和加载对象的类,若找不到,抛出异常
       4>.新对象被配置在堆上,但构造函数不会执行
       5>.如果对象在继承树上有不可序列化的祖先类,则该祖先类及在它之上的类构造函数(包括可序列化)会执行,一
            旦构造函数连锁启动之后,将无法停止,即从第一个不可序列化的父类开始,全部都会重新初始化
       6>.对象实例化变量会被还原位序列化时点的状态值,transient修饰的除外
54、static修饰的也不会被序列化,反序列化时为初始值
55、对象反序列化
//Test Serializable Read
import java.io.Serializable;
import java.io.FileOutputStream;
import java.io.FileInputStream;
import java.io.ObjectOutputStream;
import java.io.ObjectInputStream;
import java.lang.Exception;

public class TestSR{

    public static void main(String[] args){

         try{
              FileInputStream fis = new FileInputStream("tests.serializable");
              ObjectInputStream ois = new ObjectInputStream(fis);
              TestS t = (TestS)ois.readObject();
              ois.close();
              System.out.println(t);
              System.out.println(t.getWidth());
              System.out.println(t.getHeight());
         }catch(Exception e){
              e.printStackTrace();
         }

    }

}
56、缓冲区:
       1>.write.flush():强制缓冲区写入内容
       2>.BufferedWriter bw = new BufferedWriter(new FileWriter(file))
Head First Java Note
57、String split():拆分字符串
//Test String split()
import java.lang.String;

public class TestSplit{

    public static void main(String[] args){
  
         String s = "What is blue + yellow?/greeb";
         String[] ss = s.split("/"); 
         for(String sss:ss){
              System.out.println(sss);
         }

    }

}
58、文本文件保存与读取
//Test FileWriter and FileReader
import java.io.IOException;
import java.io.FileReader;
import java.io.FileWriter;
import java.lang.StringBuilder;
import java.io.BufferedReader;

public class TestFWR{

    public static void main(String[] args){
  
         String file_name = "testfwr.txt"
         StringBuilder sb = new StringBuilder();
         sb.append("有些事,不敢去想;有些人,不能忘记。\n");
         sb.append("每个兴奋与失落的时候,我都会触摸那段记忆,但是很多的时候,我又会刻意回避
                        它。\n"); 
         sb.append("什么都不愿想,我怕那些事,更怕那些事中来来往往的那些人;\n");
         sb.append("我怕那些人,更怕那些人勾起曾经的那些事。\n如果生活不够完美,我情愿放弃!");
  
         writeToFile(file_name,sb.toString());
  
         String s = readFromFile(file_name);
         System.out.println("--------------------------------------------");
         System.out.println(sb.toString());
         System.out.println("--------------------------------------------");

    }

    public static void writeToFile(String file_name,String s){
         try{
              FileWriter fr = new FileWriter(file_name);
              fr.write(s);
              fr.close();
         }catch(IOException e){
              e.printStackTrace();
         }
    }

    public static String readFromFile(String file_name){
         StringBuilder sb1 = new StringBuilder();
         try{
              FileReader fr = new FileReader(file_name);
              BufferedReader br = new BufferedReader(fr);
              String line;
              while((line = br.readLine()) != null){
                   System.out.println(line);
                   sb1.append(line + "\n"); 
              }
              fr.close(); 
         }catch(IOException e){
              e.printStackTrace(); 
         }

         return sb1.toString();
    }

}
59、java.nio特性:
       1>.可直接控制buffer
       2>.non-blocking(即在没有东西读写时不等待)输入/输出
       3>.性能高
       3>.FileInputStream可通过getCahnnel()来存取channel来使用nio
60、SerialVersionUID:类版本识别ID,对象被序列化时,该对象(及所有在其版图上的对象)会被“盖”上的标识:
       1>.根据类的结构信息计算出来的,若在对象反序列化后有不同的serialVersionUID,则还原操作失败
       2>.可把ID放在class中让类在演化过程中维持相同的ID
       3>.JDK中serialver工具查询ID:serialver class_name
61、java.io.File:对象代表磁盘上的文件或目录的路径名称,但不能读取或代表文件中的数据:
       1>.创建代表存盘文件的File对象:File f = new File(file_name);
       2>.创建新目录:File f = new File("fff"); f.mkdir();
       3>.列出目录下内容:if(f.isDirectory()){String[] s = f.list(); ......}
       4>.取得文件或目录的绝对路径:f.getAbsolutePath();
       5>.删除文件或目录(成功返回true):boolean b = f.delete();
62、客户服务器工作方式: 连接==>传送==>接受
Head First Java Note   
63、socket连接必须的服务器信息:
       1>.IP
       2>.TCP Port
           <1>.一个地址有65536个不同的port:0~1023保留给已知的特定服务器,1024~65536随意使用
           <2>.16位宽,识别服务器上特定程序的数字,代表在服务器上执行的软件逻辑识别
           <3>.常见port:20--FTP、23--Telnet、25--SMTP、37--Time、80--Http、443--Https、110--POP3
           <4>.绑定一个端口,表示程序在此特定端口上执行,故不同程序不能共享一个端口
64、使用BufferedReader从Socket上读取数据:
       1>.建立服务器的socket连接:Socket s = new Socket("127.0.0.1",5000);
       2>.建立连接到Socket上的底层输入串流的InputStreamReader:
           InputStreamReader isr = new InputStreamReader(s.getInputStream());
       3>.建立BufferedReader读取:
           BufferedReader br = new BufferedReader(isr);
           String line = br.readLine();
           ......
Head First Java Note
65、使用PrintWriter写数据到Socket:
       1>.对服务器建立socket连接:Socket s = new Socket("127.0.0.1",5000);
       2>.建立连接到Socket的PrintWriter:PrintWriter pw = new PrintWriter(s.getOutputStream());
       3>.写入数据:
           pw.println("......");
           pw.print("......");
Head First Java Note
66、服务器程序编写:
       1>.服务器应用程序对特定端口创建ServerSocket(等待客户通信):
            ServerSocket ss = new ServerSocket(4242);
       2>.客户端对服务器应用程序建立socket连接:Socket s = new Socket("127.0.0.1",4242);
       3>. 服务器创建客户端通信的新socket(与用户通信,端口与ss不同):Socket s = ss.accept();
Head First Java Note
67、客户端与服务器端示例:
//example Server
import java.io.PrintWriter;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.lang.Math;

public class Server{

    public static void go(){
         try{
              ServerSocket ss = new ServerSocket(4242);
              while(true){
                   Socket s = ss.accept();
    
                   PrintWriter pw = new PrintWriter(s.getOutputStream());
                   String info = "Wenlong.Meng Java [email][email protected][/email]";
                   pw.println(info);
                   pw.close();
                   System.out.println(info);
              } 
    
         }catch(IOException e){
              e.printStackTrace();
         }
    }

    public static void main(String[] args){
         go();
    }
  
}
//example Client
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.net.Socket;
import java.io.IOException;

public class Client{

    public static void go(){
         try{
              Socket s = new Socket("127.0.0.1",4242);

              InputStreamReader isr = new InputStreamReader(s.getInputStream());
              BufferedReader br = new BufferedReader(isr);

              String line;
              while((line = br.readLine()) != null){
                   System.out.println(line); 
              }

              br.close(); 
         }catch(IOException e){
              e.printStackTrace();
         }
    }
  
    public static void main(String[] args){
         go();
    }

}
68、Thread:表示线程的类
       1>.需要一个任务(可放在执行空间的任务--Runnable.run()),放在执行空间开始处,线程启动时执行
       2>.可启动、连接、闲置线程
       3>.代表独立的执行空间
       4>.Java程序都会启动一个主线程--将main()放入执行空间的开始位置
       5>.JVM负责主线程的启动,程序员负责自己创建的线程
       6>.线程要记录当前执行空间的执行位置
       7>.主线程启动新线程,新线程启动期间main()的线程暂停
       8>.多线程相互切换执行
       9>.setName():为线程命名,通常用来除错
       10>.Thread对象不能复用,一旦run()完成,该线程不能再启动,但Thread对象还存在堆中
       11>.线程调度器(Scheduler):决定线程状态(等待-->运行、运行-->等待/堵塞)、运行时间等,无法控制其行为
       12>.线程的正确性(时间、顺序)不能依靠线程调度器
       13>.Thread.sleep():支持线程间通信,保证沉睡前另一线程被唤醒,可能抛出InterrruptedException
       14>.线程优先级可影响调度器行为
69、启动新线程:(特殊工作也可继承Thread类覆盖run()完成,但不太符合面向对象设计原则)
       1>.建立Runnable对象(线程的任务):Runnable r = new MyRunnable();
       2>.建立Thread对象(执行工人):Thread t = new Thread(r);
       3>.启动Thread:t.start()--把Runnable对象中的run放到执行空间开始位置,等待执行
70、线程的状态:
       1>.新建:Thread t = new Thread();
       2>.可执行:t.start();
       3>.执行中
Head First Java Note
71、实现Runnable接口线程示例:
//example thread implements Runnable
import java.lang.Runnable;
import java.lang.Thread;

public class MyRunnable implements Runnable{

    public void run(){
         go();
    }

    public void go(){
         System.out.println("MyRunnable.go()");
    }

}

class ThreadTest{

    public static void main(String[] args){
         Runnable r = new MyRunnable();
         Thread t = new Thread(r);
         t.start();
         System.out.println("back in main");
    }

}
Head First Java Note
72、synchronized:每次只能被单一线程操作--原子性,保护数据。
73、锁:
       1>.每个对象都有单一的锁和钥匙
       2>.方法没有锁,故对象中有多个同步方法时,其他线程不能同时进入相同或不同的同步方法
       3>.类也有一个锁,static修饰的成员用类锁保证同步
       4>.某类在堆上有n个对象时,则有n+1个锁(与此类相关的)
74、类也有一个锁(static修饰的成员用类锁),故堆上有n个对象时,则有n+1个锁
75、同步化代价:
       1>.额外成本:查询钥匙等性能上的损耗
       2>.并行程序等待而耗时
       3>.导致死锁(deadlock)现象
76、同步化的意义:指定某段工作在封闭状态中完成
77、Collection FrameWork基本结构:
Head First Java Note
78、List:一种知道索引位置的集合,适合顺序
            1>.LinkedList:适合元素数量较大时频繁插入、删除
            2>.ArrayList:add(e)--新元素插入到最后,较快;add(index,e)--指定索引位置插入新元素,较慢
       Set:不允许重复的集合
            1>.TreeSet:有序(默认按字母排序)、无重复--插入新元素需重新排序
            2>.HashSet:无重复、查找快
       Map:key/value对应的集合,value可重复,key不能重复
            1>.HashMap:包含键值对两个对象
                <1>.key:不可重复,可为任意对象或通过autoboxing的primitive
                <2>.value  :可重复
            2>.LinkedHashMap:记住元素插入顺序,可设置依照元素上次存取的先后顺序
79、public class ArrayList<E> extends AbstractList<E> implements List<E> ...{...}
       “E”:类型参数,代表Element, 是集合所要维护和返回的元素类型,可用任何合法的java标识字符串
80、Collections.sort(List o):代表由List元素的compareTo()方法决定顺序,故元素必须实现Comparable接口
       Collections.sort(List o, Comparator c):用compare(o1,o2)方法排序
81、若类没有实现Comparable接口,且无源代码,可通过子类代该元素并实现Comparable来排序
import java.lang.Comparable;
import java.util.Comparator;
import java.util.TreeSet;
import static java.lang.System.out;

class User implements Comparable{

    private String name;

    public User(String name){
         this.name = name;
    }

    public String getName(){
         return name;
    }

    public int compareTo(Object o){
         User u = (User)o;
         return (name.compareTo(u.getName()));
    }

    public String toString(){
         return name;
    }

}

class UserCompare implements Comparator<User>{

    public int compare(User u1,User u2){
         return (u1.getName().compareTo(u2.getName()));
    }

}

class Test9{

    public void go(){
         User u1 = new User("孟文龙");
         User u2 = new User("Wenlong.Meng");
         User u3 = new User("Meng WenLong");

         UserCompare uc = new UserCompare(); 
         TreeSet<User> ts = new TreeSet<User>(uc); 
         ts.add(u1);
         ts.add(u2);
         ts.add(u3);
         out.println(ts);
    }

    public static void main(String[] args){
         new Test9().go();
    }

}
Head First Java Note
82、相等性: 
       1>.引用相等性:堆上同一个对象的两个引用相等(即hashCode()的值(一般由内存内置计算)相等)
       2>.对象相等性:堆上的两个不同对象在意义上是相同的(hashCode()和equals())
83、hashCode()与equals()的相关规定:
       1>.如果两个对象相等,则hashCode必须相等
       2>.如果两个对象相等,对其中一个对象调用equals()必须返回true
       3>.如果两个对象有相同的hashCode值,它们不一定相等
       4>.若equals()被覆盖过,则hashCode也必须被覆盖
       5>.hashCode()默认是对在heap上的对象产生独特的值。故若不覆盖,则该类的两个对象永不相同
       6>.equals()默认是执行==的比较,即测试两个引用是否为堆上的同一个对象,若不覆盖,两个对象永不相同(不
            同对象有不同字节组合)
84、由于算法的原因,不同对象可能出现相同hashCode()的值,但用它可以缩小范围。
85、TreeSet元素须满足其一:
       1>.集合中的元素是实现Comparable的类型
       2>.使用重载、取用Comparator参数的构造函数来创建TreeSet
86、Collections.sort(ArrayList<String>)排序示例:
       1>.coding
//测试排序:String
import java.util.ArrayList;
import java.io.File;
import java.io.FileReader;
import java.io.BufferedReader;
import java.lang.Exception;
import java.util.Collections;
import static java.lang.System.out;

public class UserTS{

    ArrayList<String> al = new ArrayList<String>();

    void getUserInfo(){
         try{
              BufferedReader br = new BufferedReader(new FileReader(new File("usert.txt")));
              String line= null;
              while((line = br.readLine()) != null){
                   addUser(line);
              } 
         }catch(Exception e){
              e.printStackTrace();
         }  
    }

    void addUser(String ui){
         String[] u = ui.split("/");
         String i = u[0] + ": " + u[1] + "," + u[2] + "," + u[3] + "\n"
         al.add(i);
    }

    public void go(){
         getUserInfo();
         out.println(al);
         Collections.sort(al);
         out.println(al);
    }

    public static void main(String[] args){
         new UserTS().go();
    }

}
       2>.资源
//资源usert.txt
孟文龙/Wenlong.Meng/Beijing/java SE
黄明/Ming.Huang/YinChuan/java SE
徐峰/Feng.Xu/Xi'an/java SE
王征晖/Zhenghui.Wang/Beijing/java SE
孟文龙/Wenlong.Meng/Beijing/java SE
黄明/Ming.Huang/YinChuan/java SE
徐峰/Feng.Xu/Xi'an/java SE
       3>.结果
Head First Java Note
87、Collections.sort(ArrayList<User>)排序示例:
       1>.coding
//User Object
public class User implements Comparable<User>{

    private String name;
    private String name_en;
    private String addr;
    private String job;

    public User(String name,String name_en,String addr,String job){
         this.name = name;
         this.name_en = name_en; 
         this.addr = addr;
         this.job = job;
    }

    public String getName(){
         return name;
    }

    public String getName_en(){
         return name_en;
    }

    public String getAddr(){
         return addr;
    }

    public String getJob(){
         return job;
    }

    public String toString(){
         return name + ":" + addr + "," + job;
    }

    public int compareTo(User user){
         return name.compareTo(user.getName());
    }

    public boolean equals(Object o){
         User user = (User)o;
         return getName().equals(user.getName());
    }

    public int hashCode(){
         return name.hashCode();
    }

}
import java.util.ArrayList;
import java.io.File;
import java.io.FileReader;
import java.io.BufferedReader;
import java.lang.Exception;
import java.util.Collections;
import static java.lang.System.out;
import java.util.HashSet;
import java.lang.Comparable;
import java.util.Comparator;

public class UserT{

    ArrayList<User> al = new ArrayList<User>();
  
    void getUserInfo(){
         try{
              BufferedReader br = new BufferedReader(new FileReader(new File("usert.txt")));
              String line= null;
              while((line = br.readLine()) != null){
                   addUser(line);
              }
         }catch(Exception e){ 
              e.printStackTrace();
         }
    }

    void addUser(String user){
         String[] s = user.split("/");
         User u = new User(s[0],s[1],s[2],s[3]);
         al.add(u);
    }

    public void go(){
         getUserInfo();
         System.out.println(al);
         Collections.sort(al);
         System.out.println(al);

         AddrCompare ac = new AddrCompare();
         Collections.sort(al,ac);
         out.println(al);

         HashSet<User> hs = new HashSet<User>();
         hs.addAll(al);
         out.println(hs);
    }

    public static void main(String[] args){
         new UserT().go();
    }

}
 
//Comparator
class AddrCompare implements Comparator<User>{

    public int compare(User u1, User u2){
         return u1.getAddr().compareTo(u2.getAddr());
    }

}
       2>.结果:
Head First Java Note
88、HashMap示例:
       1>.coding
import static java.lang.System.out;
import java.util.HashMap;

class TestMap{

    public static void main(String[] args){
         HashMap<String,Integer> hm = new HashMap<String,Integer>();
         hm.put("one",1); 
         hm.put("two",2);
         hm.put("three",3);

         out.println(hm);
         out.println(hm.get("two"));
    }

}
       2>.结果:
Head First Java Note
89、如果方法的参数是某类型的数组,则它也能接受此类型子类型的数组
abstract class Animal{
    void eat(){
         System.out.println("animal eating");
    }
}

class Dog extends Animal{
    void bark(){}
}

class Cat extends Animal{
    void meow(){}
}

class Test8{

    public static void main(String[] args){
         new Test8().go();
    }

    public void go(){
         Animal[] as = {new Dog(),new Cat(),new Dog()};
         Dog[] ds = {new Dog(),new Dog(),new Dog()};
         go1(as);
         go1(ds);
    }

    public void go1(Animal[] as){
         for(Animal a:as){
              a.eat();
         }
    }

}
Head First Java Note
90、如果方法的参数是某类型的范型集合,则它不能接受此类型子类型的范型集合,为了防止加入不合法类型
import java.util.ArrayList;

abstract class Animal{
    void eat(){
         System.out.println("animal eating");
    }
}

class Dog extends Animal{
    void bark(){}
}

class Cat extends Animal{
    void meow(){}
}

class Test7{

    public static void main(String[] args){
         new Test8().go();
    }

    public void go(){
         ArrayList<Animal> al = new ArrayList<Animal>();
         al.add(new Dog());
         al.add(new Cat());
         al.add(new Dog());
         go1(al);

         ArrayList<Dog> al1 = new ArrayList<Dog>();
         al1.add(new Dog()); 
         al1.add(new Dog());
         al1.add(new Dog());
         go1(al1);//编译出错
    }

    public void go1(ArrayList<Animal> as){
         for(Animal a:as){
             a.eat(); 
         }
    }

}
Head First Java Note
91、万用字符:?,可加入子类型的范型的集合,但不能添加任何东西到集合中
       public <T extends Animal> void go(ArrayList<T> l) 等同于 public void go(ArrayList<? extends
       Animal> l)
92、数组类型在运行期间检查,集合类型检查在编译期间
93、部署选择:
       1>.本机:整个应用程序都在用户计算机上以独立、可携的GUI执行,并以可执行的Jar来部署
       2>.两者之间:应用程序被分散在用户本地系统运行的客户端,连接到执行应用程序服务的服务器部分
       3>.远程:整个应用程序都在服务器端执行,客户端通过非java形式(如浏览器)来存取
Head First Java Note
94、javac -d(directory):指定编译后class文件位置,包括自动创建包目录结构
95、JAR:java ARchive,是pkzip格式的文件,包装一组类或文件,可执行的JAR中有manifest文件(带有JAR信
       息,告诉JVM关于主类的信息)
96、创建JAR可执行:
       1>.确定所有类文件均在classes目录下
       2>.创建manifest.txt描述主类:Main-fest:Myapp(主类名,无后缀;换行)--对应/META-INF/MANIFEST.MF
       3>.执行jar工具生成jar:jar -cvmf manifest.txt myapp.jar(含包结构的class、META-INF/MANIFEST.MF)
       4>.运行JAR:java -jar myapp.jar--jar须在classpath下,检查manifest寻找主类信息
97、JVM检查JAR内部并预期寻找资源,不会深入其他目录(包结构或目录符合包指令下的?万用字符的除外)
98、包:反向domain名+包名--防止命名冲突
99、jar -tf  *.jar --列出文件列表(tf:tablefile)
       jar -xf  *.jar --解压jar文件(xf:extractfile)
100、Java Web Start(JWS):通过网络发布程序
         1>.JWS helper app用来管理下载、更新程序的JWS程序
         2>.下载程序,独立于浏览器执行
         3>.自动更新
101、Java Web Start工作方式:
         1>.客户点击JWS应用程序链接(.jnlp文件)
         2>.Web服务器收到请求发出.jnlp文件(描述应用程序可执行JAR文件的xml文件)
         3>.浏览器启动JWS,它的helper app读取。jnlp文件,然后向服务器请求.jar
         4>.web服务器发送.jar文件
         5>.JWS取得jar并调用指定的main()来启动应用执行
102、JNLP(Java NetWork Lanuch Protocol):JWS通过它寻找JAR并启动应用程序(main())
<?xml version="1.0" encoding="utf-8"?>

<jnlp spec="0.2.1.0"
       codebase="指定相关文件的起始目录(如:[url]http://127.0.0.1/test[/url])"
       href="相对于codebase的位置路径(myapp.jnlp)">
  
    <information>
         <title>My App</title>
         <vendor>wenlong.meng</vendor>
         <homepage href="index.html"/> 
         <description>Head First java</description>
         <icon href="test.jpg"/> 
         <offline-allowed/>  
    </information>

    <resources>
         <j2ee version="指定java版本(如:1.3+)"/> 
         <jar href="可执行得jar(如:myapp.jar)"/>
    </resources>

    <application-desc main-class="带有main()的类"/>

</jnlp>
103、创建与部署Java Web Start的步骤:
         1>.将程序制成可执行的JAR
         2>.编写.jnlp文件
         3>.把.jnlp与JAR文件放到Web服务器
         4>.对Web服务器设定新的mime类型:application/x-java-jnlp-file
         5>.设定网页连接到.jnlp文件
<html>
     <body>
          <a href="myapp.jar">Launch My Application</a>
     </body>
</html>
104、远程过程调用:
Head First Java Note
105、RMI协议:
         1>.JRMP:RMI原生协议,为java应用间的远程调用设计
         2>.IIOP:为CORBA(Common Object Request Broker Architecture)设计,使java可与其他应用交互
106、创建远程服务步骤:
         1>.创建Remote接口:定义客户端可远程调用的方法,作为服务的多态化类--stub和服务都实现此类
             <1>.继承java.rmi.Remote:public interface MyRemote extends Remote{...}
             <2>.声明的方法均抛出RemoteException:
                    public String come(String hello) throws RemoteException;
             <3>.确定参数和返回值是primitive主数据或Serializable:通过序列化打包在网络上传送
         2>.实现Remote:真正执行类,实现方法,是客户端调用的对象
             <1>.实现java.rmi.Remote接口
             <2>.继承java.rmi.server.UnicastRemoteObject:提供远程有关功能
             <3>.编写声明RemoteException的无参构造函数
             <4>.向RMI registry注册服务
         3>.用rmic产生stub与skeleton:rmic 实现类,产生两个helper类(实现类_stub.class、实现类_skel.class
         4>.启动RMI registry(rmiregistry):用户从此处取得代理(客户端的stub/helper对象)
         5>.启动远程服务(java 实现类):服务对象开始执行,实现类会启动服务的实例,并向RMI registry注册
107、客户端取得stub:(stub类:直接给客户或通过动态类下载)
         1>.客户端查询RMI registry
         2>.RMI registry返回stub对象,并将stub自动解序列化
         3>.客户端通过stub调用方法
108、RMI示例:
         1>.创建Remote接口
//远程接口
import java.rmi.Remote;
import java.rmi.RemoteException;

public interface MyRemote extends Remote{

    public String sayHello() throws RemoteException;

}
         2>.实现Remote
//接口实现类
import java.rmi.server.UnicastRemoteObject;
import java.rmi.Naming;
import java.rmi.RemoteException;

public class MyRemoteImpl extends UnicastRemoteObject implements MyRemote{

    public String sayHello(){
         return "Wenlong.Meng,says: server is 孟文龙";
    }

    public MyRemoteImpl() throws RemoteException{}

    public static void main(String[] args){
         try{
              MyRemote service = new MyRemoteImpl();
              Naming.rebind("test",service);
         }catch(Exception e){
              e.printStackTrace();
         }
    }  
  
}
         3>.生成helper类
Head First Java Note
         4>.注册
Head First Java Note
         5>.启动服务
Head First Java Note
         6>.客户端类
//客户端类
import java.rmi.Naming;

public class MyRemoteClient{

    public static void main(String[] args){
         new MyRemoteClient().go();
    }

    public void go(){
         try{
              MyRemote service = (MyRemote)Naming.lookup("rmi://127.0.0.1/test");
              String s = service.sayHello();
              System.out.println(s);
         }catch(Exception e){
              e.printStackTrace();
         }
    }

}
         7>.执行客户端
Head First Java Note
109、必须类文件:
         1>.客户端:stub类
         2>.服务端:stub类、skeleton类、服务与远程接口
110、简单Servlet示例:
//simple example servlet code
import javax.servlet.http.*;
import java.io.*;
import javax.servlet.*;

public class Test7 extends HttpServlet{

    public void doGet(HttpServletRequest req,HttpServletResponse res)
         throws ServletException,IOException{
  
         res.setContentType("text/html");

         PrintWriter pw = new res.getWriter();

         String msg = "if you read this, it worked";

         pw.println("<html>");
         pw.println("<h1>" + msg + "</h1>");
         pw.println("</html>"); 
         pw.close();
    }
 
    public void doPost(HttpServlet req,HttpServletResponse res)
         throws ServletException,IOException{
         doGet();
    }

}
<html>
<body>
<a href="servlets/Test7">This is an Example servlet</a>
</body>
</html>
111、servlet:完全在http服务器上运行的java程序,必须放在特定位置才能执行,一般继承自HttpServlet,并覆
         盖doGet()和doPost()方法。
112、EJB服务器:具有RMI服务,还有交易管理、安全性、网络等服务。作用于RMI调用和服务层之间。
Head First Java Note
113、JINI:也是RMI,但还有以下功能:
         1>.adaptive discovery(自适应探索)
         2>.self-healing networks(自恢复网络)
114、位操作:
         1>.按位非运算符(~):将primitive主数据类型的字节组合值取反
         2>.按位与运算符(&):均为1返回1,否则返回0
         3>.按位或运算(|):其一为1返回1,否则返回0
         4>.按位异或运算(^):位不同时返回1,否则返回0
         5>.移位运算:
              <1>.右移运算符(>>):以指定量右移字节合,左方补0,正负不变
              <2>.无符号右移运算符(>>>):以指定量右移字节合,正负号可能改变
              <3>.左移运算符(<<):以指定量左移字节合,右方补0,正负号可能改变
115、包装类:
         1>.将primitive主数据类型包装成对象
         2>.使用静态工具方法
         3>.无法改变该对象的值
116、String Pool:创建新String时,JVM将它放入“String Pool”的特殊存储区中,若有同值,引用它,否则创建
         String对象,其不受Garbage Collector管理。
117、断言:
        1>.assert (条件) ;--true,继续执行; false,抛出AssertionError
        2>.assert(条件):“...”; -- 冒号后可为任何非null值的java语句
        3>.编译:javac *.java
        4>.执行:java -ea *
118、嵌套类:任何被定义在另一个类范围内的类
         内部类:非静态的嵌套类
119、存取权限:
         1>.public:任何代码
         2>.protected:包内及子类
         3>.default:包内
         4>.private:类内
120、n x m数组中,有n x m + n + 1 个变量
121、Enum示例:
import java.lang.Enum;

enum Names{

    NAME("Wenlong.Meng"){
         public String getId(){
              return "dragon";
         }
    },
  
    EMAIL("[email][email protected][/email]"){
         public String getId(){
              return "hotmail";
         }
    },

    TEL("15810076845");

    private String temp;

    Names(String temp){
         this.temp = temp;
    }

    public String getTemp(){
         return this.temp;
    }

    public String getId(){
         return "Names";
    }

}
class Test5{

    public static void main(String[] args){
         for(Names n:Names.values()){
              System.out.print(n);
              System.out.println(",Temp:" + n.getTemp() + ",Id:" + n.getId());
         }
    }

}
Head First Java Note