static

已于 2024-05-29 10:53:51 修改
阅读量461 收藏
点赞数
文章标签： java 开发语言 后端
于 2021-07-16 08:43:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xingyu19911016/article/details/118783918
版权

static关键字的作用就是：方便在没有创建实例的情况下来进行调用（方法/变量）。也就是说，被static关键字修饰的方法或者变量不需要创建实例去调用，直接根据类名就可以去访问。

1. static关键字修饰的类

用static修饰内部类，普通类是不允许声明为静态的，只有内部类才可以：

public class StaticTest {
  // static关键字修饰内部类
  public static class InnerClass {
    InnerClass() {
      System.out.println("===========静态内部类===========");
    }

    public void innerMethod() {
      System.out.println("===========静态内部方法===========");
    }
  }

  public static void main(String[] args) {
    // 直接通过StaticTest类名访问静态内部类InnerClass
    InnerClass inner = new StaticTest.InnerClass();
    // 静态内部类可以和普通类一样使用
    inner.innerMethod();
  }
}

//===========静态内部类===========
//===========静态内部方法===========

如果没有用static修饰InnerClass，则只能new一个外部类实例，再通过外部类实例创建内部类。

另外，静态内部类不持有外部类的引用，是因为其构造函数内没有传入外部类的引用。

public class OutClass {

  public static long OUTER_DATE = System.currentTimeMillis(); // 1

  static {
    System.out.println("外部类静态块加载" + System.currentTimeMillis()); // 1
  }

  public OutClass() {
    timeElapsed();
    System.out.println("外部类构造函数" + System.currentTimeMillis()); // 2
  }

  static class InnerStaticClass {
    public static long INNER_STATIC_DATE = System.currentTimeMillis(); // 4
  }

  class InnerClass {
    public long INNER_DATE = 0;

    public InnerClass() {
      timeElapsed();
      INNER_DATE = System.currentTimeMillis(); // 3
    }
  }

  // 扩大时间差
  private void timeElapsed() {
    for (int i = 0; i < 100000000; i++) {
      int a = new Random(100).nextInt(), b = new Random(100).nextInt();
      a = a + b;
    }
  }

  public static void main(String[] args) {
    OutClass outer = new OutClass();
    System.out.println("外部类静态变量加载时间：" + OutClass.OUTER_DATE);
    System.out.println("非静态内部类加载时间：" + outer.new InnerClass().INNER_DATE);
    System.out.println("静态内部类加载时间：" + InnerStaticClass.INNER_STATIC_DATE);
  }
}

//外部类静态块加载1626405022945
//外部类构造函数1626405025424
//外部类静态变量加载时间：1626405022945
//非静态内部类加载时间：1626405027582
//静态内部类加载时间：1626405027583

由此可知，静态内部类和非静态内部类一样，都是在被调用时才会被加载。

public class OutClass {

  public static long OUTER_DATE = System.currentTimeMillis();
  public static int a = 1;

  static {
    System.out.println("外部类静态块加载" + System.currentTimeMillis()); 
  }

  public OutClass() {
    timeElapsed();
    System.out.println("外部类构造函数" + System.currentTimeMillis()); 
  }

  static class InnerStaticClass {
    static {
      System.out.println("内部类静态块加载时间：" + System.currentTimeMillis()); 
    }

    public static long INNER_STATIC_DATE = System.currentTimeMillis(); 
  }

  public static void hello() {
    System.out.println("Hello");
  }

  class InnerClass {
    public long INNER_DATE = 0;

    public InnerClass() {
      timeElapsed();
      INNER_DATE = System.currentTimeMillis(); 
    }
  }

  // 扩大时间差
  private void timeElapsed() {
    for (int i = 0; i < 100000000; i++) {
      int a = new Random(100).nextInt(), b = new Random(100).nextInt();
      a = a + b;
    }
  }

  public static void main(String[] args) {
    //        System.out.println("外部类静态变量加载时间：" + OutClass.OUTER_DATE);
    OutClass.hello();
    OutClass outer = new OutClass();
    System.out.println("外部类静态变量加载时间：" + OutClass.OUTER_DATE);
  }
}

//外部类静态块加载1626406024641
//Hello
//外部类构造函数1626406027103
//外部类静态变量加载时间：1626406024641

