Ozone http://ozone.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 代理模式（Proxy） Ozone 作者: Ozone  链接：http://ozone.javaeye.com/blog/191339  发表时间: 2008年05月09日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

代理模式，个人认为就是把你要使用的一个对象尽享封装，包装。编程原对象的一个副本，在使用的时候直接使用他这个副本就可以了！他的作用用专业点的语言描述就是为其他的对象提供一个代理方便控制这个对象。当我们不能直接调用另外一个对象，但是又不得不用这个对象的某些功能，此时代理对象就能起到链接客户和目标对象的一个代理.
代理模式一般涉及到三个角色，分别为：
1. 抽象角色：他提供真实对象和代理对象的共同接口。
2. 代理角色：通俗地说，代理角色是对原对象（目标对象）进行包装，他有着和原对象相同的接口，并且可以执行真实对象的操作。
3. 真实角色:即目标对象，最终我们需要对他的操作。
代理模式分为两种，一 静态代理，二 动态代理。

接下来我们介绍一下两种代理模式：

一 静态代理
静态代理即 代理对象和被代理对象在代理之前已经确定好了。他们一起实现相同的接口或者是继承相同的抽象类。例如： 
//定义抽象角色
public abstract class AbsRole{
  abstract public void work();
}



//定义真实角色
public class RealRole extends AbsRole{
  public RealRole(){ }

  public void work(){
    System.out.println("调用真实角色中函数！");
  }
}


//代理角色
public class ProxyRole extends AbsRole{
  public RealRole real ;
  
  public ProxyRole(){
  }

  public void work(){
    this.beforeMethod();
    if(real == null){
      real = new RealRole();
    }
    real.work();
    this.endMethod();
  }

  public void beforeMethod(){
    System.out.println("代理前执行函数->beforeMethod()");
  }
  
  public void endMethod(){
    System.out.println("代理时候后执行函数->endMethod()");
  }
}


各种角色我们都已经定义好了，我们开始测试一下。 

public class Main(){
  public static void main(String[] args){
    AbsRole ar = new ProxyRole();
    ar.work();
  }
}


二 动态代理
顾名思义，就是不知道到底那个类需要做代理，在使用的时候，更具情况临时决定。
java动态代理主要是使用java.lang.reflect包中的两个类。
1. interface InvocationHandler： 他中定义了一个方法 
  public Object invoke(Object obj,Method method,Object[] obs)

其中第一个参数 obj 指的是代理类，method是被代理的方法，obs是指被代理的方法的参数组。此方法由代理类来实现。
2. Proxy：该类为动态代理类，主要包括以下内容： 

  protected Proxy(InvocationHandler h);

  static Class getProxyClass(ClassLoader loader,Class[] interfaces);

  static Object newProxyInstance(ClassLoader loader,Class[]interfaces,InvocationHandler h);


动态代理其实是在运行时生成class，所以，我们必须提供一组interface，然后告诉他class已经实现了这些interface，而且在生成Proxy的时候，必须给他提供一个handler，让他来接管实际的工作。
现在我们把静态代理的例子修改一下： 
//定义抽象角色；
public interface AbsRole{
  public void work();
}


接下来定义真实角色； 
public class RealRole implements AbsRole{
  public RealRole(){};
  
  public void work(){
    System.out.println("调用真实角色方法：RealRole.work()");
  }
}

然后书写动态代理编码 
public class DynamicProxyRole implements InvocationHandler{
  private Object sub;
  
  public DynamicProxyRole(){}

  public DynamicProxyRole(Object ob){
    this.sub = ob;
  }

  public Object invoke(Object proxy, Method method, Object[] obs) throws Throwable{
    method.invke(sub,obs);
    return null;
  }
}

代理类已经书写完毕，看看是否能正常运行。 
public class Main{
  public static void main(String[] args){
    RealRole  rr  = new RealRole();
    InvocationHandler dynamicProxy = new DynamicProxyRole(rr);
    Class<?> cls = rr.getClass();
    
    AbsRole r = (AbsRole)Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces(),DynamicProxyRole);
    r.work();
  }
}


调试成功，动态代理功能完成。

通过静态代理和动态代理学习，我们小结一下：
静态代理需要事先确定代理对象和被代理对象，他们要一起继承或者是实现相同的抽象类。动态代理可以在使用的时候传入真实对象，得到代理。动态代理还是主要依靠java本身的语言特性，实现代理，更加方便
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 09 May 2008 10:56:47 +0800 http://ozone.javaeye.com/blog/191339 http://ozone.javaeye.com/blog/191339 Adapter模式（Class Adapter） Ozone 作者: Ozone  链接：http://ozone.javaeye.com/blog/189954  发表时间: 2008年05月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

