JDK8新特性

总结:

1.写list的高效for循环时.可以list.for 有自动提示
2.写 Collections.sort(list,(Person o1,Person o2)->{
return o1.getAge() - o2.getAge();
}); 时,鼠标在o2.getAge()后面.return 自动显示
3.数组也可以遍历 数组.for
4.

一 Lambda表达式

创建一个空的maven项目
JDK8新特性

1.需求分析:

创建一个新的线程,指定线程要执行的任务

package cn.tedu.jdk.lambda;

public class Demo01Lambda {
    public static void main(String[] args) {
        //开启一个新的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("新线程中执行的代码:"+Thread.currentThread().getName());
            }
        }).start();
        System.out.println("主线程中的代码:"+Thread.currentThread().getName());
    }
}

代码分析:
1.Thread类需要一个Runnable接口作为参数.其中的run方法用来指定线程任务内容的核心
2.为了指定run方法,不得需要Runnable接口的实现类
3.为了省去定义一个Runnable实现类.,不得不使用匿名内部类
4.必须覆盖抽象run方法,方法名,方法参数,返回值类型,不得不重写一遍,而且不能出错
5.实际上,我们只关注方法体中的代码

2.Lambda表达式初体验

Lambda表达式是一个匿名函数,可以理解为是一段可以传递的代码,

new Thread(()->{ System.out.println("新线程Lambda表达式..."+Thread.currentThread().getName()); })
			.start();

lambda表达式的优点:简化了匿名内部类的使用,语法更加简单
匿名内部类语法冗余,发现lambda表达式是简化匿名内部类的使用

3.Lambda语法规则

lambda省去了面向对象的条条框框,lambda语法规则有3部分组成

(参数类型 参数名称): 参数列表
{代码体}: 方法体
-> 箭头  分割参数列表和方法体 
lambda练习1

无参无返回值的lambda
定义一个接口,

package cn.tedu.jdk.lambda.service;

public interface UserService {
    void show(); //无参无返回值
}

然后创建主方法使用

package cn.tedu.jdk.lambda;

import cn.tedu.jdk.lambda.service.UserService;

public class Demo03Lambda {
    /**
     * (String[] args)->{}
     * @param args
     */
    public static void main(String[] args) {
        goShow(new UserService() {
            @Override
            public void show() {
                System.out.println("show 方法执行了...");
            }
        });
        System.out.println("-----------------");
        goShow(()->{
            System.out.println("lambda show方法 执行了...");
        });
    }
    public static void goShow(UserService userService){
        userService.show();
    }
}

输出:

show 方法执行了...
-----------------
lambda show方法 执行了...

lambda练习2

完成一个有参有返回值的lambda案例
创建一个Person对象

package cn.tedu.jdk.lambda.domain;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private Integer age;
    private Integer height;
}

然后我们在main方法中,.List集合中保存多个person对象,然后对这些对象做根据age排序操作

package cn.tedu.jdk.lambda;

import cn.tedu.jdk.lambda.domain.Person;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Demo04Lambda {

    public static void main(String[] args) {
        List<Person> list = new ArrayList<Person>();
        list.add(new Person("周杰伦", 33, 175));
        list.add(new Person("刘德华", 50, 185));
        list.add(new Person("许攸", 46, 165));
        list.add(new Person("曹操", 30, 169));

//        Collections.sort(list, new Comparator<Person>() {
//            public int compare(Person o1, Person o2) {
//                return o1.getAge() - o2.getAge();
//            }
//        });
//        for (Person person : list) {
//            System.out.println(person);
//        }

        System.out.println("------------------");
        Collections.sort(list,(Person o1,Person o2)->{
            return o1.getAge() - o2.getAge();
        });
        for (Person person : list) {
            System.out.println(person);
        }
    }

}

我们发现在sort方法的第二个参数是一个Comparator接口的匿名内部类,且执行的方法有参数和返回值,我们可以改写为lambda表达式
输出结果

------------------
Person(name=曹操, age=30, height=169)
Person(name=周杰伦, age=33, height=175)
Person(name=许攸, age=46, height=165)
Person(name=刘德华, age=50, height=185)

4.@FunctionalInterface注解

使用lambda时,这个接口只能保证有一个抽象方法

package cn.tedu.jdk.lambda.service;

/**
 * @FunctionalInterface
 * 这是一个标志注解,被该注解修饰的接口,只能声明一个抽象方法
 */
@FunctionalInterface
public interface UserService {
    void show();
}

5.Lambda表达式的原理

JDK8新特性
lambda中的代码是在这个方法里面执行的
JDK8新特性

利用JDK自带工具javap 对字节码进行反汇编操作
javap -c -p XXX.class文件
-c 表示对代码进行反汇编
-p 显示所有的类和成员

在这个反编译的源码中我们看到了一个静态方法 lambda$main$0()

小结:

匿名内部类在反编译时.会产生一个class文件
lambda表达式在程序运行时会形成一个类
1.在类中会新增一个static方法,该方法体就是lambda表达式的代码
2.还会形成一个匿名内部类,实现接口,重写抽象方法
3.在接口中重写方法,调用新生成的方法

6.Lambda表达式省略写法

在lambda表达式标准写法基础上,可以省略的语法规则为:
1.小括号内的参数类型可以省略
2.如果小括号内有且仅有一个参数,则小括号可以省略
3.如果大括号内有且仅有一条语句,则可以同时省略大括号,return关键字及语句分号

package cn.tedu.jdk.lambda;

import cn.tedu.jdk.lambda.service.OrderService;
import cn.tedu.jdk.lambda.service.StudentService;

