Java入门------static关键字和静态属性、方法

static关键字：

在定义一个类时，只是描述某事物的特征和行为，并没有产生具体的数据，只有通过new关键字创建该类的实例对象时，才会开辟栈内存及内存，在堆内存中要保存对象的属性时，每个对象会有自己的属性。

如果希望某些属性被所有对象共享，就必须将其声明为static属性，如果属性使用了static关键字进行修饰，则该属性可以直接使用类名称进行调用，static关键字还可以修饰成员方法。

静态属性：

如果在Java程序中使用static修饰属性，则该属性称为静态属性（也称全局属性），静态属性可以使用类名直接访问。

格式如下：

类名.属性名
1

举例：

class student1{
    String name;
    int age;
    String school="A大学";
    public student1(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void info(){
        System.out.println("姓名："+this.name+"年龄："+this.age+"学校："+school);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

public class Example{
    public static void main(String[]args){
        student1 stu1=new student1("张三",10);
        student1 stu2=new student1("李四",20);
        student1 stu3=new student1("王五",18);
        stu1.info();
        stu2.info();
        stu3.info();
        }
        }
1
2
3
4
5
6
7
8
9
10

输出：

姓名：张三年龄：10学校：A大学
姓名：李四年龄：20学校：A大学
姓名：王五年龄：18学校：A大学
1
2
3

上述实例，三名同学均来自A大学。

假设现在A大学需要改名为B大学，那么意味着，学校中所有学生的学校信息都要被修改，这样做显然是很麻烦的。

为了解决这种问题，我们可以使用static关键字修饰school属性，将其变为公共属性，school只会分配一块内存空间，被student类的所有对象共享，只要某个对象进行了一次修改，全部学生对象的school属性值都会发生改变。
修改如下：

 static String school="A大学";
1

stu1.school="B大学";//只修改stu1对象的学校属性
1

输出：

//stu1/stu2/stu3对象的school属性都发生了变化
姓名：张三年龄：10学校：B大学
姓名：李四年龄：20学校：B大学
姓名：王五年龄：18学校：B大学
1
2
3
4

由此，可以得出这样一个结论，static声明的属性是所有对象共享的。
自始至终，school属性的内存空间大小并未有任何改变。

静态方法：

如果想要使用类中的成员方法，就需要先将这个类实例化，而在实际开发时，开发人员有时候希望在不创建对象的情况下，通过类名就可以直接调用某个方法，要实现这样的效果，只需要在成员方法前加上static关键字，使用static关键字修饰的方法通常称为静态方法。

同静态变量一样，静态方法也可以通过类名和对象访问。

类名.方法/实例对象名.方法
1

静态方法的使用：

举例：

class Example{
    public static void main(String[]args){
        student1 stu1=new student1("张三",18);
        student1 stu2=new student1("jason",19);
        student1 stu3=new student1("小明",20);
        stu1.setAge(20);//最终将实例stu1的年龄属性替换成20
        stu2.setName("小红");//最终将实例stu2的名字属性替换成"小红”
        //将所有实例的学校属性替换成B大学，由于它是使用static声明的，所以可以直接使用类名进行调用
        student1.setSchool("B大学");
        stu1.info();
        stu2.info();
        stu3.info();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

class student1{
    private String name;
    private int age;
    private static String school="A大学";
    public student1(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void info(){
        System.out.println("姓名："+this.name+",年龄："+this.age+",学校："+school);
    }
    //将student1类的所有属性进行封装，要想更改属性就必须使用setter方法
    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 String getSchool(){
        return school;
    }
    public static void setSchool(String school){
        student1.school=school;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

输出：

姓名：张三,年龄：20,学校：B大学
姓名：小红,年龄：19,学校：B大学
姓名：小明,年龄：20,学校：B大学
1
2
3

静态方法只能访问静态成员，因为非静态成员需要创建对象才能访问，即随着对象的创建，非静态成员才会分配内存，而静态方法在被调用时可以不创建任何对象。

静态代码块：

在Java类中，用static关键字修饰的代码块称为静态代码块，当被类加载时，静态代码块会执行，由于类只加载一次，因为静态代码块只执行一次，在程序中，通常使用静态代码块对类的成员变量进行初始化。

举例：

class Example{
    public static void main(String[]args){
        student1 stu1=new student1();
        student1 stu2=new student1();
        student1 stu3=new student1();
    }
}
1
2
3
4
5
6
7

class student1{
    String name;
    //构造代码块
    {
        System.out.println("我是构造代码块");
    }
    //静态代码块
    static{
        System.out.println("我是静态代码块");
    }
    //构造方法
    public student1(){
        System.out.println("我是student1类的构造方法");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出：

我是静态代码块
我是构造代码块
我是student1类的构造方法
我是构造代码块
我是student1类的构造方法
我是构造代码块
我是student1类的构造方法
1
2
3
4
5
6
7

从输出结果，我们不难看出，代码块的执行顺序为静态代码块—>构造代码块----->构造方法。

static修饰的量会随着class文件一同加载，属于优先级最高的

上述实例中，虽然我们创建了三个实例化对象，但是静态代码块中的内容只被执行了依次且是第一次被执行，这就说明静态代码块在类第一次使用时才会被加载，并且只会加载一次。