BlogJava-Colorful Day-随笔分类-JAVA foundation

从codes学java tiger之varargs

BlueO2 — Mon, 26 Jun 2006 12:25:00 GMT

public class Artist {

    String[] others;
     /** Creates a new instance of Artist */
     public Artist() {
    }
     public Artist(String name,String  others) {
         for (String other : others) {
            System.out.println(other);
        }
         this .others = others;
    }
     public void wildestMethod(Object  objs) {
     // this method will accept any arguments
    }
     public static void main(String[] args) {
        Artist artist = new Artist( " You " , " 1 " , " 2 " );
        artist.wildestMethod( 1 , 3.5 , " AA " , new Artist());
    }

}

BlueO2 2006-06-26 20:25 发表评论

从code学习java tiger之自动装箱拆箱

BlueO2 — Thu, 22 Jun 2006 10:34:00 GMT

public class AutoBoxing {

     /** Creates a new instance of AutoBoxing */
     public AutoBoxing() {
    }
     public void boxingDemo() {
         // auto boxing
        Integer i = 0 ;
         float f = 1.66f ;
        Float F = f;
         // auto unboxing
        Integer I = new Integer( 1 );
         int i2 = I;
         // null value test, it will case NullPointerException
        Integer I2 = null ;
         int i3 = I2;
    }
     public void testOperator() {
        Integer i = 1 ;
         while ( true ) {
            i ++ ;
            System.out.println( " Counter: " + i);
             if (i > 5 ) break ;
        }
    }
     public void testCompare() {
         // it's equal because -127~127 are immutable objects
        Integer i = 1 ;
        Integer i2 = 1 ;
         if (i == i2) System.out.println( " 1:Equal " );
         else System.out.println( " 1:Not Equal " );
         // it's not equal because j and j2 are different objects
        Integer j = 200 ;
        Integer j2 = 200 ;
         if (j == j2) System.out.println( " 200:Equal " );
         else System.out.println( " 200:Not Equal " );
    }
     public void testControl() {
        Boolean flag = true ;
        Integer i = 20 ;
        Integer j = 30 ;
         if (flag) {
            System.out.println( " Boolean affects " );
        }
         if (i < j)
            System.out.println( " Integer affects " );
    }
     public void testMethod( double arg) {
        System.out.println( " public void testMethod(double arg) is invoked " );
    }
     public void testMethod(Integer arg) {
        System.out.println( " public void testMethod2(Integer arg) is invoked " );
    }
     public static void main(String args[]) {
        AutoBoxing auto = new AutoBoxing();
        auto.testCompare();
        auto.testOperator();
        auto.testControl();
         int i = 1 ;
         // public void testMethod(Integer arg) wouldn't be invoked
         // because  public void testMethod(double arg) will be invoked in JDK1.4
         // Java tiger consider the backward capability
        auto.testMethod(i);
        auto.boxingDemo();
    }

}

BlueO2 2006-06-22 18:34 发表评论

从code学习java tiger 之枚举

BlueO2 — Thu, 22 Jun 2006 10:22:00 GMT

public enum User {
Admin,User,Guest,Unknown
}

public class Login {

     private User user;
    EnumMap < User,String > userName = new EnumMap < User, String > (User. class );
     /** Creates a new instance of Login */
     public Login() {
        userName.put(User.Admin, " Administrator " );
        userName.put(User.User, " David " );
        userName.put(User.Guest, " Steve " );
    }
     public boolean isAdmin(User user) {
         if (user.equals(User.Admin)) {
             return true ;
        }
         return false ;
    }
     public void printUserRole() {
        User[] users = user.values();
         for (User u : user.values()) {
            System.out.println(u.toString());
        }
    }
     public void isRole(User user) {
         switch (user) {
             case Admin:
                System.out.println( " admin " );
                 break ;
             case User:
                System.out.println( " User " );
                 break ;
             case Guest:
                System.out.println( " Guest " );
                 break ;
             default :
                System.out.println( " unknow " );
        }
    }
     public static void main(String[] args) {
        Login login = new Login();
        System.out.println(login.isAdmin(User.Admin));
        login.printUserRole();
        login.isRole(User.User);
    }

}

BlueO2 2006-06-22 18:22 发表评论

从codes学java tiger之范型

BlueO2 — Tue, 20 Jun 2006 10:18:00 GMT

