Java8新特性

最新推荐文章于 2024-03-05 10:15:00 发布

郭士超

最新推荐文章于 2024-03-05 10:15:00 发布

阅读量280

点赞数

分类专栏： java笔记文章标签： java 函数 jdk 函数式开发人员

本文链接：https://blog.csdn.net/qq_29244755/article/details/78299421

版权

java笔记专栏收录该内容

19 篇文章 0 订阅

订阅专栏

导语

可以了解一下Java8的新特性，但是这些东西一般是不会使用的。

主要内容

使用default与static定义接口方法
Lamda表达式
方法引用
内建函数式接口

具体内容

使用default与static定义接口方法

从Java发展之初到今天已经经过20年的时间了，在这20年的时间里面所有的开发者都知道，Java的接口由全局常量和抽象方法所组成。但是从JDK1.8的时代，这一组成改变了。
如果说现在有某一个接口，这个接口随着时间的发展已经产生了2W个子类。突然有一天发现，这个接口里的方法不足，应该再增加一个方法，而针对于所有不同的子类，这个方法的功能实现是完全一样的。按照最初的做法是在每一个子类上都覆写这个新的方法。那么就要修改2W个子类。
所以为了解决这样的问题，允许在接口里面定义普通方法了。但是如果要定义普通方法就必须明确的使用default来进行定义。

范例：定义default方法

public interface Message {  // 定义接口
    public void print();  // 这是一个接口里原本定义的方法
    default void fun() {  // 在接口里定义了一个普通的方法
        System.out.println("毁三观的方法出现了！");
    }
}

public class MessageImpl implements Messagee {
    @Override
    public void print() {
        System.out.println("Hello World !");
    }
}

public class TestDemo {
    public static void main(String args[]) {
        Message msg = new MessageImpl();
        msg.fun();  // 此方法是在接口里面定义的
    }
}

输出结果

毁三观的方法出现了！

除了使用default定义方法之外，还可以使用static定义方法，一旦使用了static定义方法意味着这个方法可以直接由类名称调用。

范例：定义static方法

public interface Message {  // 定义接口
    public void print();  // 这是一个接口里原本定义的方法
    static void get() {
        System.out.println("直接由接口调用！");
    }
}

public class TestDemo {
    public static void main(String args[]) {
        Message.get();
    }
}

输出结果

直接由接口调用！

在JDK1.8里面有一个最重要的概念：内部类访问方法参数的时候可以不加final关键字。
所有出现的这些新特性，完全打破了Java已有的代码组成形式。

Lamda表达式

分析函数式编程的产生原因。
掌握函数式编程的语法。

Lamda属于函数式编程的概念，为什么需要函数式的编程呢？
如果想要清楚函数式编程的产生目的，那么必须通过匿名内部类来分析。

范例：匿名内部类

public interface Message {
    public void print();
}

public class TestDemo {
    public static void main(String args[]) {
        fun(new Message() {
            public void print() {
                System.out.println("Hello World !");
            }
         });
    }
    public static void fun(Message msg) {
        msg.print();
    }
}

实际上整个代码之中，如果是fun()方法，最终需要的只是一个输出而已，但是由于Java的开发结构性完整要求，所以不得不在这个核心的语句上嵌套更多的内容。
以上的做法要求的实在是过于严谨了，氢在JDK1.8时代引入了函数式的编程，可以简化代码。

范例：使用Lamda表达式

public interface Message {
    public void print(String str);
}

public class TestDemo {
    public static void main(String args[]) {
        // 首先定义此处表达里面需要接收的变量，单行语句直接进行输出
        fun((s) -> System.out.println(s));
    }
    public static void fun(Message msg) {
        msg.print("Hello World !");  // 设置参数内容
    }
}

输出结果

Hello World !

整个操作里面匿名内部类只是进行一行语句的输出，所以此时使用了Lamda表达式可以非常轻松的完成代码要求。
对于Lamda语法有三种形式：
- (参数) -> 单行语句。
- (参数) -> {多行语句}。
- (参数) -> 表达式。

范例：编写一个表达式

public interface Message {
    public int add(int x, int y);
}

public class TestDemo {
    public static void main(String args[]) {
        fun((s1, s2) -> s1 + s2);
    }
    public static void fun(Message msg) {
        System.out.println(msg.add(10, 20));
    }
}

输出结果

方法引用

一直以来都只是在对象上能够发现引用的应用，而对象引用的特点：不同的对象可以操作同一块内容。而所谓的方法引用指为一个方法设置别名，相当于一个方法定义了不同的名字。
方法引用在Java8之中一共定义了四种形式：
- 引用静态方法：类名称 :: static 方法名字。
- 引用某个对象的方法：实例化对象 :: 普通方法。
- 引用特定类型的方法：特定类 :: 普通方法。
- 引用构造方法：类名称 :: new。

引用静态方法

范例：引用静态方法
在String类里面有一个valueOf方法：public static String valueOf(int x);

public interface Message<P,R> {
    public R zhuanhuan(P p);
}

