java的类变量和类方法（static），main方法，代码块

已于 2024-07-04 23:54:19 修改
阅读量432 收藏
点赞数
分类专栏： java基础 文章标签： java
于 2022-11-17 12:58:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_64044840/article/details/127876907
版权

一、类变量（静态变量）的引入

  1. 利用传统方法的缺陷引入类变量：
    • 思路：
      • 1）. 在main方法中定义一个变量count
      • 2）. 当一个小孩加入游戏后count++。最后count就能统计有多少个小孩玩游戏了
public class ChildGame {
    public static void main(String[] args) {
//        定义变量count统计有多少人参加游戏
        int count=0;
        
        Child child1 = new Child("老大");
        child1.join();
        count++;
        Child child2 = new Child("老二");
        child2.join();
        count++;
        Child child3 = new Child("老三");
        child3.join();
        count++;
        System.out.println("count="+count);
    }
}
class Child{
    private String name;

    public Child(String name) {
        this.name = name;
    }
    public void join(){
        System.out.println(name+" 加入了游戏");
    }
}
  1. 问题分析：
    • 1）. count是一个独立于对象的变量，地位很尴尬，对象不能调用这个变量。
    • 2）. 后面要访问count很麻烦，因为没有使用到OOP

由此，我们就可以引出 类变量（也叫静态变量）

  1. 传统方法缺陷的改进
    • 前面方法的缺陷主要是count不是属于所有对象的-》
    • 思考：还是设计一个int count 表示总人数，还是count++来计算人数的增加，但是这个count要设计为所有对象共享的，这便是类变量与一般变量的不同的之一了。

代码改进：

public class ChildGame {
    public static void main(String[] args) {
//        定义变量count统计有多少人参加游戏

//        int count=0;
        Child child1 = new Child("老大");
        child1.join();
//        count++;
        child1.count++;
        Child child2 = new Child("老二");
        child2.join();
        child2.count++;
        Child child3 = new Child("老三");
        child3.join();
        child3.count++;

//        类变量可以通过类名来访问
        System.out.println("count="+Child.count);
//        下面三个的count都是同一个count
        System.out.println(child1.count);//3
        System.out.println(child2.count);//3
        System.out.println(child3.count);//3
    }
}
class Child{
    private String name;

//    定义一个静态变量count
    public static int count=0;
//    该变量最大的特点就是能够被所有的Child对象实例使用

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

  1. static变量共识：

    • 1）static变量是同一个类所有对象共享
    • 2）static类变量，在类加载的时候就生成了

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

  3. 语法：

    • 访问修饰符 static 数据类型 变量名;【推荐使用这个】
    • static 访问修饰符 数据类型 变量名；
    • 如何访问：
      • 类名.类变量名
      • 或者对象名.类变量名【静态变量的访问修饰符的访问权限和普通变量一样】
public class visitStatic {
    public static void main(String[] args) {
//        类名.类变量名
//        类变量是随着类的加载而创建的，所以即使没有创建对象也可以访问
        System.out.println(A.name);
//        通过对象名.类变量名
        A a = new A();
        System.out.println(a.name);

    }
}
class A{
//   类变量
//    类变量的访问，必须遵守 相关的访问权限
    public static String name;
}

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

  1. 什么时候使用类变量
    • 当我们需要让某个类的所有对象都共享一个变量的时候，就可以考虑使用类变量（静态变量）。
  2. 类变量和实例变量（普通属性）的区别：
    • 类变量是该类所有对象共享的，而实例变量则是每个对象独享的;
  3. 加上static的变量就称为：类变量（静态变量），否则称为：实例变量（普通变量/非静态变量）
  4. 类变量可以通过 类名.类变量名 或者 对象名.类变量名 来访问，但java设计者推荐使用类名.类变量名的方式来访问
  5. 实例变量不能通过类名.变量名访问
  6. 类变量是在加载时就初始化了，也就是说，即使你没有创建对象，只是类加载了，就可以使用类变量了
  7. 类变量的声明周期是随类的加载开始，到类的消亡而销毁的

二、类方法

