Java的第一遍学习笔记 类变量(static)

类变量 

简介

    类变量也叫静态变量或静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

public static int a;

类变量内存布局

根据版本的不同，static变量的存储位置可能在堆中也可能在静态域。下面是两个相关的博客：

Java static变量保存在哪？_晚晴小筑-CSDN博客_java static变量存储在哪里

java中的静态变量和Class对象究竟存放在哪个区域？ - 知乎

不管static变量在哪里，有几条共识—— 1. static 变量是同一个类所有对象共享。 2. static类变量，在类加载的时候就生成了（因此可以用类名进行调用，即使没有创建对象实例也可以访问）。

如何定义类变量

语法： 访问修饰符  static  数据类型  变量名；（推荐，也可以访问修饰符和static调换位置）

如何访问类变量

类名.类变量名（推荐）    或者    对象名.类变量名 

注意静态变量的访问修饰符的访问权限和范围和普通属性相同。

注意事项

1. 什么时候需要用类变量：当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量（静态变量）：比如定义学生类，统计所有学生共交多少钱。

2. 类变量与实例变量（普通属性）区别：类变量是该类的所有对象共享的，而实例变量是每个对象独享的。

3. 加上static称为 类变量 或 静态变量。否则称为 实例变量/普通变量/非静态变量。

4. 实例变量不能通过 类名.类变量名 的方式访问。

5. 类变量是在类加载时就初始化了，也就是说，即使没有创建对象，只要类加载了，就可以使用类变量了。

6. 类变量的生命周期是随类的加载开始，随着类消亡而销毁。

类方法

基本介绍

 类方法也叫静态方法，形式如下：

访问修饰符 static 数据返回类型 方法名(){ }  //推荐
static 访问修饰符 数据返回类型 方法名(){ }

使用方式： 类名.类方法名 或 对象名.类方法名。

使用场景

    当方法中不涉及到任何和对象相关的成员（也就是不需要声明一个对象），则可以将方法设计成静态方法，提高开发效率，比如Math类，Arrays类的方法等。

    在实际开发中，往往会将一些通用的方法设计成静态方法，这样不需要创建对象就可以使用了，比如冒泡排序，打印一维数组等。

注意事项

1. 类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区，类方法中无this参数，普通方法中隐含着this参数。

2. 类方法可以通过类名调用，也可以通过对象名调用（遵循继承规则，只要能继承，可以用父类名调用，也可以用子类名调用）。普通方法只能通过对象名调用。

3. 类方法中不允许使用和对象有关的关键字，比如this和super。

4. 静态的方法，只能访问静态的成员（没有this，只能访问类变量和类方法）。非静态的方法，可以访问静态成员和非静态成员。

public class Person {
    private int id;
    private static int total = 0;
    public static void setTotalPerson(int total){
        this.id = total;   //错误，不能使用this
        this.total = total; //错误，不能使用this
        Person.total = total; //正确，如果不重名的话可以不加类名
    }
}

5. 不能用普通方法给静态变量赋值。

public class Person {
    public static int id = this.show();  //报错
    public int show(){
        System.out.println("调用show");
        return 10;
    }
}

main方法

解释形式

public static void main(String[] args){}

1. public：因为main方法是Java虚拟机进行调用的，因此访问修饰符需要使用public。

2. static：Java虚拟机在执行main方法时不必创建对象，所以该方法必须是static。

3. String[] args：main方法接收String类型的数组参数，该数组中保存执行Java命令时传递给所运行的类的参数。

public class args{
	public static void main(String[] args) {
		System.out.println("传入的第一个参数是"+args[0]);
		System.out.println("传入的第二个参数是"+args[1]);
		System.out.println("传入的第三个参数是"+args[2]);
	}
}

 在IDEA中传入参数：

特别提示

1. 在main方法中，我们可以直接调用main方法所在类的静态方法或静态属性。

2. 但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。

public class Test {
    public static double PI = 3.14;
    public int ss = 10;
    public static void test100(){
        System.out.println("调用静态方法");
    }
    public static void main(String[] args) {
        test100();  
        System.out.println(PI);
        System.out.println(ss);  //报错
    } 
}

代码块

基本介绍

    代码块又称为初始化块，属于类中的成员（即类的一部分），类似于方法，将逻辑语句封装在方法体中，用{}包围起来。

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

基本语法

(static){...

};

1. static关键字和分号(;)可写可不写。

2. 代码块分为两类，使用static修饰的叫做静态代码块，没有static修饰的叫做普通代码块/非静态代码块。

3. 逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）。

好处

1. 相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作。

2. 场景：如果多个构造器中都有重复的语句，可以抽取到代码块中，提高代码的重用性。

public class Person {
    private String name;
    private int age;
    private String job;

    {
        System.out.println("输入信息中...");
        System.out.println("请稍后...");
        System.out.println("信息输入成功");
    }  //代码块
    public Person(String name, int age, String job) {
        System.out.println("调用三个参数的构造器");
        this.name = name;
        this.age = age;
        this.job = job;
    }

    public Person(String name) {
        System.out.println("调用一个参数的构造器");
        this.name = name;
    } //不管用哪个构造器创建对象，都会先调用代码块的内容
}

public class Test {
    public static void main(String[] args) {
        Person a = new Person("shang",10,"teacher");
    }
}

注意事项

1. static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象，就执行。

2. 类什么时候被加载 —— (1) 创建对象实例时(new)   (2) 创建子类对象实例，父类也会被加载  (3) 使用类的静态成员时(静态属性，静态方法)。注意只会执行一次。

