Java学习笔记

Java学习笔记

文章目录

• Java基础
• • 1、反射
  • • 1.1 概述
  • 2、注解
  • 3、异常
  • • 3.1 概述
    • 3.2 异常处理
    • • 3.2.1 捕获异常
      • 3.2.2 抛出异常
    • 3.3 NullPointerException
    • 3.4 断言
  • 4、泛型
  • • 4.1 概述
    • 4.2 泛型使用
    • 4.3 泛型编写
    • 4.4 擦拭法
    • 4.5 泛型继承
    • 4.6 extends通配符
    • 4.7 super通配符
  • 4、I/O流
  • 5、日期
  • 6、代码规范
• Java集合
• 并发编程
• • 1、并发
  • • 1.1 概述
    • • 1.1.1 多线程概念
      • 1.1.2 并行和并发
      • 1.1.3 用户级线程和内核级线程
      • 1.1.4 多线程模型
      • 1.1.5 Java线程的运行过程：
      • 1.1.6 线程安全
  • 2、线程池
  • • 2.1 概述
    • 2.2 创建方式
    • • 2.2.1 FixedThreadPool
      • 2.2.2 CachedThreadPool
      • 2.2.3 SingleThreadExecutor
      • 2.2.4 ScheduledThreadPool
      • 2.2.5 SingleThreadScheduledExecutor
      • 2.2.6 newWorkStealingPool
      • 2.2.7 ThreadPoolExecutor
    • 2.3 选用标准
  • 3、JUC
  • • 3.1 概述
  • 4、锁机制
  • • 4.1 锁分类
    • • 4.1.1 自旋锁
      • 4.1.2 偏向锁
      • 4.1.3 适应性自旋锁
      • 4.1.4 锁粗化
      • 4.1.5 锁消除
      • 4.1.6 轻量级锁
      • 4.1.7 重量级锁
  • 5、事务
  • • 5.1 概述
• JVM
• • 1、内存区域
  • 2、垃圾回收机制
  • 3、JVM调优
• 日志管理
• • 1、日志级别
  • 2、日志格式
  • 3、日志框架
  • • 3.1 logback和slf4j
    • • 3.1.1 pom依赖
      • 3.1.2 配置文件
      • 3.2.3 Java代码中使用
    • 3.2 log4j
    • • 3.2.1 pom依赖
      • 3.2.2 配置文件
      • 3.2.3 Java代码中使用
    • 3.3 log4j2
    • • 3.3.1 pom依赖
      • 3.3.2 配置文件
  • 4、日志打印原则
  • • 4.1 不要使用e.printStackTrace()
    • 4.2 异常日志不要只打印一半，而是输出全部错误信息
    • 4.3 禁止在线上环境开启debug
    • 4.4 不要记录了异常，又抛出异常
    • 4.5 避免重复打印日志
    • 4.6 日志文件分离
    • 4.7 核心功能模块，建议打印完整的日志
