Java 语言基础（常用设计原则和设计模式，常用 Java 8~11 新特性）

常用设计原则和设计模式

常用的设计原则（记忆）

软件开发的流程

• 需求分析文档、概要设计文档、详细设计文档、编码和测试、安装和调试、维护和升级

常用的设计原则

开闭原则（Open Close Principle）

• 对扩展开放对修改关闭，为了使程序的扩展性好，易于维护和升级。

里氏代换原则（Liskov Substitution Principle）

• 任何基类可以出现的地方，子类一定可以出现，多使用多态的方式。

依赖倒转原则（Dependence Inversion Principle）

• 尽量多依赖于抽象类或接口而不是具体实现类，对子类具有强制性和规范性

接口隔离原则（Interface Segregation Principle）

• 尽量多使用小接口而不是大接口，避免接口的污染，降低类之间耦合度。

迪米特法则（最少知道原则）（Demeter Principle）

• 一个实体应当尽量少与其他实体之间发生相互作用，使系统功能模块相对独立。高内聚，低耦合。

合成复用原则（Composite Reuse Principle）

• 尽量多使用合成/聚合的方式，而不是继承的方式。

常用的设计模式

基本概念

• 设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
• 设计模式就是一种用于固定场合的固定套路。

基本分类

• 创建型模式 - 单例设计模式、工厂方法模式、抽象工厂模式、...
• 结构型模式 - 装饰器模式、代理模式、...
• 行为型模式 - 模板设计模式、...

设计模式详解（重点）

单例设计模式

• 单例设计模式主要分为：饿汉式 和 懒汉式，懒汉式需要对多线程进行同步处理。

普通工厂模式

基本概念

• 普通工厂方法模式就是建立一个工厂类，对实现了同一接口的不同实现类进行实例的创建。

类图结构

主要缺点

• 在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，并且可能出现空指针异常。

多个工厂方法模式

类图结构

主要缺点

• 在多个工厂方法模式中，为了能够正确创建对象，先需要创建工厂类的对象才能调用工厂类中的生产方法。

静态工厂方法模式

类图结构

实际意义

• 工厂方法模式适合：凡是出现了大量的产品需要创建且具有共同的接口时，可以通过工厂方法模式进行创建。

主要缺点

• 工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序生产新的产品，就必须对工厂类的代码进行修改，这就违背了开闭原则。

抽象工厂模式

类图结构

装饰器模式

基本概念

• 装饰器模式就是给一个对象动态的增加一些新功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。

类图结构

实际意义

• 可以实现一个类功能的扩展。
• 可以动态的增加功能，而且还能动态撤销（继承不行）。
• 缺点：产生过多相似的对象，不易排错。

代理模式

基本概念

• 代理模式就是找一个代理类替原对象进行一些操作。
• 比如我们在租房子的时候找中介，再如我们打官司需要请律师，中介和律师在这里就是我们的代理。

类图结构

实际意义

• 如果在使用的时候需要对原有的方法进行改进，可以采用一个代理类调用原有方法，并且对产生的结果进行控制，这种方式就是代理模式。
• 使用代理模式，可以将功能划分的更加清晰，有助于后期维护。

代理模式和装饰器模式的比较

• 装饰器模式通常的做法是将原始对象作为一个参数传给装饰者的构造器，而代理模式通常在一个代理类中创建一个被代理类的对象。
• 装饰器模式关注于在一个对象上动态的添加方法，然而代理模式关注于控制对对象的访问。

模板方法模式

基本概念

• 模板方法模式主要指一个抽象类中封装了一个固定流程，流程中的具体步骤可以由不同子类进行不同的实现，通过抽象类让固定的流程产生不同的结果。

类图结构

实际意义

• 将多个子类共有且逻辑基本相同的内容提取出来实现代码复用。
• 不同的子类实现不同的效果形成多态，有助于后期维护。

新特性

这里只收集了一些比较常用的新特性，可以到 Java 的官网了解更多新特性。

Java 8 的新特性

Java 8 的概述

• Java 8 是 Java 语言的一个重要版本，该版本于 2014 年 3 月发布，是自 Java 5 以来最具革命性的版本，这个版本包含语言、编译器、库、工具和 JVM 等方面的十多个新特性。