昨天讨论了Adapter模式的一种情况Object Adapter，他比较适用于某些时候的二次开发，但我们拿到某一个组件的class文件，没有源码，只有功能列表的情况时，某些时候整合需要Object adapter。Adapter还有另外一种情况 Class Adapter。
我们现在的程序使用接口 PutBags 
public interface PutBags {
  public void putAllBags();
}

如果我们有一个类的class文件PutFootBall，而无法适用其源码。只能适用其中的putAllFootBall()方法。 
public class PutFootBall {
  public void putAllFootBall(){
    System.out.println("Put Football....");
  }
}

而在我们现有的程序所适用的方式是 
public class Put implements PutBags{
  public void putAllBags(){
    System.out.println("Realize method....");
  }
  public void putOther(){
    System.out.println("Other....");
  }
}

如果我们现在不想改变PutBags接口，并且不希望改变PutAllFootBall()此时

我们考虑，如何让Put类既有第三方类的功能，又不改变原有的接口继承？简

单的讲，要想某个类拥有其他的类的功能继承是最普遍的方法。所以我们使用

继承并实现的方式 
public class Put extends PutFootBall implements PutBags{
  public void putAllBags(){
    putBall();  
}
}

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Mon, 05 May 2008 23:07:32 +0800 http://ozone.javaeye.com/blog/189954 http://ozone.javaeye.com/blog/189954 Adapter模式（Object Adapter） Ozone 作者: Ozone  链接：http://ozone.javaeye.com/blog/189561  发表时间: 2008年05月05日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Adapter模式使原本由于接口不兼容而不能在一起工作的类可以一起工作，即为一个内容合适但接口不匹配的对象创建一个新的接口.Adapter模式让现存的对象适应新的类结构,而不受他们的接口限制.
例如现在，我们有一个球袋类BasketballBag负责完成装入篮球。 
public class BasketballBag{
    public void putBasketball(){
        System.out.println("Put in BasketBall....");
    }
}

有一个专门负责装入操作的类的方法putBalls()来调用BasketballBag类中方法来放入篮球。 
public class PutBall{
    public void putBalls(BasketballBag bb){
        bb.putBasketball();
    }
}

此时我们有一个足球类FootballBag负责装入完成装入足球。 
public class FootballBag{
    public void putFootball(){
        System.out.println("Put in FootBall....");
    }
}

前面提到的类中的方法putBalls()用来调用BaskballBag中的方法来放入篮球，我们能不能使用同一个方法来放入足球呢？我们试一试 
public class Main {
    public static void main(String[] args){
        PutBall pb = new PutBall();
		
        System.out.println("BasketBall");
        BasketballBag bb = new BasketballBag();
        pb.putBalls(bb);
		
        System.out.println("FootBall")
        FootballBag fb = new FootballBag();
        pb.putBalls(fb);
    }

}

运行报错，告诉我们参数类型不匹配。在上述程序中，如何使用 
FootballBag fb = new FootballBag();
pb.putBalls(fb);

来执行呢？
那我们可以考虑使用一种办法是的pb.putBalls(fb) 中的 fb 参数类型能够和函数需要的类型相匹配。我们可以考虑让单独使用一个新的类，让他继承BasketballBag，并且加入扩展功能（调用/实例 FootballBag）。 
public class BallBag extends BasketballBag{
    FootballBag fb;
    public BallBag(FootballBag fb){
        this.fb = fb;
    }
    public void putFootballs(){
        fb.putFootball();
    }
}

类写好了，感觉不错，看看调试情况,修改一下刚刚的 Main类 
public class Main {
    public static void main(String[] args){
        PutBall pb = new PutBall();
		
        System.out.println("BasketBall");
        BasketballBag bb = new BasketballBag();
        pb.putBalls(bb);
		
        System.out.println("FootBall")
        FootballBag fb = new FootballBag();
        BallBag bbag = new BallBag(fb);
        pb.putBalls(fb);
    }

}

ok，测试通过。通过这个例子，我们得到一种把接口不兼容的类混合在一起使用的方法，而这种方法可以被称作Adapter模式。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Mon, 05 May 2008 00:12:46 +0800 http://ozone.javaeye.com/blog/189561 http://ozone.javaeye.com/blog/189561 Decorator模式 Ozone 作者: Ozone  链接：http://ozone.javaeye.com/blog/189547  发表时间: 2008年05月04日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

