java之static

静态变量

如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于所在的类，也就是说，既然属于类，就可以不靠创建对象来调用了。

定义格式和使用格式

当static修饰成员变量时，该变量成为类变量，该类的每个对象都共享同一个类变量的值。
静态变量可通过类名来调用他。
格式：
static 数据类型 变量名
代码：

Student.java

public class Student {
    private int id;//学号
    private String name;//姓名
    private int age;//年龄
    static  String room;
    private static  int idCount = 0;//学号计数器，每当newL一个新对象时，计数器++；
    private static  String str = "123";

    public Student() {
        this.id = idCount++;

    }

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setId(int id) {
        this.id = id;
    }

    public int getId() {
        return id;
    }
}

Demo03StaticStudent.java

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

//        Student one = new Student("郭靖",19);
//        one.room = "101教室";
//        Student two = new Student("黄蓉",16);
//        System.out.println("姓名:"+one.getName()+",年龄:"
//                +one.getAge()+",教室："+one.room+",学号："+one.getId());
//        System.out.println("姓名:"+two.getName()+",年龄:"
//                +two.getAge()+",教室："+two.room+",学号："+two.getId());

        Student.room = "101教室";

        //首先设置一下教室，这是静态的动词，应该通过类名称来调用
        Student one = new Student("郭靖",21);
        System.out.println("one的姓名；"+ one.getName()+",one的年龄："+one.getAge());
        System.out.println("one的教室：" + Student.room);

        Student two = new Student("黄蓉",22);
        System.out.println("two的姓名；"+ two.getName()+",one的年龄："+two.getAge());
        System.out.println("two的教室：" + Student.room);
    }
}

one的姓名；郭靖,one的年龄：21
one的教室：101教室
two的姓名；黄蓉,one的年龄：22
two的教室：101教室

静态方法

一旦使用static修饰成员方法，那么就成了静态方法。静态方法不属于对象，而是属于类的，建议使用类名来调用，而不需要创建类的对象。
定义格式

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

• 静态方法调用注意事项：
  
  • 静态不能访问非静态,也就是普通成员变量或成员方法。反之成员方法可以直接访问类变量或静态方法。
  • 静态方法可以访问类变量(static修饰的成员变量)和静态方法。
    原因：因为内存中是现有静态内容，后有非静态内容。
  • 静态方法当中不能用this。
    原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。
• 调用格式

    //访问类变量
    类名.类变量名;

    //调用静态方法
    类名.静态方法名(参数);

代码：
MyClass.java

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("z这是一个静态方法。");
        //System.out.println(num);静态不能直接访问非静态
        //在内存中现有静态内容，后有非静态内容，先人不知道后人，后人能够知道先人
        //
        System.out.println(numStatic);
    }
}

Demo02StaticMethod

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

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

        //对于静态方法来说，可以通过对象名称调用，也可以通过类名称来调用
        obj.methodStatic();//不推荐，这种写法在编译之后也会被java翻译成为"类名称.静态方法名"
        MyClass.methodStatic();//推荐使用

        //对于本类中的静态方法，可以省略类名称
        myMethod();

    }
    public static  void myMethod() {
        System.out.println("自己的静态方法！");
    }
}

代码实例2：

public class Demo02_2 {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < 5; i++) {
            System.out.println("请输入第"+i+"元素：");
            list.add(sc.next());
        }
        print(list);
    }


    /*
    static修饰的方法是随类加载而加载的，不需要创建对象直接通过类来调用。所以这里的print方法是static的，如果没有static修饰，则在主方法中无法调用。
     */
    public static void print(List<String> list) {
        for (int i = 0; i < list.size(); i++) {
            String temp = list.get(i);
            System.out.println("元素："+temp+"的长度为"+temp.length());
        }
    }
}

附加小笔记

static修饰的内容

• 是随着类的加载而加载的，且只加载一次。
• 存储于一块固定的内存区域(静态区)，所以，可以直接被类名调用。
• 它优先于对象存在，所以可以被所有对象共享，它不能去访问普通成员变量和方法。

静态代码块

静态代码块的格式是：

public class 类名称 {  
    static {
    //静态代码块的内容
    }
}

特点：

• 第一次用到本类时，静态代码块执行第一次。
• 静态内容总是优先于非静态，所以静态代码块总是优先于构造方法先执行。

静态代码块的典型用途：

用来一次性的对静态成员变量进行赋值，Java中的静态代码块是在JVM虚拟机加载类的时候执行，静态代码块只在第一次new执行一次，之后不再执行，而非静态代码块在每new一次就执行一次。如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们。

静态代码块执行顺序：

主调类的静态代码块
对象父类的静态代码块
对象的静态代码块
对象父类的非静态代码块
对象父类的构造函数
对象的非静态代码块
对象的构造函数

实例：
Person.java

public class Person {
    static
    {
        System.out.println("静态代码块");
    }

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

}

Demo04Static.java

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

        Person  p = new Person();
        Person p1 = new Person();
    }
}

静态代码块
构造方法执行
构造方法执行