静态导入
导入其他类中的静态属性和方法,然后,在导入的类中,象使用自己的属性或者方法一样使用
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:
使用该注释后,可以对类或者方法加入一些说明信息,便于理解用法(即开篇注释处)