函数式接口

• 函数式接口主要指只包含一个抽象方法的接口，如：java.lang.Runnable、java.util.Comparator 接口等。
• Java 8 提供 @FunctionalInterface 注解来定义函数式接口，若定义的接口不符合函数式的规范便会报错。
• Java 8 中增加了 java.util.function 包，该包包含了常用的函数式接口，具体如下： 接口名称方法声明功能介绍Consumer<T>void accept(T t)根据指定的参数执行操作Supplier<T>T get()得到一个返回值Function<T,R>R apply(T t)根据指定的参数执行操作并返回Predicate<T>boolean test(T t)判断指定的参数是否满足条件

Lambda 表达式

• Lambda 表达式是实例化函数式接口的重要方式，使用 Lambda 表达式可以使代码变的更加简洁紧凑。
• lambda 表达式：参数列表、箭头符号 -> 和方法体组成，而方法体中可以是表达式，也可以是语句块。
• 语法格式：(参数列表) -> {方法体;} -- 其中 ()、参数类型、{} 以及 return 关键字可以省略。

方法引用

• 方法引用主要指通过方法的名字来指向一个方法而不需要为方法引用提供方法体，该方法的调用交给函数式接口执行。
• 方法引用使用一对冒号 :: 将类或对象与方法名进行连接，通常使用方式如下：
  • 对象的非静态方法引用：ObjectName :: MethodName

Person person = new Person("xxx", 24);
// 匿名内部类
Consumer<String> consumer = new Consumer<String>() {
   @Override
   public void accept(String s) {
  person.setName(s);
  }
};
consumer.accept("renda1");
System.out.println("person = " + person); // renda1 24

// Lambda 表达式
Consumer<String> consumer1 = s -> person.setName(s);
consumer1.accept("renda2");
System.out.println("person = " + person); // renda2 24

// 方法引用
Consumer<String> consumer2 = person::setName;
consumer2.accept("renda3");
System.out.println("person = " + person); // renda3 24

// 匿名内部类
Comparator<Integer> comparator = new Comparator<Integer>() {
   @Override
   public int compare(Integer o1, Integer o2) {
       return Integer.compare(o1, o2);
  }
};
System.out.println(comparator.compare(10, 20));  // -1

// Lambda 表达式
Comparator<Integer> comparator1 = (o1, o2) -> Integer.compare(o1, o2);
System.out.println(comparator1.compare(10, 20)); // -1

// 方法引用
Comparator<Integer> comparator2 = Integer::compare;
System.out.println(comparator2.compare(10, 20)); // -1

// 匿名内部类
Comparator<Integer> comparator3 = new Comparator<Integer>() {
   @Override
   public int compare(Integer o1, Integer o2) {
       return o1.compareTo(o2);
  }
};
System.out.println(comparator3.compare(10, 20)); // -1

// Lambda 表达式
Comparator<Integer> comparator4 = (o1, o2) -> o1.compareTo(o2);
System.out.println(comparator4.compare(10, 20)); // -1

// 方法引用
Comparator<Integer> comparator5 = Integer::compareTo;
System.out.println(comparator5.compare(10, 20)); // -1

// 匿名内部类
BiFunction<String, Integer, Person> biFunction = new BiFunction<String, Integer, Person>() {
   @Override
   public Person apply(String s, Integer integer) {
       return new Person(s, integer);
  }
};
System.out.println(biFunction.apply("renda", 24)); // renda 24

// Lambda 表达式
BiFunction<String, Integer, Person> biFunction1 = (s, integer) -> new Person(s, integer);
System.out.println(biFunction1.apply("renda", 24)); // renda 24

// 方法引用
BiFunction<String, Integer, Person> biFunction2 = Person::new;
System.out.println(biFunction2.apply("renda", 24)); // renda 24

// 匿名内部类
Function<Integer, Person[]> function3 = new Function<Integer, Person[]>() {
   @Override
   public Person[] apply(Integer integer) {
  return new Person[integer];
  }
};
Person[] pArr = function3.apply(3);
System.out.println(Arrays.toString(pArr));

// Lambda 表达式
Function<Integer, Person[]> function4 = integer -> new Person[integer];
System.out.println(Arrays.toString(function4.apply(4)));

