增强for循环

增强for循环的作用：为了简化遍历集合和数组的步骤

增强for循环的适用对象：数组、所有实现了Iterable接口的实现类的对象（map不能直接使用，因为map没有实现Iterable接口）

注意：对象不能为空，如果传入的数组或集合为null，编译报错

问题：map也想使用增强for，那么可以参照map使用iterator的方法，先把map集合转成Set集合，然后可以使用增强for,示例：

Set<Map.Entry<K,V>> set =map.entrySet();

for(Map.Entry<K,V> entry:set)

{

         循环体；//得到的元素是Map.Entry<K,V>键值对关系

}

 

增强for循环的格式：

for(遍历出来的元素的数据类型变量名：遍历的目标对象)

{

循环体

}

增强for和普通for的区别：

1：增强for必须要有被遍历的目标，普通for不需要指定的遍历目标

例：增强for不能输出100次“哈哈”语句

2：增强for内部原理是Iterator在操作，但是只能取出，不能修改集合或数组内的元素，示例：

 

[java] view plaincopy
 
  1. ArrayList<String> a1 = new ArrayList<String>();  
  2. A1.add(“001”);  
  3. A1.add(“002”);  
  4. A1.add(“003”);  
  5.   
  6. For(String s:a1)  
  7. {  
  8.     System.out.println(s);  
  9. }  


 

输出结果为：

001

002

003

内部实现是增强for第一次执行时，s就指向了集合a1的第一个元素，而不是获取第一个元素的引用，所以不能修改集合的值，这个也是高级for的局限性

普通for可以修改元素的值

可变参数：

格式：数据类型… 变量名

可变参数实质上是一个数组，编译器在调用可变参数的时候，为该可变参数隐式创建一个数组，在方法体中以数组的形式访问参数

public void run(int … a)//红色为可变参数的形式，传入参数个数不确定

{}                                                    ps:   “...”的前后有无空格都可以

使用范例：

 

[java] view plaincopy
 
  1. Public static void main(String args[])  
  2. {  
  3.     sum(2,3,4,5,6,7);   
  4.     sum(2,3,4,5,6,7,8,9,10); //传入的参数个数可以任意个数  
  5. }  
  6. Public void sum(int … arr)   
  7. {  
  8.     for(int i:arr)//java虚拟机会把传入的参数封装到数组中  
  9. {  
  10.     sum+=1;  
  11. }  
  12. System.out.println(sum);  
  13. }  

 

使用可变参数需要注意的地方，一定要定义在参数列表的最后面（也就是说一个方法中只能存在一个可变参数，因为只有一个能作为最后）

public void run(String str,int… a)//红色为可变参数的形式，传入参数个

数不确定

静态导入：

问题:当一个类中同时存在静态成员和非静态成员的时候能否使用静态导入？

静态导入是不是会自动选择静态的成员导入，非静态的不导入？

解答：使用静态导入的类，该类的可以同时存在静态成员和非静态成员，导入时会会自动选择静态的成员导入，非静态的不导入

静态导入的注意事项：

1：如果使用静态导入的两个类中方法中的静态方法出现了重名

例：collections类中存在sort(collection c)

         Array类中也存在sort(int[]arr)

         但是方法接收的参数类型不一致，那么不会出错，编译器会自动选择正确参数的方法

         但是如果参数类型一致，那么使用时必须加上类名以示区分

 

2：如果在类中存在一个方法print()方法

在从另外一个包中静态导入一个同名的print()方法，那么编译器会优先调用本类中print()方法，如果此时想要使用静态导入的print()方法，就要加上类名以示区分

枚举：

一些方法在运行的时候，它需要的数据不是任意的，而是必须是一定范围内的，为了规避输入不合法的值，只能输入程序中规定好的值

怎么定义枚举：

         enum类名

{

枚举值，枚举值，枚举值；

}

枚举要注意的事项

1：枚举值的默认修饰符是publicstatic final

2:每个枚举值都是枚举类的对象

3：枚举类的构造方法是私有化的

4：枚举类可以有成员属性

5：枚举也能有构造方法，构造方法必须是private私有的

6：枚举值必须放在枚举类的第一行，任何方法和成员都必须位于枚举值的后面

 

枚举的几个比较重要的方法

ValueOf(String name):把字符串转换成枚举对象，返回带指定名称的指定枚举类型的枚举常量。名称必须与在此类型中声明枚举常量所用的标识符完全匹配

Values();得到所有的枚举值，返回来一个枚举数组，数组里存储的是枚举值

 

如果枚举里只有一个成员时，那么可以当做单例模式的实现形式

理解：因为枚举成员也是一个对象，构造方法也被私有了，简化了书写

装箱与拆箱

[java] view plaincopy
 
  1. package it.cast.test;  
  2.   
  3. public class AutoBoxDemo1 {  
  4.   
  5.         /** 
  6.          * @param args 
  7.          */  
  8.         public static void main(String[] args) {  
  9.                 // TODO Auto-generated method stub  
  10.                 Integer a=200;  
  11.                 Integer b=200;  
  12.                 if(a==b)  
  13.                         System.out.print("a==b");  
  14.                 else  
  15.                         System.out.print("a!=b");  
  16.         }  
  17.   
  18. }  
  19. //输出结果是：a！=b  
  20.   
  21.   
  22. package it.cast.test;  
  23.   
  24. public class AutoBoxDemo1 {  
  25.   
  26.         /** 
  27.          * @param args 
  28.          */  
  29.         public static void main(String[] args) {  
  30.                 // TODO Auto-generated method stub  
  31.                 Integer a=100;  
  32.                 Integer b=100;  
  33.                 if(a==b)  
  34.                         System.out.print("a==b");  
  35.                 else  
  36.                         System.out.print("a!=b");  
  37.         }  
  38.   
  39. }  
  40. //输出结果是:a==b  


 

为了节省空间，Integer创建了一个缓冲区，范围整数：-128~127  

如果存入的数在这个范围内，那么就会在缓冲区内取，如果超出这个范围，则会new创建一个新的Integer对象

 

使用的是享元模式

什么叫享元模式：

有多个小对象,他们中有多个相同的属性,这时把他们相同的属性变成一个对象(相同的属性称为内部状态),把不同的属性变成参数,称为外部状态.

 

我的理解：也就是封装，把相同的属性封装到一个对象里面，自定义的特有的属性变成参数，通过传递参数，使这个对象变成特有的对象