Java基础学习第二十六天（静态导入、增强for循环、可变参数、自动装箱与自动拆箱、枚举类）

一、静态导入

1、静态导入的作用： 简化书写。
静态导入可以作用一个类的所有静态成员。

2、静态导入的格式：
import static 包名.类名.静态的成员；

3、静态导入要注意的事项： 如果静态导入的成员与本类的成员存在同名的情况下，那么默认使用本类的静态成员，如果需要指定使用静态导入的成员，那么需要在静态成员前面加上类名。

import static java.util.Collections.*;
import static java.lang.System.out;

public class Demo26.1 {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        list.add(13);
        list.add(9);
        list.add(10);
        list.add(19);       
        //排序
        Collections.sort(list);
        out.println("集合的元素："+ list);
        out.println("索引值："+ binarySearch(list,13));
        out.println("最大值："+ max(list));
    }   
    public static void sort(ArrayList<Integer> list){
        System.out.println("本类的sort方法.....");
    }
}

二、增强for循环

1、增强for循环的作用： 简化迭代器的书写格式。（注意：增强for循环的底层还是使用了迭代器遍历）

2、增强for循环的适用范围： 如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环。

3、增强for循环的格式：
for(数据类型 变量名 :遍历的目标){ }

4、增强for循环要注意的事项
① 增强for循环底层也是使用了迭代器获取的，只不过获取迭代器由jvm完成，不需要我们获取迭代器而已，所以在使用增强for循环变量元素的过程中不准使用集合对象对集合的元素个数进行修改。
② 迭代器遍历元素与增强for循环变量元素的区别：使用迭代器遍历集合的元素时可以删除集合的元素，而增强for循环变量集合的元素时，不能调用迭代器的remove方法删除元素。
③普通for循环与增强for循环的区别：普通for循环可以没有变量的目标，而增强for循环一定要有变量的目标。

public class Demo26.2{
    public static void main(String[] args) {
        HashSet<String> set = new HashSet<String>();
        //添加元素
        set.add("狗娃");
        set.add("狗剩");
        set.add("铁蛋");  

        //使用迭代器遍历Set的集合
        Iterator<String> it = set.iterator();
        while(it.hasNext()){
            String temp = it.next();
            System.out.println("元素："+ temp);
            it.remove();
        }   

        //使用增强for循环解决
        for(String item : set){
            System.out.println("元素："+ item);            
        }           

        int[] arr = {12,5,6,1};     
        //普通for循环的遍历方式
        for(int i = 0 ; i<arr.length ; i++){
            System.out.println("元素："+ arr[i]);
        }       
        //使用增强for循环实现
        for(int item :arr){
            System.out.println("元素："+ item);
        }           
        //注意：Map集合没有实现Iterable接口，所以map集合不能直接使用增强for循环，如果需要使用增强for循环需要借助于Collection的集合。
        HashMap<String, String> map = new HashMap<String, String>();
        map.put("001","张三");
        map.put("002","李四");
        map.put("003","王五");
        map.put("004","赵六");
        Set<Map.Entry<String, String>> entrys = map.entrySet();
        for(Map.Entry<String, String> entry :entrys){
            System.out.println("键："+ entry.getKey()+" 值："+ entry.getValue());
        }       
    }
}

import java.util.Iterator;

//自定一个类使用增强for循环
class MyList implements Iterable<String>{   
    Object[] arr = new Object[10];  
    int index = 0 ; //当前的指针 
    public void add(Object o){
        arr[index++] = o;  // 1
    }   
    public int size(){
        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++];
            }
            @Override
            public void remove() {      
            }
        };
    }
}
public class Demo26.3{  
    public static void main(String[] args) {
        MyList list = new MyList();
        list.add("张三");
        list.add("李四");
        list.add("王五");     
        for(String item :list){
            System.out.println(item);
        }       
    }   
}

三、可变参数

1、可变参数的格式：数据类型… 变量名

2、可变参数要注意的细节
① 如果一个函数的形参使用上了可变参数之后，那么调用该方法的时候可以传递参数也可以不传递参数。
② 可变参数实际上是一个数组对象。
③ 可变参数必须位于形参中的最后一个参数。
④ 一个函数最多只能有一个可变参数，因为可变参数要位于形参中最后一个位置上。

需求： 定义一个函数做加法功能（函数做几个数据的加法功能是不确定）

