语法糖机制(JDK1.5新特性) ---- 程序员的最爱目录

109 阅读 0 评论 72 点赞

我是靠谱客的博主威武麦片，这篇文章主要介绍语法糖机制(JDK1.5新特性) ---- 程序员的最爱目录，现在分享给大家，希望可以做个参考。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Test {
    public static void main(String[] args) {
          
            //自动装箱
            int num = 200;
            Integer integer = num;

            
            Integer a = new Integer(20);
            Integer b = new Integer(120);
            //自动拆箱
            int sum = a + b; 
            System.out.println(sum);
            
            Integer i = 100; //自动装箱
            i += 200; //先自动拆箱，再自动装箱

        }
    }

2.jdk1.5版本之前是手动拆装箱!

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class Test {
    public static void main(String[] args) {
            
        //手动装箱
        Integer integer = Integer.valueOf(100);

        Integer a = new Integer(5);
        Integer b = new Integer(15);
        //手动拆箱
        int i = a.intValue();
        int j = b.intValue();
        System.out.println(i + j);

        }

    }

补充:自动拆装箱里面有一个定律就是自动拆装箱的数字如果大于127,那么俩个对象的地址值不相等,如果小于等于127,那么俩个对象的地址值是相等的!

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class ChaiZhuangXiangTest {
    public static void main(String[] args) {
           
        Integer sum1=128;
        Integer sum2=128;

        Integer sum3=127;
        Integer sum4=127;

        //Integer中重写了equals方法,重写之后判断的是内容是否相等.所以用==判断地址值是否相等.
        System.out.println(sum1==sum2);       //false
        System.out.println(sum3==sum4);       //true

        }
    }

其原因需要认真查看底层代码实现才能懂! 其详细介绍在这里! ------> 这里这里!

二.增强for循环

JDK1.5版本之后才出现了增强for循环,也可称为新式for循环.它的出现简化了数组和Collection集合的遍历.

1.语法格式(快捷生成方式: 集合或数组名.for 然后回车即可!)

for(元素数据类型变量 : 数组或者Collection集合) {
使用变量即可，该变量就是元素
}

2.好处和注意事项

好处是简化了遍历,注意事项------>增强for的目标要判断是否为null并且在迭代集合的途中，不能增删元素，会报并发修改异常.(并发修改异常------->这里这里)

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.util.ArrayList;

public class Test {
    public static void main(String[] args) {

        //数组
        int[] arr = {10, 50, 30, 90, 25, 30};
        
        //增强for循环 JDK1.5
        //for(容器中元素的数据类型 变量名:容器名)
        for (int ele : arr) {
            System.out.println(ele);
        }

        //集合
        ArrayList<String> list = new ArrayList<>();
        list.add("aaa");
        list.add("bbb");
        list.add("ccc");
        list.add("ddd");
        list.add("eee");
        list.add("fff");
        
        for (String s : list) {
            System.out.println(s);
        }

    }
}

三.可变参数

1.可变参数适用于定义方法的时候不知道该定义多少个参数的情况!

2.格式:修饰符返回值类型方法名(数据类型… 变量名){}

3.注意事项

这里的变量其实是一个数组
如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class Test {
        public static void main(String[] args) {
            
            int sum1 = add(2, 6);
            int sum2 = add(2, 6, 7);
            int sum3 = add(2, 6, 7, 8);
            System.out.println(sum1);
            System.out.println(sum2);
            System.out.println(sum3);
        }

        public static int add(int... a) {
            //此时可以传入多个数据.
            System.out.println(a.length);
            int sum = 0;
            for (int i : a) {
                sum += i;
            }
            return sum;
        }

}

四.静态导入

也就是可以把静态方法直接像导包一样在Public class Test之前导入!例如: import static java.lang.Math.random;就直接将Math类中的random方法导入了!也可以使用通配符" * "把Math类下的所有静态方法都导入,如:import static java.lang.Math.*;导入成功之后再次调用Math下的random方法时就可以不用写类名调用了.

五.枚举

1.枚举的介绍