public class TestDemo {
    public static void main(String args[]) {
        // 即：将String.valueOf()方法变为了Message接口里的zhuanhuan()方法
        Message<Integer, String> msg = String :: valueOf();
        String str = msg.zhuanhuan(1000);
        Systemout.println(str.replaceAll("0", "9"));
    }
}

输出结果

普通方法引用

范例：普通方法引用

public interface Message<R> {
    public R upper();
}

public class TestDemo {
    public static void main(String args[]) {
        // String类的toUpperCase()定义：public String toUpperCase()
        // 这个方法没有参数，但是有返回值，并且这个方法一定要在有实例化对象的情况下才可以调用
        // "hello"字符串是String类的实例化对象，所以可以直接调用toUpperCase()方法
        // 将toUpperCase()函数的应用交给了Message接口
        Message<String> msg = "hello" :: toUpperCase;
        String str = msg.upper();  // 相当于“"hello".toUpperCase()”
        Systemout.println(str);
    }
}

输出结果

HELLO

通过两个代码演示发现，如果要实现函数的引用，那么必须要有接口，而且最为关心的是，接口里面需要只存在一个方法（如果出现多个方法是无法引用的）。
所以为了保证被引用接口里面只能够有一个方法，那么就需要一个注解的声明@FunctionalInterface。表示此为函数式接口，只能够定义一个方法。

引用特定类的方法

在进行方法引用的过程里面还有另外一种形式的引用（它需要特定类的对象支持），正常情况下如果使用了“类 :: 方法”，引用的一定是类中的静态方法，但是这种形式也可以引用普通方法。
例如：在String类里面有一个方法public int compareTo(String anotherString)。
如果要进行比较的话，比较的形式：字符串1对象.compareTo(字符串2对象)，也就是说如果真要引用这个方法就需要准备出两个参数。

范例：引用特定类的方法

@FunctionalInterface
public interface Message<P> {
    public int compare(P p1, P p2);
}

public class TestDemo {
    public static void main(String args[]) {
        Message<String> msg = String :: compareTo;
        System.out.println(msg.compare("A", "B"));
    }
}

输出结果

-1

与之前相比，方法引用前不再需要定义对象，而是可以理解为将对象定义在了参数上。

引用构造方法

范例：引用构造方法

@FunctionalInterface
public interface Message<C> {
    public C create(String t, double p);
}

public class Book {
    private String title;
    private double price;
    public Book(String title, double price) {
        this.title = title;
        this.price = price;
    }
    @Override
    public String toString() {
        return "书名：" + this.title + "，价格：" + this.price + "。";
    }
}

public class TestDemo {
    public static void main(String args[]) {
        Message<String> msg = Book :: new;  // 引用构造方法
        // 调用的虽然是create()，但是这个方法引用的是Book类的构造
        Book book = msg.create("Java开发", 20.2);
        System.out.println(book);
    }
}

输出结果

书名：Java开发，价格：20.2)。

对象的引用是使用不同的名字，而方法引用是需要一个函数式的接口，并且要设置好参数。

内建函数式接口

观察在JDK1.8中提供的新的函数式接口包以及提供的四个函数式接口。
对于方法的引用，严格来讲都需要定义一个接口，可是不管如何操作，实际有可能操作的接口只有四种，在JDK1.8里面提供了一个包：java.util.function，提供有以下四个核心接口：
- 功能性接口（Funcation）：此接口需要接收一个参数，并且返回一个处理结果。

public interface Function<T, R> {
    public R apply(T t);
}

消费型接口（Consumer）：此接口只是负责接收数据（引用数据是不需要返回），并且不返回处理结果。

public interface Consumer<T> {
    public void accept(T t);
}

供给型接口（Suppliers）：此接口不接收参数，但是可以返回结果。

public interface Suppliers<T> {
    public T get();
}

断言型接口（Predicate）：进行判断操作使用。

public interface Predicate<T> {
    public boolean test(T t);
}

所有在JDK1.8之中由于存在有以上的四个功能型接口，所以一般很少会由用户去定义新的函数式接口。

范例：观察函数式接口——接收参数并且返回一个处理结果
String类有一个方法：public boolean startsWith(String str)。

public class TestDemo {
    public static void main(String args[]) {
        Function<String, Boolean> fun = "##hello" :: startsWith;
        System.out.println(fun.apply("##"));
    }
}

输出结果

true

范例：消费型接口

public class TestDemo {
    public static void main(String args[]) {
        Consumer<String> cons = System.out :: println;
        cons.accept("Hello World !");
    }
}

输出结果

Hello World !

范例：供给型接口
引用String类的toUpperCase()方法：public String toUpperCase()。

public class TestDemo {
    public static void main(String args[]) {
        Supplier<String> sup = "hello" :: toUpperCase;
        System.out.println(sup.get());
    }
}

输出结果

HELLO

范例：断言型接口
引用String类的equalsIgnoreCase()方法。

public class TestDemo {
    public static void main(String args[]) {
        Predicate<String> pre = "hello" :: equalsIgnoreCase;
        System.out.println(sup.test("hello"));
    }
}

输出结果