JavaSE03_Day02(下)-新日期类、lambda表达式、设计模式

一、新日期类

1.1 新日期类简介

　　Java 8 在 java.time 包下提供了很多新的 API，以下为两个比较重要的API:

• Local(本地) − 简化了日期时间的处理，没有时区的问题。

• Zoned(时区) − 通过指定的时区处理日期时间。

新的java.time包涵盖了所有处理日期，时间，日期/时间，时区，时刻(instants)，过程 (during)与时钟(clock)的操作。

1.2 为什么还需要新的日期类

　　Java 8通过发布新的Date-Time API 来进一步加强对日期与时间的处理。 在旧版的 Java中，日期时间 API 存在诸多问题，其中有:

• 非线程安全 − java.util.Date 是非线程安全的，所有的日期类都是可变的，这是Java日期类最大的问题之一。

• 设计很差 − Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text 包中定义。java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。

• 时区处理麻烦 − 日期类并不提供国际化，没有时区支持，因此Java引入了 java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题。

1.3 本地化日期时间API

 package cn.tedu.newtime;
 ​
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 ​
 /**
  * Java8新日期类的案例演示
  * 当前案例是不区分时区的本地时间
  * @author cjn
  *
  */
 public class LocalDemo01 {
 ​
     public static void main(String[] args) {
         /*
          * LocalDateTime:年月日时分秒
          * LocalDate:年月日
          * LocalTime:时分秒
          */
         LocalDateTime currentTime = LocalDateTime.now();
         System.out.println("当前的日期时间为：" + currentTime);
         
         //获取日期
         LocalDate date = currentTime.toLocalDate();
         LocalDate date2 = LocalDate.now();
         System.out.println("当前日期为：" + date);
         System.out.println("当前日期为：" + date2);
         
         //获取时间
         LocalTime time = currentTime.toLocalTime();
         LocalTime time2 = LocalTime.now();
         System.out.println("当前时间为：" + time);
         System.out.println("当前时间为：" + time2);
         
         //获取年
         System.out.println(currentTime.getYear());
         //获取月
         System.out.println(currentTime.getMonth());
         //获取日
         System.out.println(currentTime.getDayOfMonth());
         //获取小时
         System.out.println(currentTime.getHour());
         //获取分钟
         System.out.println(currentTime.getMinute());
         //获取秒
         System.out.println(currentTime.getSecond());
         
         /*
          * 设置日期和时间 2002年12月30日T9:00:00
          */
         LocalDateTime date3 = currentTime.withYear(2002)
                 .withMonth(12).withDayOfMonth(30).withHour(9).withMinute(0).withSecond(0);
         System.out.println(date3);
         
         /*
          * 设置小时
          */
         LocalTime time3 = currentTime.withHour(17).toLocalTime();
         System.out.println(time3);
         System.currentTimeMillis();
         
         //将字符串转换为日期时间
         String timeStr = "08:00:01";
         LocalTime time4 = LocalTime.parse(timeStr);
         System.out.println(time4);
         
     }
 ​
 }

测试结果：

 当前的日期时间为：2021-07-31T20:42:12.465
 当前日期为：2021-07-31
 当前日期为：2021-07-31
 当前时间为：20:42:12.465
 当前时间为：20:42:12.466
 2021
 JULY
 31
 20
 42
 12
 2002-12-30T09:00:00.465
 17:42:12.465
 08:00:01

1.4 支持时区的API

 package cn.tedu.newtime;
 ​
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 ​
 /**
  * Java8新日期类对于时区所支持的API使用案例
  * @author cjn
  *
  */
 public class ZoneDemo01 {
 ​
     public static void main(String[] args) {
         ZonedDateTime zone = ZonedDateTime.now();
         System.out.println(zone);
         
         ZoneId id = zone.getZone();
         System.out.println(id);
         
         id = ZoneId.of("Europe/Paris");
         System.out.print(id);
         
         ZonedDateTime zone2 = zone.withZoneSameInstant(id);
         System.out.println(zone2);
         
     }
 ​
 }

测试结果：

 2021-07-31T20:40:30.035+08:00[Asia/Shanghai]
 Asia/Shanghai
 Europe/Paris2021-07-31T14:40:30.035+02:00[Europe/Paris]

 

二、lambda表达式

2.1 定义

　　JDK8之后推出的新特性，是使得java可以以"函数式编程"专用表达式可以代替匿名内部类，就地对抽象类或接口进行实现 (lambda实现的类或接口只能有一个方法)

2.2 优缺点

　　lambda最直接感受是用更短的语句创建匿名内部类，代码更少更简单，但是同时也带来代码不易读的缺点。

2.3 格式

 (参数)->{ 方法体 }

