目录

什么是类变量

类变量的定义语法：

如何访问类变量

类变量内存布局

总结：

类变量的注意事项和使用细节

类方法

类方法基本介绍

类方法使用细节和注意事项

类方法例题

第一题

第二题

第三题

类变量方法重点

理解main方法的语法

什么是类变量

类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

类变量的定义语法：

访问修饰符 static 数据类型 变量名；[推荐]

static 访问修饰符 数据类型 变量名；

如何访问类变量

类名.类变量名 或者 对象名.类变量名 【静态变量的访问修饰符的访问权限和范围 和 普通属性是一样的。】

推荐使用：类名.类变量名；

说明：类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问

代码演示：

package idea.chapter10.static_;

/**
 * 讲解static修饰符的基本使用
 */
public class static01 {
    public static void main(String[] args) {
        //什么是类变量
        //类变量也叫静态变量/静态属性，是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。
        //举例
        //如何演示，当一个属性变成静态属性之后，无论哪个类去访问该属性，访问到的都是同一个对象
        T.age--;//首先我们将age属性--，因为原来是10 ，减完之后就变成了9
        System.out.println(T.age);//因此在这里输出的时候，输出的就是9
        T.age--;//这里我们将age属性又--了，因为我们已经减过一次了所以在减一次 ，减完之后就变成了8
        //这里创建了一个方法，通过方法去访问，就是为了体现，当访问一个静态属性的时候，访问的都是同一个对象
        static01.test();//所以这里输出的时候就是8


        //如何访问类变量
        //类名.类变量名 或者 对象名.类变量名 【静态变量的访问修饰符的访问权限和范围 和 普通属性是一样的。】
        //推荐使用：类名.类变量名；

        //对象名.类变量名
        T t = new T();
        System.out.println(t.age);

        //类名.类变量名
        System.out.println(T.age);

        //也要遵守访问修饰符的权限,我们可以看到两种使用方式都不能访问私有的属性
        //System.out.println(T.name);
        //System.out.println(t.name);


        //说明：类变量是随着类的加载而创建，所以即使没有创建对象实例也可以访问
    }

    public static void test() {
        System.out.println(T.age);
    }
}

class T {
    //类变量的定义语法：
    //首先我们在T类中定义了一个静态属性，和平常定义的属性相比，只多了一个static，只需要使用static修饰符修饰的属性就是静态属性

    //访问修饰符 static 数据类型 变量名；[推荐]
    public static int age = 10;
    //static 访问修饰符 数据类型 变量名；
    static public double sum = 100;

    private static String name = "jack";
}

类变量内存布局

思路分析：

1.我们知道类变量只会加载一次，所以我们这里创建了两个对象的实例，通过对象实例去访问count这个属性，访问到的其实都是同一个对象当然不推荐使用对象实例去访问静态属性

2.static修饰的属性，在类加载的时候就已经完成了

package idea.chapter10.static_;

/**
 * 讲解类变量在内存中的布局
 */
public class static02 {
    public static void main(String[] args) {
        /*
        思路分析：
        1.我们知道类变量只会加载一次，所以我们这里创建了两个对象的实例，通过对象实例去访问count这个属性，访问到的其实都是同一个对象,当然不推荐使用对象实例去访问静态属性
        2.static修饰的属性，在类加载的时候就已经完成了
         */
        Child child1 = new Child("jack");
        Child child2 = new Child("tom");
        child1.join();
        child2.join();
        System.out.println(child1.count);
        System.out.println(child2.count);
    }
}

class Child { //类
    private String name;
    //定义一个变量 count ,是一个类变量(静态变量) 
    //该变量最大的特点就是会被Child 类的所有的对象实例共享
    public static int count = 0;

    public Child(String name) {
        this.name = name;
    }

    public void join() {
        System.out.println(name + " 加入了游戏..");
    }
}

总结：

（1）static变量是同一个类所有对象共享

（2）static类变量，在类加载的时候就已经生成了

类变量的注意事项和使用细节

1.什么时候需要用类变量 当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态变量)：比如：定义学生类，统计所有学生共交多少钱。Student (name, static fee)

2.类变量与实例变量(普通属性)区别 类变量是该类的所有对象共享的，而实例变量是每个对象独享的。

3.加上static称为类变量或静态变量，否则称        为实例变量/普通变量/非静态变量

4.类变量可以通过 类名.类变量名 或者 对象名.类变量名 来访问，但java设计者推荐我们使用 类名.类变量名方式访问。

5.实例变量不能通过 类名.类变量名 方式访问。

6.类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量了。

7.类变量的生命周期是随类的加载开始，随着类消亡而销毁

代码演示：

package idea.chapter10.static_;

/**
 * 演示static修饰符的注意事项和使用细节
 */
