JAVA学习笔记整理七(JDK5新特性)

原创 2016年05月31日 12:46:58

静态导入

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

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

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

版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

【JavaSE学习笔记】泛型,jdk5之后新特性

泛型,jdk5之后新特性 A.泛型 1)概述 创建集合对象或者去调用方法的时候,将数据类型(引用类型)当作一种参数进行传递 2)格式 ...

黑马程序员_java jdk5.0新特性和枚举的学习笔记

------- android培训、java培训、期待与您交流! ---------- 1.Jdk5.0新特性: Collection在jdk1.5以后,有了一个父接口Iterable,这个接口的出...

黑马程序员________Java集合Map及其JDK1.5新特性泛型机制的学习笔记

------- android培训、java培训、期待与您交流! ----------         Map接口的子类特点是将对象成键值对的方式,成对存入集合,并且要保证键的唯一性...

黑马程序员_java jdk5.0新特性和枚举的学习笔记

------- android培训、java培训、期待与您交流! ----------   1.Jdk5.0新特性: Collection在jdk1.5以后,有了一个父接口Iterable,...
  • gsdimz
  • gsdimz
  • 2012年12月09日 00:48
  • 319

黑马程序员_java基础加强学习笔记之(JDK1.5新特性)

JDK1.5新特性:主要是通过一些特性来简化开发的代码,提高代码的复用性以及安全性。 JDK1.5新特性有: 1静态导入(Static import) 2可变参数(Var args) 3增强的“for...

黑马程序员_java学习笔记16—java5的新特性

------- android培训、java培训、期待与您交流! ---------- Java 5中的新特性 一、静态带入 (1) import语句可以导入一个类或某个包中的所有类 ...

学习笔记-JDBC与JDK新特性

1.杨辉三角 class Yanghui {  public static void main(String[] args)   {   shu();  }  public static void...

一个JDK1.5的新特性:枚举学习笔记

枚举 枚举就是一个特殊的类。可以有若干公有方法或抽象方法。采用抽象方法定义nextDay就将大量的if.else语句转移成了一个个独立的类。 枚举的构造方法等其他信息必须放在成员类表之后,...

HTML5新特性基础学习笔记上

1.HTML5音频视频 音频播放 1.Audio(音频) HTML5提供了播放音频文件的标准 2.control(控制器) control属性供添加播放,暂停和音量控件 3.标签: 定义声音 规定...

《Android群英传》学习笔记:Android 5.X新特性详解

学习笔记
  • PANJU_
  • PANJU_
  • 2016年10月25日 13:03
  • 236
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:JAVA学习笔记整理七(JDK5新特性)
举报原因:
原因补充:

(最多只允许输入30个字)