BlogJava-杰点-文章分类-JAVA

交通灯

杰点 — Tue, 11 Jan 2011 03:08:00 GMT

交通灯的核心是：由路来生成车，并且检测灯的颜色来放行汽车。抽象了现实的随机车辆行驶。

灯的数量是确定的，使用了枚举。并且由车的通行对称性，得出对称的灯颜色需要一致。并使用定时器设置灯的点亮。

1 //抽象出所有的灯，共12个灯
2 package traffic;
3
4 //每个方向都有一个灯，因为车辆行驶是对称结构，并且对称的等的显示颜色是一样的
5
6 public enum Lamp {
7     //元素各表示一个控制方向的灯
8     S2N("N2S","S2W",false),S2W("N2E","E2W",false),E2W("W2E","E2S",false),E2S("W2N","S2N",false),
9
10     N2S(null,null,false),N2E(null,null,false),W2E(null,null,false),W2N(null,null,false),
11
12     //这几个方向已经包含在了上面定义的方向中
13     S2E(null,null,true),E2N(null,null,true),N2W(null,null,true),W2S(null,null,true);
14
15     private Lamp(String opposite,String next,boolean lighted){
16         this.opposite = opposite;
17         this.next = next;
18         this.lighted = lighted;
19     }
20
21
22
23     private boolean lighted;
24
25     private String opposite;
26
27     private String next;
28     public boolean isLighted(){
29         //是否绿灯
30         return lighted;
31     }
32
33     //对称方向的灯颜色要一致
34     public void light(){
35         this.lighted = true;
36         if(opposite != null){
37             Lamp.valueOf(opposite).light();
38         }
39         System.out.println(name() + " lamp is green，有6个方向可以看到车通过");
40
41     }
42
43 // 对称的灯颜色一致并且点绿下一个灯
44     public Lamp blackOut(){
45         this.lighted = false;
46         if(opposite != null){
47             Lamp.valueOf(opposite).blackOut();
48         }
49
50         Lamp nextLamp= null;
51         if(next != null){
52             nextLamp = Lamp.valueOf(next);
53             System.out.println("绿灯�" + name() + "切换为" + next);
54             nextLamp.light();
55         }
56         return nextLamp;
57     }
58 }
59

1 //灯控制器，根据车辆通行的对称性可知，对称方向的灯要颜色一致
2 package traffic;
3
4 import java.util.concurrent.Executors;
5 import java.util.concurrent.ScheduledExecutorService;
6 import java.util.concurrent.TimeUnit;
7
8 public class LampController {
9     private Lamp currentLamp;
10
11     public LampController(){
12         //刚开始让由南向北的灯变绿;
13         currentLamp = Lamp.S2N;
14         currentLamp.light();
15
16         //每隔10秒将灯变红点亮下一个绿灯
17         ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
18         timer.scheduleAtFixedRate(
19                 new Runnable(){
20                     public  void run(){
21                         currentLamp = currentLamp.blackOut();
22                 }
23                 },
24                 10,
25                 10,
26                 TimeUnit.SECONDS);
27     }
28 }
29

1 //由路产生车，并检测灯的颜色，放行汽车
2 package traffic;
3
4 import java.util.ArrayList;
5 import java.util.List;
6 import java.util.Random;
7 import java.util.concurrent.ExecutorService;
8 import java.util.concurrent.Executors;
9 import java.util.concurrent.ScheduledExecutorService;
10 import java.util.concurrent.TimeUnit;
11
12 //road 产生车辆，一个方向对应3条路，共有4个方向 12条路
13 public class Road {
14     private List<String> vechicles = new ArrayList<String>();
15
16     private String name =null;
17     public Road(String name){
18         this.name = name;
19
20         //模拟车辆
21         ExecutorService pool = Executors.newSingleThreadExecutor();
22         pool.execute(new Runnable(){
23             public void run(){
24                 for(int i=1;i<1000;i++){
25                     try {
26                         Thread.sleep((new Random().nextInt(10) + 1) * 1000);
27                     } catch (InterruptedException e) {
28                         e.printStackTrace();
29                     }
30                     vechicles.add(Road.this.name + "_" + i);
31                 }
32             }
33
34         });
35
36         //每隔一秒检查灯
37         ScheduledExecutorService timer =  Executors.newScheduledThreadPool(1);
38         timer.scheduleAtFixedRate(
39                 new Runnable(){
40                     public void run(){
41                         if(vechicles.size()>0){
42                             boolean lighted = Lamp.valueOf(Road.this.name).isLighted();
43                             if(lighted){
44                                 System.out.println(vechicles.remove(0) + " is traversing !");
45                             }
46                         }
47
48                     }
49                 },
50                 1,
51                 1,
52                 TimeUnit.SECONDS);
53
54     }
55 }
56

