Java基础增强(新特性)

版权声明: https://blog.csdn.net/qq_33278885/article/details/82312636

JDK5新特性

JDK5新特性:
自动装箱和拆箱
泛型
增强for循环
静态导入
可变参数
枚举

枚举:

枚举概述
是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内。举例:一周只有7天,一年只有12个月等。
回想单例设计模式:单例类是一个类只有一个实例
那么多例类就是一个类有多个实例,但不是无限个数的实例,而是有限个数的实例。这才能是枚举类。

枚举
通过自己定义一个枚举类来演示案例
第一版

public class Direction {
	// 创建几个实例
	public static final Direction FRONT = new Direction();
	public static final Direction BEHIND = new Direction();
	public static final Direction LEFT = new Direction();
	public static final Direction RIGHT = new Direction();

	// 构造私有,别人就不能无限的创建了
	private Direction() {
	}
}


第二版

public class Direction2 {
	// 创建几个实例
	public static final Direction2 FRONT = new Direction2("前");
	public static final Direction2 BEHIND = new Direction2("后");
	public static final Direction2 LEFT = new Direction2("左");
	public static final Direction2 RIGHT = new Direction2("右");

	// 构造私有,别人就不能无限的创建了
	// private Direction2() {
	// }

	// 加入成员变量,并去掉无参构造
	private String name;

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

	public String getName() {
		return name;
	}
}


第三版

public abstract class Direction3 {
	// 创建几个实例
	public static final Direction3 FRONT = new Direction3("前") {
		@Override
		public void show() {
			System.out.println("前");
		}

	};
	public static final Direction3 BEHIND = new Direction3("后") {
		@Override
		public void show() {
			System.out.println("后");
		}

	};
	public static final Direction3 LEFT = new Direction3("左") {
		@Override
		public void show() {
			System.out.println("左");
		}

	};
	public static final Direction3 RIGHT = new Direction3("右") {
		@Override
		public void show() {
			System.out.println("右");
		}

	};

	// 构造私有,别人就不能无限的创建了
	// private Direction2() {
	// }

	// 加入成员变量,并去掉无参构造
	private String name;

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

	public String getName() {
		return name;
	}

	// 加入抽象方法
	public abstract void show();
}


发现自己定义一个枚举类,比较麻烦,所以,java就提供了枚举类供我们使用。
格式是:只有枚举项的枚举类
public enum 枚举类名 {
            枚举项1,枚举项2,枚举项3…;
}

/*
 * 通过JDK5提供的枚举来做枚举类
 */
public enum Direction {
	FRONT, BEHIND, LEFT, RIGHT;
}
/*
 * 通过JDK5提供的枚举来做枚举类
 */
public enum Direction2 {
	FRONT("前"), BEHIND("后"), LEFT("左"), RIGHT("右");

	private String name;

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

	public String getName() {
		return name;
	}

	// @Override
	// public String toString() {
	// return "我爱林青霞";
	// }
}
/*
 * 通过JDK5提供的枚举来做枚举类
 */
public enum Direction3 {
	FRONT("前") {
		@Override
		public void show() {
			System.out.println("前");
		}
	},
	BEHIND("后") {
		@Override
		public void show() {
			System.out.println("后");
		}
	},
	LEFT("左") {
		@Override
		public void show() {
			System.out.println("左");
		}
	},
	RIGHT("右") {
		@Override
		public void show() {
			System.out.println("右");
		}
	};

	private String name;

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

	public String getName() {
		return name;
	}

	public abstract void show();
}
public class DirectionDemo {
	public static void main(String[] args) {
		

		Direction3 dd = Direction3.FRONT;
		dd = Direction3.LEFT;

		switch (dd) {
		case FRONT:
			System.out.println("你选择了前");
			break;
		case BEHIND:
			System.out.println("你选择了后");
			break;
		case LEFT:
			System.out.println("你选择了左");
			break;
		case RIGHT:
			System.out.println("你选择了右");
			break;
		}
	}
}

注意事项
定义枚举类要用关键字enum
所有枚举类都是Enum的子类
枚举类的第一行上必须是枚举项,最后一个枚举项后的分号是可以省略的,但是如果枚举类有其他的东西,这个分号就不能省略。建议不要省略
枚举类可以有构造器,但必须是private的,它默认的也是private的。枚举项的用法比较特殊:枚举(“”);
枚举类也可以有抽象方法,但是枚举项必须重写该方法
枚举在switch语句中的使用