  1. 基本介绍：类方法也叫静态方法
  2. 语法：
    • 访问修饰符 static 数据返回类型 方法名(){} 【推荐】
    • static 访问修饰符 数据返回类型 方法名(){}
    • 类方法的调用：
      • 使用方式：类名.类方法名 【静态方法的访问修饰符的访问权限和普通方法一样】
public class static_Method {
    public static void main(String[] args) {
//        创建两个学生对象，交学费
        Stu tom = new Stu("tom");
        //这里可以使用，但是有警告了，而且当写到tom.的时候，也没有提示出来了
        tom.payFee(100);
        Stu.payFee(100);
        Stu.showFee();
   //这样就可以不创建对象，直接使用方法计算两个数的和了
        System.out.println(Cul.sum(8,199));
    }
}
class Cul{
    public static int sum(int a,int b){
        return a+b;
    }
}
class Stu{
    private String name;
    int a=10;
//    定义一个静态变量来累积学生的学费
    private static double fee=0;

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

//    1. 当使用static修饰方法后，该方法就变成了静态方法
    public static void payFee(double fee){
        Stu.fee+=fee;
    }

    public static void showFee(){
        System.out.println("总学费有 :"+Stu.fee);
    }
}
  1. ** 类方法的使用场景**
    • 当方法中不涉及到任何对象相关的成员，则可以将方法设计成静态方法，提高开发效率
      • 比如：工具类的方法： Math类，Arrays类，Collections集合类…

小结： 在程序员实际开发，往往会将一些通用的方法，设计为静态方法，这样我们不需要创建对象就可以使用了，比如打印一堆数组，冒泡排序，完成某个计算任务…

二、类方法使用的注意事项和细节：

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

  • 小结： 静态方法，只能访问静态的成员，非静态方法，可以访问静态成员和非静态成员【必须遵循访问权限】

三、main方法

  1. 解释main方法的形式：public static void main(String[] args){}
  2. main方法是由虚拟机调用的。因为java虚拟机需要调用类的mian()方法（java虚拟机跟main方法的类不是同一个类），所有该方法就必须是public
  3. java虚拟机在执行main方法的时候，不需要创建对象，所以该方法必须为static方法
  4. 该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所允许的类的参数。
  5. 在命令行执行java程序的时候：java 执行的程序 参数1 参数2 参数3 …
    • 这些参数就会成为main方法的参数数组args的变量，遍历输出args[i]就是输出这些添加进去的数，
    • 如果没有添加任何数进去，那么就什么都不返回

– idea插入args数组的数据
在这里插入图片描述
点击这里之后-------------》弹出一个提示框，点击第一行（edit configurations…)
在这里插入图片描述
然后点击ok就可以了，这里可以自由地添加数据进去，用空格隔开就行。

public class Main_01 {
    public static void main(String[] args) {
//        args是如何传入的
//        遍历显示
        for (int i=0;i<args.length;i++){
            System.out.println("第"+(i+1)+"个参数为"+args[i]);
        }
    }
}

运行结果：

第1个参数为小学
第2个参数为大学
第3个参数为研究生
  • 特别提示
    • 在main方法中，我们可以直接调用mian方法所在类的静态方法或静态属性
    • 但是，不能直接调用该类的非静态成员，必须创建该类的一个实例对象才能通过这个对象去访问类中的非静态成员
public class main_02 {
//    静态变量
    private static String name="大刀爱java";
//    非静态属性
    private int n1=1000;

//    静态方法
    private static void hi(){};
//    非静态方法
    public void cry(){}

    public static void main(String[] args) {

//        1. 静态方法main，可以访问本类的静态成员
        System.out.println("name="+name);
        hi();
//        2. 静态方法main 不可以访问本类的非静态成员
//        System.out.println(n1);//报错的
//        cry(); //报错
//        3.main方法不能直接调用该类的非静态成员，
//        必须创建该类的一个实例对象才能通过这个对象去访问类中的非静态成员
        main_02 main_02 = new main_02();
        System.out.println(main_02.n1);
        main_02.cry();


    }
}

四、代码块

  1. 1基本介绍

    • 代码化块又称为初始化块，属于类中的成员【即，是类中的一部分】，类似于方法，将逻辑语句封装在方法体中，通常用{ }包围起来
    • 但和方法不同，没有方法名，没有返值，没有参数，只有方法体，而且不用通过对象或类显式调用，而且加载类的时候，或创建对象的时候隐式调用。

  2. 基本语法

