尚硅谷Java入门视频教程第十七章——Java9&Java10&Java11新特性

第17章：Java9&Java10&Java11新特性
- 17.1 Java 9 的新特性
- - 1. JDK 和 JRE 目录结构的改变
  - 2. 模块化系统: Jigsaw -> Modularity
  - - 解决单元测试junit导入后仍然报错的问题
  - 3. Java的REPL工具： jShell命令
  - 4. 语法改进：接口的私有方法
  - 5. 语法改进:钻石操作符使用升级
  - 6. 语法改进：try语句的升级（自动关流）
  - 7. String存储结构变更
  - 8. 集合工厂方法：快速创建只读集合
  - 9. InputStream 加强
  - 10. 增强的 Stream API
  - 12. Javascript引擎升级：Nashorn
- 17.2 Java 10 新特性
- - 1. 局部变量类型推断
  - 2. 集合新增创建不可变集合的方法copyOf
- 17.3 Java 11 新特性
- - 1. 新增了一系列字符串处理方法
  - 2. Optional 加强

第17章：Java9&Java10&Java11新特性

17.1 Java 9 的新特性

JDK 9 的发布
- 经过4次跳票，历经曲折的Java 9 终于终于在2017年9月21日发布。
- 从Java 9 这个版本开始，Java 的计划发布周期是 6 个月。
  这意味着Java的更新从传统的以特性驱动的发布周期，转变为以时间驱动的（6 个月为周期）发布模式，并逐步的将 Oracle JDK 原商业特性进行开源。
- 针对企业客户的需求，Oracle 将以三年为周期发布长期支持版本（long term support）。
- Java 9 提供了超过150项新功能特性，包括备受期待的模块化系统、可交互的 REPL 工具：jshell，JDK 编译工具，Java 公共 API 和私有代码，以及安全增强、扩展提升、性能管理改善等。可以说Java 9是一个庞大的系统工程，完全做了一个整体改变。
Java 9 中有哪些不得不说的新特性？
- 官方提供的新特性列表：
  https://docs.oracle.com/javase/9/whatsnew/toc.htm#JSNEW-GUID-C23AFD78-C777-460B-8ACE-58BE5EA681F6
- 或参考 Open JDK
  http://openjdk.java.net/projects/jdk9/
- 在线Oracle JDK 9 Documentation
  https://docs.oracle.com/javase/9/

1. JDK 和 JRE 目录结构的改变

2. 模块化系统: Jigsaw -> Modularity

谈到 Java 9 大家往往第一个想到的就是 Jigsaw 项目。众所周知，Java 已经发展超过 20 年（95 年最初发布），Java 和相关生态在不断丰富的同时也越来越暴露出一些问题：
- Java 运行环境的膨胀和臃肿。每次JVM启动的时候，至少会有30～60MB的内存加载，主要原因是JVM需要加载rt.jar，不管其中的类是否被classloader加载，第一步整个jar都会被JVM加载到内存当中去（而模块化可以根据模块的需要加载程序运行需要的class）
- 当代码库越来越大，创建复杂，盘根错节的“意大利面条式代码”的几率呈指数级的增长。不同版本的类库交叉依赖导致让人头疼的问题，这些都阻碍了 Java 开发和运行效率的提升。
- 很难真正地对代码进行封装, 而系统并没有对不同部分（也就是 JAR 文件）之间的依赖关系有个明确的概念。每一个公共类都可以被类路径之下任何其它的公共类所访问到，这样就会导致无意中使用了并不想被公开访问的 API。
本质上讲也就是说，用模块来管理各个package，通过声明某个package暴露，模块(module)的概念，其实就是package外再裹一层，不声明默认就是隐藏。因此，模块化使得代码组织上更安全，因为它可以指定哪些部分可以暴露，哪些部分隐藏。
实现目标
- 模块化的主要目的在于减少内存的开销
- 只须必要模块，而非全部jdk模块，可简化各种类库和大型应用的开发和维护
- 改进 Java SE 平台，使其可以适应不同大小的计算设备
- 改进其安全性，可维护性，提高性能
模块将由通常的类和新的模块声明文件（module-info.java）组成。该文件是位于java代码结构的顶层，该模块描述符明确地定义了我们的模块需要什么依赖关系，以及哪些模块被外部使用。在exports子句中未提及的所有包默认情况下将封装在模块中，不能在外部使用。
- 要想在java9demo模块中调用java9test模块下包中的结构，需要在java9test的module-info.java中声明：
  
  exports：控制着哪些包可以被其它模块访问到。所有不被导出的包默认都被封装在模块里面