1 //主类
2 package traffic;
3
4 public class MainClass {
5
6
7     public static void main(String[] args) {
8
9         //生成12条路
10         String [] directions = new String[]{
11                 "S2N","S2W","E2W","E2S","N2S","N2E","W2E","W2N","S2E","E2N","N2W","W2S"
12         };
13         for(int i=0;i<directions.length;i++){
14             new Road(directions[i]);
15         }
16
17         //生成交通灯，开始自动运行
18         new LampController();
19     }
20
21 }
22

杰点 2011-01-11 11:08 发表评论

银行调度

杰点 — Tue, 11 Jan 2011 02:45:00 GMT

摘要: 银行调度，模拟了实际生活中的银行对客户服务的排队管理系统。将现实中排队管理，抽象为对象模型。抽象出了一个号码机，为每个客户生产号码标识，并形成一个先进先出的队列，模拟了现实中的排队。将对客户的服务，进行抽象，得出是由服务窗口进行叫号，而不是窗口服务员。这个案例的核心，就是号码管理机器，为每个客户生成一个号码，并排成先进先出队列，模拟了实际生活。然后由服务窗口，取队列的号... 阅读全文

杰点 2011-01-11 10:45 发表评论

泛型

杰点 — Tue, 04 Jan 2011 02:05:00 GMT

泛型

<>发音为typeof ArrayList ArrayList typeof Integer

ArrayList成为原始类型

1.泛型是给编译器看的，为了规范数据类型。以前的集合可以添加各种类型的对象。

2.通过字节码比较 collection3.getClass() == collection2.getClass()
可以发现，编译过后的字节码中并没有类型信息。

3.可以通过反射，透过泛型往集合中添加各种类型元素
collection3.getClass().getMethod("add",Object.class).invoke(collection3,"abc");

4.参数化类型不考虑类型参数的继承
Vector v= new Vector() //错误
Vector v= new Vector() //错误

5.在创建数组实例时，数组的元素不能使用参数化的类型
Vector vectorList[] = new Vector[10];

? 通配符。用于通配任意类型的集合
public static void printCollection(Collection collection){
collection.size();
//collection.add(); 可以调用与参数化无关的方法
}

杰点 2011-01-04 10:05 发表评论

注解

杰点 — Tue, 04 Jan 2011 02:01:00 GMT

注解 Annotation

一个注解就是一个类

@SuppressWarnings("deprecation") 源文件阶段

@Override 重写源文件阶段

@Deprecated 过时 RUNTIME阶段

注解类
@interface A{
}

应用了“注解类”的类
@A
class B{
}

注解反射
class C{
B.class.isAnnotationPresent(A.class)

A a=B.class.getAnnotation(A.class)
}

@Retention元注解
RetetionPolicy.SOURCE 对应源文件
RetetionPolicy.CLASS 对应class文件
RetetionPolicy.RUNTIME 内存中的字节码

RetetionPolicy是枚举，
只包含 SOURCE,CLASS,RUNTIME三个元素

1 //注解类
2 import java.lang.annotation.ElementType;
3 import java.lang.annotation.Retention;
4 import java.lang.annotation.RetentionPolicy;
5 import java.lang.annotation.Target;
6
7 @Retention(RetentionPolicy.RUNTIME)
8 @Target({ElementType.METHOD,ElementType.TYPE})
9 //Target 参数一个可以，两个以上参数为数组
10 //注解的注解目标({方法,类})  描述class，interface enum 的父类都是TYPE
11 public @interface MyAnnotation {
12     //为注解添加属性，这里的属性就是方法，不需要加public abstract。系统默认加
13     String color() default "blue"; //为属性增加默认值
14     String value();  //当只有一个value属性时，赋值时可以不用value=
15
16 }
17

1 //注解的使用
2 @MyAnnotation(color="red",value="444")
3
4 public class AnnotationTest {
5
6     /**
7      * @param args
8      */
9     @SuppressWarnings("deprecation")
10     @MyAnnotation("bacd")
11     public static void main(String[] args) {
12         // TODO Auto-generated method stub
13         System.runFinalizersOnExit(true);
14         //判断字节码中是否有注解，不加RUNTIME则没有，字节码在内存中,RUNTIME内存运行阶段
15         if(AnnotationTest.class.isAnnotationPresent(MyAnnotation.class))
16         {
17             MyAnnotation myAnnotation=(MyAnnotation)AnnotationTest.class.getAnnotation(MyAnnotation.class);
18             System.out.println(myAnnotation.color());
19         }
20     }
21
22 }
23