调用外部类的静态变量、静态方法可以让外部类得到加载，但是不能让静态内部类被加载。

public class OutClass {

  public static long OUTER_DATE = System.currentTimeMillis();
  public static int a = 1;

  static {
    System.out.println("外部类静态块加载" + System.currentTimeMillis()); 
  }

  public OutClass() {
    timeElapsed();
    System.out.println("外部类构造函数" + System.currentTimeMillis()); 
  }

  static class InnerStaticClass {
    static {
      System.out.println("内部类静态块加载时间：" + System.currentTimeMillis()); 
    }

    public static long INNER_STATIC_DATE = System.currentTimeMillis(); /
  }

  public static void hello() {
    System.out.println("Hello");
  }

  class InnerClass {
    public long INNER_DATE = 0;

    public InnerClass() {
      timeElapsed();
      INNER_DATE = System.currentTimeMillis(); // 3
    }
  }

  // 扩大时间差
  private void timeElapsed() {
    for (int i = 0; i < 100000000; i++) {
      int a = new Random(100).nextInt(), b = new Random(100).nextInt();
      a = a + b;
    }
  }

  public static void main(String[] args) {
    System.out.println("内部类静态变量加载时间" + InnerStaticClass.INNER_STATIC_DATE);
    System.out.println("外部类静态变量加载时间" + OutClass.OUTER_DATE);
  }
}

//外部类静态块加载1626406319875
//内部类静态块加载时间：1626406319876
//内部类静态变量加载时间1626406319876
//外部类静态变量加载时间1626406319875

加载静态内部类的时候，还是会先加载外部类，才加载静态内部类。

静态内部类不会自动初始化，只有调用静态内部类的成员变量、方法，静态域或者构造方法的时候才会加载静态内部类。

2 static关键字修饰方法

static修饰方法称作静态方法，由于静态方法不依赖于任何对象就可以访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。但是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。

public class Person {
    private String str1 = "property";
    private static String str2 = "static_property";

    public Person() {
    }

    public void print1() {
        System.out.println(str1);
        System.out.println(str2);

        print2();
    }

    public static void print2() {
//        System.out.println(str1); // 报错
        System.out.println(str2);
//        print1(); // 报错
    }

}

修饰方法是，其实跟类一样，可以直接通过类名来进行调用：

public class StaticTest {
  public static void test() {
    System.out.println("=========静态方法==========");
  }

  public static void main(String[] args) {
    // 方式一：直接通过类名
    StaticTest.test();
    // 方式二：
    StaticTest staticTest = new StaticTest();
    staticTest.test();
  }
}
//=========静态方法==========

3 static关键字修饰代码块

static关键字还有一个比较关键的作用就是用来生成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类被初次加载的时候，会按照static块的顺序来执行每一个static块，并且只会执行一次。为什么说static块可以用来优化程序性能，是因为它的特性：只会在类加载的时候执行一次：

public class Person {
  private long birthDate;

  public Person(long birthDate) {
    this.birthDate = birthDate;
  }

  boolean isBornBoomer() {
    long startDate = Date.parse("1946-1-1");
    long endDate = Date.parse("1964-12-31");
    return birthDate > startDate && birthDate < endDate;
  }
}

isBornBoomer是用来判断这个人是否是1946-1964年出生的，而每次isBornBoomer被调用的时候，都会生成startDate和endDate着两数值，造成空间浪费，改成这样效率会更好：

public class Person {
    private long birthDate;

    private static long startDate, endDate;

    static {
        startDate = Date.parse("1946-1-1");
        endDate = Date.parse("1946-12-31");
    }

    public Person(long birthDate) {
        this.birthDate = birthDate;
    }

    boolean isBornBoomer() {
        return birthDate > startDate && birthDate < endDate;
    }
}

因此，很多时候会将一些只需要进行一次的初始化操作都放在static代码块中进行。

验证一下类初始化的顺序：父类静态变量、父类静态代码块、子类静态变量、子类静态代码块、父类普通变量，父类普通代码块，父类构造函数，子类普通变量，子类普通代码块，子类构造函数

public class Father {
  static {
    System.out.println("Father static");
  }

  public Father() {
    System.out.println("Father constructor");
  }

}