最近遇到一个需求，是要对一个类增加一些新的功能，原则上讲是不改变这个类的代码，不改变这个类的继承关系。以前了解过Decorator模式，所以特意又深入学习一会。
什么时候需要Decorator模式：它的主要功能是不改变类的代码和继承关系，为这个类增加功能。
例如我要计划做一件事情（例如 打印某段文字） 
public class DoWork(){
    public void doWork(){
        System.out.prinln("Do Work.....");
    }
}
]
可是由于工作变化，我需要在DoWork之前做另外一件事（打印一段特殊文字），并且在做完DoWork以后还要做一些简单的处理（同样是打印文字）。如何在不改变原有的继承关系的前提下实现此功能？
首先我们观察，所有的工作都是围绕做某件事情，所以我们可以抽象出一个接口。 
public interface Work(){
    public void doWork();
}

所以原有的类可以更改为 
public class DoWork implements Work(){
  public void doWork(){
      System.out.println("Do Work....");
  }
}

我们可以考虑按照要求，我们所要添加的两个动作也是围绕的doWork()来做文章，只是具体的实现办法有些变换，我们可以不可以另外添加一个辅助的类 OtherWork,通过他来实现要求中的两个功能，并且调用原来计划要执行的工作。 
public class DoAllWork implements Work(){
    private Work work;
    //为调用原来计划需要执行的任务做准备
    public DoAllWork(Work work){
        this.work = work;
    }
    public void beforeWork(){
        System.out.println("Before Work....");
    }
    public void endWork(){
        System.out.println("End Work....");
    }
    public void doWork(){
        beforeWork();
        work.doWork();
        endWork();
    }
}

我们测试一下，这个DoAllWork是不是能完成我们的需要 
public class Main(){
    public static void main(String[] args){
        Work work = new DoWork();
        DoAllWork daw = new DoAllWork(work);
        daw.doWork;
    }
}

OK,运行一下，一切都以实现 ：） 这种通过简单的一个实现类，帮助我们达到了要求，这种模式就是Decorator模式。
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sun, 04 May 2008 22:48:56 +0800 http://ozone.javaeye.com/blog/189547 http://ozone.javaeye.com/blog/189547 郁闷啊！ Ozone 作者: Ozone  链接：http://ozone.javaeye.com/blog/137497  发表时间: 2007年11月02日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

最近一直忙着学习新技术。以前总是感觉自己喜欢去研究那学比较成熟的技术，最近突然迷恋上学习一些新的，比较陌生得东西。在这过程中清楚的感觉的自己的基础知识太过贫乏了，开始怀疑自己这两年都在什么？时间就这么荒废了。到头来虽然看看自己有很多参与和负责的项目，但是想想技术，自己总是觉得自己比较空虚。和股市中“只赚指数，不赚钱”的感觉差不多。 所以从现在开始给自己一个六个月的计划，补充基础知识。从最简单的 jsp + servlet +java基础知识开始。不要放过一些细节。研究一下以前参与的过的项目。好好总结一下！
希望从明年下半年开始有个新的开始！
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 02 Nov 2007 09:21:13 +0800 http://ozone.javaeye.com/blog/137497 http://ozone.javaeye.com/blog/137497 javascript中document学习[转载] Ozone 作者: Ozone  链接：http://ozone.javaeye.com/blog/104699  发表时间: 2007年07月24日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

JS中document对象详解
document 文挡对象 - JavaScript脚本语言描述
对象属性 
  document.title              //设置文档标题等价于HTML的<title>标签
  document.bgColor            //设置页面背景色
  document.fgColor            //设置前景色(文本颜色)
  document.linkColor          //未点击过的链接颜色
  document.alinkColor         //激活链接(焦点在此链接上)的颜色
  document.vlinkColor         //已点击过的链接颜色
  document.URL                //设置URL属性从而在同一窗口打开另一网页
  document.fileCreatedDate    //文件建立日期，只读属性
  document.fileModifiedDate   //文件修改日期，只读属性
  document.fileSize           //文件大小，只读属性
  document.cookie             //设置和读出cookie
  document.charset            //设置字符集 简体中文:gb2312

对象方法 
  document.write()                   //动态向页面写入内容
  document.createElement(Tag)        //创建一个html标签对象
  document.getElementById(ID)        //获得指定ID值的对象
  document.getElementsByName(Name)   //获得指定Name值的对象

images集合(页面中的图象)

a)通过集合引用 
    document.images              //对应页面上的<img>标签
    document.images.length       //对应页面上<img>标签的个数
    document.images[0]           //第1个<img>标签           
    document.images[i]           //第i-1个<img>标签


b)通过nane属性直接引用 
 <img name="oImage">
     document.images.oImage       //document.images.name属性


c)引用图片的src属性 
 document.images.oImage.src   //document.images.name属性.src


d)创建一个图象 
    var oImage
    oImage = new Image()
    document.images.oImage.src="/1.jpg"

