day8_static关键字

一、static关键字

1.1问题引入

如果某个类型的所有对象，都具有一个相同的属性值，那么这个属性值就没有必要在所有对象中，都存储一份。

坏处：浪费内存空间；维护难度大，一旦需要修改，就得修改所有的对象。

不使用static关键字

示例代码

public class Student {
    
    private int id;
    private String name;
    private int age;
    private String country="中国";
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

内存图

static关键字描述

• static关键字可以用于修饰类的成员变量、方法和代码块。

• static修饰的变量称为静态变量。

• static修饰的方法称为静态方法。

• static修饰的初始化代码块，称为静态初始化块。

• static修饰类，静态内部类（后面讲）

---

1.2静态变量

用static修饰的变量叫做静态变量（类变量）。

静态变量的特征：类的所有对象共享同一个静态变量。

例如：

static int x

示例代码：修改上面例子 使国家变为静态变量

public class Student {
    private int id;
    private String name;
    private int age;
    static String country="中国";  // 静态变量
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void sayHello(){
        System.out.println("hello...");
    }
    public int add(int a,int b){
        return a+b;
    }
}

1、 java7之前，方法区位于永久代(PermGen)，永久代和堆相互隔离，永久代的大小在启动JVM时可以设置一个固定值，不可变；

2、 java7中，static变量从永久代移到堆中；

3、 java8中，取消永久代，方法存放于元空间(Metaspace)，元空间仍然与堆不相连，但与堆共享物理内存，逻辑上可认为在堆中

静态变量的特点

static的解释：

• 静态、静止的。静态变量不会随着对象的变化而变化

• 加载时机：

• 静态变量随着类的加载进方法区，就直接在静态区给开辟了存储静态变量的内存空间

• 静态变量优先于对象而存在

• 静态变量被所有该类对象所共享

• 代码层面：可以使用类名直接调用，不需要使用对象名称。在不创建对象的前提下，仍然可以使用这个静态变量。建议使用类名来访问。

静态变量和非静态变量的区别

1、概念上，所属不同

非静态变量属于对象，静态变量属于类

2、内存空间不同，存储位置不同

• 非静态变量存储在堆内存

• 静态变量属于类，存储在方法区的静态区中

3、内存时间不同，生命周期不同

• 非静态变量属于对象，所以生命周期和对象相同，随着对象的创建而存在，随着对象的消失而消失

• 静态变量属于类，所以生命周期和类相同，随着类的加载（创建对象、类名访问静态变量、类名访问静态方法、反射的方式、加载子类、运行某个测试类）而存在，随着类的消失（内存管理）而消失

4、访问方式不同

• 非静态变量只能使用对象名访问

• 静态变量既可以使用对象访问，也可以通过类名访问：

  类名.静态变量名

  类名.静态方法名()

1.3静态方法

当static 修饰成员方法时，该方法称为类方法或静态方法。静态方法在声明中有static ，建议使用类名来直接调用，而不需要创建类的对象。调用方式非常简单。

格式

修饰符 static 返回值类型 方法名 (参数列表){
    // 执行语句
}

举例：在Student类中定义静态方法

public static void showNum() {
    System.out.println("num:" + autoIncrementNum);
}

静态方法调用注意事项

• 静态方法可以直接访问类中静态变量和静态方法

• 静态方法不能直接访问成员变量和成员方法，成员方法可以直接访问静态变量和静态方法（静态方法和成员先于对象出现）

• 静态方法中，不能使用关键字

示例代码

public class Student {
    private int id;
    private String name;
    private int age;
    static String country="中国";  // 静态变量
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public static void sayHello(){
        System.out.println("hello..."+country);  //静态方法中可以直接访问静态成员
        //System.out.println(name);静态方法中，不能方法非静态成员（成员变量和成员方法）
        //add(1,2); 
    }
    public void introduce(){
        System.out.println("我是"+name+" 来自"+country);  // 非静态方法中可以直接方法静态成员
    }
    public int add(int a,int b){
        return a+b;
    }
}

调用格式总结

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属于一个类，共享使用同一个静态成员，但是不建议。

// 访问类变量
类名.类变量名；
// 调用静态方法
类名.静态方法名(参数)；

示例代码

public static void main(String[] args) {
    Student stu1 = new Student();
    Student stu2 = new Student();
    /*
        System.out.println(stu1.country);
        System.out.println(stu2.country);
        */
    //System.out.println(Student.country);  // 静态变量 是不属于任何一个对象的，直接属于类
    stu1.sayHello();
    stu2.sayHello();
    stu1.add(1,2);
    Student.sayHello();  //静态方法可以通过类名直接调用
    //Student.add(1,2);  不能通过类名直接调用成员方法（非静态方法）   
}

二、静态初始化块以及案例

---

1.1静态初始化块

static 修饰的初始化块

特征：在类加载时，只会执行一次

例如

static{
    
}

初始化代码块和静态代码块的区别

{  // 初始化代码块——每创建一个对象，就会执行一次
    System.out.println("初始化代码块");
}
    
static{  // 静态代码块——在类加载时，只会执行一次
    System.out.println("静态初始化代码块");
}

三、static特征总结以及单例模式

---

1.1static特征总结

1. 静态方法中不能访问非静态成员变量和成员方法,非静态方法可以访问静态成员变量和静态方法

2. 静态方法中不能使用this关键字

3. 静态会随着类的加载而加载，随着类的消失而消失。说明它的生命周期很长。

4. 优先于对象存在。-->静态是先存在，对象是后存在。

5. 被所有实例(对象)所共享。

6. 可以直接被类名调用

静态变量（类变量）和实例变量的区别

存放位置

1：类变量随着类的加载而加载存在于方法区中.

2：实例变量随着对象的建立而存在于堆内存中.

生命周期

1：类变量生命周期最长,随着类的消失而消失.

2：实例变量生命周期随着对象的消失而消失.

静态优缺点

1：优点:对对象的共享数据进行单独空间的存储,节省空间

2：缺点：生命周期过长,访问出现局限性。（静态只能访问静态）

什么时候定义静态变量

静态变量（类变量）当对象中出现共享数据

例如：学生的学校名称。学校名称可以共享

什么时候定义静态方法

如果功能内部没有访问到非静态数据

1.2单例模式（Singleton）

GOF的23种设计模式中的其中一种

一些人总结出来用来解决特定问题的固定的解决方案。

解决一个类在内存中只能存在一个对象，想要保证对象的唯一。

思路

• 将构造方法私有化

• 在类中创建一个私有的本类对象

• 提供一个用类名调用的公有方法获取该对象。

示例代码

class Single {
    private static Single s = new Single(); // 饿汉式
    private Single() {
    }
    public static Single getInstance() {
        return s;
    }
}
class Single2 {
    private static Single2 s = null; // 懒汉式
    private Single2() {
    }
    public static Single2 getInstance() {
        if (s == null) {
            s = new Single2();
        }
        return s;
    }
}

---