public class Son extends Father {

  static {
    System.out.println("Son Static");
  }

  public Son() {
    System.out.println("Son constructor");
  }

  public static void main(String[] args) {
    new Son();
  }

}

//Father static
//Son Static
//Father constructor
//Son constructor

4 static关键字修饰变量

static变量也称为静态变量也叫类变量，说明这个变量是属于这个类的，而不是属于对象，没有被static修饰的变量成员叫做实例变量，这个变量是属于某个具体的对象的。

静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅单在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

static成员变量的初始化顺序按照定义的顺序进行初始化。

public class StaticTest {
  private static String name = "java的架构技术栈";

  public static void main(String[] args) {
    String name = StaticTest.name;
  }
}

静态变量存放在方法区中，被所有线程所共享的。 以下是内存图解：
Java 运行时数据区

堆区

  • 存储的全部是对象
  • JVM只有一个堆区（heap）被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身

栈区

  • 每个线程包含一个栈区，栈中只保存原始数据类型的对象和自定义对象的引用（不是对象），对象都存放在堆区中
  • 每个栈中的数据（原始类型和对象引用）都是私有的，其他栈不能访问

方法区

  • 又叫静态区，跟堆一样，被所有线程共享。
  • 方法区中包含的都是在整个程序中永远唯一的元素，如static变量

比如以下代码：

public class Person {
    static String firstName;
    String lastName;

    public void showName() {
        System.out.println(firstName + lastName);
    }

    public static void showFirstName() {
        System.out.println(firstName);
    }

    public static void main(String[] args) {
        Person p = new Person();
        Person.firstName = "萧";
        p.lastName = "峰";
        p.showName();

        Person p2 = new Person();
        Person.firstName = "段";
        p2.lastName = "誉";
        p2.showName();
    }    
}

内存模型：

内存模型

从上面可以看出，静态方法是从方法区调用的。堆内存中的成员变量lastName是随着对象的产生而产生，随着对象的消失而消失。

通过以下代码来具体分析：

public class Person {

    String name;
    int age;
    static String country;

    public Person() {

    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, String c) {
        this.name = name;
        this.age = age;
        country = c;
    }

    public void show() {
        System.out.println(name + "---" + age + "---" + country);
    }

}

class PersonDemo {
    public static void main(String[] args) {
        Person p1 = new Person("邓丽君", 16, "中国");
        p1.show();
        Person p2 = new Person("林青霞", 22);
        p2.show();
        Person p3 = new Person("张曼玉", 20);
        p3.show();

        Person.country = "美国";
        p3.show();
        p1.show();
        p2.show();
    }
}
//邓丽君---16---中国
//林青霞---22---中国
//张曼玉---20---中国
//张曼玉---20---美国
//邓丽君---16---美国
//林青霞---22---美国

当程序运行时，.class文件进行加载，这时在方法区会有.class文件区：

方法区

而.class文件区内会有两个区，代码中有两个类，一个是Person，一个是PersonDemo：

方法区

.class区域内有成员属性和成员方法，而对于静态属性和静态方法，系统会自动的把它们分配到静态区（方法内有一个静态区）。静态区也有两块区域一个是PersonDemo类标记的main方法，一个是Person标记的变量country（String类型出事默认值为null）：

方法区

得出结论：静态的内容随着.class文件加载而加载。

接着main方法进栈，main是静态修饰，静态方法可以通过类名调用，所以，根本不需要创建对象，main方法一进栈系统就会为它开辟空间：

方法区、堆、栈
接着它创建了第一个对象Person p1 = new Person("邓丽君", 16, "中国");：

栈

然后new Person()在进入堆内存之后系统会为它分配空间和一个内存地址，假如是：0X0001，同时这块内存区域内有name = nulll; age = 0;、静态标记和方法标记：

堆

静态标记是： 静态区域有一个变量country，它有一个内存地址，假如是0X01，它是跟静态标记是有关联的，这个时候静态标记是指向静态区的country的：

堆、栈、方法区

方法标记： 系统在创建对象的时候，会自动生成一个方法区，这个方法区是属于当前对象的Person，而这个方法区也有一个内存地址，假如是0X02；构造方法与show方法等方法都存储在方法区内，它是由Person标记的内存地址是0X02，这是堆内存中的方法标记则与方法区产生关联，直到这时它所有的初始化才完成。