就是一个类只能存在几个固定的对象,那么这个就是枚举.我们就可以使用这些对象可以表示一些固定的值。举例: 一年只有4个季节等。案例演示如下:

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//季节，自定义枚举
public class Season {
    String name;
    public static final Season spring = new Season("春天");
    public static final Season summer = new Season("夏天");
    public static final Season autumn = new Season("秋天");
    public static final Season winter = new Season("冬天");

    private Season(String name) {
        this.name = name;
    }
}



public class MyTest {
    public static void main(String[] args) {
        //调用枚举内容
        Season spring = Season.spring;
        Season summer = Season.summer;
        Season autumn = Season.autumn;
        Season winter = Season.winter;

        System.out.println(spring.name);
        System.out.println(summer.name);
        System.out.println(autumn.name);
        System.out.println(winter.name);

    }
}

枚举类也可以有抽象方法，但是枚举项必须重写该方法。

复制代码

//季节，自定义枚举
public abstract class Season {
    String name;
    public static final Season spring = new Season("春天") {

@Override
        public void show(String name) {
            System.out.println(name);
        }
    };
    public static final Season summer = new Season("夏天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    };
    public static final Season autumn = new Season("秋天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    };
    public static final Season winter = new Season("冬天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    };

private Season(String name) {
        this.name = name;
    }

//抽象方法
    public abstract void show(String name);
}

public class MyTest {
    public static void main(String[] args) {

Season spring = Season.spring;
        Season summer = Season.summer;
        Season autumn = Season.autumn;
        Season winter = Season.winter;

System.out.println(spring.name);
        System.out.println(summer.name);
        System.out.println(autumn.name);
        System.out.println(winter.name);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
//季节，自定义枚举
public abstract class Season {
    String name;
    public static final Season spring = new Season("春天") {

        @Override
        public void show(String name) {
            System.out.println(name);
        }
    };
    public static final Season summer = new Season("夏天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    };
    public static final Season autumn = new Season("秋天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    };
    public static final Season winter = new Season("冬天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    };

    private Season(String name) {
        this.name = name;
    }

    //抽象方法
    public abstract void show(String name);
}



public class MyTest {
    public static void main(String[] args) {

        Season spring = Season.spring;
        Season summer = Season.summer;
        Season autumn = Season.autumn;
        Season winter = Season.winter;

        System.out.println(spring.name);
        System.out.println(summer.name);
        System.out.println(autumn.name);
        System.out.println(winter.name);
    }
}

定义枚举类要用关键字enum, 所有枚举类都是Enum的子类，但是不要显式的写出来, 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略, 建议不要省略。补:这个同第一个写枚举的意思是一样的, 这个更加方便!

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//季节，自定义枚举 enum 这个关键字就是用来定义枚举的
public enum Season {
    //枚举项
    SPRING, SUMMER, AUTUMN, WINTER;
}



public class MyTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        Season summer = Season.SUMMER;
        Season autumn = Season.AUTUMN;
        Season winter = Season.WINTER;
        System.out.println(spring);
        System.out.println(summer);
        System.out.println(autumn);
        System.out.println(winter);
    }
}

枚举类可以有构造器，但必须是private的，它默认的也是private的。

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//季节，自定义枚举 enum 这个关键字就是用来定义枚举的
public enum Season {
    //枚举项
    SPRING("春天"), SUMMER("夏天"), AUTUMN("秋天"), WINTER("冬天");
    String name;

    //构造器
    private Season(String name) {
        this.name = name;
    }
}



public class MyTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        Season summer = Season.SUMMER;
        Season autumn = Season.AUTUMN;
        Season winter = Season.WINTER;
        System.out.println(spring);
        System.out.println(summer);
        System.out.println(autumn);
        System.out.println(winter);
    }
}

枚举项的用法比较特殊：格式: 枚举(“ ”)

复制代码

//季节，自定义枚举 enum 这个关键字就是用来定义枚举的
//枚举类，本身就是抽象的，不需要加 abstract
public enum Season {
    //枚举项,    格式: 枚举(“  ”);
    SPRING("春天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    }, SUMMER("夏天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    }, AUTUMN("秋天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    }, WINTER("冬天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    };
    String name;

private Season(String name) {
        this.name = name;
    }

public abstract void show(String name);
}

public class MyTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        Season summer = Season.SUMMER;
        Season autumn = Season.AUTUMN;
        Season winter = Season.WINTER;
        System.out.println(spring);
        System.out.println(summer);
        System.out.println(autumn);
        System.out.println(winter);

}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
//季节，自定义枚举 enum 这个关键字就是用来定义枚举的
//枚举类，本身就是抽象的，不需要加 abstract
public enum Season {
    //枚举项,    格式: 枚举(“  ”);
    SPRING("春天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    }, SUMMER("夏天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    }, AUTUMN("秋天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    }, WINTER("冬天") {
        @Override
        public void show(String name) {
            System.out.println(name);
        }
    };
    String name;

    private Season(String name) {
        this.name = name;
    }

    public abstract void show(String name);
}


public class MyTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        Season summer = Season.SUMMER;
        Season autumn = Season.AUTUMN;
        Season winter = Season.WINTER;
        System.out.println(spring);
        System.out.println(summer);
        System.out.println(autumn);
        System.out.println(winter);

    }
}

枚举在switch语句中的使用。

复制代码

//季节，自定义枚举 enum 这个关键字就是用来定义枚举的
public enum Season {
    //枚举项,一般大写，多个有逗号隔开，最后一个枚举项,后面没有代码分号可以省略不写，如果还有代码那分号得写上
    SPRING, SUMMER, AUTUMN, WINTER;
    //String name;
}

int ordinal = spring.ordinal();
        System.out.println(ordinal);

System.out.println(spring.toString());
        System.out.println(spring.name());

// byte short int 字符串，枚举
        switch (Season.SPRING) {
            case SPRING:
                System.out.println("春天");
                break;
            case SUMMER:
                System.out.println("夏天");
                break;
            case WINTER:
                System.out.println("冬天");
                break;
            case AUTUMN:
                System.out.println("秋天");
                break;
        }
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
//季节，自定义枚举 enum 这个关键字就是用来定义枚举的
public enum Season {
    //枚举项,一般大写，多个有逗号隔开，最后一个枚举项,后面没有代码分号可以省略不写，如果还有代码那分号得写上
    SPRING, SUMMER, AUTUMN, WINTER;
    //String name;
}



public class MyTest {
    public static void main(String[] args) {
        Season spring = Season.SPRING;
        Season summer = Season.SUMMER;
        Season autumn = Season.AUTUMN;
        Season winter = Season.WINTER;
        System.out.println(spring);
        System.out.println(summer);
        System.out.println(autumn);
        System.out.println(winter);

        int ordinal = spring.ordinal();
        System.out.println(ordinal);

        System.out.println(spring.toString());
        System.out.println(spring.name());

        // byte short int 字符串，枚举
        switch (Season.SPRING) {
            case SPRING:
                System.out.println("春天");
                break;
            case SUMMER:
                System.out.println("夏天");
                break;
            case WINTER:
                System.out.println("冬天");
                break;
            case AUTUMN:
                System.out.println("秋天");
                break;
        }
    }
}

枚举的单例模式(只有一个枚举项)

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//这个枚举类，只有一个枚举项，其实就是单例模式
public enum Student {
    ONE
}


public class MyTest {
    public static void main(String[] args) {
        Student one = Student.ONE;
        System.out.println(one);
        Student one2 = Student.ONE;
        System.out.println(one == one2);
}

总结:定义枚举类要用关键字enum, 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是建议不要省略, 枚举类可以有构造器，但必须是private的。枚举项的用法比较特殊：枚举(“”);枚举类也可以有抽象方法，但是枚举项必须重写该方法。枚举在还可以在switch语句中使用!

2.枚举类的常见方法

int ordinal() // 返回枚举项的序号
int compareTo(E o) //比较两个枚举项的返回的是两个枚举项序号的差值
String name() //获取枚举项的名称
String toString() //获取枚举项的名称
<T> T valueOf(Class<T> type,String name) //用来获取指定的枚举项参数1:枚举类对应的字节码对象参数2 枚举项的名称
values() //获取所有的枚举项, 此方法虽然在JDK文档中查找不到，但每个枚举类都具有该方法，它遍历枚举类的所有枚举值非常方便

复制代码

public static void main(String[] args) {
	
	// 测试
	Direction front = Direction.FRONT ;
	Direction behind = Direction.BEHIND;
	Direction left = Direction.LEFT ;
	Direction right = Direction.RIGHT ;
	
	System.out.println(front.ordinal());
	System.out.println(behind.ordinal());
	System.out.println(left.ordinal());
	System.out.println(right.ordinal());
	
	System.out.println("----------------------------------");

System.out.println(front.compareTo(right));
	
	System.out.println("----------------------------------");
	
	System.out.println(front.name());
	
	System.out.println("----------------------------------");
	
	System.out.println(front.toString());
	System.out.println(front);
	
	System.out.println("----------------------------------");
	
	// <T> T valueOf(Class<T> type,String name):	用来获取指定的枚举项
	// type: 表示的是对应的枚举的字节码文件对象
	// name: 就是枚举项的名称
	Direction direction = Direction.valueOf(Direction.class, "RIGHT") ;
	System.out.println(direction);
	
	System.out.println("----------------------------------");
	
	Direction[] directions = Direction.values() ;
	
	for(Direction d : directions){
		System.out.println(d);
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public static void main(String[] args) {
	
	// 测试
	Direction front = Direction.FRONT ;
	Direction behind = Direction.BEHIND;
	Direction left = Direction.LEFT ;
	Direction right = Direction.RIGHT ;
	
	System.out.println(front.ordinal());
	System.out.println(behind.ordinal());
	System.out.println(left.ordinal());
	System.out.println(right.ordinal());
	
	System.out.println("----------------------------------");

	System.out.println(front.compareTo(right));
	
	System.out.println("----------------------------------");
	
	System.out.println(front.name());
	
	System.out.println("----------------------------------");
	
	System.out.println(front.toString());
	System.out.println(front);
	
	System.out.println("----------------------------------");
	
	// <T> T valueOf(Class<T> type,String name):	用来获取指定的枚举项
	// type: 表示的是对应的枚举的字节码文件对象
	// name: 就是枚举项的名称
	Direction direction = Direction.valueOf(Direction.class, "RIGHT") ;
	System.out.println(direction);
	
	System.out.println("----------------------------------");
	
	Direction[] directions = Direction.values() ;
	
	for(Direction d : directions){
		System.out.println(d);
	}

}

(小编也在努力学习更多哟!以后再慢慢挖掘,慢慢补充啦!)

希望对友友们有所帮助!!!!

最后

以上就是威武麦片最近收集整理的关于语法糖机制(JDK1.5新特性) ---- 程序员的最爱目录的全部内容，更多相关语法糖机制(JDK1.5新特性)内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：JAVASE基础知识
浏览次数：109 次浏览
发布日期：2023-05-29 23:57:01
本文链接：https://www.kaopuke.com/article/k-p-k_14_ujogfy_14__23__2_4.html

语法糖机制(JDK1.5新特性) ---- 程序员的最爱目录

目录

一.自动拆装箱机制

1.自动拆装箱

2.jdk1.5版本之前是手动拆装箱!

二.增强for循环

1.语法格式(快捷生成方式: 集合或数组名.for 然后回车即可!)

2.好处和注意事项

三.可变参数

1.可变参数适用于定义方法的时候不知道该定义多少个参数的情况!

2.格式:修饰符返回值类型方法名(数据类型… 变量名){}

3.注意事项

四.静态导入

五.枚举

1.枚举的介绍

2.枚举类的常见方法

最后

评论列表共有 0 条评论

发表评论取消回复

语法糖机制(JDK1.5新特性) ---- 程序员的最爱目录

目录

一.自动拆装箱机制

1.自动拆装箱

2.jdk1.5版本之前是手动拆装箱!

二.增强for循环

1.语法格式(快捷生成方式: 集合或数组名.for 然后回车即可!)

2.好处和注意事项

三.可变参数

1.可变参数适用于定义方法的时候不知道该定义多少个参数的情况!

2.格式:修饰符 返回值类型 方法名(数据类型… 变量名){}

3.注意事项

四.静态导入

五.枚举

1.枚举的介绍

2.枚举类的常见方法

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

微信扫一扫：分享

2.格式:修饰符返回值类型方法名(数据类型… 变量名){}

发表评论取消回复