• 设计模式
• • 1、创建型
  • • 1.1 单例模式
    • • 1.1.1 意图
      • 1.1.2 主要解决
      • 1.1.3 何时使用
      • 如何解决
      • 关键代码
      • 几种实现方式
      • • 1、懒汉式，线程不安全
        • 2、懒汉式，线程安全
        • 3、饿汉式，线程安全
        • 4、双重校验锁，线程安全
        • 5、静态内部类，线程安全
        • 6、枚举，线程安全
    • 1.2 建造者模式（Builder Pattern）
    • • 意图
      • 主要解决
      • 何时使用
      • 如何解决
      • 关键代码
      • 实现方式
      • • 步骤1：创建一个表示食物条目和食物包装的接口
        • 步骤2：创建实现 Packing 接口的实体类
        • 步骤3：创建实现 Item 接口的抽象类，该类提供了默认的功能。
      • 步骤4：创建扩展了 Burger 和 ColdDrink 的实体类
      • • 步骤5：创建一个 Meal 类，带有上面定义的 Item 对象。
        • 步骤6：创建一个 MealBuilder 类，实际的 builder 类负责创建 Meal 对象
        • 步骤7：BuiderPatternDemo 使用 MealBuilder 来演示建造者模式（Builder Pattern）
    • 原型模式（Prototype Pattern）
    • • 意图
      • 主要解决
      • 何时使用
      • 如何解决
      • 关键代码
      • 实现方式
      • • 步骤1：创建一个实现了 *Cloneable* 接口的抽象类
        • 步骤2：创建扩展了上面抽象类的实体类。
        • 步骤3：创建一个类，从数据库获取实体类，并把它们存储在一个 *Hashtable* 中。
        • 步骤4：*PrototypePatternDemo* 使用 *ShapeCache* 类来获取存储在 *Hashtable* 中的形状的克隆。
    • 1.3 工厂模式
    • • 意图
      • 主要解决
      • 何时使用
      • 如何解决
      • 关键代码
      • 实现方式
      • • 步骤1：创建一个接口
        • 步骤2：创建接口的实现类
        • 步骤3：创建一个工厂，生成基于给定信息的实体类的对象
        • 步骤4：使用该工厂，通过传递类型信息来获取实体类的对象
    • 1.4 抽象工厂模式
    • • 意图
      • 主要解决
      • 何时使用
      • 如何解决
      • 关键代码
      • 实现方式
      • • 步骤1：为形状创建一个接口
        • 步骤2：创建形状接口的实体类。
        • 步骤3：为颜色创建一个接口
        • 步骤4：创建实现颜色接口的实体类
        • 步骤5：为颜色和形状对象创建抽象类来获取工厂
        • 步骤6：创建扩展了 AbstractFactory 的工厂类，基于给定的信息生成实体类的对象。
        • 步骤7：创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂
        • 步骤8：使用 FactoryProducer 来获取 AbstractFactory，通过传递类型信息来获取实体类的对象
  • 2、结构型
  • • 2.1 代理模式
    • 2.2 装饰器模式
  • 3、行为型
  • • 3.1 观察者模式（Observer Pattern）
    • • 意图
      • 主要解决
      • 何时使用
      • 如何解决
      • 关键代码
      • 实现方式
      • • 步骤1：创建Subject类
        • 步骤2：创建Observer类
        • 步骤3：创建实体观察者类
        • 步骤4：使用 *Subject* 和实体观察者对象
    • 3.2 模板方法模式
    • 3.3 责任链模式
• 数据结构与算法
• • 1、数据结构
  • 2、算法
• 参考
• • 1、Java基础
  • • 1.1 反射
    • 1.2 注解
    • 1.3 异常
    • 1.4 I/O流
    • 1.5 日期
    • 1.6 代码规范
  • 2、Java集合
  • 2、并发编程
  • • 2.1 并发
    • 2.1 线程池
    • 2.2 JUC
    • 2.3 锁机制
    • 2.4 事务
  • 3、JVM
  • • 3.1 内存区域模型
  • 4、日志管理
  • 5、设计模式

Java基础 1、反射 1.1 概述

反射就是把Java的各种成分映射成相应的Java类。

反射是java语言的一个特性，它允程序在运行时（注意不是编译的时候）来进行自我检查并且对内部的成员进行 *** 作。例如它允许一个java的类获取他所有的成员变量和方法并且显示出来。Java 的这一能力在实际应用中也许用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。

Class 对象是在加载类时由 Java 虚拟机以及通过调用类加载器中的 defineClass 方法自动构造的。

2、注解 3、异常 3.1 概述 3.2 异常处理 3.2.1 捕获异常 3.2.2 抛出异常 3.3 NullPointerException 3.4 断言 4、泛型 4.1 概述

泛型就是编写模板代码来适应任意类型；

泛型的好处是使用时不必对类型进行强制转换，它通过编译器对类型进行检查；

注意泛型的继承关系：可以把ArrayList向上转型为List（T不能变！），但不能把ArrayList向上转型为ArrayList（T不能变成父类）。

4.2 泛型使用

使用泛型时，把泛型参数替换为需要的class类型，例如：ArrayList，ArrayList等；

可以省略编译器能自动推断出的类型，例如：List list = new ArrayList<>();；

