【javaSE】JDK1.8之枚举与可变参数

1.枚举(enum)

enum关键字与class interface同级，代表是一个类的创建
用枚举取代通过使用构造方法开辟新对象的方式
枚举类中也可以拥有成员属性，通过构造方法尾成员赋初值，
定义枚举类的实例对象时，其参数列表要与构造方法的参数列表对应，多个对象用逗号分隔，且要放在类括号中的行首
一个源文件只能定义一个public类型的枚举类型
所有的枚举类型都隐式继承java.lang.Enum，因此枚举类不能再继承其他类，但是可以实现接口

public enum EnumTest {

    MONDAY(00,00,00),TUESDAY,WEDNSDAY,THURSDAY,FRIDAY;
    private int hour;
    private  int minutes;
    private int seconds;

    EnumTest() {
    }
    EnumTest(int hour, int minutes, int seconds) {
        this.hour = hour;
        this.minutes = minutes;
        this.seconds = seconds;
    }
}

Enum的常用方法：

public finalString name();//返回枚举常量的名称，在其枚举声明中进行声明

public final int ordinal()；//返回枚举类的序数（在枚举声明中的位置，从0开始）

public String toString();//返回枚举常量的名称

public static values();//静态方法，将枚举类型的成员以返回值是枚举类型的数组返回

public static valueOf(String name);//静态方法，返回带指定名称的指定枚举类型的枚举常量

 Week[] weeks=Week.values();
        for(int i=0;i<weeks.length;i++){
            System.out.print(weeks[i].ordinal());//int
            System.out.println(weeks[i].toString());//String
            System.out.println(weeks[i].name());//String
            System.out.println(weeks[i]);//Week
        }

枚举类支持switch语句：

public class EnumTest {
    public static void main(String[] args) {
        //获取枚举成员
        Week weekday=Week.FRIDAY;
        switch (weekday) {
            case MONDAY:
                System.out.println("周一");
                break;
            case TUESDAY:
                System.out.println("周二");
                break;
            case FRIDAY:
                System.out.println("周五");
                break;
        }
    }
}

2.注解

准确覆写注解,如果该方法确定成功覆写，则不会有语法 错误；如果没有成功覆写，则认为是语法错误。

@override

过期的注解,可以使用，但是不推荐，因此提高了版本的兼容性

@Deprecated

压制警告，当调用了某些操作可能产生问题的时候就会出现警告进行，但是警告信息并不是错，这个时候又不想总提示警告， 这个时候可以使用压制警告

@SuppressWarnings

接口新特性

在jdk1.8支持的新特性中,接口可以拥有普通方法.
1.通过default关键字定义接口中的普通方法.需通过对象调用

interface NewInterface {
    void print();
    //新特性中1.可以使用default定义普通方法
    public default void fun(){
        System.out.println("接口中的普通方法");
    }
}
class NewInterfaceImp implements NewInterface{

    @Override
    public void print() {
        System.out.println("实现接口的抽象方法");
    }

}
public class TestInterface{
    public static void main(String[] args) {
        NewInterface in=new NewInterfaceImp();
       //普通方法与子类实现的抽象方法都需要对象调用
        in.fun();
        in.print();
    }
}

2.通过static定义静态方法,需通过接口名调用

interface NewInterface {
    void print();
    //新特性中2.可以使用static定义静态方法方法
    public static NewInterface getNewInterface(){
        return new NewInterfaceImp();
    }
}
class NewInterfaceImp implements NewInterface{

    @Override
    public void print() {
        System.out.println("实现接口的抽象方法");
    }

}
public class TestInterface{
    public static void main(String[] args) {
        //接口中的静态方法需要接口名调用
        System.out.println(NewInterface.getNewInterface());;
    }
}

虽然接口与抽象类越来越相似,但是接口比抽象类更强大的是,接口可以多继承,而抽象类只能单继承.

可变参数

用于定义个数不定的参数，语法：

public [ static] [final] 返回值 方法名称（[参数类型  ... 参数名称]）

参数上使用的...实际上是表示一个数组结构，因此不能再在参数列表中定义数组。

public class Test {
    public static void main(String[] args) {
        System.out.println( add(1,2,3));
        System.out.println( add(1, 45, 67, 34, -100));
        tell("小明",66,34.0,88,95.5);
    }
    //使用可变参数就不限定传入参数的个数，但是类型必须对应
    public static double add(int...data){
      double sum=0.0;
        for(double i:data){
            sum+=i;
        }
        return sum;
    }
    //传递多种类型的参数，可变参数要放在参数列表的末尾一个声明
    //一个方法中只能设置一个可变参数
    public static  void tell(String name,double...score){
      int sum=0;
        for(double s:score){
            sum+=s;
        }
        System.out.println(name+"的总成绩为："+sum);
    }
}

静态导入

使用静态导入（将类的静态方法导入），就好像在主类中定义的方法一样，可以直接调用方法（不通过对象）
语法：import static 包名.类名.静态方法名;

import static 包名.类名.*;//导入包内所有的静态方法 

Java虽支持静态导入，但是如果在静态导入的类中出现由同名方法，会引起二义性，因此，在这种情况下，需使用类的全限定名：包名.类名.方法名
如果代码中使用到的两个类名相同，但是包名不同，也应使用全限定名：包名.类名