同时在页面上建立一个<img>标签与之对应就可以显示 
<html>
<img name=oImage>
<script language="javascript">
    var oImage
    oImage = new Image()
    document.images.oImage.src="/1.jpg"
</script>
</html>

forms集合(页面中的表单)

a)通过集合引用 
    document.forms                  //对应页面上的<form>标签
    document.forms.length           //对应页面上<form>标签的个数
    document.forms[0]               //第1个<form>标签
    document.forms[i]               //第i-1个<form>标签
    document.forms[i].length        //第i-1个<form>中的控件数
    document.forms[i].elements[j]   //第i-1个<form>中第j-1个控件


b)通过标签name属性直接引用 
    <form name="Myform"><input name="myctrl"></form>
    document.Myform.myctrl          //document.表单名.控件名


<html>
<!--Text控件相关Script-->
<form name="Myform">
<input type="text" name="oText">
<input type="password" name="oPswd">
<form>
<script language="javascript">
//获取文本密码框的值
document.write(document.Myform.oText.value)
document.write(document.Myform.oPswd.value)
</script>
</html>


<html>
<!--Select控件相关Script-->
<form name="Myform">
<select name="oSelect">
<option value="1">1</option>
<option value="2">2</option>
<option value="3">3</option>
</select>
</form>

<script language="javascript">
    //遍历select控件的option项
    var length
    length=document.Myform.oSelect.length
    for(i=0;i<length;i++)
    document.write(document.Myform.oSelect[i].value)
</script>

<script language="javascript">
    //遍历option项并且判断某个option是否被选中
    for(i=0;i<document.Myform.oSelect.length;i++){
    if(document.Myform.oSelect[i].selected!=true)
    document.write(document.Myform.oSelect[i].value)
    else
    document.write("<font color=red>"+document.Myform.oSelect[i].value+"</font>")   
    }
</script>

<script language="javascript">
    //根据SelectedIndex打印出选中的option
    //(0到document.Myform.oSelect.length-1)
    i=document.Myform.oSelect.selectedIndex
    document.write(document.Myform.oSelect[i].value)
</script>

<script language="javascript">
    //动态增加select控件的option项
    var oOption = document.createElement("OPTION");
    oOption.text="4";
    oOption.value="4";
    document.Myform.oSelect.add(oOption);
</script>
<html>

<Div id="oDiv">Text</Div>
  document.all.oDiv                        //引用图层oDiv
  document.all.oDiv.style                 
  document.all.oDiv.style.display=""       //图层设置为可视
  document.all.oDiv.style.display="none"   //图层设置为隐藏

/*document.all表示document中所有对象的集合
只有ie支持此属性，因此也用来判断浏览器的种类*/
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 24 Jul 2007 12:45:00 +0800 http://ozone.javaeye.com/blog/104699 http://ozone.javaeye.com/blog/104699 javascript页面表格排序 Ozone 作者: Ozone  链接：http://ozone.javaeye.com/blog/103272  发表时间: 2007年07月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

javascript页面排序

今天项目中需要页面点击表头,按升降排序,查找了各方面资料,根据网上实例,自己改写了一个简单的例子
说到排序,肯定少不了Array Methods 中的 sort(),简单的介绍一下.
sort()方法可用来排列数组中的元素,语法是 
    arrayObject.sort(sortByRequest)

注释: 1.sortByRequeset是可选项，指定排列次序。必须是一个函数。
2.sort()默认是没有参数，函数按照字母大小排列。如果是数字按照默认情况排列，会出现错误（e.g：1,11,2,21）
3.当使用sort()后，array发生改变。

页面表格js排序，首先要得到具体哪个表格，这个不需要讲了吧！ 
    sTable = document.getElementById(tableId);

表格找到后必须对表格的内容进行应用,即得到表格tbodies的集合. 
    var tbody = table.tBodies[0];
    var colRows = tbody.rows;


得到tbodies集合以后放入Array里面 
    var aTrs = new Array;
    for (var i=0; i < colRows.length; i++) {
	      aTrs[i] = colRows[i];
    }

所有信息已经准备完毕,我们对array进行排序(也就是上面代码中的aTrs) 
     aTrs.sort(compareEle());

其中compareEle()是指定排列次序的函数。
当把数字（aTrs）排列完毕以后，需要重新生成表格 

    var oFragment = document.createDocumentFragment();            
    for(var i=0; i < aTrs.length; i++) {
        oFragment.appendChild(aTrs[i]);
    }
        tbody.appendChild(oFragment);