不指定泛型参数类型时，编译器会给出警告，且只能将视为Object类型；

可以在接口中定义泛型类型，实现此接口的类必须实现正确的泛型类型。

4.3 泛型编写

静态方法

静态方法不能引用泛型类型，必须定义其他类型（例如）来实现静态泛型方法。例如：

public class Pair {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public T getLast() { ... }

    // 对静态方法使用:
    public static Pair create(T first, T last) {
        return new Pair(first, last);
    }
}

上述代码会导致编译错误，因为我们无法在静态方法create()的方法参数和返回类型上使用泛型类型T。

对于静态方法，我们可以单独改写为“泛型”方法，只需要使用另一个类型即可。对于上面的create()静态方法，我们应该把它改为另一种泛型类型，例如，：

public class Pair {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public T getLast() { ... }

    // 静态泛型方法应该使用其他类型区分:
    public static  Pair create(K first, K last) {
        return new Pair(first, last);
    }
}

这样才能清楚地将静态方法的泛型类型和实例类型的泛型类型区分开。

多个泛型类型

泛型还可以定义多种类型。例如，我们希望Pair不总是存储两个类型一样的对象，就可以使用类型：

public class Pair {
    private T first;
    private K last;
    public Pair(T first, K last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() { ... }
    public K getLast() { ... }
}

在使用的时候，指出两种类型即可：

Pair p = new Pair<>("test", 123);

Java标准库的Map就是使用两种泛型类型的例子。它对Key使用一种类型，对Value使用另一种类型。

4.4 擦拭法

泛型是一种类似”模板代码“的技术，不同语言的泛型实现方式不一定相同。Java语言的泛型实现方式是擦拭法（Type Erasure）。所谓擦拭法是指，虚拟机对泛型其实一无所知，所有的工作都是编译器做的。

例如，我们编写了一个泛型类Pair，这是编译器看到的代码：

public class Pair {
    private T first;
    private T last;
    public Pair(T first, T last) {
        this.first = first;
        this.last = last;
    }
    public T getFirst() {
        return first;
    }
    public T getLast() {
        return last;
    }
}

而虚拟机根本不知道泛型。这是虚拟机执行的代码：

public class Pair {
    private Object first;
    private Object last;
    public Pair(Object first, Object last) {
        this.first = first;
        this.last = last;
    }
    public Object getFirst() {
        return first;
    }
    public Object getLast() {
        return last;
    }
}

因此，Java使用擦拭法实现泛型，导致了：

1. 编译器把类型视为Object；
2. 编译器根据实现安全的强制转型。

使用泛型的时候，我们编写的代码也是编译器看到的代码：

Pair p = new Pair<>("Hello", "world");
String first = p.getFirst();
String last = p.getLast();

而虚拟机执行的代码并没有泛型：

Pair p = new Pair("Hello", "world");
String first = (String) p.getFirst();
String last = (String) p.getLast();

所以，Java的泛型是由编译器在编译时实行的，编译器内部永远把所有类型T视为Object处理，但是，在需要转型的时候，编译器会根据T的类型自动为我们实行安全地强制转型。

Java泛型的局限：

1. 不能是基本类型，例如int，因为实际类型是Object，Object类型无法持有基本类型：

   Pair p = new Pair<>(1, 2); // compile error!
   

2. 无法取得带泛型的Class。观察以下代码：

   public class Main {    public static void main(String[] args) {    	Pair p1 = new Pair<>("Hello", "world");        Pair p2 = new Pair<>(123, 456);        Class c1 = p1.getClass();        Class c2 = p2.getClass();        System.out.println(c1==c2); // true        System.out.println(c1==Pair.class); // true    }}class Pair {    private T first;    private T last;    public Pair(T first, T last) {        this.first = first;        this.last = last;    }    public T getFirst() {        return first;    }    public T getLast() {        return last;    }}
   

   因为T是Object，我们对Pair和Pair类型获取Class时，获取到的是同一个Class，也就是Pair类的Class。

   换言之，所有泛型实例，无论T的类型是什么，getClass()返回同一个Class实例，因为编译后它们全部都是Pair