JAVA学习笔记整理七（JDK5新特性）

静态导入

导入其他类中的静态属性和方法，然后，在导入的类中，象使用自己的属性或者方法一样使用

Import static  包.类.*；

import static java.lang.Math.PI;//静态导入
import static java.lang.Math.pow;
import static java.lang.Math.max;

public class StaticImportDemo {
	public static void main(String[] args) {
		System.out.println("未使用静态导入：" + Math.PI * Math.pow(10, 2));
		System.out.println("使用静态导入：" + PI * pow(10, 2));
		System.out.println(max(13, 2));
	}
}

//未使用静态导入：314.1592653589793
//使用静态导入：314.1592653589793
//13

变长参数

1.    在方法声明中，可以使用“…”实现数量不确定的同一个类型的变量

2.    Java 编译器将可变参数转换成数组处理

3.    Varargs参数必须处于参数列表的最后。

4.    一个方法只能有一个varargs 参数

public class ArgsDemo {
	public static void main(String[] args) {
		int a = 10, b = 20, c = 30;
		System.out.println("add(a, b)=" + add(a, b));
		System.out.println("add(a, b, c)=" + add(a, b, c));
		System.out.println("add(a, b, c, 100)=" + add(a, b, c, 100));
		System.out.println("add()=" + add());
		System.out.println("add1(a, a, c)=" + add1(a, a, c));
	}

	// private static int add(int a, int b) {//若不使用...，则参数个数确定，一旦更改个数就需要重载方法
	// return a + b;
	// }

	// private static int add(int a, int b, int c) {
	// return a + b + c;
	// }

	private static int add(int... args) {// 可以传入0或多个参数
		int sum = 0;
		for (int i = 0; i < args.length; i++) {
			sum = +args[i];
		}
		return sum;
	}

	private static int add1(int a, int... args) {
	    // 可变长参数只能写一个,变长参数之后不能再写其他参数,若参数之前有其他参数，则有几个其他参数就必须至少传入几个对应参数
		int sum = a;
		for (int i = 0; i < args.length; i++) {
			sum += args[i];
		}
		return sum;

	}
}

//add(a, b)=20
//add(a, b, c)=30
//add(a, b, c, 100)=100
//add()=0
//add1(a, a, c)=50

增强的for循环

用于遍历数组或者集合

public class ForDemo {
	public static void main(String[] args) {
		int[] arr = new int[10];
		Random r = new Random();
		for (int i = 0; i < arr.length; i++) {
			arr[i] = r.nextInt(100);
		}

		System.out.print("数组:[");
		for (int i = 0; i < arr.length; i++) {
			int temp = arr[i];
			System.out.print(temp + (i == arr.length - 1 ? "]" : ","));
		}

		System.out.println("\n");
		System.out.print("数组:");
		for (int temp : arr) {// 增强性for循环
			System.out.print(temp + ",");
		}
	}
}
//数组:[20,63,33,53,59,2,29,35,94,86]
//
//数组:20,63,33,53,59,2,29,35,94,86,

枚举

1.    枚举最简单的形式就是一个命名常量的列表

2.    使用enum关键字定义枚举类型

3.    每一个枚举常量都是它的枚举类型的一个对象

4.    类集对枚举的支持——EnumMap、EnumSet

    使用时：需先定义一个枚举，再在类中使用

public enum Week {
	SUNDAY("星期天"), MONDAY, TUESDAY("星期二"), WEDNESDAY("星期三"), THURSDAY("星期四"), FRIDAY(
			"星期五"), SATURDAY("星期六");

	private String cn;

	// 可以有构造方法，但是只能是私有的,且枚举必须一一都有相对应的构造方法
	private Week(String cn) {
		this.cn = cn;
		System.out.println("=======");
	}

	private Week() {
	}
	
	public String getCn(){
		return cn;
	}
}