杰点 2011-01-04 10:01 发表评论

类加载器

杰点 — Tue, 04 Jan 2011 02:00:00 GMT

BootStrap JRE/lib/rt.jar
|
ExtClassLoader JRE/lib/ext/*.jar
|
AppClassLoader CLASSPATH指定的所有jar或目录

| |
自定义类加载器

类加载器也是一个类，但BootStrap不是，它嵌入虚拟机，是最根部的加载器，加载下层类。

类加载器实行委托机制，如AppClassLoader发起加载类，则委托父类，则一直委托到BootStrap，再开始往下寻找类，
一直到AppClassLoader，如果它也找不到，则抛出异常

自定义类加载器必须继承ClassLoader类，并指定一个父类加载器。

1.程序运行阶段，碰到一个类，先调用该线程里的类加载器加载类。
可以为线程指定类加载器。
2.如果类A引用类B，JAVA虚拟机将使用加载了A的类加载器加载B。

杰点 2011-01-04 10:00 发表评论

集合

杰点 — Wed, 29 Dec 2010 05:31:00 GMT

9.集合框架
1)基本概念:用于存放对象的对象(与数组类似.即集合也是对象.只能存对象)

2)和数组的差异
A.数组存放的内容由数组类型指定,集合存放的内容为Object类型的引用
B.数组只有1种数据结构(按照索引存储),集合的数据结构分为Set.List和Map三大类.每个类中还包含若干的小类
C.数组的容量在创建时指定,无法在使用中动态扩展.所有集合类型的容量都是不定的.根据需求自动扩展

3)基本组成
A.接口:用于定义集合的功能框架
B.实现类:实现对应的接口.实现集合的具体功能
C.工具:提供对集合操作的辅助功能

4)接口
A.Collection
定义存储内容为单个对象的数据结构及相关的操作方法
B.Set
继承Collection,存储内容无序且不可重复
C.List
继承Collection,存储元素有序且可以重复
D.SortedSet
继承Set.可以对存储内容进行排序
E.Map
定义存储内容为2个对象（键值对）的数据结构及相关的操作方法
键（标识性,所以不可重复）对象无序且不可重复，值对象可以重复顺序由对应的键对象决定
F.SortedMap
继承Map，可以对键对象进行排序

5)名词解释
A.无序:存储顺序与放入顺序无关
B.有序:存储顺序与放入顺序一致
C.排序:按照一定的逻辑对内容进行排序,存储顺序依照排序的结果进行排列

6)实现类
A.List(3个实现类)
ArrayList:内部存储形式为数组,擅长查询操作,对插入和删除操作效率较低

LinkedList:内部存储形式为双向链表.擅长插入和删除操作,对查询操作效率较低

Vector:ArrayList的线程安全版本,可保证多线程并发防问时的数据准确和一致性,但对效率影响很大,实际开发中使用较少

B.HashSet的重复性判断
i)在执行add()操作时进行,将加入的对象与集合中已存在的对象进行比较,满足相等性条件时,待加入的对象无法加入集合中
ii)比较内容
将2个对象调用equals()结果为true
将2个对象分别调用hashcode()的结果相同
同时满足以上2个条件则判断两个对象相同

C.TreeSet
构造器
TreeSet()--使用默认的排序和重复性判断逻辑
注:只有少量类型(String.包装类型)存在默认排序和重复性判断逻辑,如Integer升序;如果对没有默认的排序和重复性判断逻辑的对象使用该操作,将在执行时产生ClassCastException
TreeSet(Comparator)--使用指定的比较器实现排序和重复性判断逻辑
实现原理:在加入元素时执行比较(原有元素和待加入的元素),比较时调用比较器的compare().根据返回值决定排列的顺序是否重复
compare()的第一个参数--待加入的元素
compare()的第二个参数--集合中原有的元素
返回值
>0    待加入元素在原有元素的右边
<0    待加入元素在原有元素的左侧
=0    相同,待加入元素不加入
注:当>0或<0时,如集合的相应方向存在未比较的元素,则应继续比较直至完全确定位置后才执行加入

D.Map的实现类
HashMap和HashTable的关系相当于ArrayList和Vector的关系
HashMap的重复性判断规则(key)
在元素加入时(put)进行判断.方式与HashSet完全相同
E.TreeMap的排序和重复性判断规则(key)
在元素加入时(put)进行判断.方式与TreeSet完全相同

1 //List集合实现类LinkedList ArrayList
2 import java.util.*;
3 public class ListTest {
4
5     /**
6      * @param args
7      */
8     public static void main(String[] args) {
9         // TODO Auto-generated method stub
10         String a="A",b="B",c="C",d="D",e="E"; //定义字符串对象
11         List<String> list= new LinkedList<String>(); //创建List集合
12         list.add(a); //集合中添加元素
13         list.add(e);
14         list.add(d);
15         Iterator<String> fristIterator=list.iterator();//创建集合迭代器
16         System.out.println("修改前集合中的元素为");
17         while(fristIterator.hasNext()){
18             System.out.println(fristIterator.next()+" ");
19         }
20         list.set(1,b);
21         list.set(2,c);
22         Iterator<String> it=list.iterator();
23         System.out.println("修改后集合中的元素为");
24         while(it.hasNext()){
25             System.out.println(it.next()+" ");
26         }
27
28     }
29
30 }

