精华内容
下载资源
问答
  • static关键字的作用
    千次阅读
    2022-01-11 21:12:00

    1.定义全局静态变量和局部静态变量:在变量前面加上static关键字。初始化的静态变量会在.data段分配内存,未初始化的静态变量会在.bss段分配内存。直到程序结束,静态变量始终会维持前值。只不过全局静态变量和局部静态变量的作用域不一样;

    2.定义静态函数:在函数返回类型前加上static关键字,函数即被定义为静态函数。静态函数只能在本源文件中使用;

    3.在变量类型前加上static关键字,变量即被定义为静态变量。静态变量只能在本源文件中使用;

    //示例
    static int a;
    static void func();
    

    4.在c++中,static关键字可以用于定义类中的静态成员变量:使用静态数据成员,它既可以被当成全局变量那样去存储,但又被隐藏在类的内部。类中的static静态数据成员拥有一块单独的存储区,而不管创建了多少个该类的对象。所有这些对象的静态数据成员都共享这一块静态存储空间。

    5.在c++中,static关键字可以用于定义类中的静态成员函数:与静态成员变量类似,类里面同样可以定义静态成员函数。只需要在函数前加上关键字static即可。如静态成员函数也是类的一部分,而不是对象的一部分。所有这些对象的静态数据成员都共享这一块静态存储空间。

    更多相关内容
  • C语言中static关键字作用
  • 主要介绍了c++中的 static 关键字,在我们日常使用过程中,static通常有两个作用,具体内容在文中给大家详细介绍,需要的朋友可以参考下
  • 今天主要学习下Java语言中的static关键字static关键字的含义及使用场景static是Java50个关键字之一。static关键字可以用来修饰代码块表示静态代码块,修饰成员变量表示全局静态成员变量,修饰方法表示静态方法。...

    今天主要学习下Java语言中的static关键字。

    f7a6417740f5343f022d5ecfe0163083.png

    static关键字的含义及使用场景

    static是Java50个关键字之一。static关键字可以用来修饰代码块表示静态代码块,修饰成员变量表示全局静态成员变量,修饰方法表示静态方法。(注意:不能修饰普通类,除了内部类,这是为什么?)class A {

    static {

    System.out.println("A : 静态代码块");

    }

    static int i ; // 静态变量

    static void method() {

    System.out.println("A: 静态方法");

    }

    }

    简而言之,被static关键字修饰的内容都是静态的。

    静态是相对于动态的,动态是指Java程序在JVM上运行时,JVM会根据程序的需要动态创建对象并存储对象(分配内存),对象使命结束后,对象会被垃圾回收器销毁,即内存回收由JVM统一管理并分配给其他新创建的对象;静态是指Java程序还没有运行时,JVM就会为加载的类分配空间存储被static关键字修饰的内容;如静态成员变量,Java类加载到JVM中,JVM会把类以及类的静态成员变量存储在方法区,我们知道方法区是线程共享且很少发生GC的区域,所以被static关键字修饰的内容都是全局共享的,且只会为其分配一次存储空间。

    所以当类的某些内容不属于对象,而由对象共享即属于类的时候,就可以考虑是否用static关键字进行修饰。

    static关键字的的作用

    1 修饰代码块

    类中用static关键字修饰的代码块称为静态代码,反之没有用static关键字修饰的代码块称为实例代码块。

    实例代码块会随着对象的创建而执行,即每个对象都会有自己的实例代码块,表现出来就是实例代码块的运行结果会影响当前对象的内容,并随着对象的销毁而消失(内存回收);而静态代码块是当Java类加载到JVM内存中而执行的代码块,由于类的加载在JVM运行期间只会发生一次,所以静态代码块也只会执行一次。

    因为静态代码块的主要作用是用来进行一些复杂的初始化工作,所以静态代码块跟随类存储在方法区的表现形式是静态代码块执行的结果存储在方法区,即初始化量存储在方法区并被线程共享。

    2 修饰成员变量

    类中用static关键字修饰的成员变量称为静态成员变量,因为static不能修饰局部变量(为什么?),因此静态成员变量也能称为静态变量。静态变量跟代码块类似,在类加载到JVM内存中,JVM会把静态变量放入方法区并分配内存,也由线程共享。访问形式是:类名.静态成员名。public class StaticTest {

    public static void main(String[] args) {

    System.out.println(D.i);

    System.out.println(new D().i);

    }

    }

    class D {

    static {

    i = 2;

    System.out.println("D : 静态代码块1");

    }

    static int i;

    }

    静态变量存储在类的信息中,且可以在线程间共享,那么它当然也属于该类的每个对象,因此可以通过对象访问静态变量,但编译器并不支持这么做,且会给出警告。

    注意:

    一个类的静态变量和该类的静态代码块的加载顺序。类会优先加载静态变量,然后加载静态代码块,但有多个静态变量和多个代码块时,会按照编写的顺序进行加载。class D {

    static {

    i = 2;

    System.out.println("D : 静态代码块1");

    }

    static {

    i = 6;

    System.out.println("D : 静态代码块2");

    }

    static int i;

    }

    可以想一下运行的结果。

    静态变量可以不用显式的初始化,JVM会默认给其相应的默认值。如基本数据类型的byte为0,short为0,char为\u0000,int为0,long为0L,float为0.0f,double为0.0d,boolean为false,引用类型统一为null。

    静态变量既然是JVM内存中共享的且可以改变,那么对它的访问会引起线程安全问题(线程A改写的同时,线程B获取它的值,那么获取的是修改前的值还是修改后的值呢?),所以使用静态变量的同时要考虑多线程情况。如果能确保静态变量不可变,那么可以用final关键字一起使用避免线程安全问题;否则需要采用同步的方式避免线程安全问题,如与volatile关键字一起使用等。

    static关键不能修饰局部变量,包括实例方法和静态方法,不然就会与static关键字的初衷-共享相违背。

    3 修饰方法

    用static关键字修饰的方法称为静态方法,否则称为实例方法。通过类名.方法名调用,但需要注意静态方法可以直接调用类的静态变量和其他静态方法,不能直接调用成员变量和实例方法(除非通过对象调用)。class D {

    static {

    i = 2;

    System.out.println("D : 静态代码块");

    }

    static final int i;

    int j;

    static void method() {

    System.out.println(i);

    System.out.println(new D().j);

    method1();

    new D().method2();

    }

    static void method1() {

    System.out.println(i);

    }

    void method2() {

    System.out.println(i);

    }

    }

    注意:既然类的实例方法需要对象调用才能访问,而静态方法直接通过类名就能访问,那么在不考虑部署服务器的情况下,一个类是如何开始执行的呢?最大的可能就是通过“类名.静态方法”启动Java,而我定义那么多静态方法,JVM又是如何知道主入口呢?

    或许,你想到了main方法。

    没错,就是main方法被Java规范定义成Java类的主入口。Java类的运行都由main方法开启:public static void main(String[] args) {

    for (String arg : args) { // 参数由外部定义

    System.out.println(arg);

    }}

    但注意main并不是Java关键字,它只是一个规定的程序入口的方法名字;另外main方法可以重载。

    注意:static关键字虽然不能修饰普通类,但可以用static关键字修饰内部类使其变成静态内部类。static关键字本身的含义就是共享,而Java类加载到JVM内存的方法区,也是线程共享的,所以没必要用static关键字修饰普通类。

    4 静态导入

    在用import导入包或者类时,可以用static修饰包名或者类,表示静态导入。静态导入可以与动态导入放在一起比较来加深理解。

    动态导入是当你程序运行时需要new一个不在此包中的类的对象时,才会根据全路径类名加载类;而静态导入则是随着类的加载而加载静态导入的类,所以它是提前导入的。public class StaticTest {

    static void method1() {

    System.out.println("static method1");

    }

    static void method2() {

    System.out.println("static method2");

    }

    }

    静态导入:import static com.starry.staticImport.StaticTest.method1;

    public class Client {

    public static void main(String[] args) {

    method1(); //

    StaticTest.method2();

    }

    }

    注意method1()是静态导入,所以可以不需要通过类名访问;而method2()没有导入,则需要通过类名调用。那么什么时候需要静态导入呢?

    静态导入常用于静态方法以及含有静态方法的类,枚举类等的导入,可以在编译阶段确定导入类的信息或者方法信息。

    static关键字的缺点

    封装是Java类的三大特性之一,也是面向对象的主要特性。因为不需要通过对象,而直接通过类就能访问类的属性和方法,这有点破坏类的封装性;所以除了Utils类,代码中应该尽量少用static关键字修饰变量和方法

    展开全文
  • Java中static关键字作用

    千次阅读 2021-08-16 14:37:24
    static关键字主要有两种作用: 第一,为某特定数据类型或对象分配单一的存储空间,而与创建对象的个数无关。 第二,实现某个方法或属性与类而不是对象关联在一起 具体而言,在Java语言中,static主要有4中使用情况:...

    static关键字主要有两种作用:

    第一,为某特定数据类型或对象分配单一的存储空间,而与创建对象的个数无关。

    第二,实现某个方法或属性与类而不是对象关联在一起

    具体而言,在Java语言中,static主要有4中使用情况:成员变量、成员方法、代码块和内部类

    (1)static成员变量:

    Java类提供了两种类型的变量:用static关键字修饰的静态变量和不用static关键字修饰的实例变量。静态变量属于类,在内存中只有一个复制,只要静态变量所在的类被加载,这个静态变量就会被分配空间,因此就可以被使用了。对静态变量的引用有两种方式,分别是“类.静态变量"和”对象.静态变量"

    实例变量属于对象,只有对象被创建后,实例变量才会被分配内存空间,才能被使用,它在内存中存在多个复制,只有用“对象.实例变量”的方式来引用。

    (2)static成员方法:

    Java中提供了static方法和非static方法。static方法是类的方法,不需要创建对象就可以被调用,而非static方法是对象的方法,只有对象被创建出来后才可以被使用

    static方法中不能使用this和super关键字,不能调用非static方法,只能访问所属类的静态成员变量和成员方法,因为当static方法被调用时,这个类的对象可能还没被创建,即使已经被创建了,也无法确定调用哪个对象的方法。同理,static方法也不能访问非static类型的变量。

    单例设计模式:

    static一个很重要的用途就是实现单例设计模式。单利模式的特点是该类只能有一个实例,为了实现这一功能,必须隐藏类的构造函数,即把构造函数声明为private,并提供一个创建对象的方法,由于构造对象被声明为private,外界无法直接创建这个类型的对象,只能通过该类提供的方法来获取类的对象,要达到这样的目的只能把创建对象的方法声明为static,程序实例如下:

    class Singleton{
    private static Singleton instance=null;
    private Singleton(){}
    public static Singleton getInstance(){
    if(instance==null){
    instance=new Singleton();
    }
    return instance;
    }
    }

    (3)static代码块

    static代码块在类中是独立于成员变量和成员函数的代码块的。注意:这些static代码块只会被执行一次

    (4)static与final结合使用表示的意思:

    对于变量,若使用static final修饰,表示一旦赋值不能修改,并且通过类名可以访问。

    对于方法,若使用static final修饰,表示该方法不可被覆盖,并且可以通过类名直接访问。

    public class Test{

    public static int testStatic(){
    
    	static final int i=0;
    
    	System.out.println(i++);
    
    	
    
    }
    
    public static void main(String[] args){
    
    	Test test=new Test();
    
    	test.testStatic();
    
    }
    

    }

    上述程序运行的结果:编译失败.
    在Java语言中,不能在成员函数内部定义static变量.

    展开全文
  • java中的static关键字

    千次阅读 2021-03-09 00:29:26
    一、static代表着什么在Java中并不存在全局变量的概念,但是我们可以通过static来实现一个“伪全局”的概念,在Java中static表示“全局”或者“静态”的意思,用来修饰成员变量和成员方法,当然也可以修饰代码块。...

    一、static代表着什么

    在Java中并不存在全局变量的概念,但是我们可以通过static来实现一个“伪全局”的概念,在Java中static表示“全局”或者“静态”的意思,用来修饰成员变量和成员方法,当然也可以修饰代码块。

    Java把内存分为栈内存和堆内存,其中栈内存用来存放一些基本类型的变量、数组和对象的引用,堆内存主要存放一些对象。在JVM加载一个类的时候,若该类存在static修饰的成员变量和成员方法,则会为这些成员变量和成员方法在固定的位置开辟一个固定大小的内存区域(只要这个类被加载,Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们),有了这些“固定”的特性,那么JVM就可以非常方便地访问他们。同时如果静态的成员变量和成员方法不出作用域的话,它们的句柄都会保持不变。同时static所蕴含“静态”的概念表示着它是不可恢复的,即在那个地方,你修改了,他是不会变回原样的,你清理了,他就不会回来了。

    同时被static修饰的成员变量和成员方法是独立于该类的,它不依赖于某个特定的实例变量,也就是说它被该类的所有实例共享。所有实例的引用都指向同一个地方,任何一个实例对其的修改都会导致其他实例的变化。

    二、怎么使用static

    static可以用于修饰成员变量和成员方法,我们将其称之为静态变量和静态方法,直接通过类名来进行访问。

    ClassName.propertyName

    ClassName.methodName(……)

    static修饰的代码块表示静态代码块,当JVM装载类的时候,就会执行这块代码,其用处非常大。

    1、static变量

    static修饰的变量我们称之为静态变量,没有用static修饰的变量称之为实例变量,他们两者的区别是:

    静态变量是随着类加载时被完成初始化的,它在内存中仅有一个,且JVM也只会为它分配一次内存,同时类所有的实例都共享静态变量,可以直接通过类名来访问它。但是实例变量则不同,它是伴随着实例的,每创建一个实例就会产生一个实例变量,它与该实例同生共死。

    把一个变量声明为静态变量通常基于以下三个目的:

    作为共享变量使用

    减少对象的创建

    保留唯一副本

    public class TestStatic {

    public static int count = 0;

    public static void main(String[] args){

    TestStatic test1=new TestStatic();

    System.out.println(test1.count);

    TestStatic test2=new TestStatic();

    test2.count++;

    System.out.println(test1.count+" "+test2.count+" "+TestStatic.count);

    }

    }

    =======================

    0

    1 1 1

    可见,static变量并不是所在类的某个具体对象所有,而是该类的所有对象所共有的,静态变量既能被对象调用,也能直接拿类来调用。

    2、static方法

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

    但是要注意的是,虽然在静态方法中不能访问非静态成员方法和非静态成员变量,但是在非静态成员方法中是可以访问静态成员方法/变量的。

    因为static方法独立于任何实例,因此static方法必须被实现,而不能是抽象的abstract。

    总结一下,对于静态方法需要注意以下几点:

    (1)它们仅能调用其他的static 方法。

    (2)它们只能访问static数据。

    (3)它们不能以任何方式引用this 或super。

    3、static代码块

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

    为什么说static块可以用来优化程序性能,是因为它的特性:只会在类加载的时候执行一次。下面看个例子:

    class Person{

    private Date birthDate;

    public Person(Date birthDate) {

    this.birthDate = birthDate;

    }

    boolean isBornBoomer() {

    Date startDate = Date.valueOf("1946");

    Date endDate = Date.valueOf("1964");

    return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;

    }

    }

    isBornBoomer是用来判断这个人是否是1946-1964年出生的,而每次isBornBoomer被调用的时候,都会生成startDate和birthDate两个对象,造成了空间浪费,如果改成这样效率会更好:

    class Person{

    private Date birthDate;

    private static Date startDate,endDate;

    static{

    startDate = Date.valueOf("1946");

    endDate = Date.valueOf("1964");

    }

    public Person(Date birthDate) {

    this.birthDate = birthDate;

    }

    boolean isBornBoomer() {

    return birthDate.compareTo(startDate)>=0 && birthDate.compareTo(endDate) < 0;

    }

    }

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

    4. 静态内部类

    内部类一般情况下使用不是特别多,如果需要在外部类里面定义一个内部类,通常是基于外部类和内部类有很强关联的前提下才去这么使用。

    在说静态内部类的使用场景之前,我们先来看一下静态内部类和非静态内部类的区别:

    非静态内部类对象持有外部类对象的引用(编译器会隐式地将外部类对象的引用作为内部类的构造器参数);而静态内部类对象不会持有外部类对象的引用

    由于非静态内部类的实例创建需要有外部类对象的引用,所以非静态内部类对象的创建必须依托于外部类的实例;而静态内部类的实例创建只需依托外部类;

    并且由于非静态内部类对象持有了外部类对象的引用,因此非静态内部类可以访问外部类的非静态成员;而静态内部类只能访问外部类的静态成员;

    两者的根本性区别其实也决定了用static去修饰内部类的真正意图:

    内部类需要脱离外部类对象来创建实例

    避免内部类使用过程中出现内存溢出

    第一种是目前静态内部类使用比较多的场景,比如JDK集合中的Entry、builder设计模式。

    HashMap Entry:

    8d9e608d4dd2

    builder设计模式:

    public class Person {

    private String name;

    private int age;

    private Person(Builder builder) {

    this.name = builder.name;

    this.age = builder.age;

    }

    public static class Builder {

    private String name;

    private int age;

    public Builder() {

    }

    public Builder name(String name) {

    this.name = name;

    return this;

    }

    public Builder age(int age) {

    this.age=age;

    return this;

    }

    public Person build() {

    return new Person(this);

    }

    }

    public String getName() {

    return name;

    }

    public void setName(String name) {

    this.name = name;

    }

    public int getAge() {

    return age;

    }

    public void setAge(int age) {

    this.age = age;

    }

    }

    // 在需要创建Person对象的时候

    Person person = new Person.Builder().name("张三").age(17).build();

    第二种情况一般出现在多线程场景下,非静态内部类可能会引发内存溢出的问题,比如下面的例子:

    public class Task {

    public void onCreate() {

    // 匿名内部类, 会持有Task实例的引用

    new Thread() {

    public void run() {

    //...耗时操作

    };

    }.start();

    }

    }

    声明并创建了一个匿名内部类对象,该对象持有外部类Task实例的引用,如果在在run方法中做的是耗时操作,将会导致外部类Task的实例迟迟不能被回收,如果Task对象创建过多,会引发内存溢出。

    优化方式:

    public class Task {

    public void onCreate() {

    SubTask subTask = new SubTask();

    subTask.start();

    }

    static class SubTask extends Thread {

    @Override

    public void run() {

    //...耗时操作

    }

    }

    }

    三、static关键字的误区

    1、static关键字会改变类中成员的访问权限吗?

    与C/C++中的static不同,Java中的static关键字不会影响到变量或者方法的作用域。在Java中能够影响到访问权限的只有private、public、protected(包括包访问权限)这几个关键字。看下面的例子就明白了:

    8d9e608d4dd2

    提示错误"Person.age 不可视",这说明static关键字并不会改变变量和方法的访问权限。

    2、能通过this访问静态成员变量吗?

    虽然对于静态方法来说没有this,那么在非静态方法中能够通过this访问静态成员变量吗?先看下面的一个例子,这段代码输出的结果是什么?

    public class Main {

    static int value = 33;

    public static void main(String[] args) throws Exception{

    new Main().printValue();

    }

    private void printValue(){

    int value = 3;

    System.out.println(this.value);

    }

    }

    ======================

    33

    这里面主要考查对this和static的理解。this代表什么?this代表当前对象,那么通过new Main()来调用printValue的话,当前对象就是通过new Main()生成的对象。而static变量是被对象所享有的,因此在printValue中的this.value的值毫无疑问是33。在printValue方法内部的value是局部变量,根本不可能与this关联,所以输出结果是33。在这里永远要记住一点:静态成员变量虽然独立于对象,但是不代表不可以通过对象去访问,所有的静态方法和静态变量都可以通过对象访问(只要访问权限足够)。

    3、static能作用于局部变量么?

    在C/C++中static是可以作用域局部变量的,但是在Java中切记:static是不允许用来修饰局部变量。不要问为什么,这是Java语法的规定。

    4、static和final一块用表示什么?

    static final用来修饰成员变量和成员方法,可简单理解为“全局常量”!

    对于变量,表示一旦给值就不可修改,并且通过类名可以访问。

    对于方法,表示不可覆盖,并且可以通过类名直接访问。

    static执行顺序

    对象的初始化顺序:首先执行父类静态的内容,父类静态的内容执行完毕后,接着去执行子类的静态的内容,当子类的静态内容执行完毕之后,再去看父类有没有非静态代码块,如果有就执行父类的非静态代码块,父类的非静态代码块执行完毕,接着执行父类的构造方法;父类的构造方法执行完毕之后,它接着去看子类有没有非静态代码块,如果有就执行子类的非静态代码块。子类的非静态代码块执行完毕再去执行子类的构造方法。总之一句话,静态代码块内容先执行,接着执行父类非静态代码块和构造方法,然后执行子类非静态代码块和构造方法。

    子类的构造方法,不管这个构造方法带不带参数,默认的它都会先去寻找父类的不带参数的构造方法。如果父类没有不带参数的构造方法,那么子类必须用supper关键子来调用父类带参数的构造方法,否则编译不能通过。

    参考文献

    展开全文
  • static关键字作用是什么

    千次阅读 2020-08-30 20:35:17
    static关键字作用: 1、修饰函数的局部变量 有默认值0,只du执行一次,运行一开始就开zhi辟了内存,内存放在全局 2、修饰全局函数和全局变量 只能在本源文件使用 3、修饰类里面的成员变量 和1差不多,定义多个...
  • 一、static关键字的特点: static是一个修饰符,用于修饰类的成员方法、类的成员变量,另外可以编写static代码块来优化程序性能。 1. static修饰成员方法 static修饰的方法一般称作静态方法,由于静态方法不依赖...
  • static关键字作用详解

    千次阅读 2020-11-25 14:42:33
    static关键字作用(修饰类、方法、变量、静态块) 1、修饰函数的局部变量: 特点:有默认值0,只执行一次,运行一开始就开辟了内存,内存放在全局 2、修饰全局函数和全局变量: 特点:只能在本源文件使用 3、...
  • C++ static关键字作用

    万次阅读 多人点赞 2019-06-18 16:04:14
    C++ static关键字作用 1.static修饰全局变量 当同时编译多个文件时,所有未加static前缀的全局变量和函数都具有全局可见性,其它的源文件也能访问。 未加static的全局变量,在符号表中是global符号,其他目标文件...
  • C++中static关键字作用

    千次阅读 2020-01-22 11:41:37
    C++中的static关键字作用总结 C++中的static的两种用法:一种是面向过程程序设计,第二种是面向对象程序设计。前者应用于普通变量和函数,不涉及类;后者涉及static在类中的作用。 1.面向过程设计中的static ...
  • java 中static关键字作用

    千次阅读 多人点赞 2018-05-22 10:57:39
    static关键字主要有两种作用: 第一,为特定数据类型或对象分配单一的存贮空间,而与创建对象的个数无关。第二,希望某个方法或属性与类而不是对象关联在一起,也就是说, 在不创建对象的情况下就可以通过类来直接...
  • 主要介绍了Java中static关键字作用和用法详细介绍,本文讲解了static变量、静态方法、static代码块、static和final一块用等内容,需要的朋友可以参考下
  • OC中static关键字作用

    2020-05-27 18:04:56
    static关键字可以修饰函数和变量,作用如下: 一、隐藏 通过static修饰的函数或者变量,在该文件中,所有位于这条语句之后的函数都可以访问,而其他文件中的方法和函数则不行; 二、静态变量 类方法不可以访问...
  • static关键字作用

    2018-08-10 11:24:22
    static关键字作用 static关键字作用 static关键字最基本的用法 静态块 static修饰类 static关键字最基本的用法 被static关键字修饰的常量或方法可以直接通过类名调用(如:类名.变量名,类名.方法...
  • 主要介绍了JAVA面试题 浅析Java中的static关键字,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • static关键字作用

    2021-08-26 10:51:21
    static作用:常用来修饰变量。 全局变量被static修饰后,就称之为静态全局变量;局部变量被static修饰后,就称之为静态局部变量。统称为静态变量。 如果需要进一步解释下面的现象,可以了解iOS的内存管理方面的...
  • c语言中的static关键字作用

    万次阅读 多人点赞 2018-08-19 17:42:15
    我们知道,全部变量在整个工程都可以被访问(一个文件中定义,其它文件使用的时候添加extern关键字声明 ),而在添加了static关键字之后,这个变量就只能在本文件内被访问了。因此,在这里,static的作用就是限定...
  • C语言中的Static关键字作用

    千次阅读 2022-04-03 20:04:17
    static用于修饰局部变量时,通常在某个函数体内,只能在此函数内调用。 void test() { int i = 0; i++; printf("%d ", i); } int main() { int i = 0; for (i = 0; i < 10; i++) { test(); } return...
  • static关键字有两个主要的作用:第一、为某特定数据或对象分配单一的存储空间;第二、通俗来讲就是用static修饰的方法不需要创建对象,可以通过类名直接调用方法 二、static的使用 (1)static成员变量 首先我们要...
  • C++ Static关键字作用介绍

    千次阅读 2021-06-25 13:14:58
    在全局变量前加上关键字static,全局变量就定义成一个全局静态变量。 **内存中的位置:** 静态存储区,在整个程序运行期间一直存在。 **初始化**:未经初始化的全局静态变量会被自动初始化为0(自动对象的值是任意...
  • C/C++中static关键字作用详细总结
  • 今天主要学习下Java语言中的static关键字static关键字的含义及使用场景static是Java50个关键字之一。static关键字可以用来修饰代码块表示静态代码块,修饰成员变量表示全局静态成员变量,修饰方法表示静态方法。...
  • Static关键字可以修饰什么?  从以下测试可以看出, static 可以修饰:  1. 语句块  2. 成员变量(但是不能修饰局部变量)  3. 方法  4. 接口(内部接口)  5. 类(只能修饰在类中的类, 即静态内部类)  6. ...
  • C语言中static关键字用法和作用

    千次阅读 多人点赞 2021-04-11 00:15:44
    static关键字可以修饰:局部变量、全局变量、函数 static修饰后改变了什么? 1.改变了生存周期; 2.改变了作用域; static修饰不同对象时的作用: 1.局部变量: 局部变量就是在函数内定义的变量,普通的局部变量...
  • 主要介绍了Java中static关键字作用和用法详细介绍,主要讲了静态方法、静态变量、静态类、static和final一块用等内容。需要的朋友可以参考下
  • C语言static关键字的简单介绍
  • 关键字static作用

    万次阅读 多人点赞 2019-05-05 12:21:14
    1、 关键字static作用是什么? 正确答案: 这个简单的问题很少有人能回答完全。在C语言中,关键字static有三个明显的作用: 1). 在函数体,一个被声明为静态的变量在这一函数被调用过程中维持其值不变。 2). 在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 691,567
精华内容 276,626
关键字:

static关键字的作用