static修饰

static修饰

static作为常用的修饰符，修饰的字段和方法会有什么不同呢？

文章目录

• 系列文章目录
• 一、static修饰的成员变量
• 二、static修饰的成员方法
• 总结

一、static修饰的成员变量

1.定义

a、static修饰的变量称为静态成员变量，为所有的对象所共有的。

b、静态成员变量存放在方法区。

c、静态成员变量是类的属性，在JVM加载类的时候开辟空间和初始化。

因此，即使你没有实例化一个类，仍然是可以通过类名调用静态成员变量的。

如图：

class Student{
    private String name;
    private int age;
    
    public static String classes ="102";
    
}
public class Text {
    public static void main(String[] args) {
        System.out.println(Person.classes);

    }
}

2、调用

对于静态成员变量，可以采用多种方式，进行调用。

a.通过类名直接调用（代码规范）

b.通过实例化对象，xxx.xxx

c.通过类内部的接口

public class test_Fz {
    public static void main(String[] args) {
        Person peo = new Person();//如果有一个Person类
        System.out.println(peo.classes);//1
        System.out.println(Person.classes);//2
       

    }
}

3.注意

a.静态变量不可以在非静态方法中创建（语法）。

二、static修饰的成员方法

1.在静态方法中调用非静态成员变量。 

public class Test {
    int testA = 10;
    public static void function(){
        Test test = new Test();
        System.out.println(test.testA);
    }
}

2.static不可以修饰构造方法。（语法错误）

        

3.如果在继承中，父类方法被static修饰，子类不能重写。

代码如下（示例）：

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

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public static void eat(){
        System.out.println("eating");
    } 

}
class Child extends Person {
    public String infantName;
    public Child(String name, int age) {
        super(name, age);
    }
    
    public void eat() {//error
        System.out.println("eating");
    }
}

此时，代码存在语法错误。

思考

如果将Child的方法也使用static修饰，你会发现这时编译器不会报错了。

如图

public static void eat() {
        System.out.println("eating");
    }

但是，这样一来，与非静态方法重写又什么区别呢？

看👇图代码

class Person {
    public static void eat(){
        System.out.println("Person eating");
    }
}
class Child extends Person {
    public static void eat() {
        System.out.println("Child eating");
    }
}
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        Person person1 = new Child();
        Child child = new Child();
        person.eat();
        person1.eat();
        child.eat();
    }
}

如上代码运行后，输出结果依次为：Person eating 

                                                         Person eating 

                                                         Child eating 

由此，可以发现，Person person1 = new Child();person1对eat的引用，并没有发生多态，所以静态方法在编译期间，是进行静态绑定的。