修饰符{
 代码（逻辑语句）
}

说明注意：

 1）修饰符可选，要写的话，只能写static
 2) 代码块分为两类：使用static修饰的是静态代码块；没有使用static修饰的叫普通代码块
 3）逻辑语句可以为任何逻辑语句（输入，输出，方法调用，循环，判断...）
  1. 3代码块的好处
    • 代码块相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作
    • 场景：如果多个构造器中都有重复的语句，就可以抽到初始化代码块中，提高代码块的重用性
public class block01 {
    public static void main(String[] args) {
        Movie movie1 = new Movie("你好");
        System.out.println("==============================");
        Movie movie2 = new Movie("唐人街探案", 100, "大刀");

    }
}

class Movie{
    private String name;
    private double price;
    private String director;

//    3个构造器--》
//    1）下面的三个构造器都有三条相同的语句
//    2）这样写显得代码很冗余
//    3）这时我们就可以将相同的代码块放进一个代码块中去
//    4）这样当我们不管调用哪个构造器创建对象，都会先调用代码块的内容
//    5）代码块调用的顺序优先于构造器

    public Movie(String name) {
//        System.out.println("电影准备开始");
//        System.out.println("广告回来，下集更精彩");
//        System.out.println("下一集开始了");
        this.name = name;
        System.out.println("Movie(String name)构造器被调用");
    }
    {
        System.out.println("电影准备开始");
        System.out.println("广告回来，下集更精彩");
        System.out.println("下一集开始了");
    }
    public Movie(String name, double price) {
//        System.out.println("电影准备开始");
//        System.out.println("广告回来，下集更精彩");
//        System.out.println("下一集开始了");
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
//        System.out.println("电影准备开始");
//        System.out.println("广告回来，下集更精彩");
//        System.out.println("下一集开始了");
        this.name = name;
        this.price = price;
        this.director = director;
        System.out.println("Movie(String name, double price, String director)构造器被调用");
    }
}

运行结果：

电影准备开始
广告回来，下集更精彩
下一集开始了
Movie(String name)构造器被调用
==============================
电影准备开始
广告回来，下集更精彩
下一集开始了
Movie(String name, double price, String director)构造器被调用

四、1、代码块的使用注意事项和细节：

  1. static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次；
    • 如果是普通代码块，每创建一个对象（new），就执行一次。
    • 如果只是使用类的静态成员时，普通代码块并不会被执行。（可以这么理解，普通代码块就是构造器的补充，构造器被调用，普通代码块就被调用)
public class block03 {
    public static void main(String[] args) {
        DD dd = new DD();
        System.out.println("=======================");
        DD dd1 = new DD();
        System.out.println("=======================");
//        如果只使用类的静态代码块，普通代码块并不会被执行
        System.out.println(DD.n1);
    }
}
class DD{
    public static int n1=99999;
//    静态代码块
    static {
    System.out.println("DD静态代码块被执行");
    }
    {
        System.out.println("DD普通代码块被加载");
    }
}

运行结果：

DD静态代码块被执行
DD普通代码块被加载
=======================
DD普通代码块被加载
=======================
99999
  1. 什么时候类加载（重点）
    • 1）创建对象实例的时候（也就是new），类会被加载
    • 2）创建子类对象实例，父类也会被加载。【父类先被加载，子类后被加载】
    • 3）使用类的静态成员时（静态属性或者静态方法），类会被加载（普通代码块不会被加载）

代码演示：

注意：这里代码在不继承父类的时候，就会只加载类的本身（创建对象实例的时候（也就是new），类会被加载）

public class block02 {
    public static void main(String[] args) {
        //什么时候类被加载
//      1.  创建对象实例的时候（new）,类被加载
        AA aa = new AA();
//       2.创建子类对象实例，父类也会被加载
//        继承的本质：先加载父类后加载子类
//        3. 使用类的静态成员的时候（静态属性，静态方法），类被加载
        System.out.println("=====================================");
        System.out.println(Cat.n1);
    }
}

