By

前言

Github：https://github.com/HealerJean

博客：http://blog.healerjean.com

版本 发布时间 重大更新
Java SE 8 2014年3月18日 Lambda表达式、Stream API、Date/Time API等
Java SE 9 2017年9月21日 模块化系统、REPL工具等
Java SE 10 2018年3月20日 局部变量类型推断、G1垃圾收集器改进等
Java SE 11 2018年9月25日 HTTP Client API、ZGC垃圾收集器等
Java SE 12 2019年3月19日 Switch表达式改进、JVM Constants API等
Java SE 13 2019年9月17日 Text Blocks、ZGC并发垃圾收集器改进等
Java SE 14 2020年3月17日 Records、Pattern Matching for instanceof等
Java SE 15 2020年9月15日 Sealed Classes、Hidden Classes等

#

一. 接口

1、支持定义私有方法

package com.hlj.java8.Interface.Demo03InterfaceDefaultPack;
public interface MyInterface {
  
    void method1();

    void method2();

    /**
     * 1、默认的方法修饰符，public default (public 可以省略，default不可以省略)
     *
     * 默认方法可以有方法体实现 :具体实现
     * 作用：
     * 1、新加一个功能，不会影响其他已经使用这个接口的其他功能。接口升级的时候，用到，同事子类也可以实现覆盖重写
     */
    public default  void methodNew(){
        System.out.println("interface  default 方法");
    }

    /**
     * 2、接口中允许定义静态风阀 ，静态方法的修饰符：public static （public可以省略，static不可以省略）
     */
    public static void methodStatic(){
        System.out.println("接口中的静态方法");
    }

}



package com.hlj.java8.Interface;

import com.hlj.java8.Interface.Demo03InterfaceDefaultPack.MyInterface;
import com.hlj.java8.Interface.Demo03InterfaceDefaultPack.impl.MyInterfaceImpl;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @Desc:
 * @Author HealerJean
 * @Date 2018/9/14  上午11:48.
 */
public class Demo01 {

    @Test
    public void demo(){

        MyInterface myInterface = new MyInterfaceImpl() ;

        /**
         *  我们发现这个里面的默认方法，可以帮我们继承下去，我们也可以对这个方法进行覆盖重写
         */
        myInterface.methodNew();

        MyInterface.methodStatic();

    }
}

二、模块化

WX20181009-175940@2x

1、样例

1）创建 module-info.java

必须是 java 文件夹下面才可以创建 module-info.java，添加两个maven。module项目。分别为one和two

module one {
}


module two {
}

2）设置模块的依赖和权限

a、设置 module 级别为 9

WX20181009-191640

b、 one 中创建两个包和方法

WX20181009-191823

package com.hlj.java9.can;


public static class UtilCan {

    public void can(){
        System.out.println("can");
    }
}


package com.hlj.java9.cannot;

public static class UtilCanNot {

    public void canNot(){
        System.out.println("canNot");
    }
}

c、 one 中 module-info.java

module one {
//导出可用包
     exports  com.hlj.java9.can;
}

d、two 中进行引入，如果发现为红报

module two {
     requires one;
}

e、two 中开始使用

package com.hlj.java9.use;


import com.hlj.java9.can.UtilCan;
//import com.hlj.java9.cannot.UtilCanNot; //导入了，但是报错

public class Use {

    public static void main(String[] args) {
        UtilCan.can();
//        UtilCanNot.canNot(); 可以导入，但是编译不成功
    }
}

2、模块化中的服务

1)、one 模块提供服务

a、接口

package com.hlj.java9.api;

public interface MyServiceInter {

    void method();

}

b、实现类

package com.hlj.java9.api.impl;

import com.hlj.java9.api.MyServiceInter;


public class MyServiceInterImpl  implements MyServiceInter {

    @Override
    public void method() {
        System.out.println("接口实现类");
    }
    
    public static  void staticImpl(){
    System.out.println("接口实现类中自己定义的静态方法");
}

}

c、第二个实现类

package com.hlj.java9.api.impl;

import com.hlj.java9.api.MyServiceInter;


public class MyServiceInterImplTwo implements MyServiceInter {

    @Override
    public void method() {

        System.out.println("第二个接口实现类");
    }
}

d、one module-info.java 服务开始提供

import com.hlj.java9.api.MyServiceInter;
import com.hlj.java9.api.impl.MyServiceInterImpl;
import com.hlj.java9.api.impl.MyServiceInterImplTwo;

module one {

   //导出可用包
     exports  com.hlj.java9.can;

     //对外提供的接口服务 ,下面指定的接口以及提供服务的impl，如果有多个实现类，用用逗号隔开    
     exports  com.hlj.java9.api;
     provides MyServiceInter  with MyServiceInterImpl, MyServiceInterImplTwo;
}

2）two 模块开始调用

a、two module-info.java

import com.hlj.java9.api.MyServiceInter;

module two {
     requires one;

     //使用接口的名称 ，上面已经导入了one模块了
     uses MyServiceInter  ;
}

b、开始使用

package com.hlj.java9.Consumer;

import com.hlj.java9.api.MyServiceInter;
//import com.hlj.java9.api.impl.MyServiceInterImpl;

import java.util.ServiceLoader;

public class ConsumerUse {
    public static void main(String[] args) {

        //专门用来提供服务的类
        ServiceLoader<MyServiceInter> loader = ServiceLoader.load(MyServiceInter.class);
        //所有的实现类
        for(MyServiceInter service:loader){
            service.method();
        }
//        MyServiceInterImpl.staticImpl(); ont中export必须是第一层包，不可以套多层
    }
}

ContactAuthor