增强for循环、可变参数、自动装箱与自动拆箱、枚举——Java基础

1. 增强for循环

 增强for循环作用：简化迭代器的书写格式

 适用范围： 实现Iterable接口的对象或者数组对象都可以使用for循环
 格式：    for（变量类型    变量名：遍历的目标） 
 注意事项： 
 *   1.  底层还是使用迭代器遍历，获取迭代器由jvm完成，增强for循环过程不允许使用集合修改
 *   2.  迭代器遍历与增强for循环区别：  可以用迭代器的remove方法删除元素；增强for不行；
 *   3.  普通for循环可以没有遍历的目标，增强for循环一定要有目标。  

 *   4.  Map集合没有实现Iterable接口，不能直接使用增强for循环，需要借助于collection集合实现

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class test_1{
	public static void main(String args[])  { 	
	    HashSet<String> set = new HashSet<String>();	   
	    set.add("fzx");
	    set.add("xzf");
	    set.add("nvxia");
	    
/*		Iterator<String> it = set.iterator(); 
		while (it.hasNext()) {
			it.next();
		}*/
// 增强 for 循环	    
	/*  for (String tmp :set ) {
			System.out.println(tmp);
		// 	set.remove("fzx");    //  迭代器
		}*/
	    
	/*    int[] arr = {12,5,6,1};
	    for(int tmp :arr) {	    	
	    	System.out.println(tmp);	    	
	    }*/
	    
	    HashMap<String, String> aa = new HashMap<String,String>();  // Map 没有实现 超级接口，需要变成单例集合遍历
	    aa.put("1", "a");
	    aa.put("3", "c");
	    aa.put("2", "b");
	    Set<Map.Entry<String, String>> ent = aa.entrySet();    	    
	    for(Map.Entry<String, String> entry : ent) {
	    	System.out.println(entry.getKey() + "  " + entry.getValue());
	    }	   
	}   
}

自行定义一个类 使用增强for循环

import java.util.Iterator;

class mylist implements Iterable<String>{	
  Object[]  arr = new Object[10];
  int index = 0;
  public void add(Object o) {
	  arr[index++] = o;
  } 
  public int sixe(){
	  return index;
  }

   @Override
    public Iterator<String> iterator() {	 
	      return new Iterator<String>() {    // 匿名内部类
	    	 int cursor = 0;
			@Override
			public boolean hasNext() {				
				return cursor < index;
			}
			@Override
			public String next() {				
				return (String) arr[cursor++];
			}  
		};
    }
}
public class test_1{
      public static void main(String args[])  { 		 
	mylist list = new mylist();
	list.add("fzx");
	list.add("zx");
	list.add("x");	
	for(String item : list) {		
		System.out.println(item);
	 }	    	   
  }   
}

2.  可变参数

 可变参数的格式：    数据类型...  变量名 
注意事项：
      1.  调用该方法可以传递参数也可以不传递参数
      2.  可变参数实际上是一个数组对象
      3.  可变参数必须位于形参中的最后一个

      4.  一个函数最多只能有一个可变参数

例子： 定义一个函数做加法功能

public class test_1{
	 public static void main(String args[])  { 
    //   int[] arr = {1,2,45,6,7};     
   //    add();   // 创建一个空元素的数组传给可变参数		 
       add(1,1,2,3);  
  }  
 public static void add(int b, int... arr ) {		 
	 System.out.println(arr);
	 System.out.println(arr.length);
		 		 
	/* int sum = 0;
	for(int item : arr) {			 
	     sum = sum+item; 
	 }		 
	 System.out.println(sum);*/		 
    }	 
}

3. 自动装箱 与 自动拆箱

  基本数据类型    包装类型
      byte       Byte
      short      Short
      int        Integer
      long       Long
      float      Float
      double     Double
      boolean    Boolean
      char       Character

/\\\\\\

public class test_1{
	 public static void main(String args[])  { 		 
	         String str = "12";
		 int i = Integer.parseInt(str);  // 字符串转化成  int 类型数据
		 System.out.println(i);		 
		 System.out.println(Integer.toString(i));   // 把数字转化成字符串		 
//   把整数转换成对应的进制形式	 
		 System.out.println("10的二进制 ： " + Integer.toBinaryString(10));
		 System.out.println("10的八进制 ： " + Integer.toOctalString(10));
		 System.out.println("10的十六进制 ： " + Integer.toHexString(10));		 
// 	进制转换。。。。。最大为  36 进制 
		String data = "10";
		int a = Integer.parseInt(data,5);
		System.out.println(a); 		 
	//  集合： 任意对象类型数据的容器		
//  自动装箱： 自动把java得基本数据类型转化成对象类型数据
		int b = 10;
		Integer c = b;    //  c 为引用数据类型		
//  自动拆箱： 把引用数据类型的数据转化成基本类型的数据	
		Integer d = new Integer(11);
		int  e = d;
		
		Integer  f = 128;
		Integer  g = 128;
		System.out.println((f==g));    // Integer类内部维护了缓冲数据，范围： -128~127
	 }	 
}

4.  枚举

 *  枚举： 一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，可以直接使用枚举 
 *  枚举类的定义格式：
         enum 类名{   ......    }
枚举类需要注意：
 *      1.  枚举类也是一个特殊的类
 *      2.  枚举值默认的修饰符是 public  static final 
 *      3.  枚举值是枚举值所属类的数据类型, 然后枚举值是指向了本类的对象的
 *      4.  枚举类的构造方法默认修饰符是   private 
 *      5.  枚举类可以定义自己的成员变量与 成员函数
 *      6.  枚举类可以自定义构造函数，且创建枚举值的时候需要传入参数，而且构造函数的修饰符必须是private.
 *      7.  枚举类可以存在抽象的方法，但是枚举值必须实现抽象的方法
 *      8.  枚举值必须位于枚举类的第一个语句 

enum Sex{
	man("男"){
		@Override
		public void run() {
			System.out.println(" hehe ");		
		}	
	},women("女"){
		@Override
		public void run() {
			System.out.println(" xixi ");			
		}		
	};  	
//  public static final Sex man =new  Sex();
//  public static final Sex man =new  Sex();		
	String value;  // 成员变量
	
	public void getvalue() {    //  成员函数
		System.out.println("value: " + value);		
	}		
	private Sex(String value) {      //  构造函数
		this.value = value;
	}	
	public abstract void run();	   //  抽象方法
}

public class test_1{
	 public static void main(String args[])  {
		 Sex sex = Sex.man;
		 sex.value = "男";
		 sex.getvalue();
                 sex.run();
	 }	 
}

/\\\\\\

enum Gender{
	man("男"),woman("女");	
	String value;	
	private Gender(String value){
		this.value = value;
	}
}
class Person{	
	private String name;	
	private	Gender sex;

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Gender getSex() {
		return sex;
	}
	public void setSex(Gender sex) {
		this.sex = sex;
	}		
}
public class test_1 {	
	public static void main(String[] args) {
		Person p = new Person();
		p.setName("狗娃");
		p.setSex(Gender.woman);
		System.out.println("名字："+ p.getName()+" 性别："+ p.getSex().value);		
	}	
}

\\\\