static关键字

1.1 概述

引入：
        我们之前定义了很多成员变量（name , age , sex）
        其实我们只写了一份，但是发现每个对象都可以用，就说明
        Java中这些成员变量或者方法是存在所属性的。
        有些是属于对象的，有些是属于类本身的。

    Java是通过成员变量是否有static修饰来区分是类的还是属于对象的。

    static == 静态 == 修饰的成员（方法和成员变量）属于类本身的。

    按照有无static修饰，成员变量和方法可以分为：
        成员变量：
            （1）静态成员变量（类变量）：
                    有static修饰的成员变量称为静态成员变量也叫类变量，属于类本身的，
                     直接用类名访问即可。

            （2）实例成员变量
                    无static修饰的成员变量称为实例成员变量，属于类的每个对象的，
                    必须用类的对象来访问。

        成员方法：
            （1）静态方法
                    有static修饰的成员方法称为静态方法也叫类方法，属于类本身的，
                    直接用类名访问即可。

            （2）实例方法
                    无static修饰的成员方法称为实例方法，
                    属于类的每个对象的，必须用类的对象来访问。

以前我们定义过如下类：

public class Student {
    // 成员变量
    public String name;
    public char sex; // '男'  '女'
    public int age;

    // 无参数构造器
    public Student() {

    }
    
    // 有参数构造器
    public Student(String  a) {

    }
}

我们已经知道面向对象中，存在类和对象的概念，我们在类中定义了一些成员变量，例如name,age,sex ,结果发现这些成员变量，每个对象都存在（因为每个对象都可以访问）。

而像name ,age , sex确实是每个学生对象都应该有的属性，应该属于每个对象。

所以Java中成员（变量和方法）等是存在所属性的，Java是通过static关键字来区分的。static关键字在Java开发非常的重要，对于理解面向对象非常关键。

关于 static 关键字的使用，它可以用来修饰的成员变量和成员方法，被static修饰的成员是属于类的是放在静态区中，没有static修饰的成员变量和方法则是属于对象的。我们上面案例中的成员变量都是没有static修饰的，所以属于每个对象。

1.2 定义格式和使用

static是静态的意思。 static可以修饰成员变量或者修饰方法。

1.2.1 静态变量及其访问

有static修饰成员变量，说明这个成员变量是属于类的，这个成员变量称为类变量或者静态成员变量。 直接用 类名访问即可。因为类只有一个，所以静态成员变量在内存区域中也只存在一份。所有的对象都可以共享这个变量。

如何使用呢

例如现在我们需要定义传智全部的学生类，那么这些学生类的对象的学校属性应该都是“传智”，这个时候我们可以把这个属性定义成static修饰的静态成员变量。

定义格式

修饰符 static 数据类型 变量名 = 初始值； 

举例

public class Student {
    public static String schoolName = "程序员"； // 属于类，只有一份。
    // .....
}

静态成员变量的访问:

格式：类名.静态变量

public static void  main(String[] args){
    System.out.println(Student.schoolName); // 程序员
    Student.schoolName = "java";
    System.out.println(Student.schoolName); // java
}

1.2.2 实例变量及其访问

无static修饰的成员变量属于每个对象的， 这个成员变量叫实例变量，之前我们写成员变量就是实例成员变量。

需要注意的是：实例成员变量属于每个对象，必须创建类的对象才可以访问。

格式：对象.实例成员变量

1.2.3 静态方法及其访问

有static修饰成员方法，说明这个成员方法是属于类的，这个成员方法称为类方法或者静态方法**。 直接用 类名访问即可。因为类只有一个，所以静态方法在内存区域中也只存在一份。所有的对象都可以共享这个方法。

与静态成员变量一样，静态方法也是直接通过类名.方法名称即可访问。

举例

public class Student{
    public static String schoolName = "程序员"； // 属于类，只有一份。
    // .....
    public static void study(){
    	System.out.println("java");   
    }
}

静态成员变量的访问:

格式：类名.静态方法

public static void  main(String[] args){
    Student.study();
}

1.2.4 实例方法及其访问

无static修饰的成员方法属于每个对象的， 这个成员方法叫实例方法。

需要注意的是：实例方法是属于每个对象，必须创建类的对象才可以访问。

格式：对象.实例方法

示例：

public class Student {
    // 实例变量
    private String name ;
    // 2.方法：行为
    // 无 static修饰，实例方法。属于每个对象，必须创建对象调用
    public void run(){
        System.out.println("学生可以跑步");
    }
	// 无 static修饰，实例方法
    public  void sleep(){
        System.out.println("学生睡觉");
    }
    public static void study(){
        
    }
}

public static void main(String[] args){
    // 创建对象 
    Student stu = new Student ;
    stu.name = "王";
    // Student.sleep();// 报错，必须用对象访问。
    stu.sleep();
    stu.run();
}