枚举类中的几个常见方法
int compareTo(E o)
String name()
int ordinal()
String toString()
<T> T valueOf(Class<T> type,String name)
values()
此方法虽然在JDK文档中查找不到,但每个枚举类都具有该方法,它遍历枚举类的所有枚举值非常方便

扫描二维码关注公众号,回复: 3157701 查看本文章
public class EnumMethodDemo {
	public static void main(String[] args) {
		// int compareTo(E o)
		Direction2 d21 = Direction2.FRONT;
		Direction2 d22 = Direction2.BEHIND;
		Direction2 d23 = Direction2.LEFT;
		Direction2 d24 = Direction2.RIGHT;
		System.out.println(d21.compareTo(d21));
		System.out.println(d21.compareTo(d24));
		System.out.println(d24.compareTo(d21));
		System.out.println("---------------");
		// String name()
		System.out.println(d21.name());
		System.out.println(d22.name());
		System.out.println(d23.name());
		System.out.println(d24.name());
		System.out.println("--------------");
		// int ordinal()
		System.out.println(d21.ordinal());
		System.out.println(d22.ordinal());
		System.out.println(d23.ordinal());
		System.out.println(d24.ordinal());
		System.out.println("--------------");
		// String toString()
		System.out.println(d21.toString());
		System.out.println(d22.toString());
		System.out.println(d23.toString());
		System.out.println(d24.toString());
		System.out.println("--------------");
		// <T> T valueOf(Class<T> type,String name)
		Direction2 d = Enum.valueOf(Direction2.class, "FRONT");
		System.out.println(d.getName());
		System.out.println("----------------");
		// values()
		// 此方法虽然在JDK文档中查找不到,但每个枚举类都具有该方法,它遍历枚举类的所有枚举值非常方便
		Direction2[] dirs = Direction2.values();
		for (Direction2 d2 : dirs) {
			System.out.println(d2);
			System.out.println(d2.getName());
		}
	}
}

JDK6新特性(很少见所以不讲)

JDK7新特性

二进制字面量
数字字面量可以出现下划线
switch 语句可以用字符串
泛型简化
异常的多个catch合并

JDK7出现了一个新的异常处理方案:
    try{

        }catch(异常名1 | 异常名2 | ...  变量 ) {
            ...
       }

      注意:这个方法虽然简洁,但是也不够好。
          A:处理方式是一致的。(实际开发中,好多时候可能就是针对同类型的问题,给出同一个处理)
           B:多个异常间必须是平级关系。

try-with-resources 语句

import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;

public class Demo {
	public static void main(String[] args) {
		// 二进制字面量
		int x = 0b100101;
		System.out.println(x);
		// 数字字面量可以出现下划线
		int y = 1_1123_1000;
		// 不能出现在进制标识和数值之间
		int z = 0x111_222;
		// 不能出现在数值开头和结尾
		int a = 0x11_22;
		// 不能出现在小数点旁边
		double d = 12.3_4;
		// switch 语句可以用字符串?自己回顾
		// 泛型简化
		ArrayList<String> array = new ArrayList<>();
		// 异常的多个catch合并
		method();
	}

	private static void method() {
		// try-with-resources 语句
		// try(必须是java.lang.AutoCloseable的子类对象){…}

		try {
			FileReader fr = new FileReader("a.txt");
			FileWriter fw = new FileWriter("b.txt");
			int ch = 0;
			while ((ch = fr.read()) != -1) {
				fw.write(ch);
			}
			fw.close();
			fr.close();
		} catch (IOException e) {
			e.printStackTrace();
		}

		// 改进版的代码
		try (FileReader fr = new FileReader("a.txt");
				FileWriter fw = new FileWriter("b.txt");) {
			int ch = 0;
			while ((ch = fr.read()) != -1) {
				fw.write(ch);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

JDK8新特性(看一下)

这是另外一位道友整理的笔记,蛮细的,可以看下

https://blog.csdn.net/cdw8131197/article/details/68553148

猜你喜欢

转载自blog.csdn.net/qq_33278885/article/details/82312636
今日推荐