// 方法引用
Function<Integer, Person[]> function5 = Person[]::new;
System.out.println(Arrays.toString(function5.apply(5)));

• 方法引用是在特定场景下 lambda 表达式的一种简化表示，可以进一步简化代码的编写使代码更加紧凑简洁，从而减少冗余代码。

Stream 接口

代码

// 过滤 list 集合的元素，再全部打印出来
list.stream().filter(person -> person.getAge() >= 18).forEach(System.out::println);

// 跳过 list 开头的两个元素，再取三个元素，并全部打印出来
list.stream().skip(2).limit(3).forEach(System.out::println);

// 获取 list 中所有元素的年龄并全部打印出来
list.stream().map(Person::getAge).forEach(System.out::println);

// 排序并打印
list.stream().sorted().forEach(System.out::println);

// 判断是否没有年龄大于 60 的元素
list1.stream().noneMatch(person -> person.getAge() > 60);

// 获取年龄最大值
list.stream().max((o1, o2) -> o1.getAge() - o2.getAge());

// 获取所有元素的年龄累加和
list.stream().map(Person::getAge).reduce((Integer::sum));

// 获取所有元素的名字并全部收集起来到一个 list 之中，再遍历 list 打印出来
list.stream().map(Person::getName).collect(Collectors.toList()).forEach(System.out::println);

基本概念

• java.util.stream.Stream 接口是对集合功能的增强，可以对集合元素进行复杂的查找、过滤、筛选等操作。
• Stream 接口借助于 Lambda 表达式极大的提高编程效率和程序可读性，同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势。

使用步骤

• 创建 Stream，通过一个数据源来获取一个流。
• 转换 Stream，每次转换返回一个新的 Stream 对象。
• 对 Stream 进行聚合操作并产生结果。

创建方式

• 方式一：通过调用集合的默认方法来获取流，如：default Stream stream()
• 方式二：通过数组工具类中的静态方法来获取流，如：static IntStream stream(int[] array)
• 方式三：通过Stream接口的静态方法来获取流，如：static Stream of(T... values)
• 方式四：通过Stream接口的静态方法来获取流，如：static Stream generate(Supplier<? extends T> s)

中间操作

• 筛选与切片的常用方法如下： 方法声明功能介绍Stream filter(Predicate<? super T> predicate)返回一个包含匹配元素的流Stream distinct()返回不包含重复元素的流Stream limit(long maxSize)返回不超过给定元素数量的流Stream skip(long n)返回丢弃前 n 个元素后的流
• 映射的常用方法如下： 方法声明功能介绍Stream map(Function<? super T,? extends R> mapper)返回每个处理过元素组成的流Stream flatMap(Function<? super T,? extends Stream<? extends R>> mapper)返回每个被替换过元素组成的流，并将所有流合成一个流
• 排序的常用方法如下： 方法声明功能介绍Stream sorted()返回经过自然排序后元素组成的流Stream sorted(Comparator<? super T> comparator)返回经过比较器排序后元素组成的流

终止操作

• 匹配与查找的常用方法如下： 方法声明功能介绍Optional findFirst()返回该流的第一个元素boolean allMatch(Predicate<? super T> predicate)返回所有元素是否匹配boolean noneMatch(Predicate<? super T> predicate)返回没有元素是否匹配Optional<T> max(Comparator<? super T> comparator)根据比较器返回最大元素Optional<T> min(Comparator<? super T> comparator)根据比较器返回最小元素long count()返回元素的个数void forEach(Consumer<? super T> action)对流中每个元素执行操作
• 规约的常用方法如下： 方法声明功能介绍Optional<T> reduce(BinaryOperator<T> accumulator)返回结合后的元素值
• 收集的常用方法如下： 方法声明功能介绍<R,A> R collect(Collector<? super T,A,R> collector)使用收集器对元素进行处理

Optional类

代码

System.out.println(Optional.of("renda").orElseThrow()); // renda

String str1 = null;
Optional<String> optional = Optional.ofNullable(str1);
Optional<Integer> integer = optional.map(String::length);
System.out.println("integer = " + integer); // Optional.empty
System.out.println(integer.orElse(0)); // 0

