2023-10-11-T-JAVA

1. 易忘知识点

用于记录已遗忘的知识点

1.1 基础语法

  • 一个JAVA文件中的不同类中均可以有public static 方法， 并且可用java 类名的方式运行public static方法

  • javadoc 用于生成java文件的文档，使用方式javadoc xxx.java.

  • 补码 = 反码 + 1， 计算机运行使用补码

    • 正数：原码，反码，补码都一样：第一位是符号位，0代表正数，数值位为二进制数
    • 负数：
      • 原码：第一位是符号位，1代表负数，数值位为2进制数
      • 反码：第一位是符号位，1代表负数，数值位为对应原码的数值位取反
      • 补码：反码数值位加1

  • 方法重载（Overload）

    • 方法名必须相同

    • 形参列表必须不同：参数顺序，类型，个数，至少有一样不同

    • 返回类型：无要求

      注意：仅仅是形参名不同无法实现方法重载

  • 可变参数

    java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法

    1
    2
    3
    public void varPara(int... parameters){
      //parameters 是一个数组
    }
    1. 可变参数的实参可以为0或任意多个
    2. 可变参数的实参可以是数组
    3. 可变参数可以和普通类型的参数放在一个形参列表里，但需要保证可变参数在最后
    4. 一个形参列表中只能出现一个可变参数

  • 构造器

    • 构造器没有返回值
    • 方法名和类名必须相同
    • 参数列表和成员方法一样的规则
    • 构造器的调用由系统完成
    • 构造器，即构造方法可以重载
    1
    2
    3
    4
    5
    class Constructer{
      public Constructer(){
        
      }
    }

    作用：对新对象的初始化

  • 反编译

    javap [-c -v] 类名

    -c 对代码反汇编

    -v 输出附加信息

1.2 面向对象

  • 代码块

    属于类中的成员，将逻辑语句封装在方法体中，通过“{}”包围起来。

    和方法不同，没有方法名，没有返回值，没有参数，只有方法体，不通过类或对象显式调用。在加载类或者创建对象时隐式调用。

    1
    2
    3
    [修饰符]{
      code...
    }; // 此分号可有可无

    修饰符 可选，使用修饰符时只能用static

    代码块使用场景：e.g. 当多个构造器中有相同的代码语句时，可以将其放入代码块中

    创建对象时，系统先调用代码块，后调用构造器

  • 类加载顺序

    1. 父类的静态代码块和静态属性
    2. 子类的静态代买块和静态属性
    3. 父类的普通代码块和普通属性
    4. 父类的构造方法
    5. 子类的普通代码块和普通属性
    6. 子类的构造方法

  • final关键字

    使用情况:

    (1) 当一个类不希望被继承时, 可使用final关键字修饰

    (2) 当不希望类中某个方法被子类重写时, 可用final关键字修饰

    (3) 当不希望类中某个属性的值被修改时, 使用final关键字修饰

    (4) 当不希望某个局部变量被修改时, 使用final关键字修饰

  • abstract 类

    当不打算在父类中定义某些方法,但又想提前声明这些方法时, 使用abstract修饰这个父类以及这些方法

    1
    2
    3
    class abstract Test{
      public abstract void m(); // 没有方法体
    }

    • interface

      JDK8.0后接口可以有静态方法, 默认方法

      在接口中抽象方法可以省略abstract关键字

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      public interface Test{
         public int n1 = 10;
         default public void ok(){ // 默认方法, 注意要使用default关键字修饰
           System.out.println("ok..");
         }
        public static void test(){ // 静态方法
          System.out.println("test.."); 
        }
      }

      一个类可以同时实现多个接口

      1
      2
      3
      class Test implements IA, IB, ...{
        ...
      }

      接口中的属性是final static修饰的, 例如在接口中写int a = 1; , 实际上是public static final int a = 1;

  • 内部类

    一个类的内部又完整地嵌套了另一个类结构. 被嵌套的类称为内部类(inner class), 嵌套的其他类称为外部类(outer class). 

    1
    2
    3
    4
    5
    6
    // 基本语法
    class Outer{// 外部类
      class Inner{// 内部类
        
      }
    }

    内部类的分类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    //1. 定义在外部类的局部位置(如方法中, 代码块中)
    //1.1 局部内部类
    class Outer01{
      private int n1 = 1;
      public void m1(){
        class Inner01{ // 可使用final修饰
          private int n1 = 22;
          public void m10(){
            System.out.println(A.this.n1); // 可以直接访问所在外部内的所有成员, 使用 外部类名.this精确定位
          }
        }
      }//局部内部类的作用域只在对应的方法体内或代码块中
    }

    //1.2 匿名内部类
    class Outer02{
      private int n2 = 1;
      public void m2(){
        IA ia = new IA(){ // class xxx implements IA{...}
          public void test(){
            System.out.println(n2);
          }
        }
      }
    }
    interface IA{}

    //2. 定义在外部类的成员变量位置
    //2.1 成员内部类

    class Outer03{
      private int n3 = 1;
      class Inner{
        public void m3(){
          System.out.println(n3);
        }
      }
    }

    //2.2 静态内部类

    class Outer04{
      private int n4 = 1;
      static class Inner{
        public void m4(){
          System.out.println(n4);
        }
      }
    }

  • 枚举

