10Java基础之static

static

• 它叫静态，可以修饰成员变量、成员方法。

成员变量按照有无static修饰，分为两种：

• 类变量
• 实例变量(对象的变量)
  
  
• 在类中，有static修饰的变量叫做类变量，也称为静态变量。它的特点是属于类，在计算机内存中只加载一次，它会被类和对的全部对象共享。
• 在类中，无static修饰的变量叫做实例变量，或者对象变量。它属于每个对象。也就是说每个对象都会有一个age。
  
  
  
  案例：

学生类：
public class Student {
    // 静态变量：有static修饰，属于类持有，在内存中只有一份，被类和全部对象共享
    static String name;
    // 实例变量：无static修饰，属于每一个对象。
    int age;
}

测试类：
// 目标，理解static修饰成员变量的用法
// 静态变量访问方式推荐：类名.静态变量
public class Demo01 {
    public static void main(String[] args) {
        Student.name = "袁华";
        System.out.println(Student.name);

        // 对象.静态变量（不推荐）
        Student s1 = new Student();
        s1.name = "马冬梅";

        System.out.println(s1.name);

        Student s2 = new Student();
        s2.name = "秋雅";

        System.out.println(s1.name);
        System.out.println(Student.name);

        // 对象.实例变量
        // Student.age = 18; //报错
        s1.age = 23;
        s2.age = 24;

        System.out.println(s1.age);
        System.out.println(s2.age);
    }
}
输出结果：
袁华
马冬梅
秋雅
秋雅
23
24

类变量的使用场景

• 在开发中，如果某个数据只需要一份，且希望能够被共享(访问，修改)，则该数据可以定义成类变量来记住它。
  
  例如：
• 系统启动后，要求用户类可以记住自己创建了多少个用户对象。
  
  
• 我们可以在构造器里进行计数，因为每次new一个对象的时候，都会调用一次构造器。
  
  案例：

用户类：
public class User {
    public static int number;

    public User(){
//        User.number++;
        // 注意：访问当先类中的静态成员变量，不需要对象
        number++;
    }
}

main方法调用：
public static void main(String[] args) {
        // 目标：搞清楚static修饰成员变量的应用场景
        new User();
        new User();
        new User();
        new User();

        System.out.println("创建了几个对象：" + User.number);
    }
结果：
4

static修饰成员方法

• 成员方法的分类：
  • 类方法：有static修饰的成员方法，属于类方法。
    
    
  • 实例方法：无static修饰的成员方法，属于对象。
    
    
    
    案例：

学生类：
public class Student {
    double score;
    // 静态方法：有static修饰，属于类持有，建议用类名访问，也可以用对象访问
    public static void printHello(){
        for (int i = 0; i < 3; i++) {
            System.out.println("hello world");
        }
    }

    // 实例方法：无static修饰，属于对象持有，必须用对象访问
    public void printPass(){
        System.out.println(score > 60? "及格": "不及格");
    }
}

测试main方法：
// 理解静态方法，实例方法的使用
public class Test {
    public static void main(String[] args) {
        // 1. 类名.静态方法名（推荐）
        Student.printHello();
        Student s1 = new Student();
        System.out.println("------------------");
        // 1. 对象名.静态方法名（不推荐）
        s1.printHello();
        System.out.println("------------------");
        // 2. 对象.实例方法名()
        s1.score = 61;
        s1.printPass();
    }
}

输出结果：
hello world
hello world
hello world
------------------
hello world
hello world
hello world
------------------
及格

• 搞懂main方法
  • main方法是静态方法，在IDEA工具中，运行main方法时，其实是运行的Test.main()方法。
  • 在同一个类中有多个static方法，在调用时类名可以省略。例如：Test.run(),可以简写成run()。

static修饰成员方法的使用场景

• 类方法的常见应用场景，做工具类。

• 什么是工具类？

  • 工具类中的方法都是一些类方法，每个方法都是用来完成一个功能的，工具类是给开发人员共同使用的。
    
    

• 使用类方法来设计工具类有啥好处？

  • 提高代码复用。
  • 调用方便，提高开发效率。

• 为什么工具类中的方法要用类方法，而不用实例方法？

• 实例方法需要创建对象来调用，此时对象只为了调用方法。但是对象十分占内存，这样会大量浪费资源。

• 类方法，直接用类名调用即可，调取方便，也能节省内存。

由于工具类没有创建对象的需求，建议将工具类的构造器进行私有。

static注意事项

• 使用类方法，实例方法时的几点注意事项：
  1. 类方法中可以直接访问类的成员，不可以直接访问实例成员。
  2. 实例方法中既可以直接访问类成员，也可以直接访问实例成员。
  3. 实例方法中可以出现shis关键字，类方法中不可以出现this关键字。