- 对应在java 9demo 模块的src 下创建module-info.java文件：
  
  requires：指明对其它模块的依赖

解决单元测试junit导入后仍然报错的问题

在module day13的src下创建module-info.java，指明对junit的依赖，但执行时报错：

java.lang.reflect.InaccessibleObjectException: Unable to make public void com.atguigu.java.Java9Test1.test1() accessible: module day13 does not "exports com.atguigu.java" to module junit

问题解决：在module-info.java中增加exports com.atguigu.java;:

3. Java的REPL工具： jShell命令

产生背景
像Python 和 Scala 之类的语言早就有交互式编程环境 REPL (read - evaluate - print -loop) 了，以交互式的方式对语句和表达式进行求值。开发者只需要输入一些代码，就可以在编译前获得对程序的反馈。而 之前的Java版本要想执行代码，必须创建文件、声明类、提供测试方法方可实现。
设计理念
即写即得、快速运行
实现目标
- Java 9 中终于拥有了 REPL工具：jShell。让Java可以像脚本语言一样运行，从控制台启动jShell，利用jShell在没有创建类的情况下直接声明变量，计算表达式，执行语句。即开发时可以在命令行里直接运行Java的代码，而无需创建Java文件，无需跟人解释”public static void main(String[] args)”这句废话。
- jShell也可以从文件中加载语句或者将语句保存到文件中。
- jShell也可以是tab键进行自动补全和自动添加分号。
常用命令：

4. 语法改进：接口的私有方法

Java 8中规定接口中的方法除了抽象方法之外，还可以定义静态方法和默认的方法。一定程度上，扩展了接口的功能，此时的接口更像是一个抽象类。
在Java 9中，接口更加的灵活和强大，连方法的访问权限修饰符都可以声明为private的了，此时方法将不会成为你对外暴露的API的一部分。

5. 语法改进:钻石操作符使用升级

将能够与匿名实现类共同使用钻石操作符（diamond operator）在Java 8中如下的操作是会报错的：

编译报错信息：Cannot use “<>” with anonymous inner classes.

Java 9中如下操作可以正常执行通过：