2.4 无参无返回值方法使用lambda表达式案例

 package cn.tedu.lambda;
 ​
 /**
  * 无参无返回值方法使用lambda表达式案例
  * @author cjn
  *
  */
 public class LambdaDemo01 {
 ​
     public static void main(String[] args) {
         //匿名内部类的书写方案
         Runnable runnable = new Runnable() {            
             @Override
             public void run() {
                 System.out.println("好好学习，天天向上");                
             }
         };
         
         //使用lambda表达式书写
         Runnable runnable2 = ()->{
             System.out.println("好好学习，天天向上");
         };
         //如果方法中只有一行代码的情况下，可以进行省略掉{}
         Runnable runnable3 = ()->System.out.println("好好学习，天天向上");
 ​
         Thread thread = new Thread(runnable3);
         thread.start();
     }
 ​
 }

测试结果：

 好好学习，天天向上

2.5 有参有返回值方法使用lambda表达式案例

 package cn.tedu.lambda;
 ​
 import java.io.File;
 import java.io.FileFilter;
 ​
 /**
  * 有参有返回值方法使用lambda表达式案例
  * @author cjn
  *
  */
 public class LambdaDemo02 {
 ​
     public static void main(String[] args) {
         File file = new File(".");
         System.out.println(file.getAbsolutePath());
         
         //使用匿名内部类的方式创建文件过滤器对象
         FileFilter filter = new FileFilter() {      
             @Override
             public boolean accept(File pathname) {              
                 return pathname.getName().startsWith(".");
             }
         };
         
         //使用lambda表达式的书写方案改写
         FileFilter filter2 = (pathname)->{
             return pathname.getName().startsWith(".");
         };
         
         //因为方法体中只有一行代码，可以省略{},return需要省略
         FileFilter filter3 = (pathname)->pathname.getName().startsWith(".");
         
         //显示符合要求的文件资源
         File[] files = file.listFiles(filter3);
         for (File f : files) {
             System.out.println(f.getName());
         }
 ​
     }
 ​
 }

测试结果：

 D:\2103班级\workspace\javase12\.
 .classpath
 .project
 .settings

 

三、设计模式

3.1 定义

　　软件设计模式(Design pattern)，又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

3.2 优点

　　使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。

3.3 种类划分

　　设计模式总共有23种设计模式

• 创建型模式：对象实例化的模式，目的是用于解耦对象实例化的过程。

• 结构型模式：把类或者对象集合到一起，然后形成一个更大的结构的模式。

• 行为型模式：类和对象进行交互，划分职责和算法。

毕业以后：

设计模式的书籍：《重学Java设计模式》

数据结构的书籍:《大话数据结构》

算法的书籍：《小灰的算法之旅》

Java知识书籍：《Java核心技术卷I和II》

3.4 简单工厂

• 定义：

  工厂的一个存在的意义其实是生产制造商品，根据工厂的抽象程度可以分为工厂方法模式和抽象工厂模式。根据产品是具体的产品，还是具体的工厂，可以划分为简单工厂模式和工厂方法模式。

• 优点：

  可以根据对不同对象的创建方式进行封装，然后可以向工厂传递需要进行生产加工的类型进行创建响应的对象，使用该方案代码的扩展性比较好，易于维护。

• 设计原则：

  开闭原则(对扩展进行开发，对修改进行关闭)

• 场景：

  非常明确的根据不同的条件创建不同的对象。

• UML图：

• 代码案例：

Food

 package cn.tedu.food;
 /**
  * 食材的抽象超类
  * @author cjn
  *
  */
 public abstract class Food {
     //返回所有食物的名字
     public abstract String name();
 }

Fish

 package cn.tedu.food;
 ​
 public class Fish extends Food{
     @Override
     public String name() {
         return "水煮鱼";
     }
 }

Chicken

 package cn.tedu.food;
 ​
 public class Checken extends Food{
     @Override
     public String name() {
         return "宫保鸡丁";
     }
 }

FoodFactory

 package cn.tedu.food;
 /**
  * 食物工厂类
  * @author cjn
  *
  */
 public class FoodFactory {
     /**
      * 根据不同的需求返回具体的实例对象
      * @param name
      * @return
      */
     public static Food getInstance(String name) {
         //声明一个食品变量
         Food food = null;
         //返回的食物取决于具体的需求
         if ("水煮鱼".equals(name)) {
             food = new Fish();
         } else if ("宫保鸡丁".equals(name)) {
             food = new Chicken();
         }
         return food;
     }
     
 }

Test

 package cn.tedu.food;
 ​
 public class Test {
 ​
     public static void main(String[] args) {
         // 顾客点餐水煮鱼
         String name = "宫保鸡丁";
         Food food = FoodFactory.getInstance(name);
         System.out.println(food.name());
     }
 ​
 }