中日韩亚洲人成无码网站,亚洲男女一区二区三区,亚洲性猛交XXXX

fckeditor 更改囄��上传路径为绝对�\�?java-core-2.4.jar

梓枫 — Wed, 29 Jun 2011 02:19:00 GMT

在网上找了好久都没有扑ֈ�完全解决�q�个问题的办法，只好自己试着��L��?br />目的是更改fckeditor的上传图片到另一个工�E�中�Q�避免每�ơ更新项目版本时都要重新把附件拷贝一��?br />

首先扑ֈ�fckeditor.properties
在其中加�?br />

#上传文�g的绝对�\�?nbsp;(上传时用到的目录)

connector.userFilesAbsolutePath = D:/temp/image

#在web上��用文件时的虚拟目�? �Q�读取图片时用到�Q?/span>

connector.userFilesPath = http://localhost:8080/temp

更改ConnectorServlet�c�M��的doGet()�Ҏ��
扑ֈ�以下代码
//   String typePath = UtilsFile.constructServerSidePath(request, resourceType);
//   String typeDirPath = getServletContext().getRealPath(typePath);
    更改以上两行代码为：
   String typePath=D:/temp/image;
   String typeDirPath =D:/temp/image;

doPost()�Ҏ��同doGet�Ҏ��一��h��改同��L��代码

三、找�?font face="Verdana">fckeditor\editor\filemanager\browser\default\frmresourceslist.html文�g
扑ֈ�以下代码:
   var sCurrentFolderPath = oFolderNode.attributes.getNamedItem('path').value ;
   var sCurrentFolderUrl = oFolderNode.attributes.getNamedItem('url').value ;
   再其下方增加
   var num = sCurrentFolderUrl.indexOf('http');
    sCurrentFolderUrl =sCurrentFolderUrl.substring(num,sCurrentFolderUrl.lenght);

四�?nbsp; 扑ֈ�文�gfckeditor\editor\dialog\fck_image\fck_image.js
   更改�Ҏ��:
   function OnUploadCompleted( errorNumber, fileUrl, fileName, customMsg ){}
   在switch ( errorNumber )�q�行代码上面增加以下代码�Q?br />   var num = fileUrl.indexOf('http');
fileUrl =fileUrl.substring(num,fileUrl.lenght);

===========this over .....

以上��是更改为绝对�\径的整个�q�程�Q�也许有更好的办法，期待其出�?...

梓枫 2011-06-29 10:19 发表评论

Collections.sort() �?List 排序

梓枫 — Mon, 16 Mar 2009 14:19:00 GMT

class User {
String name;
String age;

public User(String name,String age){
   this .name = name;
   this .age = age;
}
public String getAge() {
   return age;
}
public void setAge(String age) {
   this .age = age;
}
public String getName() {
   return name;
}
public void setName(String name) {
   this .name = name;
}
}

public class SortTest {
public static void main(String[] args){
  List userlist = new ArrayList();
  userlist.add( new User( " dd " , " 4 " ));
  userlist.add( new User( " aa " , " 1 " ));
  userlist.add( new User( " ee " , " 5 " ));
  userlist.add( new User( " bb " , " 2 " ));
  userlist.add( new User( " ff " , " 5 " ));
  userlist.add( new User( " cc " , " 3 " ));
  userlist.add( new User( " gg " , " 6 " ));

Collections.sort(userlist, new Comparator < User > (){
public int compare(User arg0, User arg1) {
                  User user0 = (User)arg0;
                  User user1 = (User)arg1;
                   // 首先比较�q�龄�Q�如果年龄相同，则比较名�?/span>
                   int flag = user0.getAge().compareTo(user1.getAge());
                   if (flag == 0 ){
                    return user0.getName().compareTo(user1.getName());
                  } else {
                    return flag;
                  }
                 }

        });

   for ( int i = 0 ;i < userlist.size();i ++ ){
   User user_temp = (User)userlist.get(i);
      System.out.println(user_temp.getAge() + " , " + user_temp.getName());
  }

}
}

// 首先比较�q�龄�Q�如果年龄相同，则比较名�?/span>

�l�果:
    1 , aa
    2 , bb
    3 , cc
    4 , dd
    5 , ee
    5 , ff
    6 , gg

梓枫 2009-03-16 22:19 发表评论

-------------格式化输�?------------

梓枫 — Mon, 02 Mar 2009 14:00:00 GMT

System.out.format("%b\n",new Date());

对于b(布尔�c�d��)来说�Q?/font>