class Animal{
    static {
        System.out.println("Animal的静态代码块被执行");
    }
}
class Cat extends Animal{
    public static int n1=999;
    static {
        System.out.println("Cat的静态代码块被调用");
    }
}
class BB{
    static {
        System.out.println("父类BB的静态代码块被加载");
    }

}

class AA extends BB{
//    静态代码块
    static {
    System.out.println("静态代码块AA被执行");
   }
}

运行结果：

父类BB的静态代码块被加载
静态代码块AA被执行
=====================================
Animal的静态代码块被执行
Cat的静态代码块被调用
999

3. 创建一个对象时，在一个类的调用顺序是：（重点）

  • 第一：调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级是一样的,如果有多个静态代码块和多个静态属性初始化，则按照它们定义的顺序调用，谁先定义，谁先调用）
public class block04 {
    public static void main(String[] args) {
        C c = new C();
    }
}
class C{
    private static int n1=getN1();
    static {
        System.out.println("C 静态代码块");
    }
    public static int getN1(){
        System.out.println("getN1被调用");
        return 100;
    }
}
  • 第二：调用普通代码块和普通属性的初始化（注意：普通代码块和普通属性初始化调用的优先级是一样的,如果有多个普通代码块和多个普通属性初始化，则按照它们定义的顺序调用，谁先定义，谁先调用）
  • 第三：调用构造器
public class block04 {
    public static void main(String[] args) {
        C c = new C();
    }
}
class C{
//    构造器

    public C() {
        System.out.println("C()构造器被调用");
    }

    //    普通属性
    private int n2=getN2();
//普通代码块
    {
        System.out.println("C的普通代码块");
    }
//    普通方法
    private int getN2(){
        System.out.println("getN2被调用");
        return 200;
    }
//静态属性
    private static int n1=getN1();
//    静态代码块
    static {
        System.out.println("C 静态代码块");
    }
//    静态方法
    public static int getN1(){
        System.out.println("getN1(静态）被调用");
        return 100;
    }
}

运行结果：