枚举: 枚举属于一种特定的类, 里面只包含一组有限的特定的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
//1. 自定义枚举

class Season{
    private String name;
    private String desc;
    // public Season season = new Season("ok", "001");


    public static final Season SPRING = new Season("Spring", "Warm");
    public static final Season SUMMER = new Season("Summer", "Hot");
    public static final Season AUTUMN = new Season("Autumn", "Cozy");
    public static final Season WINTER = new Season("Winter", "Cold");

    private Season(String name, String desc){
        this.name = name;
        this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }
}







//2. 使用enum关键字


enum Season_{
    //1. 多个常量时， 用','间隔
    //2. 常量对象需要定义在类的最前面

    SPRING("Spring", "Warm"), SUMMER("Summer", "Hot"), AUTUMN("Autumn","Cozy"), WINTER("Winter","Cold");
    
    private String name ;
    private String desc;
    private Season_(String name, String desc){
      this.name = name;
      this.desc = desc;
    }

    public String getName() {
        return name;
    }

    public String getDesc() {
        return desc;
    }
}

  • 注解

    注解(Annotation)也被称为元数据, 用于修饰包, 类, 方法, 属性, 构造器, 局部变量等数据信息

    不影响程序逻辑, 但是注解可以被编译和执行

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    //1. @Override 标明方法为重写方法
    //2. @Deprecated 标明某个类或方法已过时
    //3. @SuppressWarnings 抑制编译器警告


    //元注解, 注解的注解
    //1. @Retention(RetentionPolicy.SOURCE)  指定注解的作用范围(SOURCE(编译器使用后直接丢弃), CLASS(记录在class文件, 但jvm运行时不保留), RUNTIME)
    //   代码(SOURCE) ==> class 文件(class) ==> JVM运行(RUNTIME)
    //2. Target(ElementType.METHOD) 指定注解的使用范围(CONSTRUCTURE, FIELD, LOCAL_VARIABLE, METHOD, PACKAGE, PARAMETER, TYPE)
    //3. Documented 指定该注解是否在javadoc中显示
    //4. Inherited 子类会继承父类注解

    • 异常

      运行时异常: 程序运行时发生异常

      编译时异常: 编译器检测出的异常

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    Java.lang.Throwable
      -Error
      -Exception
      	--编译时异常
      		--IOException
      		--SQLException
        --运行时异常 RuntimeException
      		--NullPointException
      		--ArrayindexOutOfBundsException
      		--ArithmeticException
      		--ClassCastExcetption
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    // 1. try-catch-finally
    try{
      ...
    }catch(NullPointerException e){
      e. sss;
    }catch(ArithmeticException e){
      
    }finally{
      
    }

    // 2. throws

    public void method() throws {
      
    }
    //当抛出的是运行时异常, 调用该方法的方法可以不处理
    //当抛出的是编译时异常, 调用该方法的方法需要进行处理

1.3 集合

2. 重难点

2.1 设计模式

2.1.1 单例设计模式

所谓的单例设计模式，就是采取一定的方法保证在整个软件系统中，对于某个类只能存在一个实例，并且该类只提供一个取得其实例的方法。

单例模式有两种：懒汉式和饿汉式

  • 饿汉式

    (1) 构造器私有化

    (2) 类的内部创建对象, 同时创建实例

    (3) 向外暴露一个静态的公共方法

    (4) 代码实现

    1
    2
    3
    4
    5
    6
    7
    class SingleTon{
      private SingleTon(){};
      private static SingleTon instance = new SingleTon();
      public static SingleTon getSingleTon(){
        return instance;
      }
    }

  • 懒汉式

    (1) 构造器私有化

    (2) 类的内部创建对象

    (3) 向外暴露一个静态的公共方法, 同时创建实例

    (4) 代码实现

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    class SingleTon{
      private SingleTone(){};
      private static SingleTon instance;
      public static SingleTon getSingleTon(){
        if(instance == null){ // 有线程风险
          instance = new SingleTon();
        }
        return instance;
      }
    }

2.1.2 模版设计模式

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中，模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤

1
2
3
4
5
6
7
8
class abstract Template{
  public abstract void job();
  public void calculate(){
    int i = 1;
    job();
    int j = 3;
  }
}

3. JVM

3.1 JAVA和JVM简介

3.2 虚拟机与JAVA虚拟机

3.3 JVM整体结构

3.4 Java代码执行流程

3.5 JVM架构模型

3.6 JVM生命周期

3.7 JVM发展历程

JVM与JAVA体系结构
类加载子系统-修改
运行时数据区概述及线程
程序计数器
虚拟机栈
本地方法接口
本地方法栈
堆
方法区
直接内存
执行引擎
StringTable
垃圾回收概述
垃圾回收相关算法
垃圾回收相关概念
垃圾回收器

Tech
#Tech #Java
2023-10-11-T-JAVA
http://example.com/2023/10/11/2023-10-11-T-JAVA/
Author
Fei
Posted on
October 11, 2023
Licensed under