jdk1.5新特性: 静态导入 & 增强for循环 & 可变参数 & 自动装箱与自动拆箱 & 枚举类

静态导入

静态导入可以作用一个类的所有静态成员。
静态导入的格式 : import static 包名.类名.静态的成员；
import static java.util.Collections.sort;
import static java.util.Collections.binarySearch;
import static java.util.Collections.max;
静态导入要注意的事项：
1. 如果静态导入的成员与本类的成员存在同名的情况下，那么默认使用本类的静态成员，如果需要指定使用静态导入的成员，那么需要在静态成员前面加上类名

import static java.util.Collections.sort;
import static java.util.Collections.binarySearch;
import static java.util.Collections.max;

import static java.lang.System.out;

public class Demo{

    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循环

增强for循环的作用：简化迭代器的书写格式。(注意：增强for循环的底层还是使用了迭代器遍历)
增强for循环的适用范围：如果是实现了Iterable接口的对象或者是数组对象都可以使用增强for循环
增强for循环的格式：
for(数据类型变量名 :遍历的目标){}
增强for循环要注意的事项：
1. 增强for循环底层也是使用了迭代器获取的，只不过获取迭代器由jvm完成，不需要我们获取迭代器而已，所以在使用增强for循环变量元素的过程中不准使用集合对象对集合的元素个数进行修改
2. 迭代器遍历元素与增强for循环变量元素的区别：使用迭代器遍历集合的元素时可以删除集合的元素，而增强for循环变量集合的元素时，不能调用迭代器的remove方法删除元素
3. 普通for循环与增强for循环的区别：普通for循环可以没有变量的目标，而增强for循环一定要有变量的目标

public class Demo {
    
    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);
        }
        
        
        
        //需求： 在控制台打印5句hello world.
        for(int i = 0 ; i < 5; i++){
            System.out.println("hello world");
        }
        */
        
        //注意： 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());
        }
    }
}

自定义增强for循环

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 Demo {
    public static void main(String[] args) {
        MyList list = new MyList();
        list.add("张三");
        list.add("李四");
        list.add("王五");
        
        for(String item :list){
            System.out.println(item);
        }   
    }   
}

jdk1.5可变参数

可变参数的格式：数据类型... 变量名
可变参数要注意的细节：
1. 如果一个函数的形参使用上了可变参数之后，那么调用该方法的时候可以传递参数也可以不传递参数
2. 可变参数实际上是一个数组对象
3. 可变参数必须位于形参中的最后一个参数
4. 一个函数最多只能有一个可变参数，因为可变参数要位于形参中最后一个位置上

需求 : 定义一个函数做加法功能(函数做几个数据的加法功能是不确定)

public class Demo {

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

自动装箱与自动拆箱

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

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

public class Demo {
   
   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.toBinaryString(10));
       System.out.println("10的十六进制："+ Integer.toHexString(10));
       
       
       //可以把字符串当成对应的进行数据帮你转换
       String data = "10";
       int a = Integer.parseInt(data, 2);
       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; //把a存储的值赋予给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 这些数据在一个数组中。如果你获取的数据是落入到这个范围之内的，那么就直接从该缓冲区中获取对应的数据。
           
   }
}

枚举

问题：某些方法所接收的数据必须是在固定范围之内的
解决方案：这时候我们的解决方案就是自定义一个类, 然后是私有化构造函数，在自定义类中创建本类的对象对外使用

jdk1.5对以上问题提出了新的解决方案：就是使用枚举类解决

一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，Java5以后可以直接使用枚举予以解决。比如：方向 , 性别、季节、星期......

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

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

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 Demo {
    
    public static void main(String[] args) {
        Sex sex = Sex.man; //获取到了枚举类的对象
        sex.value = "男";
        sex.getValue();
        sex.run();
        
    }   
}

switch与枚举类的应用

switch适用的数据类型： byte \ char \short \ int \ String\枚举类型
注意：case语句后面跟的枚举值，只需要单写枚举值即可，不需要再声明该枚举值是属于哪个枚举类的

//季节枚举类
enum Season{
    spring,summer,autumn,winter;
}

enum Person2{
    student,worker;
}

public eclass Demo {
    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;      
        }
    }
}

可变参数

需求 : 定义一个函数做加法功能(函数做几个数据的加法功能是不确定)
可变参数的格式：数据类型... 变量名
可变参数要注意的细节：
1. 如果一个函数的形参使用上了可变参数之后，那么调用该方法的时候可以传递参数也可以不传递参数
2. 可变参数实际上是一个数组对象
3. 可变参数必须位于形参中的最后一个参数
4. 一个函数最多只能有一个可变参数，因为可变参数要位于形参中最后一个位置上

