Java高新技术【1】 (静态导入-可变参数-增强for循环-基本数据类型的自动拆箱与装箱)

(1)静态导入

·import 语句可以导入一个类或某个包中的所有类。
·import static语句导入一个类中的某个静态方法或所有静态方法

静态导入与编译器语法设置： 
import 可以导入一个类或者一个包下的所有的类,
而import static 可以导入某个类中的一个静态方法或所有的静态方法。 
我们调用静态方法都是 类名.方法的方式进行调用,
有了import static 就可以不用写类名（jdk1.5或更高的版本），而直接写方法名了，
只是介绍有 这个一个知识点，但是并不常用因为没有多大的意义。

·语法举例：
-import static java.lang.Math.sin;
-import static java.lang.Math.*;

[java]  view plain copy print ?

1. import static java.lang.Math.*;  
2.   
3. public class StaticImport {  
4.   
5.     public static void main(String[] args){  
6.           
7.         int x = 1;  
8.         try {  
9.             x++;  
10.         } finally {  
11.             System.out.println("template");  
12.         }  
13.         System.out.println(x);  
14.           
15.           
16.         System.out.println(max(3, 6));  
17.         System.out.println(abs(3 - 6));  
18.           
19.     }  
20. }  

(2)可变参数

·问题：一个方法接受的参数个数不固定，例如：
-System.out.println(add(2,3,5));
-System.out.println(add(1,2,3,5));
·可变参数的特点：
（1）只能出现在参数列表的最后。
（2） ...位于变量类型和变量名称之间，前后有无空格都可以。
（3）调用可变参数的方法时，编译器为该可变参数隐含创建一个数组，在方法体中以数组的形式访问可变参数.

(3)java5的增强的for循环：

语法：for(VariableModifies(可选) type 变量名： 集合变量名) {....}
注意事项：(1)迭代变量必须在()中实现! 

   (2)集合变量可以是数组或者实现了Iterable接口的集合类

[java]  view plain copy print ?

1. public class VarableParameter {  
2.   
3.     /** 
4.      * @param args 
5.      */  
6.     public static void main(String[] args) {  
7.         // TODO Auto-generated method stub  
8.         System.out.println(add(2,3));  
9.         System.out.println(add(2,3,5));       
10.     }  
11.       
12.       
13.     public static int add(int x,int... args){  
14.         int sum = x;  
15.         /*       
16.          *       
17.                 for(int i=0;i<args.length;i++){ 
18.                     sum += args[i]; 
19.                 } 
20.         */  
21.           
22.         for(int arg : args){  
23.             sum += arg;  
24.         }  
25.         return sum;  
26.     }  
27. }  

（4）自动拆装箱

<1>Integer iObj = 3；自动把一个 基本数据类型 装成了一个 Integer对象，再赋值给 引用变量iObj。

<2> System.out.println(iObj + 12)； iObj是 Integer类型，而Integer类型不支持“+”法。必须要把其 变成 基本类型 才支持加法。

<3>:

 ·基本数据类型的对象缓存：

在对Integer对象的  -128~127  之间的数字的时候，使用了享元模式设计（flyweight）。

导致num1==num2 是true，即是同一个对象。

有很多个小的对象，它们有很多属性相同，就把他们变成相同的对象，
那些不同的属性把它变成方法的参数，称之为外部状态。
那些相同的属性称之为这个对象的内部状态。

[java]  view plain copy print ?

1. public class AutoBox {  
2.   
3.     /** 
4.      *  
5.      *          基本类型的自动拆装箱 
6.      *  
7.      *  
8.      * @param args 
9.      */  
10.     public static void main(String[] args) {  
11.             // 自动装箱  
12.             Integer iObj = 3;  
13.             // 自动拆箱  
14.             System.out.println(iObj + 12);  
15.           
16.               
17.              Integer num1 =12;  
18.              Integer num2 =12;  
19.              System.out.println(num1==num2);//   --true  
20.   
21.              Integer num3 =129;  
22.              Integer num4 =129;  
23.              System.out.println(num3 == num4);// --false  
24.   
25.              Integer num5 =Integer.valueOf(12);  
26.              Integer num6 =Integer.valueOf(12);  
27.              System.out.println(num5==num6);//   --true  
28.   
29.              Integer num7 =Integer.valueOf(212);  
30.              Integer num8 =Integer.valueOf(212);  
31.              System.out.println(num7==num8);//   --false  
32.     }  
33.   
34. }