本文介绍了Java 1.5引入的一些语法糖特性，包括自动拆装箱机制，增强了for循环的便利性，可变参数的使用场景及注意事项，静态导入的便捷性，以及枚举的介绍和常见方法。这些特性显著提高了Java开发的效率和代码的可读性。
目
录
1.语法格式(快捷生成方式: 集合或数组名.for 然后回车即可!)
1.可变参数适用于定义方法的时候不知道该定义多少个参数的情况!
2.格式:修饰符 返回值类型 方法名(数据类型… 变量名){}
一.自动拆装箱机制
自动拆装箱机制是jdk1.5版本之后才有的机制,因为用起来很舒心,所以有了语法糖这个说法!(jdk1.5版本之前是手动拆装箱的哈!)
1.自动拆装箱
自动装箱：自动将基本类型转换成他对应的包装类型.
自动拆箱：自动将包装类型转换成天对应的基本类型.
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版本之前是手动拆装箱!
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,那么俩个对象的地址值是相等的!
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并且在迭代集合的途中，不能增删元素，会报并发修改异常.(并发修改异常------->这里这里)
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.注意事项
- 这里的变量其实是一个数组
- 如果一个方法有可变参数，并且有多个参数，那么，可变参数肯定是最后一个
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个季节等。案例演示如下:
//季节，自定义枚举
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);
}
}
定义枚举类要用关键字enum, 所有枚举类都是Enum的子类，但是不要显式的写出来, 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略, 建议不要省略。补:这个同第一个写枚举的意思是一样的, 这个更加方便!
//季节，自定义枚举 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的。
//季节，自定义枚举 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);
}
}枚举在switch语句中的使用。
//季节，自定义枚举 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;
}
}
}
枚举的单例模式(只有一个枚举项)
//这个枚举类，只有一个枚举项，其实就是单例模式
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万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
