框架（Java相关）基础

框架前置知识

时间：2024-05-20 星期一

学习内容

• Maven构建工具

  • Maven的核心特性

  • Maven的依赖管理

  • Maven的工程打包

• 工厂模式

  • 设计模式

  • 工厂模式

  • 工厂模式的引用场景

• 反射机制

  • 反射及作用

  • 反射的四个核心类

  • 反射在项目中的应用

• Lambda表达式

  • Lambda语法

  • 函数式编程

  • Stream流式处理

Maven构建工具

Maven简介

• Maven是项目管理工具，对软件项目提供构建与依赖管理-

• Maven是Apache下的Java开源项目

• Maven为Java项目提供了统一的管理方式

Maven的核心特性

• 项目设置遵循统一的规则，保证不同开发环境的兼容性

• 强大的依赖管理，项目依赖组件自动下载、自动更新

• 可扩展的插件机制，使用简单，功能丰富

Maven项目新建时的各字段含义

• GroupId：机构或者团队的英文，采用“逆向域名”形式书写

• ArtifactId：项目名称，说明其用途

• Version:版本号，一般采用“版本+单词”的形式，例如：1.0.0.RELEASE

Maven工程项目文件结构

Maven依赖管理

• Maven利用dependency(依赖)自动下载、管理第三方Jar

• 在pom.xml文件中配置项目依赖的第三方组件

• maven自动将依赖从远程仓库下载至本地仓库，并在工程中引用

本地仓库与中央仓库

Maven通过配置文件pom.xml中内容去下载指定的依赖，首先maven首先去本地仓库寻找，找不到再去中央（远程）仓库找并下载。

由于Maven的默认仓库源是国外的，所以一般下载依赖会比较慢，所以可以修改它的下载仓库源如国内的阿里源(maven.aliyun.com)等

Maven常用命令

设计模式（工厂模式）

• 工厂模式是设计模式的一种，设计模式是前辈总结的设计经验

  • 设计模式的分类

    • 创建型模式

    • 结构型模式

    • 行为型模式

• 设计模式的目标是代码更容易理解，更容易维护

• 通过设计模式可以让代码更加可靠

工厂模式

• 工厂模式用于隐藏创建对象的细节

• 工厂模式核心：工厂类（factory）

• 工厂模式可细分为简单工厂、工厂方法与抽象工厂

反射机制

反射Reflect

• 反射（Reflect）是在运行时动态访问类与对象的技术

• 反射时JDK1.2版本后的高级特性，隶属于java.lang.reflect

• 大多数Java框架都基于反射实现参数配置、动态注入等特性

  /**
      * 传统的创建对象方式
      */
     public static void case1(){
         Scanner scanner = new Scanner(System.in);
         System.out.print("请输入计算类名:");
         String op = scanner.next();
         System.out.print("请输入a:");
         int a = scanner.nextInt();
         System.out.print("请输入b:");
         int b = scanner.nextInt();
         MathOperation mathOperation = null;
         if(op.equals("Addition")){
             mathOperation = new Addition();
         }else if(op.equals("Subtraction")) {
             mathOperation = new Subtraction();
         }else if(op.equals("Multiplication")){
             mathOperation = new Multiplication();
         }else{
             System.out.println("无效的计算类");
             return;
         }
         float result = mathOperation.operate(a, b);
         System.out.println(result);
     }
 ​
     /**
      * 利用反射创建对象更加灵活
      */
     public static void case2(){
         Scanner scanner = new Scanner(System.in);
         System.out.print("请输入计算类名:");
         String op = scanner.next();
         System.out.print("请输入a:");
         int a = scanner.nextInt();
         System.out.print("请输入b:");
         int b = scanner.nextInt();
         MathOperation mathOperation = null;
         try {
             mathOperation = (MathOperation) Class.forName("com.imooc.reflect." + op).newInstance();
         }catch(Exception e){
             System.out.println("无效的计算类");
             return;
         }
         float result = mathOperation.operate(a, b);
         System.out.println(result);
     }

反射的核心类

• Class类

• Constructor构造方法类

• Method方法类

• Field成员变量类

Class类

• Class是JVM中代表“类和接口”的类

• Class对象具体包含了某个特定类的结构信息

• 通过Class对象可获取对应类的构造方法/方法/成员变量

Class核心方法

• Class.forName(类)，静态方法，用于获取指定Class对象

• classObj.newInstance（），通过默认构造方法创建新的对象

 Class employee = Class.forName("com.imooc.entity.Employee");//获取employee类
 Employee empInstance = (Employee) employee.newInstance();//获取employee实例对象