这样，基本的功能已经介绍已经完成。
如果要在项目中加入这项功能需要考虑以下基本内容
1.浏览器的类型
2.需要定位是对哪一列进行排列
3.需要排列的列的数据类型。
4.是否连续排序（eg：如果按照升序排列以后，再次点击，应该按照降序列）
所以最终详细设计 
function ieOrFireFox(ob)
{
    if (ob.textContent != null)
	return ob.textContent;
    var s = ob.innerText;
    return s.substring(0, s.length);
}

//排序 tableId: 表的id,iCol:第几列 ；dataType：iCol对应的列显示数据的数据类型
function sortAble(tableId, iCol, dataType) {
	var table = document.getElementById(tableId);
	var tbody = table.tBodies[0];
	var colRows = tbody.rows;
	var aTrs = new Array;
         //将将得到的列放入数组，备用
	for (var i=0; i < colRows.length; i++) {
		aTrs[i] = colRows[i];
	}
                      
                 
	//判断上一次排列的列和现在需要排列的是否同一个。
	if (table.sortCol == iCol) {
		aTrs.reverse();
	} else {
		//如果不是同一列，使用数组的sort方法，传进排序函数
		aTrs.sort(compareEle(iCol, dataType));
	}
        
	var oFragment = document.createDocumentFragment();
                
	for (var i=0; i < aTrs.length; i++) {
		oFragment.appendChild(aTrs[i]);
	}                
	tbody.appendChild(oFragment);
	//记录最后一次排序的列索引
	table.sortCol = iCol;
}
//将列的类型转化成相应的可以排列的数据类型
function convert(sValue, dataType) {
	switch(dataType) {
	case "int":
		return parseInt(sValue);
	case "float":
		return parseFloat(sValue);
	case "date":
		return new Date(Date.parse(sValue));
	default:
		return sValue.toString();
    }
}
            
//排序函数，iCol表示列索引，dataType表示该列的数据类型
function compareEle(iCol, dataType) {
	return  function (oTR1, oTR2) {
		var vValue1 = convert(ieOrFireFox(oTR1.cells[iCol]), dataType);
		var vValue2 = convert(ieOrFireFox(oTR2.cells[iCol]), dataType);
		if (vValue1 < vValue2) {
			return -1;
		} else if (vValue1 > vValue2) {
			return 1;
		} else {
			return 0;
		}
       };
}


具体使用:
将上述代码保存为 sortable.js,在同一目录下新建sortable.html 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
 <HEAD>
  <TITLE> New Document </TITLE>
  <script src="sortable.js" type="text/javascript"></script>
 </HEAD>

 <BODY>
 <p>Sortable demo:</p>
        <table border="1" id="tableId">
            <thead>
                <tr>
                    <th onclick="sortAble('tableId', 0)"  
                         style="cursor:pointer">name</th>
                    <th onclick="sortAble('tableId', 1, 'date')"
                         style="cursor:pointer">Birthday</th>
                    <th onclick="sortAble('tableId', 2, 'int')" 
                         style="cursor:pointer">Age</th>
                </tr>
            </thead>
            <tbody>
                <tr>
                    <td>Ozone</td>
                    <td>01/12/1982</td>
                    <td>25</td>
                </tr>
                <tr>
                    <td>OnlyBlue3</td>
                    <td>10/24/1983</td>
                    <td>23</td>
                </tr>
                <tr>
                    <td>Momo</td>
                    <td>10/14/1999</td>
                    <td>8</td>
                </tr>
            </tbody>
        </table>
  
 </BODY>
</HTML>


以上例子经过 ie6 和 firefox2.0.0.5调试通过
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 20 Jul 2007 16:29:33 +0800 http://ozone.javaeye.com/blog/103272 http://ozone.javaeye.com/blog/103272 java 5.0 tiger学习笔记(二) Ozone 作者: Ozone  链接：http://ozone.javaeye.com/blog/101856  发表时间: 2007年07月17日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

generic 学习

一.使用Type-safe的list。
例如： 
List<E> list = new List<E>();
public boolean addMessage(E o){    };

其中E只是一个占位符，上例中，List<E> 中E表示list的参数可以接受的数据的类型。第二个表示函数addMessage声明了一个变量
E,并将它参数化。 
   //表示listOfString可以存入String实例，但是必须指定一个可以接受相同类型的实例给他。
   List<String> listStrings ;
   // 表示可以将String加入到listOfString中，但是无法加入其他的类型。
   List<String> listStrings = new LinkedList<String>();

例: 
      List<String> onlyStrings = new LinkedList<String>;
      onlyStrings.add("Hello");
      //onlyStrings.add(new StringBuilder("World")); 编译出现错误
      onlyStrings.add("Welcome to java");

注意：List所容许的是所有类型的对象，所以List不接受初始值，所以 primitive 类型的List。 
      //错误定义
      List<int> intOfList = new LinkedList<int>();

      //正确定义
      List<Integer> integerOfList = new LinkedList<Integer>();

