@TOC

一、类变量和类方法(静态变量和静态方法)

类变量介绍

特点

1. 静态变量最大的特点是：在一个类中定义的静态变量可以被该类的所有实例（对象）所共享
2. 类变量在类加载的时候就生成了

类变量的内存布局

注意：jdk8之前静态变量在方法区中的静态域中，jdk8之后在堆中

类变量的使用注意事项和细节

类方法的介绍

类方法的经典使用场景

类方法使用的注意事项和使用细节

二、main()方法

语法

注意：String数组args中的参数是在执行这个程序的时候把后面的参数传进去的

特别提示

main()应用

程序运行
idea中传实参

三、代码块

基本介绍

基本语法

好处（作用）

注意：代码块的调用顺序优于构造器（即代码块 构造器1 代码块 构造器2…）

代码块使用注意事项和使用细节

类和代码块的加载

注意：

• 静态代码块只会执行一次，哪怕对类new了两个对象也只会执行一次静态代码块，如果是普通代码块new了几个对象就调用几次代码块
  即：普通代码块只有在对象被创建时才会执行，静态代码块只有在类被加载时才会执行一次

创建一个对象在一个类中的调用顺序（重点）

• 静态：静态属性初始化的优先级和静态代码块的是一样的，谁在前就先初始化谁。
  
• 普通：普通属性初始化的优先级和普通代码块的是一样的，谁在前就先初始化谁。

• 构造器：最后被调用

构造器的加载

创建一个对象在有类的继承时的调用顺序（重点）

静态>普通>构造器，父>子

四、单例设计模式

什么是单例模式

应用实例

饿汉模式（还没使用这个类就已经随着类的加载 创建好了 ）

• 一个类只能有一个实例，所以对构造器私有化（此时外部的类一个对象都不能实例化了），用带static修饰符实例化一个对象，用public static方法返回（要加上static，因为不用静态方法就没法类名直接调用，那么只能通过创建对象调用，而构造器私有化了，无法创建对象，所以只能用静态方法，同时保证了无论怎么new都是同一个对象）

注意：构造器不能用static（如果我们将构造函数设置为静态，则无法初始化对象变量），

步骤

package com.bijing.static_.single_;

public class SingleTon {
    public static void main(String[] args) {
        GirlFriend girlFriend = GirlFriend.gf();
        GirlFriend girlFriend2 = GirlFriend.gf();
        System.out.println(girlFriend);
        System.out.println(girlFriend2);//和上面同一个对象
    }
}

class GirlFriend {
    private String name;
    private static GirlFriend girlFriend = new GirlFriend("aa");

    private GirlFriend(String name) {
        this.name = name;
    }

    public static GirlFriend gf() {
        return girlFriend;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}
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

饿汉模式带来的问题

可能我只想使用一个静态的属性，但是饿汉模式会加载的时候创建一个对象（一般是重量级的），如果对象又不使用会造成资源的浪费

饱汉模式

步骤

对比：和饿汉模式相比，饱汉模式第二步是声明了一个静态的对象的引用，然后提供一个静态方法get**，如果引用指向null就创建一个对象并return，因为是静态的所以每次new一个对象=get**的时候都是同一个对象。

package com.bijing.static_.single_;

public class SingleTon02 {
    public static void main(String[] args) {
        Cat cat = Cat.getCat();
        Cat cat1 = Cat.getCat();
        System.out.println(cat);
        System.out.println(cat == cat1);
    }
}

class Cat {
    private static Cat cat;
    private String name;

    private Cat(String name) {
        this.name = name;
    }

    public static Cat getCat() {
        if (cat == null) {
            cat = new Cat("喵喵");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

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

饱汉模式存在的问题

下面的这段代码可以有多个线程同时调用，从而破坏了单例模式，所以饱汉模式是线程不安全的

  public static Cat getCat() {
        if (cat == null) {
            cat = new Cat("喵喵");
        }
        return cat;
    }
1
2
3
4
5
6

两者的区别

五、final关键字

基本介绍

final修饰

• 类：不能被继承
• 方法：不能被重写，可以继承
• 属性：不能被修改
• 局部变量：不能被修改

final使用的注意事项和细节（注意2,3,7）