第20天学习Java的笔记-static静态

28天

静态static关键字

1.概述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1rR1rotO-1608259503514)(F:\Java\Learn\day15\day20.assets\image-20201218090551803.png)]

2.静态static关键字修饰成员变量

package Demo2001;

public class Student {

    private int id;
    private String name;
    private int age;
    static String room;//所在教室
    private static int idCounter = 0;//学号计数器，每当new了一个新对象的时候，计数器++

    public Student() {
        this.id = ++idCounter;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        this.id = ++idCounter;
    }

    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;
    }
}

package Demo2001;

/*
* 如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类。多个对象共享同一份数据。
* 共享的意思就是，一旦有一个给它赋值，其他的都可以直接拿来用
* */
//只需要给第一个学生的room赋值，第二个学生可以直接用这个赋值。
public class Demo01StaticField {
    public static void main(String[] args) {
        Student stu1 = new Student("xx",19);
        stu1.room = "101教室";
        System.out.println("第一个人姓名为：" + stu1.getName()
                + "年龄为：" + stu1.getAge() + "教室为：" + stu1.room + "学号为：" + stu1.getId());//第一个人姓名为：xx年龄为：19教室为：101教室

        Student stu2 = new Student("hh",18);
        System.out.println("第二个人姓名为：" + stu2.getName()
                + "年龄为：" + stu2.getAge() + "教室为：" + stu2.room + "学号为：" + stu2.getId());//第二个人姓名为：hh年龄为：18教室为：101教室


    }
}

3.静态static关键字修饰成员方法

package Demo2001;

public class MyClass {

    int num;//成员变量
    static int numStatic;//静态变量

    //成员方法
    public void method() {
        System.out.println("这是一个普通的成员方法。");
        //成员方法可以访问成员变量
        System.out.println(num);
        //成员方法可以访问静态变量
        System.out.println(numStatic);
    }

    //静态方法
    public static void methodStatic() {
        System.out.println("这是一个静态方法。");
        //静态方法不可以直接访问非静态变量
        //System.out.println(num);
        //静态方法可以访问静态变量
        System.out.println(numStatic);
    }
}

package Demo2001;

/*
* 一旦使用static修饰成员方法，那么这就成为了静态方法
* 静态方法不属于对象，而是属于类的。
*
* 如果没有static关键字，那么必须首先创建对象，然后通过对象才能使用它
* 如果有了static关键字，那么不需要创建对象，直接就能通过类名称来使用它
*
* 无论是成员变量，还是成员方法。如果有了static，都推荐使用类名称进行调用。
* 静态变量：类名称.静态变量
* 静态方法：类名称.静态方法（）
*
* 注意事项：
* 1.静态不能直接访问非静态。
* 原因：因为在内存中是先有的静态内容，后有的非静态内容。
* “先人不知道后人，但是后人知道先人。”
* 2.静态方法当中不能用this。
* 原因：this代表当前对象，通过谁调用的方法，谁就是对象。
*
* */

public class Demo02StaticMethod {
    public static void main(String[] args) {

        //首先创建对象，然后才能使用没有static关键字的内容
        MyClass myClass = new MyClass();
        myClass.method();

        //对于静态方法，可以通过对象名进行调用，也可以直接通过类名称进行调用。
        myClass.methodStatic();//正确，不推荐。这种写法在编译之后也会被javac翻译成为类名称。静态方法名
        MyClass.methodStatic();//推荐

        //对于本类当中的静态方法，可以省略类名称
        myMethod();
        Demo02StaticMethod.myMethod();//完全等效
    }

    public static void myMethod() {
        System.out.println("这是我自己的方法");
    }
}

4.静态static的内存图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-049ApoQL-1608259503516)(F:\Java\Learn\day15\day20.assets\image-20201218103008130.png)]

package Demo2001;

public class Demo03StaticStudent {
    public static void main(String[] args) {
        //首先设置一下教室，这是静态的东西，应该通过类名称进行调用。
        Student.room = "1010";

        Student stu1 = new Student("xx",19);
        System.out.println("stu1的id" + stu1.getId());
        System.out.println("stu1的姓名" + stu1.getName());
        System.out.println("stu1的年龄" + stu1.getAge());
        System.out.println("stu1的教室" + Student.room);

        Student stu2 = new Student("hh",18);
        System.out.println("stu2的id" + stu2.getId());
        System.out.println("stu2的姓名" + stu2.getName());
        System.out.println("stu2的年龄" + stu2.getAge());
        System.out.println("stu2的教室" + Student.room);
    }
}

5.静态代码块

package Demo2001;

/*
 * 静态代码块的格式是：
 *
 * public class 类名称{
 *   static {
 *       //静态代码块的内容
 *   }
 * }
 * 特点：当第一次用到本类时，静态代码块执行唯一的一次。
 *   第二次及以后，就不执行了。
 * 静态内容总是优先于非静态。
 * */
public class Person {
    static {
        System.out.println("静态代码块被执行");
    }

    public Person() {
        System.out.println("构造方法执行");
    }

}

package Demo2001;
/*
 * 静态代码块的格式是：
 *
 * public class 类名称{
 *   static {
 *       //静态代码块的内容
 *   }
 * }
 * 特点：当第一次用到本类时，静态代码块执行唯一的一次。
 *   第二次及以后，就不执行了。
 * 静态内容总是优先于非静态。
 *
 * 静态代码块的典型用途：
 * 用来一次性地对静态成员变量进行赋值。
 * */

public class Demo04Static {
    public static void main(String[] args) {
        Person person1 = new Person();
        System.out.println("======");
        Person person2 = new Person();
    }
}
/*
* 静态代码块被执行
构造方法执行
======
构造方法执行
* */