• classObj.getConstructor（），获得指定的public修饰构造方法Constructor对象

  • Constructor构造方法类

    • Constructor类是对Java类中的构造方法的抽象

    • Constructor对象包含了具体类的某个具体构造方法的声明

    • 通过Constructor对象调用带参构造方法创建对象

  •  employeeClass = Class.forName("com.imooc.entity.Employee");
     Constructor constructor = employeeClass.getConstructor(new Class[]{
                      Integer.class,String.class,Float.class,String.class
              });//调用带参构造函数
     Employee employee = (Employee) constructor.newInstance(new Object[]{
                  3033,"里尔",5000f,"研发部"
              });//获取带参构造函数实例
     System.out.println(employee);

• classObj.getMethod（）,获取指定的public修改方法Method对象

  • methodObj.invoke(),调用指定对象的对应方法

  • Method方法类

    • Method对象指代某个类中的方法的描述

    • Method对象使用classObj.getMethod()方法获取

    • 通过Method对象调用指定对象的对应方法

    •  try {
        Class employeeClass = Class.forName("com.imooc.reflect.entity.Employee");
        Constructor constructor = employeeClass.getConstructor(new Class[]{
                Integer.class,String.class,Float.class,String.class
        });
        Employee employee = (Employee) constructor.newInstance(new Object[]{3099,"里尔",5000f,"研发部"});
        //调用方法类核心方法
        Method updateSalaryMethod = employeeClass.getMethod("updateSalary", new Class[]{
                Float.class});//获取指定方法，调用参数包括：方法名，参数类属性名
        Employee employee1 = (Employee) updateSalaryMethod.invoke(employee,new Object[]{1000f});//调用执行对应实例对象的方法，调用参数包括：方法位于的实例对象，方法所需参数值
        System.out.println(employee1);
       } catch (Exception e) {
        e.printStackTrace();
       } 

• classObj.getField（），获取指定的public修改成员变量Field对象

  • Field成员变量类

    • Field对应某个特具体类中的成员变量的声明

    • Field对象使用classObj.getField()方法获取

    • 通过Field对象可为某对象成员变量赋值/取值

      • field.set(),为某对象指定成员变量赋值

      • field.get()获取某指定成员变量数值

    •  try {
                Class employeeClass = Class.forName("com.imooc.reflect.entity.Employee");
                Constructor constructor = employeeClass.getConstructor(new Class[]{
                   Integer.class,String.class,Float.class,String.class
                });
                Employee employee = (Employee) constructor.newInstance(new Object[]{
                   3099,"里尔",5000f,"研发部"
                });
                Field enameField = employeeClass.getField("ename");
                String ename = (String) enameField.get(employee);//获取public属性的ename的值
                System.out.println(ename);
                enameField.set(employee,"你好");
                String ename1 = (String) enameField.get(employee);//获取public属性的ename的值
                System.out.println("调用set方法后的ename值:\n"+ename1);
            } catch (Exception e) {
                e.printStackTrace();
            }

  • getDeclared系列方法

    • getDeclaredConstructor(s)|Method(s)|Field(s)获取对应对象

    • getConstructor(s)|Method(s)|Field(s)只能获取public对象

    • 访问非作用域内构造方法、方法、成员变量，会抛出异常

    •        Class employeeClass = Class.forName("com.imooc.reflect.entity.Employee");
             Constructor constructor = employeeClass.getConstructor(new Class[]{
                     Integer.class,String.class,Float.class,String.class
             });
             Employee employee = (Employee) constructor.newInstance(new Object[]{
                     3099,"里尔",5000f,"研发部"
             });
       ​
             Field[] fields = employeeClass.getDeclaredFields();//获取所有属性包括private和public
             //打印对象属性值
             for (Field field : fields){
       //                System.out.println(field.getName());
                 if (field.getModifiers() == 1){//public修饰属性
                     Object val = field.get(employee);
                     System.out.println(field.getName() + "." + val);
                 }else if (field.getModifiers() == 2){ //获取private修饰的属性值
                     String methodName = "get" + field.getName().substring(0,1).toUpperCase() + field.getName().substring(1);//属性get方法名
                     Method getMethod = employeeClass.getMethod(methodName);
                     Object ret = getMethod.invoke(employee);
                     System.out.println(field.getName() + ":" + ret);
                 }
             }

       

时间：2024-05-23 星期四

Lambda表达式

学习内容:Lambda语法、基于Lambda实现函数式编程、Stream流式处理

Lambda表示式是什么？

• JDK8开始支持Lambda表达式，用来让程序编写更优雅

• 利用Lambda可以更简洁的实现匿名内部类与函数声明与调用

• 基于Lambda提供stream流式处理极大简化对集合的操作

      //传统代码
      List<String> names = Arrays.asList("peter","anna","mike","xenia");
      System.out.println(names);
      //实现集合排序--传统方法
      Collections.sort(names, new Comparator<String>() {
          @Override
          public int compare(String a, String b) {
              return b.compareTo(a);
          }
      });
      System.out.println(names.toString());
 ​
      //使用Lambda表达式
      //通过lambda表达式简化匿名类的编写
      Collections.sort(names,(a,b)->b.compareTo(a));
      System.out.println(names);

Lambda语法格式

格式：(参数列表)->实现语句

