Head First Java Note

1、java工作方式：

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主数据类型：

5、命名规则：

     1>.字母、下划线(_)或$开头

     2>.后可跟数字、字母、下划线(_)或$

     3>.避开关键字

6、java保留字：

7、对象声明、创建与赋值步骤：

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()

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();

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))

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、客户服务器工作方式： 连接==>传送==>接受

   

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();

           ......

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("......");

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();

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 protected]";
                   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>.执行中

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");
    }

}

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基本结构：

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();
    }

}

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>.结果

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>.结果：

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>.结果：

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();
         }
    }

}

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(); 
         }
    }

}

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形式(如浏览器)来存取

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、远程过程调用：

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类

         4>.注册

         5>.启动服务

         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>.执行客户端

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调用和服务层之间。

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 protected]"){
         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());
         }
    }

}

 

 

 

 

 

 

本文出自 “不服不行” 博客，转载请与作者联系！