public class Demo05Lambda {
    public static void main(String[] args) {
        goStudent((String name, Integer age) -> {
            return name + age + "6666...";
        });
        //省略写法
        goStudent((name,age)->name + age + "6666...");
        System.out.println("--------------");

        goOrder((String name) -> {
            System.out.println("---->"+name);
            return 666;
        });
        //省略写法
        goOrder(name ->666);
    }

    public static void goStudent(StudentService studentService) {
        studentService.show("张三", 22);
    }

    public static void goOrder(OrderService orderService) {
        orderService.show("李四");
    }


}

7.Lambda表达式使用前提

lambda使用时有几个条件特别注意:
1.方法的参数或局部变量的类型必须为接口才能使用lambda
2.接口中有且仅有一个抽象方法 @FunctionalInterface

8.lambda和匿名内部类的对比

1.所需类型不同:
匿名内部类的类可以类,抽象类.接口,
lambda表达式需要的类型必须为接口
2.抽象方法的数量不一样
匿名内部类所需的接口中的抽象方法数量是随意的
lambda表达式所需的接口中只能有一个抽象方法
3.实现原理不一样
匿名内部类是在编译后生成的class
lambda表达式是在程序运行时动态生成class

二 接口中新增的方法

JDK8中针对接口有做新增,在JDK8之前

interface 接口名{
	静态常量;
	抽象方法;
}

在JDK8后,对接口做了增强,接口中可以有默认方法 和 静态方法

interface 接口名{
	静态常量;
	抽象方法;
	默认方法;
	静态方法;
}

默认方法

为什么要增加默认方法?

在JDK8以前,接口中只能有抽象方法和静态常量.会存在以下问题:
如果接口中新增抽象方法,那么实现类都必须抽象这个抽象方法.非常不利于接口的扩展

package cn.tedu.jdk.inter;

public interface Demo01Interface {
    public static void main(String[] args) {
        A b=new B();
        A c=new C();
    }
}
interface A{
    void test1();
    //接口中新增抽象方法,所有实现类都需要重写这个方法,不利于接口的扩展
    void test2();

}
class B implements A{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}
class C implements A{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}
接口中默认方法的格式?

接口中默认方法的语法格式

interface 接口名{
	修饰符 default 返回值类型 方法名(){方法体;}
}
package cn.tedu.jdk.inter;

public interface Demo01Interface {
    public static void main(String[] args) {
        A b=new B();
         b.test3();
        A c=new C();
    }
}
interface A{
    void test1();
    //接口中新增抽象方法,所有实现类都需要重写这个方法,不利于接口的扩展
    void test2();

    /**
     * 接口中定义的默认方法
     * @return
     */
    public default String test3(){
        System.out.println("接口中的默认方法执行了...");
        return "hello";
    }
}
class B implements A{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }

    @Override
    public String test3() {
        System.out.println("B 实现类重写了默认方法");
        return A.super.test3();
    }
}
class C implements A{
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}
接口中默认方法的使用

接口中默认方法的使用有2种方式
1.实现类直接调用接口中的默认方法
2.实现类重写接口的默认方法

静态方法

JDK8中为接口新增了静态方法,作用也是为了接口的扩展
语法规则:

interface 接口名{
	修饰符 static 返回值类型 方法名(){
		方法体;
	}
}

代码:

package cn.tedu.jdk.inter;

public interface Demo01Interface {
    public static void main(String[] args) {
        A b = new B();
        b.test3();
        A c = new C();
        A.test4();
    }
}

interface A {
    void test1();

    //接口中新增抽象方法,所有实现类都需要重写这个方法,不利于接口的扩展
    void test2();

    /**
     * 接口中定义的默认方法
     *
     * @return
     */
    public default String test3() {
        System.out.println("接口中的默认方法执行了...");
        return "hello";
    }

    /**
     * 接口中的静态方法
     * @return
     */
    public static String test4() {
        System.out.println("接口中的静态方法...");
        return "hello";
    }
}

class B implements A {
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }


//    @Override
//    public String test3() {
//        System.out.println("B 实现类重写了默认方法");
//        return A.super.test3();
//    }
}

class C implements A {
    @Override
    public void test1() {

    }

    @Override
    public void test2() {

    }
}
静态方法的使用

接口中的静态方法是不能被重写的,调用的话,只能通过接口类型来实现, 接口名.方法名

如果扩展的内容支持重写用默认方法,否则用static
JDK8新特性

default和static的区别
  1. 默认方法通过实例调用,静态方法通过接口名调用
  2. 默认方法可以被继承,实现类可以直接调用接口默认方法,也可以重写接口默认方法
  3. 静态方法不能被继承,实现类不能重写接口中的静态方法,只能通过接口名调用

三 函数式接口

函数式接口的由来?

使用lambda表达式的前提是需要有函数式接口. 而使用lambda表达式不关心接口名,抽象方法名,
只关心抽象抽象方法的参数列表和返回值类型

package cn.tedu.jdk.fun;

public class Demo01Fun {

    public static void main(String[] args) {
        fun1(arr -> {
            int sum=0;
            for (int i : arr) {
                sum+=i;
            }
            return sum;
        });
    }

    public static void fun1(Operator operator) {
        int arr[]={1,2,3,4};
        int sum=operator.getSum(arr);
        System.out.println("sum="+sum);
    }
}

/**
 * 函数式接口
 */
@FunctionalInterface
interface Operator{
    int getSum(int[] arr);
}

在JDK8后函数式接口.,package java.util.function;包下,
Supplier接口, 无参有返回值方法 T get();
Consumer接口.有参无返回值的方法 void accept(T t);

上一篇:linux安装jdk8


下一篇:学习第三天(安装jdk8 )