【Java】:类变量、类方法(static在类中的用法)及main函数细节

前言

经过一个多月的学习,终于进入了学习Java的第二阶段,本篇博客主要介绍Java面向对象高级部分中 类变量、类方法 的使用,以及 main函数语法 剖析,主要设计 static关键字 在类中的使用。

很有意思的一句话, 一个数如果没有前面的1,后面跟再多的0也是没有意义,我们应该继续努力,把1的位置往前挪 !

目录

类变量

类变量的定义

访问修饰符 static 数据类型 变量名;//推荐使用
static 访问修饰符 数据类型 变量名;//也可以

在定义时也可以赋予初始值!

什么是类变量

用static关键字修饰的成员变量即类变量,也叫 静态变量/静态属性,是该类的所有对象共享的变量 ,任何一个该类的对象去访问它时,取到的都是相同的值,同样任何一个该类的对象去修改它的值,修改的也是同一个变量。而 static变量在类加载时就生成了 ,下面以ChildGame类来演示类变量的使用并分析类变量在内存中的布局:

package com.lww.study_static_;

public class ChildGame {

    public static void main(String[] args) {

        //定义一个变量count,统计有多少个小孩加入了游戏
        //int count = 0;

        //注释快捷键,多行注释(每行都要) ctrl + /
        //注释快捷键,多行注释(首尾行) ctrl + shift + /

        Child child1 = new Child("白骨精");
        child1.join();
        //count++;
        child1.count++;

        Child child2 = new Child("狐狸精");
        child2.join();
        //count++;
        child2.count++;

        Child child3 = new Child("老鼠精");
        child3.join();
        //count++;
        child3.count++;

        //游戏结束
        //System.out.println("共有" + count + "小孩加入了游戏");
        //类变量可以通过类名访问
        System.out.println("共有" + Child.count + "小孩加入了游戏");
        //下面的代码输出结果相同
        System.out.println("child1.count = " + child1.count);
        System.out.println("child2.count = " + child2.count);
        System.out.println("child3.count = " + child3.count);
    }
}

class Child{
    private String name;

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

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

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

经过上面的代码测试,我们发现同一个类定义的不同对象,所访问到的static修饰的成员变量均是同一个,下面给出它在内存中的布局:

【Java】:类变量、类方法(static在类中的用法)及main函数细节_第1张图片

有些书上说static修饰的count变量是在方法区中的静态域,而这里提供的是存在于堆区上,这里不做过多分析,感兴趣的可以自己找找网上的文章。不管是哪一种布局,这里主要想说明的点是, 类变量在类加载时就产生了,该类的每一个实例对象都使用的是同一个类变量!

如何访问类变量

类名.类变量名//推荐使用!
对象名.类变量名

静态变量的访问修饰符的访问权限范围和普通成员变量是一样(遵循的访问规则一样)!

类变量的细节总结

  1. 什么时候需要使用类变量:当我们需要让某个类的所有对象都共享一个变量时,就可以考虑使用类变量(静态变量)
  2. 类变量与实例变量(普通属性)的区别: 类变量是该类的所有对象共享的,而实例变量是每个对象独享的
  3. 加上static称为类变量或静态变量,否则称为实例变量/普通变量/非静态变量
  4. 类变量可以通过 类名.类变量名 或者 对象名.类变量名 来访问,但Java设计者推荐我们使用 类名.类变量名 方式去访问。访问规则遵循修饰符的访问权限和范围
  5. 实例变量不能通过 类名.普通成员变量名 访问 ,因为还未创建对象实例,内存中没有该普通成员变量
  6. 类变量是在类加载时就初始化了,也就是说,即使没有创建对象,只要类加载了,就可以使用类变量了 ,这也就是为什么能够通过 类名.类变量名 方式去访问
  7. 类变量的生命周期是随类的加载开始,随着类的消亡而销毁

类方法

类方法的定义

类方法也称为静态方法,定义形式如下:

访问修饰符 static 数据返回类型 方法名() {……}//推荐使用
static 访问修饰符 数据返回类型 方法名() {……}//也可

经过上面类变量的介绍,这里的类方法理解起来会相对容易。

类方法的调用

类名.类方法名//推荐使用
对象名.类方法名

调用/访问规则同样遵循访问修饰符的访问权限和范围!下面是一段测试代码,供学习和思考:

package com.lww.study_static_;

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

