黑马程序员技术交流社区

标题: 【西安校区】java中的static关键字 [打印本页]

---

作者: 逆风TO    时间: 2019-8-22 10:51
标题: 【西安校区】java中的static关键字
java中的static关键字
1. 概述
假设有一个学生类，它的数据成员有姓名、年龄、学号、教室，对于在同一个班的同学来讲，每个同学的姓名、年龄、学号或许都是不一样的，但是教室肯定是一样的，如果有40个同学，我有必要把40个同学的教室名都设置一遍吗？没必要，教室名是40个同学共享的一个属性，它不同于名字、学号这些，当我们给教室这个变量前面加上static后，它就是一个共享的属性了，我们只需把共享的属性设置一遍，所有的对象就会共享到这一设置。

public class Student{
    private String name;  //名字
    private int age;      //年龄
    private int ID;       //学号
    private static String Room; //加上static关键字，变成共享的一个属性
}

2. 静态static关键字修饰成员时
如果一个成员变量使用了static关键字，那么这个变量不再属于对象自己，而是属于这个类。多个对象共享同一份数据

2.1 用代码演示一遍
先创建一个学生类
public class Student {
        //姓名
        private String name;
       
        //年龄
        private int age;
       
        //学号
        private int ID;
       
        //教室，我没加private关键字，是想可以直接通过Student类来修改它
        static String room;

        //生成无参构造和有参构造
        public Student() {
        }

        public Student(String name, int age, int iD) {
                this.name = name;
                this.age = age;
                this.ID = iD;
        }

        //生成各成员的setter和getter
        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 int getID() {
                return ID;
        }

        public void setID(int iD) {
                ID = iD;
        }

    public static String getRoom() {
                return room;
        }

        public static void setRoom(String room) {
                Student.room = room;
        }
}

在main中创建对象，并打印个人信息
public class staticField {

        public static void main(String[] args) {
                //先设置一下大家的教室，我们说静态成员是属于类的，所以可以直接通过(类名称.成员变量)设置教室
                Student.room = "通信1班";
               
                //新建一个学生对象小明，20岁，学号1号
                Student one = new Student("小明", 20, 1);
               
                //再新建一个学生对象小红，21岁，学号2号
                Student two = new Student("小红", 21, 2);
               
                //将小明和小红的个人信息打印一遍，顺便看看他们的教室是不是都一样
                System.out.println("学生名字：" + one.getName() + "," + "年龄：" + one.getAge() + ","  + "学号：" + one.getID() + "," + "教室：" + Student.room);
               
                System.out.println("学生名字：" + two.getName() + "," + "年龄：" + two.getAge() + "," + "学号：" + two.getID() + "," + "教室：" + Student.room);
       
           
        //在这里，我们当然也可以通过对象的方法来修改教室
        //但是，以对象的方式修改，在eclipse会有警告：类型Student中的静态方法应该以静态方式访问
        one.setRoom("通信2班");
                System.out.println(one.getRoom());
    }
}

/*输出结果：
    学生名字：小明,年龄：20,学号：1,教室：通信1班
    学生名字：小红,年龄：21,学号：2,教室：通信1班
    通信2班
*/

3. static关键字修饰方法成员时
一旦使用static修饰成员方法，那么就成为了静态方法。静态方法不属于对象，而是属于类

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

3.1 static修饰方法（代码演示）
先创建一个MyClass类，然后在里面添加一个静态方法和非静态方法
public class MyClass {
    public void method(){
        System.out.println("这是一个普通成员方法");
    }

    public static void methodStatic(){
        System.out.println("这是一个静态成员方法");
    }
}

在main中进行调用
public class staticMain {
    public static void main(String[] args) {
        //首先创建对象
        MyClass obj = new MyClass();
        //然后才能使用没有static关键字的内容
        obj.method();

        //对于静态方法来说，可以通过对象名来进行调用，也可以直接通过类名称来调用
        obj.methodStatic();  //正确，不推荐，会让人误以为它是一个普通的成员方法，这种写法在编译之                                                          后而会被javac翻译成（类名称.方法）
        MyClass.methodStatic(); //正确，推荐，既然它是静态的方法，就用它特有的（类名称.方法）来                                                                进行调用

        //对于本类当中的静态方法，可以省略类名称，当然也可以不省
        myMethod();    //在编译时，也会被翻译成staticMain.myMethod();
        staticMain.myMethod();  //与上面的写法，完全等效
    }

    public static void myMethod(){
        System.out.println("本类当中的静态方法");
    }
}

/*输出结果：
    这是一个普通成员方法
    这是一个静态成员方法
    这是一个静态成员方法
    本类当中的静态方法
    本类当中的静态方法
*/

小总结
无论是静态成员变量，还是静态成员方法，如果有了static，都推荐使用类名称来进行调用，格式如下：
静态变量：类名称.变量名
静态方法：类名称.方法名
3.2 注意事项
第一：静态方法不能访问非静态变量

原因：因为在内存当中，是先有静态的内容，后有非静态的内容，“先人不知道后人，而后人知道先人”

示例：比如在以下代码中, 静态方法methodStatic不能打印出普通成员变量num

public class MyClass {
    int num = 5; //普通成员变量
    static int staticNum = 6;  //静态成员变量

    public void method(){
        System.out.println("这是一个普通成员方法");
        System.out.println(num);  //可以
        System.out.println(staticNum);  //可以
    }

    public static void methodStatic(){
        System.out.println("这是一个静态成员方法");
        System.out.println(staticNum); //可以
        System.out.println(num);  //报错，不可以访问普通成员变量num
    }
}

第二：静态方法中不能有this

原因：this代表当前对象，可静态跟对象没关系，只跟类有关系

示例：在下面的代码中，根本无法打印this的内容

public class MyClass {

    public static void methodStatic(){
        System.out.println("这是一个静态成员方法");
        //静态方法不能使用this
        System.out.println(this);  //错误写法
    }
}

4. 静态代码块（了解）
4.1 静态代码块的格式
public class 类名称{
    static{
        //静态代码块的内容
    }
}

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

4.3 代码说明
先创建一个person类，并在里面写一个static代码块和无参构造函数
public class person {
    //静态代码块
    static{
        System.out.println("静态代码快执行");
    }

    //无参构造函数
    public person(){
        System.out.println("构造函数执行");
    }
}

在main中使用person的构造函数
public class Demo03staticBlock {
    public static void main(String[] args) {
        //第一次使用person类，构造函数被执行，同时，静态代码块在这里会悄悄地执行唯一的一次
        person one = new person();
        //第二次使用到person类，构造函数被执行，静态代码块不知执行
        person two = new person();
    }
}

/*输出结果：
    静态代码快执行
    构造函数执行
    构造函数执行
*/

4.4 静态代码块的用途
静态代码块通常用于在类刚开始被使用时，对某些变量进行批量的赋值，在一些特定的工程中也具有重要的作用，在这里先做简单的了解。

---

欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2