语源科技BlogJava-杰点

交通灯

杰点 — 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 发表评论