public class Demo26.4 {
    public static void main(String[] args) {
        int[] arr = {1,2,45,6,7};
        add(1,2,1,2,1,2);
    }   
    public static void add(int... arr){ //长度是0  
        int result = 0;
        for(int item : arr){
            result+=item;
        }
        System.out.println("总和："+ result);
    }   
}

四、自动装箱与自动拆箱

1、java是面向对象的语言，任何事物都可以使用类进行描述，sun就使用了一些类描述java中八种基本数据类型数据

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

基本数据类型数据有了对应的包装类型的好处：

public class Demo26.5 {
    public static void main(String[] args) {
        String str = "12";

        //字符串转换成int类型数据。 可以把字符串转换成对应的数字
        int i = Integer.parseInt(str);
        System.out.println(i+1);

        //把数字转换成字符串
        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));

        //可以把字符串当成对应的进制进行数据转换
        String data = "10";
        int a = Integer.parseInt(data, 2);//二进制的data
        System.out.println("a="+a);

        //集合：集合是可以存储任意对象类型数据的容器
        ArrayList list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);

        //自动装箱：自动把java的基本数据类型数据转换成对象类型数据
        int temp = 10;  //基本数据类型
        Integer b = temp; //把temp存储的值赋予给b变量

        //自动拆箱：把引用类型的数据转换成基本类型的数据
        Integer c = new Integer(13);
        int d = c;
        System.out.println(d);

        //引用的数据类型
        Integer e = 128;
        Integer f = 128; 
        System.out.println("同一个对象吗？"+(e==f)); // Integer类内部维护了缓冲数组，该缓冲数组存储的-128~127 这些数据在一个数组中。如果你获取的数据是落入到这个范围之内的，那么就直接从该缓冲区中获取对应的数据  
    }   
}

五、枚举类

1、步骤：先自定义一个类，然后是私有化构造函数，在自定义类中创建本类的对象对外使用。

2、枚举：一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，可以直接使用枚举予以解决。
枚举类的定义格式：

enum 类名{
        //枚举值
    }

/*
//自定义一个性别类
class Gender{
    String value;
    public static final Gender man = new Gender("男");
    public static final Gender woman = new Gender("女");
    private Gender(String value) {
        this.value = value;
    }
}
*/
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 Demo26.6{  
    public static void main(String[] args) {
        Person p = new Person();
        p.setName("狗娃");
        p.setSex(Gender.woman);
        System.out.println("名字："+ p.getName()+" 性别："+ p.getSex().value);    
    }
}

3、枚举要注意的细节
① 枚举类也是一个特殊的类。
② 枚举值默认的修饰符是public static final。
③ 枚举值就是是枚举值所属的类的类型， 然后枚举值是指向了本类的对象的。
④ 枚举类的构造方法默认的修饰符是private的。
⑤ 枚举类可以定义自己的成员变量与成员函数。
⑥ 枚举类可以自定义构造函数，但是构造函数的修饰符必须是private。
⑦ 枚举类可以存在抽象的方法，但是枚举值必须要实现抽象的方法。
⑧ 枚举值必须要位置枚举类的第一个语句。

//自定义一个枚举类
enum Sex{
    man("男"){
        @Override
        public void run() {
            System.out.println("男人在跑...");
        }   
    },woman("女"){
        @Override
        public void run() {
            System.out.println("女人在跑...");
        }
    }; //枚举值
    String value; //成员 变量
    //public static final Sex man = new Sex();  
    //构造函数
    private Sex(String  value){
        this.value = value;
    }
    //成员函数
    public void getValue(){
        System.out.println("value :"+ value);
    }
    public abstract void run(); 
}
public class Demo26.7{
    public static void main(String[] args) {
        Sex sex = Sex.man; //获取到了枚举类的对象
        sex.value = "男";
        sex.getValue();
        sex.run();  
    }
}

4、switch适用的数据类型： byte \ char \short \ int \ String\ 枚举类型

注意： case语句后面跟的枚举值，只需要单写枚举值即可，不需要再声明该 枚举值是属于哪个枚举类的。

//季节枚举类
enum Season{
    spring,summer,autumn,winter;
}
enum Person2{
    student,worker;
}
public class Demo26.8{
    public static void main(String[] args) {
        Season season = Season.summer;
        switch(season){
            case spring:
                System.out.println("春天...");
                break;
            case summer:
                System.out.println("夏天...");
                break;
            case autumn:
                System.out.println("秋天...");
                break;
            case winter:
                System.out.println("冬天...");
                break;      
        }
    }
}