静态Static关键字

1.静态关键子修饰成员变量。

 

首先用一个图解述一下Static的作用。

 

 

然后用一个事例实现一下。

 

package 静态关键字;

/**
 * @Author: Jason
 * @Date: 2019/7/3 20:32
 * @Version 1.0
 */
public class Student {
    private int id;
    private String name;
    private int age;
    private static int idCount;
    static String room;

    public int getId() {
        return id;
    }

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

    public Student() {
        idCount++;

    }

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

    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 静态关键字;

/**
 * @Author: Jason
 * @Date: 2019/7/3 20:35
 * @Version 1.0
 */
public class DemoStatic {
    public static void main(String[] args) {
        //一个成员变量使用了static关键子后，这个变量就属于类了，不属于它自己了。


        Student student1 = new Student("杨过", 13);
        student1.room = "102";

        System.out.println("姓名：" + student1.getName() + "年龄：" + student1.getAge()
                + "教室：" + student1.room + "学号是：" + student1.getId());


        Student student2 = new Student("小龙女", 18);
        System.out.println("姓名：" + student2.getName() + "年龄：" + student2.getAge()
                + "教室：" + student2.room + "学号是：" + student2.getId());
    }
}

运行结果：

姓名：杨过年龄：13教室：102学号是：1
姓名：小龙女年龄：18教室：102学号是：2

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

一旦使用static修饰成员方法，这就成为了静态方法，静态方法不属于对象，而是属于类的

如果方法没有static关键字，那么必须首先创建对象，然后才能通过对象使用它。

 

无论是成员变量，还是成员方法，一旦使用static关键字， 都推用类名称调用。

 

静态变量：类名称.静态变量

静态方法：类名称.静态方法

package 静态关键字;

/**
 * @Author: Jason
 * @Date: 2019/7/7 19:07
 * @Version 1.0
 */
    //一旦使用static修饰成员方法，这就成为了静态方法，静态方法不属于对象，而是属于类的
    //如果方法没有static关键字，那么必须首先创建对象，然后才能通过对象使用它。

    //无论是成员变量，还是成员方法，一旦使用static关键字， 都推用类名称调用。

    //静态变量：类名称.静态变量
    //静态方法：类名称.静态方法()

public class DemoMethodStatic {
    public static void main(String[] args) {
        MyClass obj = new MyClass();     //首先创建一个对象
                                         //然后才能使用没有static关键字的内容
       obj.method();
       //对于静态方法来说，可以通过对象名来调用，也可以通过类名来调用。
        //推荐用类名进行调用 这样好做区分
        obj.methodStatic(); //不推荐 这种写法 在编译之后也会被javac翻译成 “类名称.静态方法名”。
        MyClass.methodStatic(); //推荐


        myMethod();
    }
                //对于本类当中的静态方法，调用时可以省略类名称
    public static void myMethod(){
        System.out.println("我自己的方法！");
    }
}

 

package 静态关键字;

/**
 * @Author: Jason
 * @Date: 2019/7/7 19:03
 * @Version 1.0
 */
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(numStatic);
        //静态方法不能直接访问非静态【重点】
        //   System.out.println(num);   错误写法

    }
}

 

【注意事项】

1.静态不能直接访问非静态，

原因：在内存当中【先】有的静态内容，【后】有的非静态内容。

正所谓 “ 先人不知道后人，但后人知道先人”。

2.静态方法中不能用this。

原因：this代表当前对象，通过谁调用的方法，谁就是当前对象。

在静态方法中只是 通过类名称调用的。

 System.out.println(this); //错误的写法

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


        Student.room = "324教室";
        Student one = new Student("阿牛,", 12);
        System.out.println("one的姓名是：" + one.getName() 
              + "年龄是："+ one.getAge() 
              + "教室是：" + Student.room);
              
        Student two = new Student("阿酷,", 23);
        System.out.println("two的姓名是：" + two.getName() 
              + "年龄是："+ two.getAge() 
              + "教室是：" + Student.room);
    }
}

 

内存图：

 

3.静态代码块格式：

public class 类名称{

static {

//静态代码块的内容

}

}

特点：当第一次用到本类时，静态代码块执行唯一的一次。

静态内容总是优先于非静态，所以静态代码块比构造方法优先执行。

静态代码块的典型用途：

用来一次性地对静态成员变量进行赋值。

静态代码块的典型用途

package 静态关键字;

/**
 * @Author: Jason
 * @Date: 2019/7/7 22:35
 * @Version 1.0
 */


public class Person {
    static {
        System.out.println("静态方法块！");
    }
    public Person(){
        System.out.println("构造方法！");
    }
}

package 静态关键字;

/**
 * @Author: Jason
 * @Date: 2019/7/7 22:36
 * @Version 1.0
 */
public class Demo04Static {
    public static void main(String[] args) {
        Person one = new Person();
        Person two = new Person();
    }
}

结果：

静态方法块！
构造方法！
构造方法！