案例：

public class Test {
    // 静态成员变量
    public static String name = "好学习";
    // 静态方法
    public static void inAdder(){
        System.out.println("我在学校学习");
    }

    // 实例成员变量
    private String age;
    public void printInfo(){
        System.out.println("我的年龄是" + age);
    }

    public static void main(String[] args) {

    }

    // 1. 静态方法中可以直接访问静态的成员，不可以直接访问实例成员。
    // 3. 实例方法中可以出现shis关键字，类方法中不可以出现this关键字。
    public static void teststatic(){
        System.out.println(name);
        inAdder();

//        System.out.println(age); // 报错
//        printInfo();             // 报错
//        System.out.println(this);// 报错
    }

    //2. 实例方法中既可以直接访问类成员，也可以直接访问实例成员。
    public void test(){
        System.out.println(name);
        inAdder();

        System.out.println(age);
        printInfo();
        System.out.println(this);
    }
}

代码块

• 代码块是类的5大成分之一（成员变量，构造器，方法，代码块，内部类）

• 代码块分为两种：

  1. 静态代码块
  • 格式：static{}
  • 特点：类加载时自动执行，由于类只会加载一次，所以静态代码块也只会执行一次。
  • 作用：完成类的初始化，例如：对类变量的初始化赋值。
  1. 示例代码块
  • 格式：{}
  • 特点：每次创建对象时，执行实例代码块，并在构造器前执行；
  • 作用：和构造器一样，都是用来完成对象的初始化的，例如：对实例变量进行初始化赋值。

案例：

静态代码块案例：
// 目标：搞清楚静态代码块的作用
public class CodeBlock1 {
    // 静态代码块：有static修饰，属于类持有，与类一起优先加载，自动执行一次。
    // 作用：可以用来初始化静态变量
    static{
        System.out.println("静态代码块");
    }

    public static void main(String[] args) {
        System.out.println("main方法");
    }
}

输出结果：
静态代码块
main方法
-----------------------------------------------
实例代码块案例：
// 目标：掌握实例代码块的作用，应用场景
public class CodeBlock2 {
    // 实例代码块：属于类的每个对象，每次创建对象时都会自动执行一次，而且在构造器之前执行
    // 作用：实例变量的初始化
    {
        System.out.println("实例代码块");
    }

    public CodeBlock2(){
        System.out.println("构造器");
    }

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

输出结果：
实例代码块
构造器
实例代码块
构造器

单例设计模式

• 什么是设计模式？

  • 一个问题通常要有n种解法，其中肯定有一种解法是最优的，这个最优的解法被人总结出来，被称之为设计模式。
  • 设计模式有20多种，对应20多种软件开发中遇到的问题。

• 关于设计模式的学习，主要学习什么？

  • 为了解决什么问题
  • 该如何实现设计模式

• 单例设计模式：确保一个类只有一个对象

• 写法：

  1. 把类的构造器私有。
  2. 定义一个类变量记住类的一个对象。
  3. 定义一个类方法，返回对象。

案例：

单例类：
public class A {
    //2. 定义一个静态变量用于记住类的一个唯一对象。
    private static A a = new A();

    // 1. 把构造器私有化
    private A(){

    }

    //3. 提供一个静态方法，用于返回类的唯一对象。
    public static A get(){
        return a;
    }
}

main方法：
 public static void main(String[] args) {
        A a1 = A.get();
        A a2 = A.get();
        System.out.println(a1);
        System.out.println(a2);
 }

输出结果：
A@2f4d3709
A@2f4d3709

• 单例模式的应用场景和好处？
  
  
  • 任务管理器对象、获取运行时对象
  • 在这些业务场景下，使用单例模式，可以避免浪费内存。
• 单例设计模式的实现方式有很多

饿汉式单例：拿对象时，对象早就创建好了。

**懒汉式单例设计模式 **

• 拿对象时，才开始创建对象。（延迟加载对象）
• 写法：
  1. 把类的构造器私有。
  2. 定义一个类变量用于存储对象。
  3. 提供一个类方法，保证返回的是同一个对象。

案例：

懒汉式单例类：
public class B {
    // 2. 定义一个静态变量用于记住类的一个唯一对象
    private static B b ;

    // 1. 私有化构造器
    private B(){
    }

    // 3. 定义一个静态的get方法返回一个唯一的对象
    public static B get(){
        // 第一次来拿对象的时候，是需要创建对象的
        if(b == null){
            b = new B();
        }
        return b;
    }
}

main方法：
// 目标：实现懒汉式单例设计模式
public static void main(String[] args) {
   B b1 = B.get();
   B b2 = B.get();
   System.out.println(b1);
   System.out.println(b2);
}

输出结果：
B@2f4d3709
B@2f4d3709