二.使用Type-sefe的Map。
例如： 
       Map<Integer , Integer> map = new HashMap<Integer,Integer>();
       Map<E,T> map = new HashMap<E,T>();

其中E,T与上例中的相似，只是占位符。

语法： 
        Map<Integer,Integer> intOfMap ;
        Map<Integer,Integer> intOfMap = new Map<Integer,Integer>();

例子： 
        Map<Integer,Integer> intOfMap = new Map<Integer,Integer>();
        for(int i = 0;i<10;i++){
            intOfMap.put(i,i*3);
        }
        for(int i = 0;i<10;i++){

            System.Out.println("Map--->"+i+"  "+intOfMap.get(i));

       }

注意:此处我们加入的是int的i,默认情况下,java会在幕后把int自动转化成Integer.

三. 参数类型的遍历.

当遍历已经参数化的 List的时候,修要参数化你的Iterator.

例如: 
    List<String> stringOfList = new LinkedList<String>();
    stringOfList.add("Welcome");
    stringOfList.add("To");
    stringOfList.add("Java World");
    for(Iterator<String> i = stringOfList.iterator();i.hasNext();){
        String s = i.next();
        System.out.println("---s---〉"+s);
    }

四. 以参数类型作为参数：（接受参数类型；返回参数类型；参数类型作类型参数）
1. 接受参数类型： 
      public String getString（List<String> stringOfList）{
        for(Iterator<String> i = stringOfList.iterator();i.hasNext();){
            String s = i.next();
            System.out.println("---s---〉"+s);
         }
      }

2.返回参数类型 ： 
      public List<String> getList(){
            List<String> sList = new LinkedList<String>();
            sList.add("Hello");
            sList.add("Java");
            return sList;
      }

上述方法发挥安全类型的List，所以可以立即按照安全类型方式使用。

3.参数类型作类型参数： 
      Map<Integer,List<String>> mMap = new HashMap<Integer,List<String>>();

五.generic与类型转换

generic类型转化是按照非generic 的类型转化的，即是依照他本身的层次类型转化，而不是参数类型的层次类型
转化。
类如： 
     LinkedList<Float> floatList = new LinkedList<Float>();

转化是基于LinkedList的层次类型转化的，而不是参数 Float类型转化。


六.类型通配符
普通应用： 
       public void printList(List list){
            for(Iterator i = list.iterator();i.hasNext();){
                System.out.println("--print---"+i.next().toString());
            }
       }

如果使用generic类型,是函数可以接受所有类型的List.可以使用generic中的通配符号 ? 来表示"通配"的目的

即 
        public void printList（List<?> list）{
            for(Iterator<?> i = list.iterator();i.hasNext();){
                System.out.println("---print---->"+i.next().toString());
            }
        }

注意: List<?> list 和 List<Object> list 是两种不同的概念。

七 撰写自己的generic 
     public class Ball<T>{
        public List<T>  list;
        public Ball(){
            list = new ArrayList<T>();
        }

        public int getLenght(){
            return list.size();

        }
        public boolean isEmpty(){
            return (list.size()==0);
        }
        public void add(T o){
            list.add();
        }       
     }

如果你想使用String类型，用String替换 T 的 
       Ball<String> ball = new Ball<String>();

八：限制类型参数 
     public class IntBall<N extends Number> extends Ball<N>{

     }

如果使用 
     IntBall<String> ball = new IntBall<String>();

也可以在参数中使用限制。 
     public  static public sum(Ball<? extends Number> ball_1,Ball<? extends Number> ball_2){

     }

也可以换成另外形式 ： 
      public static <A extends Number> public sum(Ball<A> ball_1,Ball<A> ball_2){

      }

本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Tue, 17 Jul 2007 09:45:00 +0800 http://ozone.javaeye.com/blog/101856 http://ozone.javaeye.com/blog/101856 java 5.0 tiger学习笔记(一) Ozone 作者: Ozone  链接：http://ozone.javaeye.com/blog/93237  发表时间: 2007年06月22日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