1 //MAP集合和泛型
2 import java.util.*;
3 public class MapTest {
4
5     /**泛型应用
6      * @param args
7      */
8     public static void main(String[] args) throws Exception {
9         // TODO Auto-generated method stub
10
11         //HashMap 定义泛型类型变量
12         HashMap<String,Integer> maps= new HashMap<String,Integer>();
13         maps.put("zhangsan",28); //添加元素
14         maps.put("lisi",33);
15         maps.put("wangwu", 23);
16
17         //返回Set集合
18         Set<Map.Entry<String, Integer>> entrySet= maps.entrySet();
19
20         //迭代输出集合
21         for(Map.Entry<String,Integer> entry : entrySet)
22         {
23             System.out.println(entry.getKey()+" "+entry.getValue());
24         }
25         //转换类型
26         Object ob="abc";
27         String x3= autoConvert(ob);
28     }
29
30     private static <T> T autoConvert(Object object){
31         //泛型方法  类型转换
32         return (T)object;
33     }
34
35     private static <T> void fillArray(T[] a,T obj ){
36         //将某个类型的对象填充到对应类型的数组
37         for(int i=0;i<a.length;i++)
38             a[i]=obj;
39     }
40
41 }

杰点 2010-12-29 13:31 发表评论

反射

杰点 — Wed, 29 Dec 2010 05:21:00 GMT

反射的基础是Class类
Class：

JAVA类用于描述一类事物的共性。而是什么属性则是由类的实例对象来确定的，不同的实例对象有不同的属性值。

Class则是用于描述JAVA类的共性的类，描述了类的名字，访问属性，包名，字段名称列表，方法名称列表等。

Class的实例对象为某个类的字节码。
获取字节码的实例对象方法有三种
1. 类名.class System.class
2. 对象.getClass new Date().getClass()
3. Class.forName("类名") Class.forName("java.util.Date")

Class cls1=Date.class //Date类的字节码 ,已经加载到内存
Class cls2=p1.getClass();//调用对象的getClass()得到类的字节码
Class.forName("java.lang.String") //返回该类字节码

反射就是把Java类中的各种成分映射成相应的Java类，如：一个Java类中用Class类的对象来表示，一个类中组成的部分：
成员变量，方法，构造方法，包等信息，也是用一个个Java类来表示的

Class代表一份类字节码

Method 类的实例对象代表类的方法

Constructor类
Constructor类代表类中的一个构造方法

//获取某个类的所有构造方法
Constructor[] constructors=Class.forName("java.lang.String").getConstructors();

//获取某个构造方法,要用的参数类型如:String(StringBuffer buffer)
Constructor constructor=Class.forName("java.lang.String").getConstructor(StringBuffer.class);

创建实例对象
通常方法：String str=new String(new StringBuffer("abcd"));
//Constructor类的 newInstance() 方法
反射方法：String str=(String)constructor.newInstance(new StringBuffer("abc"))

Field类，代表某个类的属性
Field fieldy=pt1.getClass().getField("y"); 得出的是类的属性，值是不固定的，根据对象来确定
fieldy.get(pt1);

改field需要调用fieldy.set(obj,value);

Method类
getMethod(name,parameterytpes) //类名，方法参数类型

//执行方法用invoke(obj,parameters)
Method methodCharAt=String.class.getMethod("charAt",int.class)
//静态方法 name=null
methodCharAt.invoke(str1,1);