public class Demo {

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

自动装箱与自动拆箱

自动装箱 : 自动把java的基本数据类型数据转换成对象类型数据
自动拆箱 : 把引用类型的数据转换成基本类型的数据
java是面向对象的语言，任何事物都可以使用类进行描述，sun就使用了一些类描述java中八种基本数据类型数据:
基本数据类型: byte, short, int, long, float, double, boolean, char
包装类型 : Byte, Short, Integer, Long, Float, Double, Boolean, Character

public class Demo {
    
    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.toBinaryString(10));
        System.out.println("10的十六进制："+ Integer.toHexString(10));
        
        
        //可以把字符串当成对应的进行数据帮你转换
        String data = "10";
        int a = Integer.parseInt(data, 2);
        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; //把a存储的值赋予给b变量。
        
        //自动拆箱： 把引用类型的数据转换成基本类型的数据
        Integer c = new Integer(13);
        int d = c; //
        System.out.println(d);  
        
        //引用的数据类型
        Integer e = 128;
        Integer f = 128; 
        System.out.println("同一个对象吗？"+(e==f));  // false (-128~127中就是true)
                // Integer类内部维护 了缓冲数组，该缓冲数组存储的-128~127 这些数据在一个数组中。如果你获取的数据是落入到这个范围之内的，那么就直接从该缓冲区中获取对应的数据
    }
}

枚举类

枚举类的引入 :
- 问题 : 某些方法所接收的数据必须是在固定范围之内的
- 解决方案 : 这时候我们的解决方案就是自定义一个类,然后是私有化构造函数，在自定义类中创建本类的对象对外使用。jdk1.5对以上问题提出了新的解决方案：就是使用枚举类解决一些方法在运行时，它需要的数据不能是任意的，而必须是一定范围内的值，Java5以后可以直接使用枚举予以解决。比如：方向 , 性别、季节、星期......

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

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

    enum 类名{
        //枚举值
    }

枚举要注意的细节：
1. 枚举类也是一个特殊的类
2. 枚举值默认的修饰符是public static final
3. 枚举值就是枚举值所属的类的类型, 然后枚举值是指向了本类的对象的
4. 枚举类的构造方法默认的修饰符是private的
5. 枚举类可以定义自己的成员变量与成员函数
6. 枚举类可以自定义构造函数，但是构造函数的修饰符必须是private
7. 枚举类可以存在抽象的方法，但是枚举值必须要实现抽象的方法
8. 枚举值必须要位置枚举类的第一个语句

//自定义一个枚举类
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 Demo{
    public static void main(String[] args) {
        Sex sex = Sex.man; //获取到了枚举类的对象
        sex.value = "男";
        sex.getValue();
        sex.run();  
    }
}

switch

switch适用的数据类型： byte \ char \short \ int \ String\枚举类型
注意 : case语句后面跟的枚举值，只需要单写枚举值即可，不需要再声明该枚举值是属于哪个枚举类的

//季节枚举类
enum Season{
    spring,summer,autumn,winter;
}

enum Person2{
    student,worker;
}

public eclass Demo {
    
    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;      
        }   
    }
}

反编译

javap -c -l -private Sex // Sex是你需要查看反编译的东西

最后编辑于：2017.12.04 00:43:04

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 194,457评论 5赞 459
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 81,837评论 2赞 371
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 141,696评论 0赞 319
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 52,183评论 1赞 263
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 61,057评论 4赞 355
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 46,105评论 1赞 272
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 36,520评论 3赞 381
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 35,211评论 0赞 253
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 39,482评论 1赞 290
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 34,574评论 2赞 309
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 36,353评论 1赞 326
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 32,213评论 3赞 312
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 37,576评论 3赞 298
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 28,897评论 0赞 17
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 30,174评论 1赞 250
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 41,489评论 2赞 341
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 40,683评论 2赞 335

jdk1.5新特性: 静态导入 & 增强for循环 & 可变参数 & 自动装箱与自动拆箱 & 枚举类

静态导入

增强for循环

自定义增强for循环

jdk1.5可变参数

自动装箱与自动拆箱

枚举

switch与枚举类的应用

可变参数

自动装箱与自动拆箱

枚举类

switch

反编译

推荐阅读更多精彩内容