堆、方法区

当进行完以上步骤，它的值又被改变了：Person p1 = new Person("邓丽君",16,"中国");，这是给name,age,country进行赋值，通过走构造方法进内存,邓丽君给了name，16给了age。

堆

这时找静态变量country = 中国，但此时在堆内存中并没有这个静态变量，那么找静态标记0X01，通过内存地址0X01找到静态区0X01标记的country，这时null则被中国替代。

堆、方法区

截止到此时Person p1 = new Person("邓丽君",16,"中国")的值才赋完。

堆、栈、方法区

运行到p1.show()方法：

public void show() {
  System.out.println(name + "---" + age + "---" + country);
}

在方法区找有没有show方法，则show方法进栈，为其开辟一个空间；那么show方法在里面输出的时候首先找name，因为是p1调用，所以通用Person p1找name值，再找age值，再通过静态标注进入静态区找country值，所以第一次输出结果是：

输出

当这些值在控制台显示之后，然后这个方法调用完毕就从内存中消失：

栈

接着运行Person p2 = new Person("林青霞", 22);，步骤Person p2则在站内存开辟出第二个空间并给出内存地址0X0002；

然后new Person()在堆内存开辟空间。然后Person p2 = new Person("林青霞",22)将林青霞、22赋值给name、age，此时并没有给country值，但是它是有值的，因为他是静态变量，它的静态标记0X01指向静态区域0X01，它的值还是以前的，但是由它们两个共享一个静态区域所以不需要再次进行赋值。然后找到p2.show()方法.使show()进栈,然后show()方法通过Person p2 -> 0X0002进堆内存通过name 、age找值，再通过静态标记找country的值。然后进行输出销毁内存。p3同理:

堆、栈、方法区

在当运行到p3.country = 美国;时，美国通过Person p3进堆，通过静态标记对country的值进行更改，因为所有方法共享一个静态区所以p3.show();、p1.show();、p2.show();，输出的country值都是美国。

static内存图解

内存图解

5 总结

5.1 特点
  • static是一个修饰符，用于修饰成员（变量，函数，内部类，代码块）。static修饰的成员变量称之为静态变量或类变量
  • static修饰的成员被所有的对象共享，而普通变量是对象特有的数据
  • static优先于对象存在，因为static的成员随着类的加载就已经存在
  • static修饰的成员可以直接被类名所调用（类名.静态成员）
5.2 成员变量和静态变量的区别
  • 生命周期的不同：成员变量随着对象的创建而存在，随着对象的回收而释放；静态变量随着类的加载而存在，随着类的消失而消失
  • 调用方式不同：成员变量被对象调用；静态变量可以被类名调用
  • 别名不同：成员变量也称为实例变量；静态变量成为类变量
  • 数据存储位置不同：成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据；静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据
5.3 静态使用时需要注意的事项
  • 静态方法只能访问静态成员。（非静态既可以访问静态，又可以访问非静态）
  • 静态方法中不可以使用this或者super关键字
  • 主函数是静态的
5.4 常见误区
5.4.1 static关键字会改变类中成员的访问权限吗

Java中的static关键字不会影响到变量或者方法的作用域。在Java中能够影响到访问权限的只有private、public、protected（包括访问权限）这几个关键字。

public class StaticTest {
  public static void main(String[] args) {
    // System.out.println(new Person().name); // 报错
    System.out.println(new Person().age);
  }
}

class Person {
  private String name = "哈哈";
  public int age = 10;
}
5.4.2 能通过this访问静态成员变量吗？

虽然对于静态方法来说是没有this，那么在静态方法中能够通过this访问静态成员变量吗？

public class StaticTest {
  static int value = 33;

  public static void main(String[] args) {
    new StaticTest().print(); // 33
  }

  public void print() {
    int value = 3;
    System.out.println(this.value);
  }
}

这里面主要考察this和static的理解，this代表什么？this代表当前对象，那么通过new StaticTest()来调用print的话，当前对象就是通过new StaticTest()生成的对象。而static变量是被对象所共享的， 因此在print中的this.value的值毫无疑问是33。在print方法内部的value是局部变量，根本不可能与this关联，所以输出结果是33。这里要注意，静态成员变量虽然独立于对象，但是不代表不可以通过对象区访问，所有的静态方法和静态变量都可以通过对象访问（只要访问权限足够）。