1.3 小结

小结：
        成员变量有2种
             -- 有static修饰的属于类叫静态成员变量，与类一起加载一次，直接用类名调用即可。
             -- 无static修饰的属于类的每个对象的叫实例成员变量，
                与类的对象一起加载，对象有多少个，实例成员变量就加载多少份。必须用类的对象调用。

        成员方法有2种：
             -- 有static修饰的属于类叫静态方法，直接用类名调用即可。
             -- 无static修饰的属于类的每个对象的叫实例方法，必须用类的对象调用。

成员变量的分类和访问

目标：成员变量的分类和访问语法研究。

    成员变量按照有无static修饰分为：静态成员变量，实例成员变量。
         -- 静态成员变量：有static修饰，属于类，与类一起加载，只有一份，直接用类名访问即可。
         -- 实例成员变量：无static修饰，属于类的每个对象的，与类的对象一起加载，对象有几个
            实例成员变量就有几个，必须用类的对象来访问。

    静态成员变量的访问格式：
         -- 类名.静态成员变量。
         -- 对象.静态成员变量。(不建议的)

    实例成员变量的访问格式：
         -- 对象.实例成员变量。

    小结：
        静态成员变量只有一份，属于类，所以被类和类的全部对象共享访问。
        注意：面试中如果发现有用对象访问静态成员变量，可以直接改成用类名访问再解答。

        实例成员变量属于类的每个对象的，必须先创建对象，然后用对象访问。
    public class Student {
    // 实例成员变量 :无static修饰，属于类的每个对象的,必须用类的对象来访问。
    private String name ;
    private int age ;
    // 静态成员变量：有static修饰，属于类，与类一起加载，只有一份，直接用类名访问即可。
    public static String schoolName = "程序";

    public static void main(String[] args) {
        // 1.静态成员变量： 类名.静态成员变量。
        System.out.println(Student.schoolName);
        // 注意：同一个类中访问静态成员变量可以省略类名不写
        System.out.println(schoolName);

        // 2.实例成员变量 ：对象.实例成员变量。
        // System.out.println(name); // 报错了
        Student zzj = new Student();
        zzj.name = "猪八戒";
        System.out.println(zzj.name);
        System.out.println(zzj.age);


        // 3.静态成员变量：对象.静态成员变量。(不建议的)
        System.out.println(zzj.schoolName);
    }
}

成员方法的分类和访问

目标：成员方法的分类和访问。

    成员方法分为2种：
        -- 静态方法：有static修饰，属于类，直接用类调用即可。可以被类和对象共享。
        -- 实例方法：无static修饰，属于类的每个对象的，必须先创建对象，再调用。

    静态方法的访问格式：
        -- 类名.静态方法。
        -- 对象.静态方法。（不推荐）

    实例方法的访问格式：
        -- 对象.实例方法。

    小结：
        静态方法，属于类，可以被类和对象共享访问。
        实例方法，属于对象的，必须创建对象来访问，否则报错！
        public class Student {
    // 实例成员变量
    private String name ;
    private int age ;

    public static void go(){
        System.out.println("跑的贼快~~~");
    }

    // 1.实例方法:无static修饰，属于类的对象的。
    public void run(){
        System.out.println(this.name+"-->"+this.age+"岁：跑的贼快~~~");
    }

    // 2.静态方法：有static修饰，属于类，直接用类调用即可
    public static void inAddr(){
        System.out.println("我们都在中国！！");
    }

    public static void main(String[] args) {
        // 1.静态方法：类名.静态方法
        Student.inAddr();
        // 注意：同一个类中静态方法的调用可以省略类名不写。
        inAddr();

        // 2.实例方法：对象.实例方法
        // run(); // 报错了！
        Student ss = new Student();
        ss.name = "娜娜";
        ss.age = 1000 ;
        ss.run();

        // 3.静态方法：对象.静态方法（不推荐）
        ss.inAddr();
    }
}

面试扩展题

 -------------------------面试问答题的拓展，代码语法内容-----------------------------------
            实例方法是否可以直接访问实例变量? 可以的,实例方法和实例变量都属于同一个对象。
            实例方法是否可以直接访问静态变量？可以的,静态变量只有一份，可以被共享。
            实例方法是否可以直接访问实例方法？可以的，实例方法都是属于同一个对象。
            实例方法是否可以直接访问静态方法？可以的，静态方法可以被共享访问。

            静态方法是否可以直接访问实例变量? 不可以的，实例成员变量必须用对象访问。
            静态方法是否可以直接访问静态变量？可以的，静态变量可以被共享。
            静态方法是否可以直接访问实例方法？不可以的，实例方法必须用对象访问。
            静态方法是否可以直接访问静态方法？ 可以的，静态方法可以被共享访问
        ----------------------------------------------------------------------------------------