1 //创建一个测试反射的类
2 public class ReflectPoint {
3     private int x;
4     public int y;
5     public String str1="china";
6     public String str2="basketbool";
7     public String str3="itcast";
8     public ReflectPoint(int x, int y) {
9         super();
10         this.x = x;
11         this.y = y;
12     }
13
14 }
15

  1 //反射测试
  2 import java.lang.reflect.*;
  3 public class ReflectTest {
  4
  5     /**反射基本知识
  6      *
  7      * 反射就是把java类中的各个成分映射为java类
  8      * 反射的基础是Class类，它是java类的描述类，Class类的实例是某个类的字节码
  9      * @param args
10      */
11     public static void main(String[] args) throws Exception {
12         // TODO Auto-generated method stub
13         //Class测试
14         //Class的实例是类的字节码
15         String str1="abcde";
16
17         //获取Class实例的三种方式
18         Class cls1= str1.getClass(); //获取该对象类的字节码
19         Class cls2=String.class;  //直接调用类的字节码
20         Class cls3=Class.forName("java.lang.String");//根据类名获取字节码
21
22         System.out.println(cls1==cls2);                    //true
23         System.out.println(cls1==cls3);                    //true
24
25         //isPrimitive()是否是基本数据类型的字节码 8种+void
26         System.out.println(cls1.isPrimitive());         //false
27         System.out.println(Integer.class.isPrimitive());//false
28         System.out.println(int.class.isPrimitive());    //true
29
30         //Integer.TYPE常量代表包装的基本类型的字节码
31         System.out.println(int.class==Integer.TYPE);     //true
32
33         //数组不是基本数据类型，是对象
34         System.out.println(int[].class.isPrimitive());     //false
35         System.out.println(int[].class.isArray());       //true
36
37         //得到String类的 String(StringBuffer)构造方法
38         Constructor constructor=String.class.getConstructor(StringBuffer.class);
39         //可以构造方法，创建实例，并进行类型转换
40         String str2 = (String)constructor.newInstance(new StringBuffer("abcsd"));
41
42         ReflectPoint pt1=new ReflectPoint(3,5);
43
44         //Field类
45         Field fieldy=pt1.getClass().getField("y");
46         //fieldy的值是5吗？不是，fieldy不代表具体的值，只代表类的y变量
47         //因为取的是类的字节码，类中变量的值是根据对象来决定的
48         //通过.get(object) 来获取某个对象的值
49         System.out.println(fieldy.get(pt1));
50
51         Field fieldx=pt1.getClass().getDeclaredField("x");//获取声明过的属性
52         fieldx.setAccessible(true); //访问权限设置为true
53         System.out.println(fieldx.get(pt1));
54
55         changeString(pt1);
56         System.out.println(pt1.str1);
57         System.out.println(pt1.str2);
58         System.out.println(pt1.str3);
59
60         //Method
61         //取得类字节码中的charAt方法
62         Method methodCharAt=String.class.getMethod("charAt", int.class);
63         //调用invoke(obj,parameter) 执行方法
64         System.out.println(methodCharAt.invoke(str1,1));
65
66
67         //调用main()方法,普通方式
68         // TestArguments.main(new String[]{"abc","1111"});
69         //使用反射调用，为了解决，给定类名，而不知道实现代码的情况下用
70         //从类字节码得到 main方法
71         Method methodmain=Class.forName(args[0]).getMethod("main",String[].class);
72         methodmain.invoke(null,new Object[]{new String[]{"abc","1111"}});
73
74         //数组的反射
75         int[] a1=new int[3];
76         int[] a2=new int[4];
77         int[][] a3=new int[2][3];
78         String[] a4=new String[2];
79         //数组的字节码比较，看的是数组类型和数组维度
80         System.out.println(a1.getClass()==a2.getClass()); //true
81         System.out.println(a1.getClass()==a3.getClass()); //false
82         System.out.println(a1.getClass()==a4.getClass()); //false
83         System.out.println(a3.getClass()==a4.getClass()); //false
84         //获取父类
85         System.out.println(a1.getClass().getName());
86         System.out.println(a1.getClass().getSuperclass().getName());
87         System.out.println(a4.getClass().getSuperclass().getName());
88         //得出父类都是Object类
89         Object aobj1=a1;
90         Object aobj2=a2;
91         Object aobj4=a4;
92         //Object[] aobj5=a1; //里面装的是基本类型，基本类型不是对象，不能装入
93         Object[] aobj5=a3;
94
95         int[] t1=new int[]{12,34,2};
96         printObject(t1); //打印对象，数组是对象，但t1数组元素是基本类型
97         printObject("xyz"); //打印对象
98
99     }
100
101     private static void printObject(Object obj){
102         Class clazz=obj.getClass(); //获取该对象类的字节码
103         if(clazz.isArray()){
104             //Array是数组的反射类
105             for(int i=0;i<Array.getLength(obj);i++){
106                 System.out.println(Array.get(obj, i));
107             }
108         }else{
109             System.out.println(obj);
110         }
111     }
112
113     private static void changeString(Object obj){
114         Field[] fields=obj.getClass().getFields();
115         for(Field field:fields){
116             if(field.getType()==String.class){//同一份字节码用==
117                 try {
118                     String newValue=((String)field.get(obj)).replace('a', 'b');
119                     field.set(obj, newValue);
120                 } catch (Exception e) {
121                     // TODO: handle exception
122                 }
123             }
124         }
125     }
126 }