public class TestEnum {
	public static void main(String[] args) {
		Week week = Week.FRIDAY;// 枚举中的每一个选项就是它自身的实例,不可new
		System.out.println("星期几：" + week);
		Calendar date = Calendar.getInstance();//得到系統日期
		int a = date.get(Calendar.DAY_OF_WEEK);
		System.out.println("今天是周末吗？" + (a == 1 ? Week.SUNDAY : "不是"));//可以直接使用枚举来判断
		
		System.out.println(Week.FRIDAY instanceof Week);//判断A是否是B的实例对象或B子类的实例对象，返回boolean值
		System.out.println("week是星期几：" + week.getCn());
		System.out.println("Week.MONDAY是星期几：" + Week.MONDAY.getCn());//MONDAY没有cn对象，所以为空
		System.out.println("Week.TUESDAY是星期几：" + Week.TUESDAY.getCn());
		
		//枚举可以使用switch进行判断
		System.out.print("今天应该：");
		switch (week) {
		case SUNDAY:
			System.out.println("逛街看电影");
			break;
		case MONDAY:
			System.out.println("上班");
			break;
		case TUESDAY:
			System.out.println("上班");
			break;
		case WEDNESDAY:
			System.out.println("上班");
			break;
		case THURSDAY:
			System.out.println("上班");
			break;
		case FRIDAY:
			System.out.println("上班");
			break;
		case SATURDAY:
			System.out.println("出去玩");
			break;
		}
		
		//枚举使用增强型循环输出
		System.out.print("使用增强型循环输出：");
		for (Week w : Week.values()) {//枚举.values()表示得到全部枚举的内容
			System.out.print(w + "、");
		}
	}
}
//星期几：FRIDAY
//今天是周末吗？不是
//true
//week是星期几：星期五
//Week.MONDAY是星期几：null
//Week.TUESDAY是星期几：星期二
//今天应该：上班
//使用增强型循环输出：SUNDAY、MONDAY、TUESDAY、WEDNESDAY、THURSDAY、FRIDAY、SATURDAY、

泛型

    可以解决数据类型的安全性问题，原理是在类声明中通过一个标识来表示类中某个属性的类型，或者是某个方法的返回值及参数类型。然后在类声明时或者实例化时，只需要指定好所需要的类型即可，而不需要依次定义。

public class GenDemo {//泛型
	public static void main(String[] args) {
		//设置为String类型
		Location
    
    
     
      location = new Location<>();//使用的时候决定某些数据的数据类型
		location.x = "经度:123213";
		location.y = "纬度:123213";
		System.out.println("String类型：" + location);
		
		//设置为Integer类型（泛型的指定中无法指定基本数据类型，必须设置为一个类）
		Location
     
     
      
       location2 = new Location();
		location2.x = 121121;
		location2.y = 456456;
		System.out.println("Integer类型：" + location2);
	}
}
//String类型：Location [x=经度:123213, y=纬度:123213]
//Integer类型：Location [x=121121, y=456456]

class Location
      
      
       
       {//用T（也可以是其他任意的标识符号，T是Type的简写，较容易理解）代表类型，不具体指出，等到调用此类时再实例化具体类型
	T x;//此变量的类型由外部指定
	T y;
	public T getX() {
		return x;//返回值的类型由外部决定
	}
	@Override
	public String toString() {
		return "Location [x=" + x + ", y=" + y + "]";
	}
}

      
      
     
     
    
    

JDK7新特性

public class JDK7Demo {
	public static void main(String[] args) {
		int i = 0B1010;// 二进制的字面量
		System.out.println("输入为二进制：" + i);
		int i1 = 123_456_789;// 数字支持下划线
		System.out.println("输入含有下划线：" + i1);

		String name = "tom";
		switch (name) {// 支持字符串switch
		case "tom":
			System.out.println("字符串switch：" +name);
			break;
	default:
			break;
		}

		// 根据类型推断，省略实例化时的泛型参数
		List
      
      
       
        list = new ArrayList<>();
		try {
			Thread.sleep(100);
			new FileOutputStream("c:/config.txt");
		} catch (InterruptedException | FileNotFoundException e) {// 一个catch同时处理多种异常
			e.printStackTrace();
		}

		// 自动关闭流，原来需要手动关闭
		try (FileOutputStream out1 = new FileOutputStream("c:/config.txt")) {
			out1.write(97);
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		// out1.write(97);
	}
}
//输入为二进制：10
//输入含有下划线：123456789
//字符串switch：tom

      
      

Annotation

通过使用注释（Annotation），开发人员可以在不改变原有逻辑的情况下，在源文件嵌入一些补充信息，Annotation可以用来修饰类、属性、方法，且不影响程序运行。

1. @Override:在方法覆写时使用，用于保证方法 覆写的正确性，防止用户在覆写方法时将方法定义出错

2. @Deprecated:用来声明一个不建议使用的方法或者类，而如果方法或者类使用了该注释进行声明，在编译时会出现警告信息，但是依然可以执行

3. @SuppressWarnings :用来压制警告，可以同时压制多种警告，使用@SuppressWarnings({“unchecked”,“deprecation”})或者@SuppressWarnings(value={“unchecked”,“deprecation”})的格式

4. 自定义Annotation:[public]  @interface Annotation 名称{数据类型 变量名称()；}

5. @Target注释：明确地指出一个Annotation的使用位置（可以在一处或者多处，以“，”分隔开）

@Target(ElementType.METHOD)//method为方法声明

public @interface MyAnno {

    String value();

}

使用该自定义Annotation：

@MyAnno(value = "123")

    public void test() {

    }

@Documented：

使用该注释后，可以对类或者方法加入一些说明信息，便于理解用法（即开篇注释处）

@Inherited：

用于标注一个父类的注释是否可以被子类所继承，如果需要被继承则使用