@SuppressWarnings({"all"})
public class staticDetail {
    public static void main(String[] args) {

        //2.类变量与实例变量(普通属性)区别 类变量是该类的所有对象共享的，而实例变量是每个对象独享的。
        //如果演示这句话类变量是该类的所有对象共享的看演示
        Student student = new Student();
        Student student1 = new Student();
        //这就是两个不同对象去访问静态属性，访问到的都是同一个，同一块空间
        System.out.println(student1.fee);
        System.out.println(student.fee);


        //4.类变量可以通过 类名.类变量名 或者 对象名.类变量名 来访问，但java设计者推荐我们使用 类名.类变量名方式访问。
        //推荐这种方式
        System.out.println(Student.fee);
        //不推荐这种方式
        //System.out.println(student.fee);

        //5.实例变量不能通过 类名.类变量名 方式访问。
        //我们在A类中有一个实例变量，试试看能不能按照类变量的访问方式去访问实例属性
        //System.out.println(A.age);//这样是错误的，访问实例变量需要创建对象实例

        //6.类变量是在类加载时就初始化了，也就是说，即使你没有创建对象，只要类加载了，就可以使用类变量了。
        //7.类变量的生命周期是随类的加载开始，随着类消亡而销毁

    }
}

//这是一个学生类
class Student {
    //1.什么时候需要用类变量 当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用类变量(静态变量)：比如：定义学生类，统计所有学生共交多少钱。Student (name, static fee)
    //这是学费
    //在实际情况中，一个学校收取学费，肯定是收到同一个账户上的，所以可以该变量设置成static修饰的，这样大家都是同一的交的一个账户上，不容易出错
    public static double fee = 20;

}

class A {
    //3.加上static称为类变量或静态变量，否则称为实例变量/普通变量/非静态变量
    public static double sum = 10;//类变量或静态变量
    public int age = 100;//实例变量/普通变量/非静态变量

}

类方法

类方法基本介绍

类方法也叫静态方法。

形式如下：

访问修饰符 static 数据返回类型 方法名

【推荐】 static 访问修饰符 数据返回类型 方法名

类方法的调用：

 使用方式：类名.类方法名 或者 对象名.类方法名 前提是 满足访问修饰符的访问权限和范围】

 代码演示：

package idea.chapter10.static_;

/**
 * 演示静态方法的基本使用
 */
public class staticMethod01 {
    public static void main(String[] args) {
        //静态方法就不用创建对象实例，可以直接调用
        C.hi();
        C.say();
    }
}

class C {
    //类方法也叫静态方法。
    //形式如下：
    //访问修饰符 static 数据返回类型 方法名
    // static 访问修饰符 数据返回类型 方法名
    //类方法的调用：
    //使用方式：类名.类方法名 或者 对象名.类方法名 前提是 满足访问修饰符的访问权限和范围】

    //这就是一个静态方法，使用static关键字修饰后
    public static void hi() {
        System.out.println("hello , word ");
    }

    //这种写法也是对的
    static public void say() {

    }
}

类方法使用细节和注意事项

1)类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：类方法中无this的参数 普通方法中隐含着this的参数

2)类方法可以通过类名调用，也可以通过对象名调用。

3)普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。

代码演示：

package idea.chapter10.static_;

/**
 * 演示静态方法细节
 */
public class staticMethodDetail {
    public static void main(String[] args) {
        // 类方法使用细节和注意事项
        //1)类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区：类方法中无this的参数普通方法中隐含着this的参数
        //2)类方法可以通过类名调用，也可以通过对象名调用。
        //3)普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。
        T1.hi();//ok
        //非静态方法，不能通过类名调用
        //D.say();, 错误，需要先创建对象，再调用
        new T1().say();//可以
    }
}

class T1 {
    private int n1 = 100;
    private static int n2 = 200;

    public void say() {//非静态方法,普通方法

    }

    //静态方法,类方法
    public static void hi() {
        //类方法中不允许使用和对象有关的关键字，
        //比如this和super。普通方法(成员方法)可以。
        //在静态方法中使用this会报错
        //System.out.println(this.n1);
    }

    //类方法(静态方法)中 只能访问 静态变量 或静态方法
    //静态方法只能访问静态成员.
    public static void hello() {
        System.out.println(n2);
        System.out.println(T1.n2);
        //System.out.println(this.n2);不能使用
        hi();//OK
        //say();//错误 因为say方法不是静态方法
    }

    //普通成员方法，既可以访问  非静态成员，也可以访问静态成员
    //小结: 非静态方法可以访问 静态成员和非静态成员
    public void ok() {
        //非静态成员
        System.out.println(n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();

    }
}

类方法例题

第一题

思路分析：

    因为count是静态属性，所以在调用count方法的时候，因为是后++ 所以会先输出后++ 因此第一次输出的值就是9，注意的是在输出完之后，就自增了，编程了，所以
    我们第二此再去调用方法的时候，输出来的值已经是10了，然后还会在自增一次，变成了11，这时候再去使用this去访问，得到的值就是11

package idea.chapter10.static_;

public class staticExercise01 {
}

class Test {
    static int count = 9;