杰点 2010-12-29 13:21 发表评论

枚举

杰点 — Wed, 29 Dec 2010 05:15:00 GMT

1 //枚举综合测试
2 public class EnumTest {
3
4     /**
5      * @param args
6      */
7     public static void main(String[] args) {
8         // TODO Auto-generated method stub
9         WeekDay1 Mon=WeekDay1.MON;//实例化
10         System.out.println(Mon.nextday()); //调用枚举类内的方法
11         WeekDay weekday2=WeekDay.FRI;
12         System.out.println(weekday2);
13         System.out.println(weekday2.name());//显示枚举元素名称
14         System.out.println(weekday2.ordinal());//显示枚举元素索引
15         System.out.println(WeekDay.valueOf("SUN"));//根据字符串得到枚举对象
16         //WeekDay.values() 返回枚举元素数组
17         System.out.println(WeekDay.values().length);
18
19         System.out.println(TrafficLamp.valueOf("RED").nextlamp());
20     }
21
22     public enum WeekDay{
23         SUN(1),MON,TUE,WED,THI,FRI,SAT; //枚举元素必须位于第一位
24         /*枚举的构造方法必须私有*/
25         private WeekDay(){System.out.println("first");}
26         private WeekDay(int day){System.out.println("second");}
27     }
28
29     public enum TrafficLamp{
30         /*
31          * 带有抽象方法的枚举
32          * 每个元素都是枚举的子类
33          * 在枚举元素{}中实现抽象方法
34          *
35          * 只有一个元素的枚举，可以实现单例模式
36          * */
37         RED(30){
38             public TrafficLamp nextlamp(){
39                 return GREEN;
40             }
41         },GREEN(45){
42             public TrafficLamp nextlamp(){
43                 return YELLOW;
44             }
45         },YELLOW(5){
46             public TrafficLamp nextlamp(){
47                 return RED;
48             }
49         };
50
51         public abstract TrafficLamp nextlamp();
52         private int time;
53         private TrafficLamp(int time){this.time=time;}
54     }
55
56 }
57

1 //模拟枚举，枚举是一种特殊的类，每个元素都是枚举的实例对象，枚举可以有自己的属性和方法
2 public abstract class WeekDay1 {
3     private WeekDay1(){}//私有化构造函数，则外界无法实例化
4
5     public final static WeekDay1 MON=new WeekDay1(){
6
7         @Override
8         public WeekDay1 nextday() {
9             // TODO Auto-generated method stub
10             return SUN;
11         }
12         //WeekDay的子类，要实现抽象方法
13     };
14     //定义成员
15     public final static WeekDay1 SUN=new WeekDay1(){
16         @Override
17         public WeekDay1 nextday(){
18             return MON;
19         }
20     };
21
22     public abstract WeekDay1 nextday(); //定义一个抽象方法
23 /*    public WeekDay nexday(){
24         this是指该对象，因为类的非静态方法只能有对象来调用
25          *
26         if(this==MON){
27             return SUN;
28         }else{
29             return MON;
30         }
31     }*/
32
33     public String toString(){
34         return this==MON?"MON":"SUN";
35     }
36
37 }
38

杰点 2010-12-29 13:15 发表评论

基本数据类型的装箱和拆箱

杰点 — Wed, 29 Dec 2010 05:08:00 GMT

1 //装箱拆箱享元模式
2 public class flyWeight {
3
4     public static void main(String[] args){
5     Integer i=1127; //装箱将基本数据类型转换为对象
6     System.out.println(i+3);//拆箱将对象转换为基本类型
7
8     Integer i2=127;
9     Integer i3=127;
10     Integer i4=128;
11     Integer i5=128;
12     System.out.println(i2==i3);//true   享元模式
13     System.out.println(i4==i5);//false  享元模式将小的数据 -128～127 共享一个对象
14
15     String str1="abcds";
16     String str2="abcds";
17     System.out.println(str1==str2); //true 享元模式
18     }
19 }
20

杰点 2010-12-29 13:08 发表评论

TCP通信

杰点 — Wed, 29 Dec 2010 04:46:00 GMT

ServerSocket类