public class Person {
    private String name;
    public static int id = 10;   //静态属性
    public static void show(){   //静态方法
        System.out.println("调用静态方法");
    }

    {
        System.out.println("调用普通代码块");
    }

    static{
        System.out.println("调用静态代码块");
    }

    public Person(String name) {
        System.out.println("调用构造器");
        this.name = name;
    }
}

public class Test {
    public static void main(String[] args) {
        Person a = new Person("Jack");
        System.out.println(Person.id);
        Person.show();
    }
}

    发现在创建对象时，静态代码块和普通代码块都调用了，因为静态代码块已经调用过一次了，因此调用静态成员时没有调用静态代码块。

3. 普通的代码块，在创建对象实例时，会被隐式的调用，被创建一次，就会调用一次（可以理解为是构造器的补充）。如果只是使用类的静态成员，普通代码块并不会执行。

public class Test {
    public static void main(String[] args) {
        Person a = new Person("Jack");
        Person b = new Person("Tom");
        Person c = new Person("Smith");
    }
}

4. 创建一个对象时，在一个类中的调用先后顺序：(1) 调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按照他们定义的顺序调用）  (2) 调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级一样，与静态判断方法相同）  (3) 调用构造方法

public class Person {
    public static int id = getId();  //静态变量初始化

    {
        System.out.println("调用普通代码块");
    }   //普通代码块
 
    public int num = getNum();   //普通变量初始化

    static{
        System.out.println("调用静态代码块");
    }   //静态代码块

    public static int getId(){
        System.out.println("调用静态方法");
        return 10;
    }

    public int getNum(){
        System.out.println("调用普通方法");
        return 100;
    }

    public Person() {
        System.out.println("调用构造器!");
    }
}

    首先看静态变量初始化以及静态代码块的位置，发现静态变量初始化在前，因此先加载静态变量初始化，为了更明显的看出先后，因此调用了方法。再分析普通变量初始化和普通代码块，最后是构造器。

public class Test {
    public static void main(String[] args) {
        Person a = new Person();  //因为是初始化一个对象，因此静态代码块和普通代码块都调用
    }
}

5. 构造器的最前面其实 隐含了super()和调用普通代码块，静态相关的代码块，属性初始化，在类加载时就执行完毕了，因此优先于构造器和普通代码块。而构造器执行时先执行super和普通代码块，这与第四点相互印证。

public class Person {
    {
        System.out.println("调用父类的普通代码块");
    }
    public Person() {
        //super() 隐藏语句，Object类没有输出信息
        //调用普通代码块  隐藏语句
        System.out.println("调用父类的构造器");
    }
}

public class Student extends Person{
    {
        System.out.println("调用子类的普通代码块");
    }

    public Student(){
        // super() 隐藏语句
        // 调用普通代码块 隐藏语句
        System.out.println("调用子类的构造器");
    }
}

public class Test {
    public static void main(String[] args) {
        Student a = new Student();
    }
}

6. 静态代码块只能直接调用静态成员，普通代码块可以调用任意成员。

调用顺序总结

1. 父类的静态代码块和静态属性（优先级相同，按书写顺序执行）

2. 子类的静态代码块和静态属性（优先级相同，按书写顺序执行）

3. 父类的普通代码块和普通属性初始化（优先级相同，按书写顺序执行）

4. 父类的构造方法

5. 子类的普通代码块和普通属性初始化（优先级相同，按书写顺序执行）

6. 子类的构造方法

注：为了更好看到属性初始化的顺序，一般用方法给属性初始化，方法里加输出。

    public static int id = getId();  //静态变量初始化
    public static int getId(){
        System.out.println("调用静态方法");
        return 10;
    }

单例设计模式

设计模式

       设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索。

单例设计模式

    采取一定方法保证在整个软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法。

    单例模式有两种方式：1. 饿汉式  2. 懒汉式

饿汉式

1. 构造器私有化——防止直接new出来一个对象。

2. 类的内部创建一个静态对象。

3. 向外暴露一个静态的公共方法，该方法返回一个静态对象。

public class GirlFriend {
    private String name;
    private static GirlFriend gf = new GirlFriend("小红");  //内部创建的对象
    public static GirlFriend getInstance(){
        return gf;                            
    }                  //对外公开的获得对象方法
    private GirlFriend(String name) {
        this.name = name;
    }    //构造器私有化
}

public class Test {
    public static void main(String[] args) {
        GirlFriend gf1 = GirlFriend.getInstance();
        GirlFriend gf2 = GirlFriend.getInstance();  //都返回 gf
        if(gf1 == gf2){
            System.out.println("同一个人");   //输出 同一个人
        }
    }
}

注：饿汉式在内部就创建了对象，如果不使用的话会造成内存空间的浪费。

懒汉式

1. 仍然构造器私有化。

2. 定义一个static静态属性对象（注意不new）。

3. 提供一个public的static方法，可以返回一个static对象。

4. 当用户第一次使用getInstance方法时，才会创建static对象，再次调用就返回那个静态对象。

public class Person {
    private static Person aa;   //私有经典对象
    private Person(){
        System.out.println("构造器调用");
    }
    private static Person getInstance(){
        if(aa == null){
            aa = new Person();   //调用时才分配空间
        }
        return aa;
    }
}

区别

1. 二者最主要的区别在于创建对象的时机不同：饿汉式是在类加载之前就创建了对象实例，而懒汉式是在使用时才创建。

2. 饿汉式不存在线程安全问题，懒汉式存在线程安全问题。

3. 饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。

4. 在JavaSE标准类中，java.lang.Runtime就是经典的单例模式。