    public void count() {
        System.out.println("count=" + (count++));
    }

    /*
    思路分析：
    因为count是静态属性，所以在调用count方法的时候，因为是后++ 所以会先输出后++ 因此第一次输出的值就是9，注意的是在输出完之后，就自增了，编程了，所以
    我们第二此再去调用方法的时候，输出来的值已经是10了，然后还会在自增一次，变成了11，这时候再去使用this去访问，得到的值就是11
     */
    public static void main(String args[]) {
        new Test().count(); //9
        new Test().count(); //10
        System.out.println(Test.count);    //11
    }
}

第二题

思路分析：

        第一次去调用方法的时候，此时total是0所以返回的值就是0
        第二次去调用方法的时候，因为先创建了一个Person对象,因此就回去执行Person类中的无参构造器
        所以total就会变成1 id也变成了1 然后在去调用方法的时候，那么返回的total就变成了1，所以最后输出的结果就是1

package idea.chapter10.static_;

public class staticExercise02 {
}

class Person {      private int id;
    private static int total = 0;

    public static int getTotalPerson() {
        //id++;//错误, 注销

        return total;
    }

    public Person() {//构造器
        total++;  //total = 1
        id = total;//id = 1
    }
}

class TestPerson {
    public static void main(String[] args) {
        /*
        思路分析:
        第一次去调用方法的时候，此时total是0所以返回的值就是0
        第二次去调用方法的时候，因为先创建了一个Person对象,因此就回去执行Person类中的无参构造器
        所以total就会变成1 id也变成了1 然后在去调用方法的时候，那么返回的total就变成了1，所以最后输出的结果就是1
         */
        System.out.println( Person.getTotalPerson()); //0
        Person p1 = new Person();
        System.out.println( Person.getTotalPerson()); //1
    }
}

第三题

思路分析：

        1.首先调用了Person类的静态方法，把total的值变成了3，然后new Person1()这句话会导致对象的创建
        就回去执行Person1的无参构造器，在无参构造器中total++，所以total的值就变成了4，又把total的值赋给了id
        所以id的值也是4，在去调用m()方法的是很好 total的值已经变成了4，所以最后输出的结果就是4

package idea.chapter10.static_;

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

        Person1.setTotalPerson(3);
        new Person1(); //最后 total的值就是4
        Person1.m();//看看输出的是不是4
        /*
        思路分析：
        1.首先调用了Person类的静态方法，把total的值变成了3，然后new Person1()这句话会导致对象的创建
        就回去执行Person1的无参构造器，在无参构造器中total++，所以total的值就变成了4，又把total的值赋给了id
        所以id的值也是4，在去调用m()方法的是很好 total的值已经变成了4，所以最后输出的结果就是4
         */
    }
}

class Person1 {
    private int id;
    private static int total = 0;

    public static void setTotalPerson(int total) {
        // this.total = total;//错误，因为在static方法中，不可以使用this 关键字

        Person1.total = total;
    }

    public Person1() {//构造器
        total++;
        id = total;
    }

    //编写一个方法，输出total的值
    public static void m() {
        System.out.println("total的值=" + total);
    }
}

类变量方法重点

普通成员方法，既可以访问  非静态成员，也可以访问静态成员
小结: 非静态方法可以访问 静态成员和非静态成员

类方法(静态方法)中 只能访问 静态变量 或静态方法
技巧:静态方法只能访问静态成员.

类方法中不允许使用和对象有关的关键字
比如this和super。普通方法(成员方法)可以。

理解main方法的语法

解释main方法的形式：public static void main(String[] args)

1.main方法时虚拟机调用

2.java虚拟机需要调用类的main()方法，所以该方法的访问权限必须是public

3.java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static

4.该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数，案例演示，接收参数.

5.java执行的程序 参数1参数2参数3

特别提示：

1)在main()方法中，我们可以直接调用main方法所在类的静态方法或静态属性。

2)但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员，

代码演示：

package idea.chapter10.main_;

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

        //可以直接使用 name
        //1. 静态方法main 可以访问本类的静态成员
        System.out.println("name=" + name);
        hi();
        //2. 静态方法main 不可以访问本类的非静态成员
        //System.out.println("n1=" + n1);//错误
        //cry();
        //3. 静态方法main 要访问本类的非静态成员，需要先创建对象 , 再调用即可
        main01 main01 = new main01();
        System.out.println(main01.n1);//ok
        main01.cry();
    }

    //静态的变量/属性
    private static String name = "jack";
    //非静态的变量/属性
    private int n1 = 10000;

    //静态方法
    public static void hi() {
        System.out.println("Main01的 hi方法");
    }

    //非静态方法
    public void cry() {
        System.out.println("Main01的 cry方法");
    }
}