String str = (String) Optional.ofNullable(null).or(() -> Optional.of("renda")).get();
System.out.println(str); // renda

基本概念

• java.util.Optional 类可以理解为一个简单的容器，其值可能是 null 或者不是 null，代表一个值存在或不存在。
• 该类的引入很好的解决空指针异常，不用显式进行空值检测。

常用的方法

Java 9 的新特性

Java 9 的概述

• Java 9 发布于 2017 年 9 月发布，带来了很多新特性，其中最主要的变化是模块化系统。
• 模块就是代码和数据的封装体，模块的代码被组织成多个包，每个包中包含 Java 类和接口，模块的数据则包括资源文件和其他静态信息。

模块化的使用

语法格式

• 在 module-info.java 文件中，我们可以用新的关键词 module 来声明一个模块，具体如下： module 模块名称 { exports 模块包名; // 导出模块 requires 模块名称; // 导入模块 }

模块化的优势

• 减少内存的开销。
• 可简化各种类库和大型应用的开发和维护。
• 安全性，可维护性，提高性能。

钻石操作符的使用升级

• 在 Java 9 中允许在匿名内部类的使用中使用钻石操作符。

集合工厂方法

代码

• 如果尝试改变不可变集合，可以编译成功但是运行时会发生 UnsupportedOperationException（不支持此操作的异常）。

List<Integer> list = List.of(1, 2, 3, 4, 5);
Set<Integer> set = Set.of(6, 7, 8);
Map<Integer, String> map = Map.of(1, "one", 2, "two");

基本概念

• Java 9 的 List、Set 和 Map 集合中增加了静态工厂方法 of 实现不可变实例的创建。
• 不可变体现在无法添加、修改和删除它们的元素。
• 不允许添加 null 元素对象。

实际意义

• 保证线程安全：在并发程序中既保证线程安全性，也大大增强了并发时的效率。
• 被不可信的类库使用时会很安全。
• 如果一个对象不需要支持修改操作，将会节省空间和时间的开销。
• 可以当作一个常量来对待，并且这个对象在以后也不会被改变。

InputStream 的增强

• InputStream 类中提供了 transferTo 方法实现将数据直接传输到 OutputStream 中。

...
inputStream = new FileInputStream(...);
outputStream = new FileOutputStream(...);
// 实现数据的复制，底层是read和write方法的调用
inputStream.transferTo(outputStream);
...

Java 10 的新特性

Java 10 的概述

• Java 10 于 2018 年 3 月发布，改进的关键点包括一个本地类型推断、一个垃圾回收的增强。
• Java 10 计划只是一个短期版本，因此公开更新将在六个月内结束，9 月份发布的 Java 11 将是 Java 的长期支持（LTS）版本，LTS 版本的发布每三年发布一次。

局部变量类型推断

代码

// 由初始值可以推断出变量的类型，因此可以使用var取代

// int num = 10;
var num = 10;

// List<Integer> list = new LinkedList<>();
var list = new LinkedList<Integer>();

for (var v : list) {
    System.out.println(v);
}

for (var i = 0; i < 10; i++) {}

基本概念

• Java 10 可以使用 var 作为局部变量类型推断标识符，此符号仅适用于局部变量，增强 for 循环的索引，以及传统 for 循环的本地变量。
• 它不能使用于方法形式参数，构造函数形式参数，方法返回类型，字段，catch 形式参数或任何其他类型的变量声明。

实际意义

• 标识符 var 不是关键字，只是一个保留的类型名称。这意味着 var 用作变量，方法名或包名的代码不会受到影响，但 var 不能作为类或则接口的名字。
• 避免了信息冗余。
• 对齐了变量名。
• 更容易阅读。

Java 11 的新特性

Java 11 的概述

• Java 11 于 2018 年 9 月正式发布，这是 Java 大版本周期变化后的第一个长期支持版本，非常值得关注。

简化的编译运行操作

• 在 Java 11 中可以使用 java 命令一次性进行编译和运行操作。
• 执行源文件中的第一个类必须包含主方法。
• 不可以使用其它源文件中自定义的类。

String 类新增方法

// a aa a
"a\na".repeat(2).lines().forEach(v -> System.out.print(v + " "));