一.使用Arrays的操作.
1. toString(Object[] a) :返回指定数组的内容的字符串表示形式.
2. deepToString(Object[] a) ：返回指定数组“深层内容”的字符串表示形式，他接受的对象是数组，也就是说他可以打印出数组中的数组。
3.deepEquals(Object[] a,Object[] b) :比较两数组是不是深层相等，相等返回true,否则false;
4. fill() :主要是把指定的制，分配给数组中制定的制。参数形式不定，具体看javaDoc.
5. clone() 创建并返回此对象的一个副本
例子:
java 代码
  1. import java.util.Arrays;  
  2.  public class ArrayEG {  
  3.      private int arry[];  
  4.   
  5.      public ArrayEG(int num){  
  6.          arry = new int[num];  
  7.          for(int i=0;i  
  8.          arry[i] = i * i;  
  9.          }  
  10.      }  
  11.   
  12.      public int[] getArray(){  
  13.          return arry;  
  14.      }  
  15.   
  16.      public static void main(String[] arg){  
  17.          ArrayEG test = new ArrayEG(3);  
  18.          int[] myArray = test.getArray();  
  19.          int[] myArray1 = test.getArray().clone();  
  20.          if(Arrays.equals(myArray,myArray1)){  
  21.              System.out.println("---Arrays are equal--");  
  22.          }else{  
  23.              System.out.println("----Arrays are not equal----");  
  24.          }  
  25.          System.out.println("--print array[]-->"+Arrays.toString(myArray));  
  26.   
  27.          Arrays.fill(myArray,1,2,9);  
  28.          String[][] number = {{"X","Y"},{"O","P"}};  
  29.          String[][] number1 = {{"X","Y"},{"P","O"}};  
  30.   
  31.          if(Arrays.deepEquals(number,number1)){  
  32.              System.out.println("-------Array are equal-----");  
  33.          }else{  
  34.              System.out.println("----- Array are not equal--------");  
  35.          }  
  36.          System.out.println("---print arrays[][]--->"+Arrays.deepToString(number));  
  37.      }  
  38.   }  

二.queue 使用(frist in first out or list in first out)
特点：1.添加删除和传统的collection不相同。
      2.queue有固定的大小，使得在添加和删除的时候注意异常抛出。
      3.LinkedList 被改造实现queue接口，也可以把它当作一般的　list来使用
方法摘要：
    1.element() : 检索，但是不移除此队列的头。
    2.offer(E o) : 如果可能，将指定的元素插入此队列。
    3.peek() : 检索，但是不移除此队列的头，如果此队列为空，则返回 null。
    4.poll() : 检索并移除此队列的头，如果此队列为空，则返回 null。
    5.remove() : 检索并移除此队列的头。
Queue排序:
    PriorityQueue另外一种Queue的实现，PriorityQueue使用Comparator来排序他的项目。默认是现实"自然排序"从小到大

  例子:
java 代码
 
  1. import java.util.Queue;  
  2. import java.util.LinkedList;  
  3. import java.util.PriorityQueue;  
  4. import java.util.Comparator;  
  5. import java.io.PrintStream;  
  6.   
  7. public class QueueTest {  
  8.     public Queue q;  
  9.     public QueueTest(){  
  10.         q = new LinkedList();  
  11.     }  
  12.   
  13.     //测试FIFO  
  14.     public void testFIFO(PrintStream out){  
  15.         q.offer("Event_1");  
  16.         q.offer("Event_2");  
  17.         q.offer("Event_3");  
  18.         Object o;  
  19.         while((o=q.poll())!=null){  
  20.             out.println(o);  
  21.         }  
  22.     }  
  23.   
  24.     public static void main(String[] arg){  
  25.         QueueTest qt = new QueueTest();  
  26.         System.out.println("Test first in first out....................");  
  27.         qt.testFIFO(System.out);  
  28.         System.out.println("Test queue...................... ");  
  29.         qt.testPriorityQueue();  
  30.         System.out.println("Test queue by comparator....................");  
  31.         qt.testPriorityQueueByComparator();  
  32.     }  
  33.   
  34.     public void  testPriorityQueue(){  
  35.         PriorityQueue pq = new PriorityQueue(20);  
  36.         for(int i = 0;i<20;i++){  
  37.             pq.offer(20-i*2);  
  38.         }  
  39.   
  40.         for(int i=0;i<20;i++){  
  41.             System.out.println("----Queue print---->"+pq.poll());  
  42.         }  
  43.     }  
  44.   
  45.     public void testPriorityQueueByComparator(){  
  46.         PriorityQueue pg = new PriorityQueue(20,new Comparator(){  
  47.             public int compare(Integer i,Integer j){  
  48.                 return i>j ? i : j;  
  49.                 }  
  50.             });  
  51.         for(int i = 0; i<20 ;i++){  
  52.             pg.offer(15-i);  
  53.         }  
  54.         for(int i = 0;i<20;i++){  
  55.             System.out.println("-----Queue print with comparator-------〉"+pg.poll());  
  56.         }  
  57.     }  
  58. }  