参数列表：使用逗号分隔参数(Integer a,Integer b)，参数类型可省略(a，b)，单参数括号可省略(a)

实现语句：单行直接写，多行用{}包括

 //MathOperation接口类
 public interface MathOperation {
  Float operate(Integer a, Integer b);
 }

 //使用不同参数形式的Lambda使用
 ​
 //1.标准Lambda使用方式
      MathOperation addition = (Integer a, Integer b)->{
          System.out.println("加法运算");
          return a+b+0f;//加0f是因为，MathOperation接口中包含的方法的所需的返回值是Float类型
      };
      System.out.println(addition.operate(1,2));
 ​
 //2.Lambda允许忽略参数类型
 MathOperation substraction = (a,b)->{
  System.out.println("减法运算");
  return a-b+0f;
 };
 System.out.println(substraction.operate(3,2));
 ​
 //3.单行实现代码可以省略大括号和return
 MathOperation multiplication = (a,b)->a*b+0f;
 System.out.println("乘法运算");
 System.out.println(multiplication.operate(3,2));

函数式编程

• 函数式编程是基于函数式接口并使用lambda表达的编程方式

• 函数式编程理念是将代码作为可重用代入到程序运行中

• 函数式编程强调"你想做什么"，而不是“你想怎么做”

函数式接口

• 函数式接口是有且只有一个抽象方法的接口

• Java中拥有大量函数式接口，如java.lang.Runnable

• JDK8后提供了一系列的函数式接口，位于java.util.function

JDK8常用函数式接口

• Consumer<T>,对应有一个输入参数无输出的功能代码

• Function<T,R>,对应有一个输入参数且需要返回数据的功能代码

• Predicate<T>,用于条件判断，固定返回布尔值

函数式接口Predicate

• Predicate是新增的函数式接口，位于java.util.function

• Predicate用于测试传入的数据是否满足判断要求

• Predicate接口需要实现test()方法进行逻辑判断

 package com.imooc.lambda.sample;
 ​
 ​
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 import java.util.function.Predicate;
 ​
 /**
  * 理解函数式编程
  * Predicate函数式接口的使用方法
  */
 public class PredicateSample {
     public static void main(String[] args) {
         //判断是否小于4
         Predicate<Integer> predicate = n -> n<4;
         boolean result = predicate.test(10);
         System.out.println(result);
 ​
         List<Integer> nums = Arrays.asList(1,2,3,4,5,6,7);
 ​
 ​
         filter(nums,n->n%2==1);//取所有奇数
         filter(nums,n->n%2==0);//取所有偶数
         filter(nums,n->n>5 && n%2==0);//取所有大于5的偶数
 ​
     }
     public static void filter(List<Integer> list, Predicate<Integer> predicate){
         for (Integer num:list){
             if (predicate.test(num)){
                 System.out.print(num+ " ");
             }
         }
         System.out.println();
     }
 }

Stream流式处理

• Stream流式处理是建立在Lambda基础上的多数据处理技术

• Stream对集合数据处理进行高度抽象，极大简化代码量

• Stream可对集合进行迭代，去重，筛选，排序，聚合等一系列处理

Stream常用方法

• forEach，循环遍历

• map，map方法用于映射每个元素到对应的结果

• filter，用于设置条件过滤出元素

• limit，方法用于获取指定数量的流

• sorted，方法用于对流进行排序

• Collectors，Collectors类实现将流转换成集合和聚合元素

Stream五种的创建方式

 package com.imooc.stream;
 ​
 import org.junit.Test;
 ​
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 ​
 /**
  * Stream流对象的五种创建方式
  */
 public class StreamGenerator {
     //1.基于数组进行创建
     @Test
     public void generator1(){
          String[] arr = {"Lily", "Andy", "Jackson", "Smith"};
          Stream<String> stream = Stream.of(arr);
          stream.forEach(s-> System.out.println(s));
     }
 ​
     //2.基于集合进行创建
     @Test
     public void generator2(){
         List<String> list = new ArrayList<>();
         list.add("Lily");
         list.add("Andy");
         list.add("Jackson");
         list.add("Smith");
         Stream<String> stream = list.stream();
         stream.forEach(s-> System.out.println(s));
     }
 ​
     //3.利用generate方法创建无限长度流
     @Test
     public void generator3(){
         Stream<Integer> stream = Stream.generate(() -> new Random().nextInt(10000));
         stream.limit(10).forEach(i-> System.out.println(i));
     }
 ​
     //4.基于迭代器创建流
     @Test
     public void generator4(){
         Stream<Integer> stream = Stream.iterate(1,n->n+1);
         stream.limit(10).forEach(i-> System.out.println(i));
     }
 ​
     //5.基于字符序列创建流
     @Test
     public void generator5(){
         String str = "abcdefg我的";
         IntStream stream = str.chars();//生成字符串中每一个字符的ASCII码值
         stream.forEach(c -> System.out.println(c));
     }
 }