//java9特性五：钻石操作符的升级
@Test
public void test2() {//钻石操作符与匿名内部类在java 8中不能共存。在java9可以。//anonymous classes can now use type inferenceComparator<Object> com = new Comparator<>() {@Overridepublic int compare(Object o1, Object o2) {return 0;}};//jdk7中的新特性：类型推断ArrayList<String> list = new ArrayList<>();}

6. 语法改进：try语句的升级（自动关流）

Java 8 中，可以实现资源的自动关闭，但是要求执行后必须关闭的所有资源必须在try子句中初始化，否则编译不通过。

Java 9 中，用资源语句编写try将更容易，我们可以在try子句中使用已经初始化过的资源，此时的资源是final的：

   //java9 特性六：try操作的升级public static void main(String[] args) {//java 8之前的资源关闭的操作
//        InputStreamReader reader = null;
//        try {//            reader = new InputStreamReader(System.in);
//            char[] cbuf = new char[20];
//            int len;
//            if((len = reader.read(cbuf) )!= -1){//                String str = new String(cbuf,0,len);
//                System.out.println(str);
//            }
//        } catch (IOException e) {//            e.printStackTrace();
//        } finally {//            if(reader != null){//                try {//                    reader.close();
//                } catch (IOException e) {//                    e.printStackTrace();
//                }
//
//            }
//        }//java 8中资源关闭操作: Java 8 中，可以实现资源的自动关闭//要求自动关闭的资源的实例化必须放在try的一对小括号中
//        try(InputStreamReader reader = new InputStreamReader(System.in)){//            char[] cbuf = new char[20];
//            int len;
//            if((len = reader.read(cbuf) )!= -1){//                String str = new String(cbuf,0,len);
//                System.out.println(str);
//            }
//        } catch (IOException e) {//            e.printStackTrace();
//        }//java9中资源关闭操作：需要自动关闭的资源的实例化可以放在try的一对小括号外。//此时的资源属性是常量，声明为final的，不可修改InputStreamReader reader = new InputStreamReader(System.in);try (reader) {char[] cbuf = new char[20];int len;if((len = reader.read(cbuf) )!= -1){String str = new String(cbuf,0,len);System.out.println(str);}//            reader = null;} catch (IOException e) {e.printStackTrace();}}

7. String存储结构变更

结论：String 再也不用 char[] 来存储啦，改成了 byte[] 加上编码标记，节约了一些空间。

StringBuffer 和 StringBuilder 等相关结构也对应修改。

8. 集合工厂方法：快速创建只读集合

Java 8 要创建一个只读、不可改变的集合，必须构造和分配它，然后添加元素，最后包装成一个不可修改的集合。

缺点：写了五行。即：它不能表达为单个表达式。

Java 9因此引入了方便的方法，这使得类似的事情更容易表达

package com.atguigu.java;import org.junit.Test;import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.*;public class Java9Test1 {//java8中的写法：@Testpublic void test1() {List<String> namesList = new ArrayList<>();namesList.add("Joe");namesList.add("Bob");namesList.add("Bill");//返回的namesList是一个只读的集合namesList = Collections.unmodifiableList(namesList);
//        namesList.add("Tom");//报错java.lang.UnsupportedOperationExceptionSystem.out.println(namesList);}@Testpublic void test2() {List<String> list = Collections.unmodifiableList(Arrays.asList("a", "b", "c"));Set<String> set = Collections.unmodifiableSet(new HashSet<>(Arrays.asList("a", "b", "c")));// 如下操作不适用于jdk 8 及之前版本,适用于jdk 9Map<String, Integer> map = Collections.unmodifiableMap(new HashMap<>() {{put("a", 1);put("b", 2);put("c", 3);}});map.forEach((k, v) -> System.out.println(k + ":" + v));}@Testpublic void test3() {//此时得到的集合list也是一个只读集合。List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);//报异常list.add(6);}//java9新特性八：集合工厂方法：创建只读集合@Testpublic void test4() {List<Integer> list1 = List.of(1, 2, 3, 4, 5);//不能添加
//        list1.add(6);System.out.println(list1);Set<Integer> set1 = Set.of(23, 3, 54, 65, 43, 76, 87, 34, 46);//不能添加
//        set1.add(4);System.out.println(set1);Map<String, Integer> map1 = Map.of("Tom", 23, "Jerry", 54, "HanMeimei", 12);//不能添加//map1.put("Lilei",34);System.out.println(map1);Map<String, Integer> map2 = Map.ofEntries(Map.entry("Tom", 34), Map.entry("Jerry", 21));//不能添加
//        map2.put("Lilei",34);System.out.println(map2);}//java9新特性九：InputStream的新方法:tranferTo()@Testpublic void test5() {ClassLoader cl = this.getClass().getClassLoader();try (InputStream is = cl.getResourceAsStream("hello.txt");OutputStream os = new FileOutputStream("src\\hello1.txt")) {is.transferTo(os); // 把输入流中的所有数据直接自动地复制到输出流中} catch (IOException e) {e.printStackTrace();}}
}

9. InputStream 加强

InputStream 终于有了一个非常有用的方法：transferTo，可以用来将数据直接传输到 OutputStream，这是在处理原始数据流时非常常见的一种用法，如下示例：

//java9新特性十：Stream API的加强
@Test
public void test1(){List<Integer> list = Arrays.asList(23, 43, 45, 55, 61, 54, 32, 2, 45, 89, 7);//takeWhile 返回从开头开始的按照指定规则尽量多的元素
//        list.stream().takeWhile(x -> x < 60).forEach(System.out::println);//dropWhile():与 takeWhile 相反，返回剩余的元素。list.stream().dropWhile(x -> x < 60).forEach(System.out::println);
}

10. 增强的 Stream API

Java 的 Steam API 是java标准库最好的改进之一，让开发者能够快速运算，从而能够有效的利用数据并行计算。Java 8 提供的 Steam 能够利用多核架构实现声明式的数据处理。

在 Java 9 中，Stream API 变得更好，Stream 接口中添加了 4 个新的方法：takeWhile, dropWhile, ofNullable，还有个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代。

takeWhile()的使用
用于从 Stream 中获取一部分数据，接收一个 Predicate 来进行选择。在有序的Stream 中，takeWhile 返回从开头开始的尽量多的元素

@Test
public void test1(){List<Integer> list = Arrays.asList(23, 43, 45, 55, 61, 54, 32, 2, 45, 89, 7);//takeWhile 返回从开头开始的按照指定规则尽量多的元素list.stream().takeWhile(x -> x < 60).forEach(System.out::println);//dropWhile():与 takeWhile 相反，返回剩余的元素。
//        list.stream().dropWhile(x -> x < 60).forEach(System.out::println);
}

dropWhile()的使用
dropWhile 的行为与 takeWhile 相反，返回剩余的元素

@Test
public void test1(){List<Integer> list = Arrays.asList(23, 43, 45, 55, 61, 54, 32, 2, 45, 89, 7);//takeWhile 返回从开头开始的按照指定规则尽量多的元素
//        list.stream().takeWhile(x -> x < 60).forEach(System.out::println);//dropWhile():与 takeWhile 相反，返回剩余的元素。list.stream().dropWhile(x -> x < 60).forEach(System.out::println);
}

ofNullable()的使用
Java 8 中 Stream 不能完全为null， 否则会报空指针异常。而 Java 9 中的 ofNullable 方法允许我们创建一个单元素 Stream，可以包含一个非空元素，也可以创建一个空Stream

@Test
public void test2(){//of()参数中的多个元素，可以包含null值Stream<Integer> stream1 = Stream.of(1, 2, 3,null);stream1.forEach(System.out::println);//of()参数不能存储单个null值。否则，报异常
//        Stream<Object> stream2 = Stream.of(null);
//        stream2.forEach(System.out::println);Integer i = 10;i = null;//ofNullable()：形参变量是可以为null值的单个元素Stream<Integer> stream3 = Stream.ofNullable(i);long count = stream3.count();System.out.println(count);
}

iterate()重载的使用
这个 iterate 方法的新重载方法，可以让你提供一个 Predicate (判断条件)来指定什么时候结束迭代

@Test
public void test3(){Stream.iterate(0,x -> x + 1).limit(10).forEach(System.out::println);//java9中新增的重载的方法Stream.iterate(0,x -> x < 10,x -> x + 1).forEach(System.out::println);
}

除了对 Stream 本身的扩展，Optional 和 Stream 之间的结合也得到了改进。现在可以通过 Optional 的新方法 stream() 将一个 Optional 对象转换为一个(可能是空的) Stream 对象。

@Test
public void test4(){List<String> list = new ArrayList<>();list.add("Tom");list.add("Jerry");list.add("Tim");Optional<List<String>> optional = Optional.ofNullable(list);Stream<List<String>> stream = optional.stream();stream.map(x -> x.toString()).forEach(System.out::println);Stream<List<String>> stream1 = optional.stream();long count = stream1.count();System.out.println(count);Stream<List<String>> stream2 = optional.stream();stream2.flatMap(x -> x.stream()).forEach(System.out::println);
}

12. Javascript引擎升级：Nashorn

Nashorn 项目在 JDK 9 中得到改进，它为 Java 提供轻量级的 Javascript 运行时。Nashorn 项目跟随 Netscape 的 Rhino 项目，目的是为了在 Java 中实现一个高性能但轻量级的 Javascript 运行时。Nashorn 项目使得 Java 应用能够嵌入Javascript。它在 JDK 8 中为 Java 提供一个 Javascript 引擎。
JDK 9 包含一个用来解析 Nashorn 的 ECMAScript 语法树的 API。这个 API 使得IDE 和服务端框架不需要依赖 Nashorn 项目的内部实现类，就能够分析ECMAScript 代码。

17.2 Java 10 新特性

2018年3月21日，Oracle官方宣布Java10正式发布。
需要注意的是 Java 9 和 Java 10 都不是 LTS (Long-Term-Support) 版本。和过去的 Java 大版本升级不同，这两个只有半年左右的开发和维护期。而未来的 Java 11，也就是 18.9 LTS，才是 Java 8 之后第一个 LTS 版本。
JDK10一共定义了109个新特性，其中包含12个JEP（对于程序员来讲，真正的新特性其实就一个），还有一些新API和JVM规范以及JAVA语言规范上的改动。
JDK10的12个JEP（JDK Enhancement Proposal特性加强提议）参阅官方
文档：http://openjdk.java.net/projects/jdk/10/
JDK10的12个JEP：

1. 局部变量类型推断

产生背景
开发者经常抱怨Java中引用代码的程度。局部变量的显示类型声明，常常被认为是不必须的，给一个好听的名字经常可以很清楚的表达出下面应该怎样继续。
好处：
减少了啰嗦和形式的代码，避免了信息冗余，而且对齐了变量名，更容易阅读

适用情况：

@Test
public void test1() {//1.声明变量时，根据所附的值，推断变量的类型var num = 10;var list = new ArrayList<Integer>();list.add(123);//2.遍历操作for (var i : list) {System.out.println(i);System.out.println(i.getClass());}//3.普通的遍历操作for (var i = 0; i < 100; i++) {System.out.println(i);}
}

在局部变量中使用时，如下情况不适用：

@Test
public void test2() {//1.局部变量不赋值，就不能实现类型推断
//        var num ;//2.lambda表达式中，左边的函数式接口不能声明为var
//        Supplier<Double> sup = () -> Math.random();//        var sup = () -> Math.random();//3.方法引用中，左边的函数式接口不能声明为var
//        Consumer<String> con = System.out::println;//        var con = System.out::println;//4.数组的静态初始化中，注意如下的情况也不可以int[] arr = {1, 2, 3, 4};
//        var arr = {1,2,3,4};
}

不适用以下的结构中：

@Test
public void test3() {//        情况1：没有初始化的局部变量声明
//        var s = null;//        情况6：catch块
//        try{//
//        }catch(var e){//            e.printStackTrace();
//        }}
//情况2：方法的返回类型
//    public var method1(){//
        return 0;
//    }
// 情况3：方法的参数类型
//    public void method2(var num){//
//    }//情况4：构造器的参数类型
//    public Java10Test(var i){//
//    }//情况5：属性
//    var num;

工作原理
在处理 var时，编译器先是查看表达式右边部分， 并根据右边变量值的类型进行推断，作为左边变量的类型，然后 将该类型写入字节码当中。
注意：
- var不是一个关键字
  不需要担心变量名或方法名会与 var发生冲突，因为 var实际上并不是一个关键字，而是一个类型名，只有在编译器需要知道类型的地方才需要用到它。除此之外，它就是一个普通合法的标识符。也就是说，除了不能用它作为类名，其他的都可以，但极少人会用它作为类名。
- 这不是JavaScript
  var并不会改变Java是一门静态类型语言的事实。编译器负责推断出类型，并把结果写入字节码文件，就好像是开发人员自己敲入类型一样。

2. 集合新增创建不可变集合的方法copyOf

自 Java 9 开始，Jdk 里面为集合（List / Set / Map）都添加了 of (jdk9新增) 和 copyOf (jdk10新增) 方法，它们两个都用来创建不可变的集合。
注意：
使用of和copyOf创建的集合为不可变集合，不能进行添加、删除、替换、排序等操作，不然会报 java.lang.UnsupportedOperationException 异常。

of和copyOf使用和区别：

@Test
public void test5(){//示例1：var list1 = List.of("Java", "Python", "C");var copy1 = List.copyOf(list1);System.out.println(list1 == copy1); // true//示例2：var list2 = new ArrayList<String>();list2.add("aaa");var copy2 = List.copyOf(list2);System.out.println(list2 == copy2); // false
}

示例1和2代码基本一致，为什么一个为true,一个为false?
结论：copyOf(Xxx coll)
如果参数coll本身就是一个只读集合，则copyOf() 返回值即为当前的coll；
如果参数coll不是一个只读集合，则copyOf() 返回一个新的集合，这个集合是只读的。

17.3 Java 11 新特性

北京时间 2018年9 月 26 日，Oracle 官方宣布 Java 11 正式发布。这是 Java 大版本周期变化后的第一个长期支持版本，非常值得关注。从官网即可下载,最新发布的 Java11 将带来 ZGC、Http Client 等重要特性，一共包含 17 个 JEP（JDK Enhancement Proposals，JDK 增强提案）。其实，总共更新不止17个，只是我们更关注如下的17个JEP更新。
- 官网公开的 17 个 JEP（JDK Enhancement Proposal 特性增强提议）
JDK 11 是一个长期支持版本（LTS, Long-Term-Support）
- 对于企业来说，选择 11 将意味着长期的、可靠的、可预测的技术路线图。其中免费的OpenJDK11 确定将得到 OpenJDK 社区的长期支持， LTS 版本将是可以放心选择的版本。
- 从 JVM GC 的角度，**JDK11 引入了两种新的 GC，其中包括也许是划时代意义的 ZGC，**虽然其目前还是实验特性，但是从能力上来看，这是 JDK 的一个巨大突破，为特定生产环境的苛刻需求提供了一个可能的选择。例如，对部分企业核心存储等产品，如果能够保证不超过 10ms 的 GC 暂停，可靠性会上一个大的台阶，这是过去我们进行 GC 调优几乎做不到的，是能与不能的问题。
- 新的长期支持版本每三年发布一次

1. 新增了一系列字符串处理方法

//java 11新特性一：String中新增的方法@Testpublic void test1(){//        isBlank():判断字符串是否为空白System.out.println("  \t  \t  \n  ".isBlank());//true
//        strip():去除首尾空白System.out.println("-----" + "  \t abc \t  \n  ".strip() + "-------");//-----abc-------System.out.println("-----" + "  \t abc \t  \n  ".trim() + "-------");//-----abc-------
//        stripTrailing():去除尾部空格System.out.println("-----" + "  \t abc \t  \n  ".stripTrailing() + "-------");//-----    abc-------
//        stripLeading():去除首部空格System.out.println("-----" + "  \t abc \t  \n  ".stripLeading() + "-------");//-----abc//  -------
//        repeat(int count):复制字符串String str1 = "abc";String str2 = str1.repeat(5);System.out.println(str2);//abcabcabcabcabc//        lines().count():行数统计String str3 = "abc\ndef\ng";System.out.println(str3.lines().count());//3}

2. Optional 加强

Optional 也增加了几个非常酷的方法，现在可以很方便的将一个 Optional 转换成一个 Stream, 或者当一个空 Optional 时给它一个替代的。

    //java11新特性二：Optional新增的方法@Testpublic void test2(){var op = Optional.empty();System.out.println(op.isPresent());//判断内部的value是否存在 //falseSystem.out.println(op.isEmpty());//判断内部的value是否为空 //trueop = Optional.of("abc");//orElseThrow():value非空，返回value；否则抛异常NoSuchElementExceptionvar obj = op.orElseThrow();System.out.println(obj);//abcOptional<String> op1 = Optional.of("hello");
//        op = Optional.empty();//or:value非空，返回对应的Optional；value为空，返回形参封装的OptionalOptional<Object> op2 = op.or(() -> op1);System.out.println(op2);//Optional[abc]}

尚硅谷Java入门视频教程第十七章——Java9Java10Java11新特性相关推荐

尚硅谷Java入门视频教程第三章——数组
尚硅谷Java入门视频教程第三章第二章复习课后习题复习嵌套循环典型例题 Ecplise的安装使用第3章:数组 3.1 数组的概述 3.2 一维数组的使用 3.3 多维数组的使用 3.4 数组 ...
尚硅谷Java入门视频教程导读及第一章
尚硅谷Java入门视频教程导读及第一章 JAVA基础学习导读-编程入门 0.1概述 0.2 计算机硬件介绍中央处理器(CPU) 存储设备内存比特(bit)和字节(byte) 内存输入和输出设备 ...
尚硅谷Java入门视频教程第二章——Java基本语法
尚硅谷Java入门视频教程第二章第一章复习课后习题 Java语言概述第2章:Java基本语法 2.1 关键字和保留字 2.2 标识符(Identifier) 2.3 变量 2.3.1 变量基本概 ...
尚硅谷Java入门视频教程(在线答疑+Java面试真题)
Java核心技术一.Java基本语法 1.关键字与保留字关键字的定义和特点被Java语言赋予了特殊含义,用做专门用途的字符串(单词) 关键字中所有字母都为小写保留字的定义现有Java版本尚未 ...
尚硅谷java入门b站（347p-355p) 3.18
347 抽象类的课后练习 public abstract class Employee{private String name;private int number;private MyDate bi ...
2019版尚硅谷Java入门视频项目三中的个人出现的报错Cannot resolve symbol ‘PC‘解决方法 ——idea工具
一.问题描述 Cannot resolve symbol 'PC' 二.问题解决文章的开头我根据个人报错情况先给出解决报错的方法!!!加入如下代码: import com.PC; 这个是要根据你存放 ...
【视频分享】尚硅谷Java视频教程_Spring Boot视频教程（下）整合篇
尚硅谷Java视频教程_Spring Boot视频教程(下)整合篇巅峰之作,全网仅此一套,再无企及! SpringBoot是企业级开发的整体整合解决方案,特别用于快速构建微服务应用,旨在用最简单的方 ...
【视频分享】尚硅谷Java视频教程_Shiro视频
群里小伙伴想要Shiro方面的视频,刚好看过尚硅谷的,还行,入门算不错的,这里找来分享给大家,周末好好学习~ Apache Shiro 是目前使用率较高的一个 Java 安全框架.本视频基于 Shir ...
尚硅谷Java、HTML5前端、全栈式开发视频
Java基础阶段: 一.20天横扫Java基础(课堂实录) https://pan.baidu.com/s/1htTzZRQ 二.尚硅谷Java基础实战--Bank项目 http://pan.baid ...

尚硅谷Java入门视频教程第十七章——Java9Java10Java11新特性