构造函数
public ServerSocket()
public ServerSocket(int port) //默认数量是50个
public ServerSocket(int port,int backlog)
public ServerSocket(int port,int backlog,
InetAddress bindAddr)
close()

accept() 返回socket对象

Socket类

构造方法
public Socket()
public Socket(String host,int port)
public Socket(InetAddress address,int port)
public Socket(String host,int port,
InetAddress localAddr,int localPort)
public Socket(InetAddress address,int port,
InetAddress localAddr,int localPort)
方法
getInputStream() 返回输入流对象
getOutputStream()返回输出流对象

1 //基于TCP的服务器端
2 import java.net.*;
3 import java.io.*;
4 public class TcpServer {
5
6     /**
7      * @param args
8      */
9     public static void main(String[] args) throws Exception {
10         // TODO Auto-generated method stub
11         ServerSocket ss=new ServerSocket(8001); //创建服务器socket对象
12         Socket s=ss.accept(); //等待客户端连接，返回socket对象
13         InputStream ips= s.getInputStream();//返回输入流对象
14         OutputStream ops=s.getOutputStream();//获得输出流对象
15
16         ops.write("welcome,jiedian's Server\n".getBytes());
17
18         BufferedReader br = new BufferedReader(new InputStreamReader(ips));
19         //包装网络输入流，字节流
20         System.out.println(br.readLine());
21         /*
22         byte[] buf=new byte[1024];
23         int length=ips.read(buf);
24         System.out.println(new String(buf,0,length));
25         */
26
27         br.close();
28         //ips.close();
29         ops.close();
30         s.close();
31         ss.close();
32     }
33
34 }
35

杰点 2010-12-29 12:46 发表评论

UDP通信

杰点 — Wed, 29 Dec 2010 04:30:00 GMT

DatagramSocket类用于创建收发UDP数据包的Socket对象

构造函数
DatagramSocket() //用于发送方，系统分配端口号
DatagramSocket(int port) //用于接收方
DatagramSocket(int port,InetAddress laddr)
//udp在多个Ip地址的计算机，用于发送接收

方法
close() //关闭对象，释放资源

send(DatagramPacket p) //发送数据包

receive(DatagramPacket p) //接收数据包

DatagramPacket类创建UDP数据包

构造函数
public DatagramPacket(byte[] buf,int length)
//内存缓存区，大小接收数据对象

public Datagrampacket(byte[] buf,int length,
InetAddress address,int port)
//内存缓存区，大小，ip，端口发送数据对象

getInetAddress
getPort

getData 返回buf
getLength 返回length

InetAddress类

getByName() 静态方法
//根据字符串格式，返回一个相应的实例对象
getHostAddress()
//返回.分格的IP

1 //创建基于的UDP发送方
2 import java.net.*;
3 public class UdpSend {
4 //发送方
5     /**
6      * @param args
7      */
8     public static void main(String[] args) throws Exception{
9         // TODO Auto-generated method stub
10         DatagramSocket ds = new DatagramSocket();//创建socket发送对象，发送端口号由系统分配。
11         String strInfo="hello china 中国";//定义要发送的字符串
12         DatagramPacket dp=new DatagramPacket(strInfo.getBytes(),strInfo.getBytes().length,
13                 InetAddress.getByName("192.168.1.111"),3333); //构建数据包
14         ds.send(dp);//发送数据包
15         ds.close();
16
17     }
18
19 }
20

1 //基于UDP协议的接收方
2 import java.net.*;
3 public class UdpRev {
4
5     public static void main(String[] args) throws Exception{
6         //创建socket接收对象
7         byte[] buff=new byte[1024];
8         DatagramSocket ds= new DatagramSocket(3333);
9         DatagramPacket p= new DatagramPacket(buff,1024);
10         ds.receive(p);
11         System.out.println("content:\t"+new String(buff,0,p.getLength())
12         +"\nfrom\t"+p.getAddress().getHostAddress()+":"+p.getPort());
13         ds.close();
14     }
15
16 }

杰点 2010-12-29 12:30 发表评论

JAVA程序与其他进程的数据通信

杰点 — Wed, 29 Dec 2010 03:10:00 GMT

JAVA中可以用 Process类的实例对象表示子进程，子进程以管道流的形式连接父进程
的一个输出流和输入流

Process类的 getOutputStream getInputStream方法获得父进程连接到子进程的输入输出流

杰点 2010-12-29 11:10 发表评论

过滤流和包装类

杰点 — Wed, 29 Dec 2010 02:38:00 GMT