getN1(静态）被调用
C 静态代码块
getN2被调用
C的普通代码块
C()构造器被调用

4. 构造器的内部：构造器的前面其实隐含了super()和调用普通代码块，静态代码块和静态属性在类加载时，就执行完毕，因此优先于构造器和普通代码块执行的。

public BBB() {
//        构造器里面隐藏了一些语句：
//        1）super();
//        2）调用本类的普通代码块
        System.out.println("BBB() 构造器被调用");
    }

public class block05 {
    public static void main(String[] args) {
        new BBB();
    }
}

class AAA{
    {
        System.out.println("AAA的普通代码块");
    }
    public AAA(){
//        构造器里面隐藏了一些语句：
//        1）super();
//        2）调用本类的普通代码块
        System.out.println("AAA() 构造器被调用");
    }
}

class BBB extends AAA{
    {
        System.out.println("BBB的普通代码块。。。");
    }
    public BBB() {
//        构造器里面隐藏了一些语句：
//        1）super();
//        2）调用本类的普通代码块
        System.out.println("BBB() 构造器被调用");
    }
}

运行结果：

AAA的普通代码块
AAA() 构造器被调用
BBB的普通代码块。。。
BBB() 构造器被调用

5. 创建一个子类对象时（继承关系），静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序：

 1）父类的静态代码块和静态属性（优先级一样，具体情况按定义顺序进行）
 2）子类的静态代码块和静态属性（优先级一样，具体情况按定义顺序进行）
 3）父类的普通代码块和普通属性初始化（优先级一样，具体情况按定义顺序进行）
 4）父类的构造方法
 5）子类的普通代码块和普通属性初始化（优先级一样，具体情况按定义顺序进行）
 6）子类的构造方法

public class block06 {
    public static void main(String[] args) {
//        1)进行类的加载
//          1.1 先加载父类-->1.2 后加载子类
//        2)创建对象
//        2.1 从子类的构造器开始
        new Son();
    }
}
class Father{
    private static int m1 =getM1();
    static {
        System.out.println("2.Father 的一个静态代码块");
    }
    public static int getM1(){
        System.out.println("1.Father的getM1(静态)");
        return 100;
    }


    public int M2=getM2();
    {
        System.out.println("6.Father的一个普通代码块");
    }
    public int getM2(){
        System.out.println("5.Father的getM2(普通)");
        return 200;
    }
    public Father(){
//        隐藏了super()
//        普通代码块,普通属性的初始化...
        System.out.println("7.Father的无参构造器");
    }


}

class Son extends Father{
    private static int n1=getN1();
    static {
        System.out.println("4.Son 的一个静态代码块");
    }
    public static int getN1(){
        System.out.println("3.Son的getN1(静态)");
        return 100;
    }

    public int n2=getN2();
    {
        System.out.println("9.Son的一个普通代码块");
    }
    public int getN2(){
        System.out.println("8.Son的getN2(普通)");
        return 200;
    }
    public Son(){
        //        隐藏了super()---->Father
//        普通代码块,普通属性的初始化...
        System.out.println("10.Son的无参构造器");
    }

}

运行结果：

1.Father的getM1(静态)
2.Father 的一个静态代码块
3.Son的getN1(静态)
4.Son 的一个静态代码块
5.Father的getM2(普通)
6.Father的一个普通代码块
7.Father的无参构造器
8.Son的getN2(普通)
9.Son的一个普通代码块
10.Son的无参构造器

6. 静态代码块只能调用静态成员（静态属性和静态方法），普通代码块可以用任意成员。

大刀爱敲代码
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java学习 static之主函数main
goddreamyyh的博客
05-22 634
main函数作为我们初学的时候最特殊的一个函数，需要好好梳理了解一下。首先，main函数的格式是固定的其次，主函数是被java虚拟机识别并调用的。public：作为整个程序的入口，权限需哟是最大的static：main函数需要是静态的，因为虚拟机调用的时候不需要创建和调用对象了void：主函数不需要返回值main：main并不是关键字，只是一个普通函数，但这个函数是被java虚拟机识别的。Stri...
java 调用类的Main()方法
黄彪博客
09-07 7257
1、模拟需要被调用的main方法 package adtec.util; public class TestDemo { public static void main(String[] args) { System.out.println("adtec.util.TestDemo main method"); } }   2、实现调用其他类的main方法
JAVA main 入口方法
zhang804633234的专栏
11-18 323
【代码】JAVA main 入口方法。
【JAVA】static变量/方法/代码块
孑然的个人博客
11-15 255
在实际开发中，往往会将一些通用的方法，设计成静态的方法，这样我们不需要创建对象就可以使用了，比如打印一组数组，冒泡排序，完成某个计算任务等…但是，不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。的变量，任何一个该类的对象去访问它，取到的都是相同的值，同样任何一个该类的对象去修改它，修改的也是同一个变量。（3）普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。非静态的方法，可以访问静态成员和非静态成员。
【类变量（静态变量）和类方法笔记】
chenxiaomingya的博客
09-27 278
类变量（静态变量）和类方法笔记
Java-Static与代码块
weixin_52453515的博客
11-02 832
在类加载的时候一起加载入方法中的静态域中先与对象存在访问方式：对象名.属性名 类名.属性名（推荐）属性分为：静态（类变量）与非静态属性（实例变量）static和public都是修饰符，并列的没有先后顺序，谁先谁后都可以在静态方法中不能访问非静态的属性，报错在静态方法中不能使用this关键字，报错在静态方法中不能访问非静态的方法非静态的方法可以用对象名.方法名去调用静态的方法可以用 对象名.方法名去调用 也可以用 类名.方法名（推荐）
static & main方法 & 代码块 & final & 接口 & 内部类
最新发布
06-21
Java编程语言中的`static`, `main`方法, 代码块, `final`关键字, 接口和内部类是核心概念，对于理解和编写高效、可维护的Java程序至关重要。以下是对这些概念的详细解释： 1. **`static`关键字**： - `static`...
理解java和python类变量以及类的成员变量
09-02
总结来说，类变量在Java和Python中都是共享的，由类的所有实例共享，而成员变量是每个实例独有的。类变量可以通过类名直接访问，而成员变量需要通过实例访问。理解这些概念对于编写高效、健壮的面向对象代码至关重要...
JAVA中static方法的用法实例详解
09-03
在Java编程语言中，`static`关键字用于定义类级别的成员，包括变量和方法。静态成员不依赖于类的实例，而是直接与类相关联。这意味着它们在类加载时被初始化，并且所有类的实例都可以共享这些静态成员。下面将详细...
Java面向对象（高级）- 类的成员之四：代码块
11-19
代码块在Java中扮演着初始化类或对象成员变量的角色，特别是在需要复杂计算或获取外部信息来设定初始值时。 首先，回顾面向对象的三条主线：类及其内部成员（包括属性、方法、构造器、代码块和内部类）、封装、继承...
Java中的static静态代码块的使用详解
09-05
类`StaticBlock`的执行顺序展示了静态代码块和构造块的执行次序：静态代码块先执行，然后是非静态代码块，最后是构造方法。每次创建新对象时，这个顺序都会重复。 5. **执行顺序：** - 类的加载：静态变量初始化...
Java static静态变量、静态方法、静态代码块详解
weixin_48591974的博客
10-07 1355
Java static静态变量、静态方法、静态代码块详解
Java中main()方法为什么是static的
weixin_44810464的博客
10-30 2669
今天刷Leetcode时候遇见了一个小问题，当时我就先把代码复制到IDEA中自己编译一下，但是在实例化对象时候却碰到了这样的问题。废话不多说，直接上图 首先是测试类，然后声明一个内部类ListNode，一个简单的链表 接下来就是main()，但问题来了，为什么48、49行实例对象时会报错呢，我们来看看编译器具体怎么说 哦，编译器给了两个提示，要么将内部类ListNode加关键字static，...
Java面试题—为什么需要public static void main(String[] args)这个方法
qq_42308454的博客
09-28 7066
 常见笔试题 Java程序中程序运行入口方法main的签名正确的有（） A.public static void main(String[] args) B.public static final void main(String[] args) C.static public void main(String[] args) D.static public synchronized v...
java main方法static_java static关键字， main方法
weixin_39922361的博客
02-13 90
当类中的方法全部都是static 关键字修饰时 它的构造方法将要作为 private 私有化 ；理由是方法全是static, 不知道的人会去用对象去调用，可能调用构造方法。 static的方法直接用类名调用即可！面向对象(static关键字的特点)* A:static关键字的特点* a:随着类的加载而加载* b:优先于对象存在* c:被类的所有对象共享* 举例：咱们班级的学生应该共用同一个班级编...
JAVA之static解法。类的主方法main
holywo的博客
07-23 209
static是全局变量，其生命周期是全局 final static静态常量 静态方法 静态代码块 public class Dome2 { static String name; static { System.out.println("这里是静态代码块"+name); } { System.out.println("这里是非静态代码块"+name...
java main函数 静态_java main()静态方法
weixin_32578161的博客
02-16 1039
java main()方法是静态的。意味着不需要new()，就在内存中存在。而且是属于类的,但是对象还是可以调用的.若干个包含这个静态属性和方法的对象引用都可以指向这个内存区域。这个内存区域发生改变对所有对象都是改变的非静态的，就只有new()成对象才能使用。new出来的属性和方法只属于new出来的这个对象，相互之间不会干扰。类 中国人{public String name；public in...
java中的main方法，为什么是静态(static)的？
开发小盆友的博客
01-05 6906
回答这个问题就要理解static关键字了： static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法。被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。静态方法可以直接通过类名调用，任何的实例也都可以调用。因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变
为什么java main不能使用static 定义变量
Carey_Lu的博客
11-28 2435
只有类才存在静态的变量 方法只能对静态变量的操作 不能在方法内试图定义静态变量 否则的话会抛出编译错误静态变量的本意是为了让所有的对象共享这个变量,如果在方法里面定义静态变量的话就存在逻辑错误了,也达不到你想要目的. 因为在方法定义静态变量根本没有他的任何意义. 任何对象都有自己的方法,即使是静态方法,方法内的变量也是在方法调用时候才开始分配内存,所以想给成静态的在逻辑上存在问题。...
java类 static代码块
09-26
Java中的静态代码块是在类被加载时执行的一段代码块，它只会被执行一次。静态代码块可以用来初始化静态变量或执行一些需要在类加载时就完成的操作。静态代码块的语法如下： ``` static{ //静态代码块中的代码 } ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值