摘要: public class Generic { /** */ /** Creates a new instance of Generic */ ... 阅读全文

BlueO2 2006-06-20 18:18 发表评论

斗胆给Thinking in JAVA挑错

BlueO2 — Sat, 08 Oct 2005 04:05:00 GMT

今天晚上被讨厌的vba郁闷，以后谁再跟我说vb简单易用我跟谁急。由于计划上每天都要继续讨论java基础语言特性，所以最近也返璞归真，重读thinking in java。发现了一个问题如下：

在第9章持有你的对象arrays的比较章节，有如此代码片断：
String[] s1 = new String[5];
Arrays.fill(s1,"hi");
String[] s2 = {"hi","hi","hi","hi","hi"};
System.out.println(Arrays.equals(s1,s2));
输出结果true
Bruce给出的解释是s1的所有元素指向同一个对象，s2却拥有5个不同对象，但是Arrays.equals比较的是内容，还特意强调通过Object.equals()，所以结果为true.
首先，我们看看Arryas.fill(s1,"hi")如何工作：
SRC:
public static void fill(Object[] a, Object val) {
        fill(a, 0, a.length, val);
    }
public static void fill(Object[] a, int fromIndex, int toIndex,Object val){
        rangeCheck(a.length, fromIndex, toIndex);
        for (int i=fromIndex; i            a[i] = val;
    }

显然所有的s1中原素指向了相同的一个对象"hi"这里Bruce没错，那么后面的s2是否拥有5个不同的对象呢？我们做以下代码测试(其中捎带着String类型的测试)
import java.util.Arrays;
public class profit{
public static void main(String args[]){
String s1 = "Hi";
String s2 = "Hi";
String s3 = new String("Hi");
String s4 = new String("Hi");
if(s1==s2) System.out.println("s1 s2 equal");
if(s3==s4) System.out.println("s3 s4 equal");
//System.out.println(s3.hashCode());
//System.out.println(s4.hashCode());
String[] strArray = new String[2];
Arrays.fill(strArray,"hello");
if(strArray[0]==strArray[1]) System.out.println("strArray equal");
String[] strArray2 = {"hello","hello"};
if(strArray2[0]==strArray2[1]) System.out.println("strArray2 equal");
String[] strArray3 = {new String("hello"),new String("hello")};
if(strArray3[0]==strArray[1]) System.out.println("strArray3 equal");

输出结果：
---------- Run ----------
s1 s2 equal
strArray equal
strArray2 equal

Output completed (1 sec consumed) - Normal Termination
首先，各位应该明白最基础的东西 ==实现的比较是浅比较，就是非reference指向的具体对象内容，而是是否指向了同一个对象。第二，String类型被设计为非可变类，就是说 String s1 = "hi";与String s2 = "hi";其实指向了同一个对象，只有用new构造函数的时候才会产生新的对象，而不管内容是否已经在内存中存在。如下文字阐述了一些：
s = new String("Initial Value");
每次都会调用构造器，生成新对象，性能低下且内存开销大，并且没有意义，因为String对象不可改变，所以对于内容相同的字符串，只要一个String对象来表示就可以了。也就说，多次调用上面的构造器创建多个对象，他们的String类型属性s都指向同一个对象。
上面的结论还基于这样一个事实：对于字符串常量，如果内容相同，Java认为它们代表同一个String对象。而用关键字new调用构造器，总是会创建一个新的对象，无论内容是否相同
ok，回到我们的话题上来String[] s2 = {"hi","hi","hi","hi","hi"};是否产生了5个不同的对象呢？我写的简单的测试代码

String[] strArray2 = {"hello","hello"};
if(strArray2[0]==strArray2[1]) System.out.println("strArray2 equal");
的结果大家应该得出了结论了吧。
那么，bruce给出的代码的结果之所以为true就是因为，这么多个数组中的成员"hi"其实都是同一个对象。那么我们继续看Arrays.equals是否比较的内容呢？
SRC：
public static boolean equals(Object[] a, Object[] a2) {
        if (a==a2)
            return true;   //如果指向同一对象，当然是相同的，返回true
        if (a==null || a2==null)
            return false; //如果为null就没有相等的一说，false

        int length = a.length;
        if (a2.length != length) //长度不同
            return false;

        for (int i=0; i            Object o1 = a[i];
            Object o2 = a2[i];
            if (!(o1==null ? o2==null : o1.equals(o2))) //此处为关键，object的equals比较，Arrays.equals并没有专门为String类型重载此方法，全部都依赖Object的方法比较
                return false;
        }

return true;
}

那么我们再看看Object这个树根的equals方法吧：
public boolean equals(Object obj) {
return (this == obj);
}

短短几行代码，但是，是浅比较毫无疑问，所以，bruce说的，依赖的是Object.equals，比较的是内容，更是错误的。
但是必须强调的是，当String数组传递进来的时候，由于java的RTTI执行期型别辨识，Arryas.equals调用的其实是String.equals方法，而String.equals方法是比较内容的，所以，此处我想是bruce没有说明白，而又偏偏列举了String的例子。如果是自己写的类有没有复写equals方法，此时就调用Object.equals了，那么根本不可能比较内容，所以Arrays.equals大家一定要知道怎么回事再用。

BlueO2 2005-10-08 12:05 发表评论