        D.hi();
        //非静态方法,不能通过类名调用
        //D.say();//error,需要先创建对象,再通过对象调用
        new D().say();
        new D().ok();
    }
}

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

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

    }

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

    //类方法(静态方法)中,只能访问静态变量 或者 静态方法
    //即静态方法中只能访问静态成员
    public static void hello() {
        System.out.println(n2);
        System.out.println(D.n2);
        //System.out.println(this.n2);//error
        hi();
        //say();//error
    }

    //普通成员方法,既可以访问非静态成员,也可以访问静态成员
    public void ok() {
        //非静态成员
        System.out.println(n1++);
        System.out.println(this.n1);
        say();
        //静态成员
        System.out.println(n2);
        hello();
    }
}

常见使用场景

  1. 当方法中不涉及到任何和对象相关的成员时,可以将方法设计成静态方法,提高开发效率,比如util中的Math类、Array类中的方法很多都是设计为静态方法,他们都是可以直接通过 类名.类方法名 调用,避免创建对象的消耗
  2. 在程序员实际开发过程中,往往会将一些通用的方法,设计成静态方法,这样我们不需要创建对象就可以使用了,比如打印一堆数组,冒泡排序,完成某个计算任务等

类方法的细节总结

  1. 类方法和普通方法都是随着类的加载而加载,将结构信息存储在方法区
  2. 类方法中无this的参数,普通方法中隐含着this的参数
  3. 类方法可以通过类名调用,也可以通过对象名调用
  4. 普通方法和对象有关,需要通过对象名调用,不能通过类名调用
  5. 类方法中不允许使用和对象有关的关键字,比如this和super 。普通方法可以
  6. 类方法(静态方法)中只能访问静态成员,即只能 静态变量 或者 静态方法
  7. 普通成员方法,既可以访问 非静态成员,也可以访问 静态成员

main方法语法

深入理解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……参数由args数组接收

main()方法属于静态方法,所以在main()方法中,可以直接调用main所在类的静态方法或者静态属性,但是不能访问该类中的非静态成员,必须创建该类的实例对象后,才可以通过对象去访问,下面是一段测试代码:

import sun.applet.Main;

public class Main01 {

    //静态的变量/属性
    private static String name = "憨憨";
    //非静态的变量/属性
    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);//error
        //cry();//error
        //3\. 静态方法main 要访问本类的非静态成员,必须要先创建对象,再调用即可
        Main01 main01 = new Main01();
        System.out.println(main01.n1);
        main01.cry();
    }

}

关于args数组,这里也可以通过下面的操作进行演示,在IDEA中执行下面代码:

package com.lww.study_main_;

public class Main02 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}

我们会发现没有任何输出结果,那是因为我们还没有给执行过程传递参数,通过下面步骤设置执行该代码时要传递的参数

【Java】:类变量、类方法(static在类中的用法)及main函数细节_第2张图片

如果没有显示有Main02,可以先运行一遍再设置,点击进去后出现以下界面

【Java】:类变量、类方法(static在类中的用法)及main函数细节_第3张图片

在Program arguments栏输入要传递的运行参数,比如我这里输入的是北京 上海 西安,最后Apply后OK退出该界面,重新运行代码,会发现输出以下结果

【Java】:类变量、类方法(static在类中的用法)及main函数细节_第4张图片

当然这部分内容了解一下即可,实际开发过程中不需要我们去传递参数,但为了应付面试,我们还是要了解一下有这么个内容即可!

你可能感兴趣的:(java,jvm,开发语言,架构,微服务)