5.4.3 static能作用于局部变量吗

在Java中，static是不允许用来修饰局部变量，这是语法规定。

5.4.4 static与final的对比

static关键字在修饰变量时，会使该变量在类加载时就被初始化，不会因为对象的创建再次被加载，当变量被static修饰时就代表该变量只会被初始化一次：

public class StaticTest {
  public static double i = Math.random();
  public final double j = Math.random();

  public static void main(String[] args) {
    StaticTest staticTest1 = new StaticTest();
    StaticTest staticTest2 = new StaticTest();
    System.out.println(staticTest1.i == staticTest2.i); // true
    System.out.println(staticTest1.j == staticTest2.j); // false
  }
}

参考

https://baijiahao.baidu.com/s?id=1636927461989417537&wfr=spider&for=pc
https://blog.csdn.net/weixin_43610698/article/details/90734373
https://blog.csdn.net/yibin18566767255/article/details/79763791
https://www.cnblogs.com/maohuidong/p/7843807.html

橙子19911016
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
visdom static脚本包
03-22
在您提供的信息中，标题是“visdom static脚本包”，这暗示可能遇到了在启动 Visdom 时遇到的问题，即缺少 `/visdom/static/` 目录下的必要脚本文件。 Visdom 的正常运行依赖于这个 `/static/` 目录，因为它包含了...
java基础：静态内部类和非静态内部类对外部类属性的使用
M_Jack的博客
02-19 3982
public class InnerClassTest { int a = 1; static int b = 2; private int c = 3; private static int d = 4; //非静态内部类 class Inner1{ void test(){ System.out.println(a); //外部类属性 System.out.println(b); //外部.
java语句
星星的专栏
07-18 660
java语句共分为以下几种： 1.条件语句 public class test3{ public static void main(String args[]){ int score = 75; char grade; if(score >=80){ grade = 'A'; } else{ grade = 'B'; } System.out.println("Grade
单例模式、工厂模式 c++关键字 static
最新发布
霍迪迪的博客
06-11 1215
在头文件中使用extern和static声明变量，可以让多个源文件共享同一变量的声明，但每个使用该声明的源文件需要有一个独立的定义（没有static），以避免多重定义错误。：在文件作用域声明的静态变量（即在函数外部，但用static修饰），其作用范围限制在定义它的源文件内，即它是“内部链接”的。我们可以通过工厂类可以实例化圆形 和正方形，但每次用工厂类的时候，我们不需要每次都实例化一个工厂，因此工厂类就用到了单例模式，使工厂在整个系统的生命周期唯一，避免多次创建。所有类实例共享同一个静态成员变量的副本。
[转载]C语言中static全局变量与普通的全局变量的区别_亮仔_新浪博客
jingquanliang的专栏
11-06 233
原文地址：C语言中static全局变量与普通的全局变量的区别作者：可欣 static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？ 全局变量(外部变量)的说明之前再冠以static 就构成了静态的全局变量。全局变量本身就是静态存储方式， 静态全局变量当然也是静态存储方式。这两者在存储方式上并无不同。这两者的区别虽...
变量的声明和定义及extern与static使用注意事项
h522955926的博客
08-24 2829
变量定义和声明的区别： 变量的声明有两种情况： 定义性声明（定义）：需要建立存储空间，eg：int a；在声明时就已经建立好存储空间了。 引用性声明：不需要建立存储空间，eg：extern int a；仅是变量a的声明，不需要建立存储空间，变量a在其他文件中定义。 从广义的角度来看，声明中包含定义，定义是声明的一个特例。 外部变量的定义只能有一次，它位于所有函数之外；同一文件的外部...
定义和声明以及extern、static关键字
cj19920421的博客
07-24 2281
1. 定义只能进行一次，声明可以多次。 2. 变量定义是为变量分配存储空间，也可以初始化，不初始化的定义如：int i; 3. 声明是表明变量的类型和名称，因此定义也是声明。 4 . 没有初始化的时候，有extern表示这是声明，不是定义，不分配存储空间，如：extern int i; 5. 但是如果有初始化时，即使加了extern也是定义，如：extern int i =
变量属性（auto、register、static、extern）
一万HOURS的知识库
10-22 713
1 C语言的变量属性 C语言中的变量可以有自己的属性。 在定义变量的时候可以加上“属性”关键字。 “属性”关键字指变量的特有意义。 语法： property type var_name; 示例：int main() { auto char i; register int j; static long k; extern double a; return 0;
static详解
红魔&皮卡丘
12-06 931
转载：http://blog.csdn.net/jack__h/article/details/5483085 static 声明的变量在C语言中有两方面的特征：         1)、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。          2)、变量用static告知编译器，自己仅仅在变
变量的声明、定义、extern、static总结
h792746371的博客
07-13 1391
1. 变量的声明和定义 变量定义： 所谓定义就是编译器创建一个对象，并且为变量分配一块存储空间，并给它取上一个名字，这个名字就是我们经常所说的变量名或对象名。在程序中对象有且仅有一个定义。例如int a 在声明的时候已经建立了存储空间。 变量声明：声明有两重含义：第一重含义：告诉编译器，这个名字已经匹配到一块内存上了，下面的代表用到该变量或对象是在别的地方定义的，声明可以出现多次。 第二重含义：告
用static声明的函数和变量小结
nftyrose的博客
12-03 371
用static声明的函数和变量小结 static 声明的变量在C语言中有两方面的特征： 　　1)、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 　　2)、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。 Tips: 　　A.若全局变量仅在单个C文件中访问，则可以将这个变量修改
定义static方法
编程语言基础知识
03-12 1761
static方法使用static定义的属性可以直接被类名称访问，用static定义的方法也可以直接被类名称进行访问。同样不受到实例化对象的控制。 观察：如下代码class Person{ private String name; private int age; private static String country="中国"; public Person(String name,int...
C++中在类的声明中定义自身的static对象的问题
qq_35966235的博客
01-22 3775
可以定义自身的static对象，但是非static的对象就不可以。 静态数据成员的类型可以是所属类的类型，但是普通的数据成员不可以。普通的数据成员只能声明为所属类类型的指针或者引用 因为声明的静态数据成员不占用对象的内存。但是普通的数据成员在初始化呢的时候，首先要为对象分配内存，然后里面又有一个类，一直持续下去就不行，会无限迭代的分配内存。当然，引用和指针是可以的。引用和指针的大小是固定的。
java 结合内部类与外部类的静态（static）与非静态的用法
fmber的博客
11-05 1341
本文主要内容为java结合内部类与外部类的静态（static）与非静态的用法。       java中的静态和非静态主要由static关键字区分，static关键字可修饰成员内部类、方法和变量三种内容。类可以分为两种，外部类和内部类，内部类是包含在外部类里面的，也就是说一个内部类一定对应一个的外部类，内部类又分为成员内部类、匿名内部类和局部内部类，本文仅涉及成员内部类。
C++为什么要使用静态成员变量和静态成员函数，以及要在类内声明和在类外定义（初始化）
热门推荐
vict_wang的博客
07-30 1万+
相关文章 1.静态成员变量和静态成员函数诞生顺序，以及为什么诞生（使用场景）？ 2.有无this指针？ 3.和类以及对象的关系？ 4.如何定义以及访问的方式与普通成员变量和普通成员函数的区别？ 5.是怎么分配内存的？ 当调用一个对象的非静态成员函数时，系统会把该对象的起始地址赋给成员函数的this指针。而静态成员函数并不属于某一对象（所有对象共有，没有this指针，不能访问本类中非静态成员，有点...
C++静态成员变量必须在类的定义之外进行声明 (error LNK2001: unresolved external symbol)
scruffybear的专栏
08-22 633
C++的Visual Studio工程返回error LNK2001的错误，以及在调试运行的过程中出现了Unhandled exception (ntdll.dll)的问题，对这两个问题进行了解决。
import static
04-23
import static是Java语言中的一个关键字，用于导入静态成员。通过使用import static，可以直接使用类的静态成员，而无需使用类名来限定。 具体来说，当我们使用import static语句时，可以导入一个类中的静态成员，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值