如果�?span style="COLOR: #ff0000">字符�Q�字�W�串�Q�数字，对象为true�Q?/font>

如果�?span style="COLOR: #0000ff; BACKGROUND-COLOR: #ffffff">NULL�Q�则为FALSE

System.out.format("%c\n",new Integer(50));

对于字符�c�d��来说�Q?/p>

只能是：byte�Q?int�Q?short�Q�字�W?对应的包装类

其他的则报告错误

System.out.printf("%d\n",new Long("99"));

对于整型数据来说�Q?/p>

如下�Q?span style="COLOR: #ff0000">byte short int long 及其包装�c?/span>都可�?�?span style="COLOR: #0000ff">float double 不可�?/p>

System.out.printf("%f\n",123.00)�Q?/p>

对于��点�c�d��来说�Q�必��L��float 或者是 double �Q�其他都不可�?/p>

System.out.format("%s",'p');

对于字符来说�Q?span style="COLOR: #ff0000">字符�Ԍ��数字�Q�对�?/strong>都可以。其实就是用字符串描�q�参�?/p>

梓枫 2009-03-02 22:00 发表评论

String.split()

梓枫 — Fri, 10 Oct 2008 03:33:00 GMT

在应用中用到一些，�l�大家�ȝ��一下，仅供大家参考：
1、如果用�?”作为分隔的话，必须是如下写法：String.split("\\."),�q�样才能正确的分隔开�Q�不能用String.split(".");
2、如果用“|”作为分隔的话，必须是如下写法：String.split("\\|"),�q�样才能正确的分隔开�Q�不能用String.split("|");
�?”和“|”都是�{义字�W�，必须得加"\\";
3、如果在一个字�W�串中有多个分隔�W�，可以用“|”作��字符�Q�比如：“acount=? and uu =? or n=?�?把三个都分隔出来�Q�可以用String.split("and|or");

梓枫 2008-10-10 11:33 发表评论

JAVA反射机制

梓枫 — Mon, 11 Aug 2008 03:23:00 GMT
JAVA反射机制
    JAVA反射机制是在�q�行状态中�Q�对于�Q意一个类�Q�都能够知道�q�个�cȝ��所有属性和�Ҏ��Q�对于�Q意一个对象，都能够调用它的�Q意一个方法；�q�种动态获取的信息以及动态调用对象的�Ҏ��的功能称为java语言的反��机制�?br />Java反射机制主要提供了以下功能：在运行时判断��L��一个对象所属的�c�；在运行时构造�Q意一个类的对象；在运行时判断��L��一个类所��h��的成员变量和�Ҏ��Q�在�q�行时调用�Q意一个对象的�Ҏ��Q�生成动态代理�?br />1. 得到某个对象的属�?br />
1 public Object getProperty(Object owner, String fieldName) throws Exception {
2     Class ownerClass = owner.getClass();
3
4     Field field = ownerClass.getField(fieldName);
5
6     Object property = field.get(owner);
7
8     return property;
9 }
Class ownerClass = owner.getClass()�Q�得到该对象的Class�?br />
Field field = ownerClass.getField(fieldName)�Q�通过Class得到�c�d��明的属性�?br />
Object property = field.get(owner)�Q�通过对象得到该属性的实例�Q�如果这个属性是非公有的�Q�这里会报IllegalAccessException�?br />
2. 得到某个�cȝ��静态属�?br />
1 public Object getStaticProperty(String className, String fieldName)
2             throws Exception {
3     Class ownerClass = Class.forName(className);
4
5     Field field = ownerClass.getField(fieldName);
6
7     Object property = field.get(ownerClass);
8
9     return property;
10 }

Class ownerClass = Class.forName(className) �Q�首先得到这个类的Class�?br />
Field field = ownerClass.getField(fieldName)�Q�和上面一��P��通过Class得到�c�d��明的属性�?br />
Object property = field.get(ownerClass) �Q�这里和上面有些不同�Q�因��属性是静态的�Q�所以直接从�cȝ��Class里取�?br />
3. 执行某对象的�Ҏ��

1 public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {
2
3     Class ownerClass = owner.getClass();
4
5     Class[] argsClass = new Class[args.length];
6
7     for (int i = 0, j = args.length; i < j; i++) {
8         argsClass[i] = args[i].getClass();
9     }
10
11     Method method = ownerClass.getMethod(methodName, argsClass);
12
13     return method.invoke(owner, args);
14 }
Class owner_class = owner.getClass() �Q�首先还是必��d��到这个对象的Class�?br />
5�?行：配置参数的Class数组�Q�作为寻找Method的条件�?br />
Method method = ownerClass.getMethod(methodName, argsClass)�Q�通过Method名和参数的Class数组得到要执行的Method�?br />
method.invoke(owner, args)�Q�执行该Method�Q�invoke�Ҏ��的参数是执行�q�个�Ҏ��的对象，和参数数�l�。返回值是Object�Q�也既是该方法的�q�回倹{�?br />
4. 执行某个�cȝ��静态方�?br />
1 public Object invokeStaticMethod(String className, String methodName,
2             Object[] args) throws Exception {
3     Class ownerClass = Class.forName(className);
4
5     Class[] argsClass = new Class[args.length];
6
7     for (int i = 0, j = args.length; i < j; i++) {
8         argsClass[i] = args[i].getClass();
9     }
10
11     Method method = ownerClass.getMethod(methodName, argsClass);
12
13     return method.invoke(null, args);
14 }

基本的原理和实例3相同�Q�不同点是最后一行，invoke的一个参数是null�Q�因��是静态方法，不需要借助实例�q�行�?br />
5. 新徏实例
1
2 public Object newInstance(String className, Object[] args) throws Exception {
3     Class newoneClass = Class.forName(className);
4
5     Class[] argsClass = new Class[args.length];
6
7     for (int i = 0, j = args.length; i < j; i++) {
8         argsClass[i] = args[i].getClass();
9     }
10
11     Constructor cons = newoneClass.getConstructor(argsClass);
12
13     return cons.newInstance(args);
14
15 }

�q�里说的�Ҏ��是执行带参数的构造函数来新徏实例的方法。如果不需要参敎ͼ�可以直接使用newoneClass.newInstance()来实现�?br />
Class newoneClass = Class.forName(className)�Q�第一步，得到要构造的实例的Class�?br />
�W?～第9行：得到参数的Class数组�?br />
Constructor cons = newoneClass.getConstructor(argsClass)�Q�得到构造子�?br />
cons.newInstance(args)�Q�新建实例�?br />
6. 判断是否为某个类的实�?br />
1 public boolean isInstance(Object obj, Class cls) {
2     return cls.isInstance(obj);
3 }

7. 得到数组中的某个元素
1 public Object getByArray(Object array, int index) {
2     return Array.get(array,index);
3 }

梓枫 2008-08-11 11:23 发表评论

梓枫 — Tue, 29 Jul 2008 08:32:00 GMT

web.xml里面可以定义两种参数�Q?br />(1)application范围内的参数�Q�存攑֜�servletcontext中，在web.xml中配�|�如下：
<context-param>
           <param-name>context/paramparam-name>
           <param-value>avalible during applicationparam-value>
  context-param>
(2)servlet范围内的参数�Q�只能在servlet的init()�Ҏ��中取得，在web.xml中配�|�如下：
<servlet>
    <servlet-name>MainServletservlet-name>
    <servlet-class>com.wes.controller.MainServletservlet-class>
    <init-param>
       <param-name>param1param-name>
       <param-value>avalible in servlet init()param-value>
    init-param>
    <load-on-startup>0load-on-startup>
servlet>
在servlet中可以通过代码分别取用�Q?br />
package com.wes.controller;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

public class MainServlet extends HttpServlet {

    public MainServlet() {
        super();
      }
    public void init() throws ServletException {
          System.out.println("下面的两个参数param1是在servlet中存攄��");
          System.out.println(this.getInitParameter("param1"));
         System.out.println("下面的参数是存放在servletcontext中的");
          System.out.println(getServletContext().getInitParameter("context/param"));
       }
}
�W�一�U�参数在servlet里面可以通过getServletContext().getInitParameter("context/param")得到
�W�二�U�参数只能在servlet的init()�Ҏ��中通过this.getInitParameter("param1")�?/p>

梓枫 2008-07-29 16:32 发表评论

可变参数

梓枫 — Fri, 25 Jul 2008 08:57:00 GMT
�W�五章“可变参数�?/span>

�Ҏ��重蝲是Java和其他面向对象语�a�最��L��色的�Ҏ��之一。当许多人可能认为Java的优势是它的�c�d��Q�或者是它所带的API库，其实让相同的�Ҏ��名与各种各样可接受的参数搭配也是一件很好的事�?br />

Guitar guitar = new Guitar("Bourgeois", "Country Boy Deluxe",
GuitarWood.MAHOGANY, GuitarWood.ADIRONDACK,1.718);
Guitar guitar = new Guitar("Martin", "HD-28");
Guitar guitar = new Guitar("Collings", "CW-28"
GuitarWood.BRAZILIAN_ROSEWOOD, GuitarWood.ADIRONDACK,1.718,
GuitarInlay.NO_INLAY, GuitarInlay.NO_INLAY);

This code calls three versions of the constructor of a (fictional) Guitar class, meaning that information can be supplied when it’s available,rather than forcing a user to know everything about their guitar at one time (many professionals couldn’t tell you their guitar’s width at the nut).
Here are the constructors used:
public Guitar(String builder, String model) {
}
public Guitar(String builder, String model,
GuitarWood backSidesWood, GuitarWood topWood,
float nutWidth) {
}
public Guitar(String builder, String model,
GuitarWood backSidesWood, GuitarWood topWood,
float nutWidth,
GuitarInlay fretboardInlay, GuitarInlay topInlay) {
}

�q�段代码调用了Guitar�c�M��三个版本的构造器�Q�意味着当信息可见时�Q�这些信息会被支持，而不是迫使每一个��用者每一�ơ都要去了解关于Guitar�cȝ��所有知识。许多专家不会在关键时候告诉你他们的Guitar的内宏V��下面是用到的构造器�Q?br />
public Guitar(String builder, String model) {
}
public Guitar(String builder, String model,GuitarWood backSidesWood, GuitarWood topWood,float nutWidth) {
}
public Guitar(String builder, String model,GuitarWood backSidesWood, GuitarWood topWood,float nutWidth,
GuitarInlay fretboardInlay, GuitarInlay topInlay) {
}

然而，当你惌��d��加无限的信息�Ӟ��事情开始变得有一点不是那么有用了。例如：假设你想允许在这个构造器中增加额外的未指明的�Ҏ��。下面就是一些可能的调用的例子：

Guitar guitar = new Guitar("Collings", "CW-28"
GuitarWood.BRAZILIAN_ROSEWOOD, GuitarWood.ADIRONDACK,1.718,
GuitarInlay.NO_INLAY, GuitarInlay.NO_INLAY,"Enlarged Soundhole", "No Popsicle Brace");
Guitar guitar = new Guitar("Martin", "HD-28V","Hot-rodded by Dan Lashbrook", "Fossil Ivory Nut","Fossil Ivory Saddle", "Low-profile bridge pins");

对于�q�两个单独的情况�Q�你不得不去增加一个构造器来接受两个额外的字符�Ԍ��另外一个构造器来接受四个额外的字符丌Ӏ�试囑ְ��q�些�怼�的版本应用于早已重蝲的构造器。根据这��L��话，你最�l�会得到20�?0个那��h��蠢的构造器的版本！

原因在于我们常称做的可变参数。可变参数是Tiger的增加的另一个特性，它用一�U�相当��y妙的�Ҏ��d��地解决了�q�儿提出的问题。这一章讲�q�C��q�种相对��单的�Ҏ��的各个斚w��。这��会使你�q�速写出更好、更整洁、更灉|��的代码�?br />
创徏一个可变长度的参数列表

可变参数使得你可以指定某�Ҏ��来接受多个同一�c�d��的参敎ͼ�而且�q�不要求事先��定参数的数量（在编译或�q�行�Ӟ��?br />�q�就是Tiger的一个集成部分。事实上�Q�正是因为Java语言的一些新�Ҏ��组合在一��h��表现��Z��可变参数的特性�?br />
我如何去实现呢？
首先�Q�你要习惯的书写省略��P��。。。）。这三个��点是可变参数的关键�Q�你��会�l�常键入它们。下面是Guitar�cȝ��构造器使用可变参数来接受不��定数量字符串的一个例子：

public Guitar(String builder, String model, String...features);

参数String... features 表明��M��数量的字�W�串都可能被接受�?所以，下面所有的调用都合法的�?br />
Guitar guitar = new Guitar("Martin", "HD-28V","Hot-rodded by Dan Lashbrook", "Fossil Ivory Nut","Fossil Ivory Saddle", "Low-profile bridge pins");
Guitar guitar = new Guitar("Bourgeois", "OMC","Incredible flamed maple bindings on this one.");
Guitar guitar = new Guitar("Collings", "OM-42","Once owned by Steve Kaufman--one of a kind");
You could add the same variable-length argument to the other constructors:
public Guitar(String builder, String model,
GuitarWood backSidesWood, GuitarWood topWood,float nutWidth, String... features)
public Guitar(String builder, String model,
GuitarWood backSidesWood, GuitarWood topWood,float nutWidth,
GuitarInlay fretboardInlay,GuitarInlay topInlay,String... features)

�?-1描写了一个把所有的�q�些�Ҏ��放在一��L��单类�Q�甚至��用XX来一起传递一些可变参数�?br />Example 5-1. Using varargs in constructors

package com.oreilly.tiger.ch05;
public class Guitar {
private String builder;
private String model;
private float nutWidth;
private GuitarWood backSidesWood;
private GuitarWood topWood;
private GuitarInlay fretboardInlay;
private GuitarInlay topInlay;
private static final float DEFAULT_NUT_WIDTH = 1.6875f;
public Guitar(String builder, String model, String... features) {
this(builder, model, null, null, DEFAULT_NUT_WIDTH, null, null, features);
}
public Guitar(String builder, String model,
GuitarWood backSidesWood, GuitarWood topWood,
float nutWidth, String... features) {
this(builder, model, backSidesWood, topWood, nutWidth, null, null, features);
}
public Guitar(String builder, String model,
GuitarWood backSidesWood, GuitarWood topWood,float nutWidth,
GuitarInlay fretboardInlay, GuitarInlay topInlay,String... features) {
this.builder = builder;
this.model = model;
this.backSidesWood = backSidesWood;
this.topWood = topWood;
this.nutWidth = nutWidth;
this.fretboardInlay = fretboardInlay;
this.topInlay = topInlay;
}
}

刚才发生了什�?
当你指定了一个可变长度参数列�?Java�~�译器实际上��d�� “create an array of type <参数�c�d��>”。你键入�Q?br />
public Guitar(String builder, String model, String... features)

然而：�~�译器解释这些�ؓ�Q?br />
public Guitar(String builder, String model, String[] features)

�q�意味着重复参数列表变得��单（�q�将在“重复可变长度参数列表”里讲述�Q�，�q�与你需要完成的其他�E�序设计目标是一栗��?br />你可以像使用数组一��h��使用可变参数�?br />然而，�q�同样存在一些限制。第一�Q�在每个�Ҏ��中，你只可以使用一�ơ省略号。所以，下面的书写是不合法的�Q?br />
public Guitar(String builder, String model,
String... features, float... stringHeights)

另外�Q�省略号必须作�ؓ�Ҏ��的最后一个参数�?br />

如果你不需要传递�Q何可变参数呢�Q?/b>
那没关系�Q�你只需要以旧的方式调用构造器�Q?br />
Guitar guitar = new Guitar("Martin", "D-18");

我们再仔�l�看看，虽然�E�序中没有与下面代码相匹配的构造器�Q?br />
public Guitar(String builder, String model)

那么�Q�代码到底传递了什么呢�Q�作为可变参数的特例�Q�在参数中不传递东西是一个合法的选项。所以，当你看到 String... features�Q�你应该把它认�ؓ是零个或者更多个String参数。这省却你再��d��建另一个不带可变参数构造器的麻烦�?br />
重复可变长度参数�c�表

所有这些可变参数是很好的。但是实际上�Q�如果你不在你的�Ҏ��中��用它们的话，他们昄��仅仅是吸引眼球的东西或是�H�户的装饰品而已�?br />然而，你可以像你��用数�l�一��h��使用可变参数�Q�你会觉得这�U�用法很��单�?br />
那我怎么来��用可变参数呢�Q?/b>
首先你要��保阅读了“创��Z��个可变长度的参数列表”，你会从中了解到可变参数方法最重要的东西，那就是我们把可变参数当作数组来看待�?br />所以，�l�箋前面的例子，你可以写��Z��面的代码�Q?br />
public Guitar(String builder, String model,
GuitarWood backSidesWood, GuitarWood topWood,float nutWidth,
GuitarInlay fretboardInlay, GuitarInlay topInlay,String... features) {
this.builder = builder;
this.model = model;
this.backSidesWood = backSidesWood;
this.topWood = topWood;
this.nutWidth = nutWidth;
this.fretboardInlay = fretboardInlay;
this.topInlay = topInlay;
for (String feature : features) {
System.out.println(feature);
}
}

上面的这�D�代码看上是不是不是那么的有吸引力？但这��实体现了可变参数的�_�N��。作为另一个例子，下面�q�个��单的�Ҏ��从一�l�数字中计算出最大��|��
public static int max(int first, int... rest) {
int max = first;
for (int i : rest) {
if (i > max)
max = i;
}
return max;
}

是不是，够简单吧�Q?br />

那么如何存储可变长度参数呢？
正因为Java�~�译器把�q�些看作数组�Q�所以数�l�显然是一个存储的好选择�Q�这��在下面的例5-2中体现�?br />Example 5-2. 存储作�ؓ成员变量的可变参�?br />
package com.oreilly.tiger.ch05;
public class Guitar {
private String builder;
private String model;
private float nutWidth;
private GuitarWood backSidesWood;
private GuitarWood topWood;
private GuitarInlay fretboardInlay;
private GuitarInlay topInlay;
private String[] features;
private static final float DEFAULT_NUT_WIDTH = 1.6875f;
public Guitar(String builder, String model, String... features) {
this(builder, model, null, null, DEFAULT_NUT_WIDTH, null, null, features);
}
public Guitar(String builder, String model,
GuitarWood backSidesWood, GuitarWood topWood,
float nutWidth, String... features) {
this(builder, model, backSidesWood, topWood, nutWidth, null, null, features);
}
public Guitar(String builder, String model,
GuitarWood backSidesWood, GuitarWood topWood,
float nutWidth,
GuitarInlay fretboardInlay, GuitarInlay topInlay,
String... features) {
this.builder = builder;
this.model = model;
this.backSidesWood = backSidesWood;
this.topWood = topWood;
this.nutWidth = nutWidth;
this.fretboardInlay = fretboardInlay;
this.topInlay = topInlay;
this.features = features;
}
}

你可以简单地在Java的Collection�c�M��存储�q�些可变参数�?br />
//变量声明
private List features;
//在方法中或是构造器中的书写
this.features = java.util.Arrays.asList(features);

允许雉��度的参数列表
可变参数的一个显著的�Ҏ��是可变长度参数可以接受零到N个参数。这��意味着你可以调用这些方法中的一个方法而不传递�Q何参敎ͼ��E�序同样可以�q�行。从另一斚w��来说�Q�这又意味着�Q�作��Z��个程序员�Q�你最好意识到你必��防范这�U�情�늚�发生�?br />
如何实现它呢�Q?/b>
记得在“重复可变长度参数类表”中�Q�你��d��q�下面这个简单的�Ҏ��Q?br />
public static int max(int first, int... rest) {
int max = first;
for (int i : rest) {
if (i > max)
max = i;
}
return max;
}

你可以以多种形式来调用这个方法：
int max = MathUtils.max(1, 4);
int max = MathUtils.max(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
int max = MathUtils.max(18, 8, 4, 2, 1, 0);

有一点不是那么��o人满意的地方是，在很多情况下�Q�你要传递的数字已经存储在数�l�里�Q�或是至��是在某些集成的形式中：
//用这�U�方法来取得数字
int[] numbers = getListOfNumbers( );

要把�q�些数字传递给max()�Ҏ��是不可能的。你需要检查list的长度，从中截取掉第一个对象（如果存在�W�一个对象的话）�Q�然后检查类型来��保是int型。完成了�q�些�Q�你才可以带着数组中剩余的部分一起传递进入方法。而这数组中剩余的部分�q�要重复�Q�或者要人工地�{化�ؓ适合的格式。��M��Q�这个过�E�会很辛苦，你需要做许多琐碎的事情。仔�l�想惻I��你要记得�~�译器是��这个方法解释�ؓ下面的语句：
public static int max(int first, int[] rest)
所以，你可以做些调��_��把max()�Ҏ��改写成下面这个样子：
public static int max(int... values) {
int max = Integer.MIN_VALUE;
for (int i : values) {
if (i > max)
max = i;
}
return

你现在已�l�定义了一个可以很�Ҏ��接受数组的方法�?br />
//用这�U�方法来取得数字
int[] numbers = getListOfNumbers( );
int max = MathUtils.max(numbers);

当接受单一的可变长度参数时�Q�你使用�q�种�Ҏ��会很��单。但是，如果在最好的情况下，你传递了一个零长度的数�l�进去，�q�就会带来问题，你会得到难以预料的结果。�ؓ了解册��个问题，你需要一个小的错误检查。例5-3是MathUtils�cȝ��完整代码列表�Q�在�q�里是一个功能更强的MathUtil�c�R�?br />

�?-3 处理零参数的�Ҏ��
package com.oreilly.tiger.ch05;
public class MathUtils {
public static int max(int... values) {
if (values.length == 0) {
throw new IllegalArgumentException("No values supplied.");
}

��M��时候，你都可能会要处理雉��度的参数列表�Q�这时你��需要执行这�cȝ��错误��查。通常�Q�一个功能强大的IllegalArgumentException�c�L��一个好的选择�?br />
int max = Integer.MIN_VALUE;
for (int i : values) {
if (i > max)
max = i;
}
return max;
}
}

那么关于调用同样的方法来处理通常参数不是数组的方法，又会如何�?�q�当然是完全合法的。下面的代码都是合法调用max()�Ҏ��的手�D�：
int max = MathUtils.max(myArray);
int max = MathUtils.max(new int[] { 2, 4, 6, 8 });
int max = MathUtils.max(2, 4, 6, 8);
int max = MathUtils.max(0);
int max = MathUtils.max( );

指定对象参数�Q�而非基本�c�d��

在第四章中我们谈刎ͼ�Tiger通过拆箱增加了一�p�d��的新特征。你可以在处理可变参数时�Q�在你的�Ҏ��接受的参��C��使用对象包装�c�R�?br />
如何实现�Q?/b>
你一定记得在Java中所有的�c�L��l�都是java.lang.Object的子�c�R��这��意味着��M��对象可以被�{化成一个Object对象。更�q�一步说�Q�因为像int和short�q�样的基本类型会自动转化成他们对应的对象包装�c�（��像Integer和Short�Q?��M��Java�c�d��可以被�{化成一个Object对象�?br />所以，如果你需要你的可变参数方法可以接受最多种参数的类型，那么你可以将Object�c�d��作�ؓ参数的类型。更好的是，��Z��辑ֈ�多重功能�Q�绝大多数情况下都会使用Object对象。例如，写个用来打印�Ҏ��?br />
private String print(Object... values) {
StringBuilder sb = new StringBuilder( );
for (Object o : values) {
sb.append(o)
.append(" ");
}
return sb.toString( );
}

�q�儿最��单的意思是打印出所有的东西。然而，�q�个�Ҏ��更通用的定义是下面的样子：
private String print(String... values) {
StringBuilder sb = new StringBuilder( );
for (Object o : values) {
sb.append(o)
.append(" ");
}
return sb.toString( );
}

�q�个�Ҏ��的问题是�Ҏ��自��n不能接受字符�?整数,��点�?数组和其他的�c�d��数据�Q�而这些数据你都想要正常的打印出来。通过使用Object�q�个更�ؓ通用的类型，你可以来打印所有的一切�?br />
private String print(Object... values) {
StringBuilder sb = new StringBuilder( );
for (Object o : values) {
sb.append(o)
.append(" ");
}
return sb.toString( );
}

避免数组自动转化

Tiger增加了各�U�类型的自动转化和便利，�q�些东西在绝大多数的情况下是很好用的。不�q�的是，有些时候所有的�q�些东西会变成你的障��。其中一�U�情冉|��Q�在可变参数�Ҏ��中将多个Object对象转化为Object[]数组对象�Q�你会发现在个别的情况下�Q�你需要用Java来书写�?br />

如何实现�Q?/b>
在将要仔�l�讨��件事情前�Q�你要确信自��q��解这个问题。Java新的printf()�Ҏ��是一个很好的便利�Q��D�q�个�Ҏ��作个例子�Q?br />
System.out.printf("The balance of %s's account is $%(,6.2f\n",account.getOwner().getFullName( ),account.getBalance( ));

如果你看一下Java文档中关于printf()�Ҏ��的说明，你就会看到它是一个可变参数的�Ҏ��。它有两个参敎ͼ�一个是用于讄��字符串格式的String�c�d��变量�Q�另一个是所有要传递进字符串的Object对象:
PrintStream printf(String format, Object... args)

现在�Q�你可以把上面的代码默认��Z��面的形式�Q?br />
PrintStream printf(String format, Object[] args)

两种书写是不是完全相同呢�Q�大多数情况下是相同的。考虑一下下面的代码�Q?br />
Object[] objectArray = getObjectArrayFromSomewhereElse( );
out.printf("Description of object array: %s\n", obj);

�q�是乎有点牵强，然而要把它看作是�ؓ了自省的代码而付出的正常开销。比起其它代码，�q�样写要��z�的多。如果你正在�~�写一个代码分析工��P��或者一个集成开发环境，或者其他可能��用reflection或简单API来判断出应用�E�序会需要何�U�对象的东西�Q�这些马上会成�ؓ一个通用的案例。这儿，你不是真正关心对象数�l�的内容�Q�就像你同样不会��d��心数�l�自�w�一栗��它是什么类型？它的内存地址是多��？它的字符串代表什么意思？��L��记所有这些问题都是和数组本��n有关的，和数�l�的内容无关。例如：我们来看看下面的数组代码�Q?br />
public Object[] getObjectArrayFromSomewhereElse( ) {
return new String[] {"Hello", "to", "all", "of", "you"};
}

在这�U�情况下�Q�你肯能会写一些像下面一��L��代码来回�{�某些关于数�l�的问题�Q?br />
out.printf("Description of object array: %s\n", obj);

然而，输出�l�果�q�不是你所期望的那��P��
run-ch05:
[echo] Running Chapter 5 examples from Java Tiger: A Developer's Notebook
[echo] Running VarargsTester...
[java] Hello

�q�倒是怎么回事�Q�这��׃��是你想看到的�l�果。然而，�~�译器做了它应该做的�Q�它把在printf()�Ҏ��里的Object...转换为Object[]。实际上�Q�当�~�译器得��C��Ҏ��的调用时�Q�它看到的参数是Object[]。所以编译器不是把这个数�l�看作一个Object对象本��n�Q�而是把它分成不同的部分。这栯��传递给字符串格�?(%s)的就是第一个参数部分“Hello”字�W�串�Q�所以结果“Hello”就昄��出来了�?br />
仔细看看�q��g事，你需要去告诉�~�译器你要把整个对象数组obj看作是一个简单的对象�Q�而不是一�l�参数。请看下面奇特的代码�Q?br />
out.printf("Description of object array: %s\n", new Object[] { obj });

作�ؓ选择�Q�还有一�U�更为简单的�Ҏ��Q?br />
out.printf("Description of object array: %s\n", (Object)obj);

在上面两�U�书写情况下�Q�编译器不再认�ؓ是对象的数组�Q�而是直接认�ؓ是一个简单的Object对象�Q�而这个Object对象又恰好是一个对象数�l�。那么结果就如你所愿（臛_��在这�U�简单的应用下）�Q?br />
run-ch05:
[echo] Running Chapter 5 examples from Java Tiger: A Developer's Notebook
[echo] Running VarargsTester...
[java] [Ljava.lang.String;@c44b88

看到�l�果�Q�你肯能会感到有炚w��乱。这大概是基于reflection或者其他自省代码需要的�l�果�?br />
全章�?

梓枫 2008-07-25 16:57 发表评论

J2SE5中的最新注释功能SuppressWarnings

梓枫 — Tue, 22 Jul 2008 03:36:00 GMT
     摘要: 一、什么是注释     说�v注释�Q�得先提一提什么是元数�?metadata)。所谓元数据��是数据的数据。也��是��_��元数据是描述数据的。就象数据表中的字段一��P��每个字段描述了这个字�D�下的数据的含义。而J2SE5.0中提供的注释��是java源代码的元数据，也就是说注释是描�q�java源代码的。在J2SE5.0中可以自定义注释。��用时在@后面跟注释的名字�? ...  阅读全文

梓枫 2008-07-22 11:36 发表评论

梓枫 — Mon, 21 Jul 2008 15:01:00 GMT
     摘要: 增强的for循环
　　 ��Z��q�代集合和数�l�，增强的for循环提供了一个简单、兼容的语法。有两点值得一提：　　Init表达�?

　　在��@环中�Q�初始化表达式只计算一�ơ。这意味着您通常可以�U�除一个变量声明。在�q�个例子中，我们必须创徏一个整型数�l�来保存computeNumbers()的结果，以防止每一�ơ��@环都重新计算该方法。您可以看到�Q�下面的代码要比上面的代码整�z�一些，�q�且没有泄露变量numbers�Q?

　　未增强的For�Q�　　int sum = 0;　　Integer[] numbers = computeNumbers();　　for (int i=0; i < numbers.length ; i++) sum += numbers[i];　　　增强后的For�Q?　　　int sum = 0;　　for ( int number: computeNumbers() ) sum += number;......
  阅读全文

梓枫 2008-07-21 23:01 发表评论

中日韩亚洲人成无码网站,亚洲男女一区二区三区,亚洲性猛交XXXX

fckeditor 更改囄���上传路径为绝对�\�?java-core-2.4.jar

Collections.sort() �?List 排序

-------------格式化输�?------------

String.split()

JAVA反射机制

可变参数

J2SE5中的最新注释功能SuppressWarnings

fckeditor 更改囄��上传路径为绝对�\�?java-core-2.4.jar