包装类:包装基本操作类，完成各种类型的输入输出。
           如：DataOutputStream  提供输出基本数据类型，但并没有指定具体输入输出设备，就需要包装一个具体输出输入设备,实现这种功能的类为包装类，也叫过滤流或处理流类

  BufferedInputStream
    构造函数 BufferedInputStream(InputStream in)   BufferedInputStream(InputStream in,int size)
BufferedOutputStream 独立开辟缓存，缓冲区包装类，无论底层设备是否有缓冲区，都为实例对象建立缓冲区
    构造函数 BufferedOutputStream(OutputStream out) [默认512byte]  BufferedOutputStream(OutputStream out,int size)

DataInputStream        提供写入各种类型数据的方法
      构造函数 public DataInputStream(InputStream in)
DataOutputStream       包装Buffered类
      构造函数 public DataOutputStream(OutputStream  out)

BufferedReader BufferWriter 字符流的缓存包装类

PrintStream 类格式化输出

ObjectInputStream
ObjectOutputStream类包装类，读取写入对象类型，需要实现java.io.Serializable接口。

InputStreamReader
OutputStreamWriter 字节流与字符流的转换

Decorator 设计模式
在程序中用一个对象包装另外一个对象，这种被称为Decorator设计模式

杰点 2010-12-29 10:38 发表评论

字符编码

杰点 — Wed, 29 Dec 2010 02:16:00 GMT

1.JAVA默认编码为unicode，取出字符串中每个字符强制转换为int型，调用
Integer.toHexString()转化为16进制输出。

2.调用getBytes()返回指定编码类型的字节数组，转换为16进制输出

4.System.getProperties().list(System.out)

5.System.setProperty(key, value)

6.取出每个输入字符的字节，根据new String(buf,0,pos,"gb2312")判断

7.通过getBytes返回原来字节数组，new String解码，有的不可逆。

杰点 2010-12-29 10:16 发表评论

JAVA输入输出流

杰点 — Wed, 29 Dec 2010 02:04:00 GMT

节点流类
InputStream      OutputStream    所有字节输入输出流抽象类
BufferedInputStream BufferedOutputStream 缓存字节输入输出流
DateInputStream DateOutputStream        基本数据类型的输入输出
FileInputStream FileOutputStream        文件输入输出流类
PipedInputStream PipedOutputStream       程序字节流管道建立
ByteArrayInputStream ByteArrayOutputStream 字节数组缓存区
字符流
Reader Writer 所有字符流类的抽象类
FileReader FileWriter                    文件字符串操作
PipedReader PipedWriter                  程序字符流管道建立
StringReader   StringWriter              字符串输入输出类
BufferedReader BufferedWriter            缓存字符输入输出
InputStreamReader     字节转字符的桥梁

字符串操作
StringBuilder StringBuffer

连续读取字节的对象叫输入流

JAVA中InputStream类描述所有输入流的抽象概念

InputStream类的方法
int read()，   只读一个字节，放入整数低字节
二进制 1111 1111 byte类型为-1，int类型为255
int read(byte[] b) 返回读取的字节长度，尽可能读取字节数组长度的数据
int read(byte[] b,int off,int len) 返回读取的字节长度
long skip(long n) 返回跳过的字节长度，用于包装类
int available()    返回当前输入流中可读的字节数
void mark(int readlimit)用于包装类
void reset()    返回到标记处
boolean markSupported() 是否支持mark
void close()   关闭流

连续写入字节的对象叫输出流

JAVA中OutputStream类描述所有输入流的抽象概念

OutputStream类的方法
void write(int b) 写入整数的低字节
void write(byte[] b) 将字节数组写入到输出流
void write(byte[] b,int off,int len)
void flush() 将内存缓存区的内容清空并输出
void close()

FileInputStream
FileOutputStream //存在文件，则覆盖清除，不存在创建。
创建文件的输入流和输出流，通过构造函数初始化

===
PipedInputStream
PipedOutputStream类
无参构造函数
用于在应用程序中创建管道通信
connect()连接两个管道

===
ByteArrayInputStream
ByteArrayOutputStream类
完成对字节数组内容的读写。

ByteArrayInputStream(byte[] buf)
取得字节数组中的所有数据，作为数据源
ByteArrayInputStream(byte[] buf,int offset,int length)
取得offset 长length的字节作为数据源

ByteArrayOutputStream()
创建一个32字节的缓冲区
ByteArrayOutputStream(int)
根据指定的大小创建缓冲区

用于写入数据缓存

StringReader
StringWriter

! System.in连接到键盘，是InputStream类型的实例对象
! System.out连接到显示器，是PrintStream类型的实例对象
! 输入输出流的结束返回 -1

杰点 2010-12-29 10:04 发表评论