【Java基础】10章、面向对象编程【高级】关键字static的使用、类变量、类方法的使用技巧和使用细节、main方法的执行流程【1】

❤️本章节内容比较丰富，分阶段进行记录，本篇文章包含内容：类变量和类方法
✅学完本篇内容，你将会对类加载有一个清晰的认知，同时可以掌握static的运行机制，包含什么时期执行，执行几次

本篇文章包含：

• ✅类变量和类方法
• ✅理解main方法语法

---

1、类变量和类方法

1.1、类变量

1.1.1、引出

• 传统方法解决：
  定义一个变量count进行计数，如果来了一个小朋友(new一个实例)就让count进行+1操作
  
  代码演示

package com.fhsedu.static_;

public class ChildGame {
    public static void main(String[] args) {
        int count = 0;
        Child child1 = new Child("开心超人");
        child1.play();
        count++;
        Child child2 = new Child("粗心超人");
        child1.play();
        count++;
        Child child3 = new Child("小小怪");
        child1.play();
        count++;
        System.out.println(count);
    }
}
class Child {
    private String name;

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

    public void play() {
        System.out.println(name + "参加了比赛");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

如果我们想要取count怎么取呢？很麻烦，因为没有用到OOP类型

• 改进
  如果在Child类中有一个变量，并且这个变量在所有初始化的对象中可以共享，这样岂不是很方便解决这个问题，也保证了面向对象的封装性
  
  代码演示：

package com.fhsedu.static_;

public class ChildGame {
    public static void main(String[] args) {      
        Child child1 = new Child("开心超人");
        child1.play();
        child1.count++;
        
        Child child2 = new Child("粗心超人");
        child2.play();
        child2.count++;
        
        Child child3 = new Child("小小怪");
        child2.play();
        child2.count++;

        System.out.println("共有" + Child.count + "小孩加入了游戏");//Child.count = 3

        //下面的代码输出什么？
        System.out.println("child1.count=" + child1.count);//3
        System.out.println("child2.count=" + child2.count);//3
        System.out.println("child3.count=" + child3.count);//3
    }
}
class Child {
    private String name;
    //定义一个变量count，是一个类变量(静态变量)static 静态
    //该变量最大的特点就是会被Child 类的所有实例所引用
    public static int count = 0;
    
    public Child(String name) {
        this.name = name;
    }

    public void play() {
        System.out.println(name + "参加了比赛");
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

1.1.2、类变量内存布局

类变量是在堆中开辟了一个空间存放静态变量，所有的实例对象都可以共享

（记住：静态变量可以共用）

1.1.3、类变量

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

代码演示：调用静态属性

package com.fhsedu.static_;

public class VisitStatic {
    public static void main(String[] args) {
        //类命.类变量名
        //说明：类变量是随着类的加载而创建的，所以即使没有创建实例对象也可以访问
        System.out.println(A.name);
        A a = new A();
        //通过对象名.类变量名
        System.out.println("a.name=" + a.name);
    }
}
class A{
    public static String name = "Debug 熊猫";

}

1.2、类变量细节Detail

private int number
number就是普通属性/普通成员变量/非静态属性/非静态成员变量//实例变量

(满足访问权限)

---

• tips:这里使用类名.变量时不调用构造器

---

只要使用类，类就加载

• 只要类没有消亡，静态变量就一直存在

1.3、类方法

静态方法可以访问静态属性

并且使用的都是同一个变量，在一个类中修改所有类生效
判断下列方式使用对不对？

package com.fhsedu.static_;

public class StaticMethod {

    public static void main(String[] args) {
        //创建2个学生对象，交学费
        Stu jack = new Stu("jack");
        jack.payFee(100);
        //        Stu.payFee(100);//对不对？对

        Stu smith = new Stu("smith");
        smith.payFee(200);
        //输出当前收到的总学费
        Stu.showFee();//300.0

    }
}

class Stu {
    private String  name;//普通成员
    //定义一个静态变量，求累计学生的学费
    public static double fee;//静态属性

    public Stu(String name) {
        this.name = name;
    }
    //说明
    //1、当方法使用了static修饰后，该方法就是静态方法
    //2、静态方法就可以访问静态属性/变量
    public static void payFee(double fee) {
        Stu.fee += fee;//累计到
    }
    public static void showFee( ){
        System.out.println("StuFee" + Stu.fee);
    }
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

1.3.1、使用场景

可作为工具类使用

package com.fhsedu.static_;

public class StaticMethod {
    public static void main(String[] args) {
        //如果我们希望不创建实例，也可以调用某个方法（即当作工具来使用）
        //这时，把方法做成静态方法时非常合适
        System.out.println("9的开平方：" + Math.sqrt(9));

        System.out.println(MyTools.calSum(10,20));
    }
}
//开发自己的工具类时，可以将方法做成静态的，方便调用
class MyTools {
    //求出两个数的和
    public static double calSum(double n1,double n2) {
        return n1 + n2;
    }
}

1.4、类方法细节Detail

• 静态方法不能使用this 和 super

口诀：静态方法只能访问静态成员

演示代码：静态方法只能访问静态成员

package com.fhsedu.static_;

public class StaticMethodDetail_ {

}
class D {
    private  int n1 = 100;
    private static int n2 = 200;
    public void say() {

    }
    public static void hi() {
//        System.out.println(this.h1); //报错，不能使用this 和 super
//        say();
    }
    //类方法(静态方法)中 只能访问静态变量和静态方法
    //小结：静态方法只能访问静态成员。
    public static void hello () {
        System.out.println(n2);//200
        System.out.println(D.n2);//200
//        System.out.println(this.n2);//报错，不能使用this和super关键字
        hi();//OK
//        say();//错误
    }

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

    }
}

---

1.4.1、案例讲解

1.4.1.1、第一题

普通方法中可以访问静态属性，调用静态属性时，静态属性被初始化 这时为 9
2、执行下面代码先输出在自增I++特性 此时输出 9 但是count的值：10

3、再次执行这句话：输出10 此时count：11
4、最后输出静态变量的值：11

代码检验：

package com.fhsedu.static_;

public class StaticExercise01 {

}
class Test {
     static int count = 9;

     public void count() {
         System.out.println("count = " + (count++));//先进行输出，在自增长
     }

    public static void main(String[] args) {
        new Test().count();//9
        new Test().count();//10
        System.out.println(Test.count);//11
    }
}

1.4.1.2、查看代码是否有错误

没注意：静态方法中不能使用非静态对象

1.4.1.3、查看代码是否有误

答案是：4

this不对，不能使用this、super

---

• 小结：记住两句话(1)静态方法，只能访问静态成员 (2)非静态方法，可以访问所有的成员。(3)在编写代码时，仍然要遵守权限规则

2、理解main方法语法

2.1、介绍

+ main方法是java虚拟机在调用的（面试可能会问）

了解底层机制

使用sublime软件编写java代码，进行编译javac Hello.java文件–>Hello.class字节码文件
运行字节码文件时加上参数 ： java Hello jack lucy tom

• 特别提示

代码演示

package com.fhsedu.main_;

public class Main01 {
    //静态的变量
    private  static String name = "fhs学教育";
    //非静态的变量/属性
    private int n1 = 10000;

    //静态方法
    public static void hi() {
        System.out.println("Main01的 hi方法");
    }
    //非静态方法
    public void cry() {
        System.out.println("Main01的 cry方法");
    }
 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);
     main01.cry();
 }
}

3、Idea如何传参

• 命令行中

• idea中：

结果：

---

（文章中部分图片素材取自于网络）