注释: 对comparator还不太理解,正在研究,有结果后和大家一起共享,那位朋友有相关资料,可以留言
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Fri, 22 Jun 2007 19:17:00 +0800 http://ozone.javaeye.com/blog/93237 http://ozone.javaeye.com/blog/93237 (转)一个最珍贵的故事——职场人不得不看 Ozone 作者: Ozone  链接：http://ozone.javaeye.com/blog/91043  发表时间: 2007年06月16日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

       一对新婚夫妇生活贫困，要靠亲友的接济才能活下去。一天，丈夫对妻子说：“亲爱的，我要离开家了。我要去很远的地方找一份工作，直到我有条件给你一种舒适体面的生活才会回来。我不知到会去多久，我只求你一件事，等着我，我不在的时候要对我忠诚，我也会对你忠诚的。”
       很多天后，来到一个正在招工的庄园，他被录用了。他要老板答应他一个请求：“请允许我在这里想干多久就多久，当我觉得应该离开的时候，您就要放我走。我平时不想支取报酬，请您将我的工资存在我的账户里，在我离开的那天，您在把我挣的钱给我。”双方达成协议。
       年轻人在那里一工作就是20年，中间没有休假。一天，他对老板说：“我想拿回我的钱，我要回家了。”老板说：“好吧，我们有协议，我会照协议办的。不过我有个建议，要么我给你钱，你走人；要么我给你三条忠告，不给你钱，然后你走人。你回房间好好想想再给我答复。”
        他想了两天，然后找到老板说：“我想要你那三条忠告。”老板提醒说：“如果给你忠告，我就不给你钱了。”年轻人坚持说：“我想要忠告。”
    于是老板给了他“三条忠告”:
    第一，永远不要走捷径。便捷而陌生的道路可能要了你的命。
    第二，永远不要对可能是坏事的事情好奇，否则也会要了你的命。
    第三，永远不要在仇恨和痛苦的时候作决定，否则你以后一生会后悔的。
     老板接着说：“这里有三个面包，两个给你路上吃，另一个等你回家后和妻子一起吃吧。”
在远离自己深爱的妻子和家庭20年后，男人踏上了回家的路。一天后，他遇到了一个人，那人问他：“你去哪里？”他回答：“我要去一个沿着这条路要走20 多天的地方。”那人说：“这条路太远了，我认识一条捷径，几天就能到。”他高兴极了，正准备走捷径的时候，想起老板的第一条忠告，他回到了原来的路上。后 来，他得知那个人让他走的所谓捷径完全是个圈套。
       几天后，他走累了，发现路边有家旅馆，他打算住一夜，付过房钱后他躺下睡了。睡 梦中他被声惨叫惊醒，他跳了起来，正想开门看看发生了什么事，但他想起了第二条忠告，于是回到床上继续睡觉。起床后喝完咖啡，店主问他是否听到了叫声，他 说听到了，店主问：“您不好奇吗？”他回答说不好奇。店主说：“您是第一个活着从这里出去的客人。我的独子有疯病，他经常大声叫着引客人出来，然后将他杀 死埋掉。”
        他接着赶路，终于在一天的黄昏时分，远远望见了自己的小屋。屋里的烟囱正冒着炊烟，还依稀可以看见妻子的身影，虽然天 色昏暗，但他依然看清了妻子不是一个，还有一个男子伏在她的膝头，她抚摸着他的头发。看到这一幕，他的内心充满仇恨和痛苦，他想跑过去杀了他们，他深吸一 口气，快步走了过去，这时他想起了第三条忠告，于是停下来，决定在原地露宿一晚，第二天在做决定。天亮后，已恢复冷静的他对自己说：“我不能杀死我的妻 子，我要回到老板那里，求他收留我，在这之前，我想告诉我的妻子我始终忠于她。”她走到家门口敲了敲门，妻子打开门，认出了他，扑到他的怀里，紧紧的抱住 了他。他想把妻子推开，但没有做到。他眼含泪水对妻子说：“我对你是忠诚的，可你背叛了我......”
        妻子吃惊的说：“什么？我从未背叛过你，我等了你20年。”
       他说：“那么昨天下午你爱抚的那个男人是谁？”
       妻子说：“那是我们的儿子。你走的时候我刚刚怀孕，今年他已经20岁了。”
       丈夫走进家门，拥抱了自己的儿子。在妻子忙着做晚饭的时候，他给儿子讲述了自己的经历。一家人坐下来一起吃面包，他把老板送的面包掰开，发现里面有一沓钱-那是他20年辛辛苦苦劳动得来的工钱。
-------------------------------------------------------------------------(2007/01/16转载)----------------------------

       看过了,在深深的思考.一直没有明白.,大家一起讨论!!! 
本文的讨论也很精彩，浏览讨论>>


JavaEye推荐



]]> Sat, 16 Jun 2007 15:33:02 +0800 http://ozone.javaeye.com/blog/91043 http://ozone.javaeye.com/blog/91043