【JavaSE】JavaSE之新特性概述

下面针对JavaSE几个新特性进行概述，主要包括以下几个：

  1. lambda函数式编程--->2. 可变参数--->传递多类参数--->3. 自定义异常类--->4. 通配符？,? extends 类，？ Super 类的示例***

1. lambda函数式编程

@FunctionalInterface
interface IMessage{
    void fun();
}
public class Test{
    public static void main(String[] args) {
      IMessage message=()-> {
          System.out.println("Hello");
          System.out.println("World");
          System.out.println("Message");
      };
      message.fun();
    }
}

2. 可变参数—>传递多类参数
但是注意，如果传递多类参数，可变参数只能放在后面，并且只能设置一个可变参数

public class Test{
    public static void main(String[] args) {
        System.out.println(add("Hello"));
        System.out.println(add("Hello World",1,2,3,4));
        System.out.println(add("Hello",new int[]{1,2,3,5}));
    }
    public static int add(String msg,int ... data){
        int result=0;
        for(int i=0;i<data.length;i++){
            result+=data[i];
        }
        return  result;
    }
}

3. 自定义异常类
假如在进行加法运算时，相加为50抛出异常

class AddException extends RuntimeException{
    public AddException(String msg){
        super(msg);
    }
}
public class Test {
    public static void main(String[] args)  {
         int num1=Integer.parseInt(args[0]);
         int num2=Integer.parseInt(args[1]);
         if(50==(num1+num2)){
             throw new AddException("错误的相加操作");
         }else{
             System.out.println(num1+num2);
         }
    }
}

4. 通配符？,? extends 类，？ Super 类的示例
在程序类中加入泛型，避免了类型转换异常，但是参数不能统一

class Message<T>{
    private T message;
    public T getMessage(){
        return message;
    }
    public void setMessage(T message){
        this.message=message;
    }
}
class Message1<T extends Number>{ //设置泛型上限
    private  T messge;

    public T getMessge() {
        return messge;
    }

    public void setMessge(T messge) {
        this.messge = messge;
    }
}
public class Test{
    public static void main(String[] args) {
        Message<Integer> message=new Message<>();
        message.setMessage(100);
        fun(message);

        Message<String> message1=new Message<>();
        message1.setMessage("Hello");
        fun(message1);

        Message1<Integer> message2=new Message1<>();
       message2.setMessge(100);
       fun1(message2);

        Message1<Double> message3=new Message1<>();
        message3.setMessge(10.9);
        fun1(message3);

        Message<String> message4=new Message<>();
        message4.setMessage("Hello");
        fun2(message4);
    }
    //此时？通配符描述的是它可以接收任何类型，但因为不确定类型，所以无法修改
    public static void fun(Message<?> temp){
        System.out.println(temp.getMessage());
    }
    //此时？通配符描述的是它可以接收Number或其子类，但因为不确定类型，所以无法修改
    public static void fun1(Message1<? extends Number> temp){
        System.out.println(temp.getMessge());
    }
    //下限设置只能用在方法参数里面，可以修改内容
    public static void fun2(Message<? super String> message){
        System.out.println(message.getMessage());
    }
}