精华内容
下载资源
问答
  • Java static修饰变量

    2017-04-24 22:21:03
    一、static修饰成员变量 Java 中被 static 修饰的成员称为静态成员或类成员。 它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享。 静态成员可以使用类名直接访问,也可以使用对象名进行访问。 ...

    一、static修饰成员变量
    Java 中被 static 修饰的成员称为静态成员或类成员。
    它属于整个类所有,而不是某个对象所有,即被类的所有对象所共享
    静态成员可以使用类名直接访问,也可以使用对象名进行访问
    当然,鉴于他作用的特殊性更推荐用类名访问~~这里写代码片

    例如:

    public class StaticVariable {
        //定义一个静态变量  
        static String str = "I like Java";
    
        public static void main(String[] args) {
    
            // 静态变量可以直接使用类名来访问,无需创建类的对象
            System.out.println("通过类名直接方法访问str:"+StaticVariable.str); 
            //创建类的对象
             StaticVariable objects = new StaticVariable();
             //使用对象名来访问静态变量
            System.out.println("通过对象名访问str:"+objects.str);
            //使用对象名的形式来修改静态变量的值(当然,这里也可以用类名的形式修改静态变量的值)
            objects.str = "Objective-C";
            //再次使用类名访问该静态变量,值已经被修改
            System.out.println("通过类名直接方法访问str:"+StaticVariable.str);
        }
    
    }
    

    输出结果:

    通过类名直接方法访问str:I like Java
    通过对象名访问str:I like Java
    通过类名直接方法访问str:Objective-C

    那么什么时候将成员声明为static呢 ? 举一个例子来理解 : 所有中国人共享国籍是中国,只是名字不一样而已。那么在初始化人的时候,如果为每个人都创建一个国籍成员变量都赋值成”中国”,是不是有点多余,而且占堆内存呢? 那么,此刻我们就可以把国籍这个成员变量声明成静态的,所有的对象都共享这个国籍成员变量。也就是说,每个对象都有国籍的引用。(特有数据随对象存储在堆内存当中,共有成员变量存储在方法区(共享区/数据区))。

    优先总结下static的特点
    1、随着类加载而加载,静态也会随着类消失而消失,生命周期和类一样
    2、类优先对象而存在
    3、被所有对象所共享
    4、可以直接用类名调用

    实例变量和类变量的区别
    1、存放位置
    类变量随着类的加载而存放于方法区
    实例变量随着对象的创建而存放于栈区中
    2、声明周期
    类变量生命周期最长,随着类消失而消失
    实例变量生命周期随着对象的消失而消失

    staitc 使用注释事项:
    1、静态方法只能访问静态成员(包括方法和变量),原因是:访问实例变量和实例方法只能通过对象去访问。
    非静态方法既可以方法静态也可以访问非静态

    2、静态方法中不可以使用this/super关键字
    因为静态优先对象而存在

    3、main主函数是静态的

    什么时候使用static 呢
    1、对于成员变量来说,看是否是共享数据
    2、对于方法来说,如果方法内部没有访问到实例变量时,可以声明为static。一般作为工具类,方便使用
    (如果想让程序更为严谨,可以将该类的构造函数私有化)。

    demo地址: http://download.csdn.net/download/qq_18505715/9824298

    展开全文
  • static用于修饰变量、方法和代码块时 概述 static可用于修饰变量、方法及代码块,也叫静态修饰,修饰后的功能及用法发生改变 内容 1.修饰变量 **static ** 可用于修饰成员变量,被static修饰的 成员变量 称 静态...

    static用于修饰变量、方法和代码块时

    概述

    static可用于修饰变量、方法及代码块,也叫静态修饰,修饰后的功能及用法发生改变

    内容

    1.修饰变量

    static 可用于修饰成员变量,被static修饰的 成员变量静态变量,也称 类变量

    功能:类变量在内存中只存一份,作为该类所有对象的共享变量。在程序运行时,系统只为类变量分配一次内存,只进行一次的初始化,在加载类的过程中完成类变量的内存分配。

    用法:类变量可直接通过类名称进行访问,也可通过类的实例化对象直接方法(安全性考虑,不建议这么做)。

    未使用static修饰时:未使用static修饰的 成员变量,又叫做实例变量,实例变量在创建类的对象时,才会分配一次内存,实例变量在内存中有多个拷贝,分别属于不同对象,他们之间互不影响

    2.修饰方法

    static 可用于修饰方法,被static修饰的方法称 静态方法,也称 类方法

    功能和用法:通过静态修饰的方法,可直接由类名进行调用无需实例化对象,可以方便外界在不创建对象的情况下直接调用方法,执行功能,多应用于工具类。

    工具类的编写步骤

    • a. 构造方法私有
    • b. 所有成员方法添加 static 关键字

    3.修饰代码块

    static 修饰的代码块,也成 静态代码块

    功能和用法:静态代码块无论创建多少个对象,都是优于构造方法和构造代码块之前执行,并且只执行一次。在类加载的时候执行,类中的成员第一次使用的时候开始类加载。

    与静态代码块对应的,有 构造代码块局部代码块同步代码块

    扩展

    构造代码块:定义在成员位置,用于抽取多个构造方法中的共性代码,从而达到简化代码的目的,执行时机: 每次访问构造方法之前执行,可以执行多次;

    局部代码块:定义在局部位置,方法体内,限定局部变量的作用域;

    同步代码块:使用synchronize关键字修饰的代码块,成为同步代码块,同步代码块应用于并发操作可能造成的异常。

    展开全文
  • 1. static关键字的使用形式:static可以用作函数和变量的前缀,用以修饰变量,函数,数据成员,成员函数。(1)在C/C++中,修饰变量或函数:如,static int a; // 静态变量 static get_a(){ return a;} // 静态函数...

    1. static关键字的使用形式:
    static可以用作函数和变量的前缀,用以修饰变量,函数,数据成员,成员函数。
    (1)在C/C++中,修饰变量或函数:如,static int a;               // 静态变量
                                        static get_a(){ return a;}  // 静态函数
    (2)在C++中,修饰数据成员或者成员函数:如,
         class A {
             private:
                 static int a;                  // 静态数据成员
             public:
                 static int get_a(void);        // 静态成员函数
         };

    2. static关键字的功能:
    (1)对于函数来讲,static的作用仅限于隐藏
    (2)对于变量,除了隐藏,static还有下面两个作用:保持变量内容的持久;默认初始化为0。

     

    3. 静态变量的特点:
    (1)静态局部变量在定义它的函数内部时可见的,只能被定义它的函数使用。
    (2)静态变量存放在内存的静态数据区,静态局部变量一经定义不会再次分配存储空间,也不会自行消失,直到程序运行结束,这一点与全局变量相同。
    (3)静态变量默认初始值为0,也可专门初始化,这一点又与全局变量相同。
    (4)存储在静态数据区的变量会在程序刚开始运行时就完成初始化,也是唯一的一次初始化。共有两种变量存储在静态存储区:全局变量和static变量

     

    4. 静态函数访问规则:
    (1)在模块内的static全局变量可以被模块内所有函数访问,但不能被模块外其它函数访问;
    (2)在模块内的static函数只可被这一模块内的其它函数调用,这个函数的使用范围被限制在声明它的模块内;
    (3)对于静态变量和非静态变量,只要其对于函数是可见的,那么,无论函数前面是否有static,均可以访问该变量。

     

    例:

    /*  编辑编译环境:Dev-C++ 4.9.9.2  */
    
     /* file1:  staticDefine.h */
    
    
    #include <stdio.h>
    #include <stdlib.h>
    
    
    
    static int staticValue;
    
    
    static void printValue()
    {
           staticValue++;
           printf(" staticValue = %d /n", staticValue);
    
    
    }
    
    
    
    
    
    /* file2:  staticTest.cpp */
    
    
    #include "staticDefine.h"
    
    
    
    typedef struct
    {
        bool Hwd_Audio_MainMic_Open;
        bool HWwd_Audio_HeadsetMic_Open;
        int *TestP;
     
    }HwdAudioAutoTest;
    
    static HwdAudioAutoTest  CitAudioAutoTest;
    
    
    int main()
    {                                                // result:
        printf("%d /n", staticValue);  // 0
        printValue();                          // 1
    
        printf("%d,    %d,    %d/n", CitAudioAutoTest.Hwd_Audio_MainMic_Open, CitAudioAutoTest.Hwd_Audio_MainMic_Open, CitAudioAutoTest.TestP);  // 0    0    0
    
    
    
        {
    
             static int x = 12;
    
             printf("x = %d /n",x);      //12
    
         }
    
         //printf("x = %d /n",x);        //error
    
    
    
        while(1);
    }


     

     

    5. 静态数据成员的特点(见例1):
    (1)除了在类定义中列出静态类成员外,还必须在源文件中为其分配空间,可以同时进行显示初始化,如果不进行显示初始化,则默认初始化为0;
    (2)静态数据成员可以被类中的任何成员函数访问.

    例1:

    // 例1:
    
    /*  编辑编译环境:Dev-C++ 4.9.9.2  */
    #include <stdio.h>
    
    class A {
       private:
         static int a;
    
         //static int b = 0;  //error: ISO C++ forbids in-class initialization of non-const static member `b'
    
                                     //请与static const int b = 0; 作比较
         
       public:
         static int get_a(); // 静态成员变量a 可以被静态成员访问
         int get_a2()
         {
             return a;      // 静态成员变量a可以被非静态成员访问
         };
    };
    
    int A::a; //必须为静态数据成员分配空间,否则,会出现如下link error: undefined reference to `A::a'。这里,采用自动初始化为0,等价于  int A::a = 0;
    
    int A::get_a()
    {
        return a;
    }
    
    int main(void)
    {
        A a1;
        printf("A::get_a():  %d /n",A::get_a());    // 0, get_a只能通过类来调用
        printf("a1.get_a2():   %d ",a1.get_a2());   //0, get_a2只能通过对象来调用.
    
        while(1);
    }

    代码说明:

    错误1: ISO C++ forbids in-class initialization of non-const static member `b'
    解释:int型的静态数据成员有默认值,且是0,在定义时不可以进行赋值操作。

     

    6. 静态成员函数的特点(见例2):

    (1) 静态成员函数只可以引用本类的静态数据成员或其它(外部函数,其它类)的静态成员函数,因为这些成员在没有建立对象之前就已经存在,无须引用一个类实例便可以被调用;

    (2)同时,静态成员函数无法直接访问未经实例化的非静态成员,因为静态成员函数没有指定存放对象的地址。

            静态成员函数要想访问该对象的非静态成员,只能通过对象名或指向对象的指针来访问。

    例2:

    /*  编辑编译环境:Dev-C++ 4.9.9.2  */
    
    // 例2:
    
    
    #include <stdio.h>
    
    static int ver = 10;
    static int get_ver(void) { return ver; }
    
    class B {
       private:
         static int b;
        
       public:
         static int get_b();
         int get_b2()
         {
             return b;    
         };
    };
    
    int B::b;
    
    int B::get_b()
    {
        return b;
    }
    
    class C {
          private:
                  int i;
                  static int j;
          public:
                 static void getFun(void)
                 {
                        //i++;             //error, 参考第一条说明, 静态成员函数不能访问本类的非静态数据成员。
                        //B::get_b2();    //error, 参考第二条说明, 静态成员函数不能访问未经实例化的非静态成员。
                       
                        j++;             //OK, 参考第一条说明,getFun可以引用本类的静态数据成员
                        get_ver();       //OK,参考第一条, getFun可以引用外部函数的静态成员函数
                        B::get_b();      //OK,参考第一条, getFun可以其它类的静态成员函数
                       
                        B b1;
                        b1.get_b2();     //OK, 参考第二条说明, 静态成员函数可以访问已经实例化的非静态成员。
                 }
    
                 static int get_i( C &x)
    
                 {
    
                     return x.i;            //OK,// 静态成员函数通过对象名来访问该对象的非静态成员
    
                 }
    };
    
    int C::j = 0; // 必须进行初始化
    
    int main(void)
    {
    
       C c1;
       printf("x = %d /n", C::get_i(c1));
    
    
       C::getFun();
      
        while(1);
    }

     

    展开全文
  • final可以修饰类,方法,变量。 final修饰的类不可以被继承。 final修饰的方法不可以被覆盖。 final修饰变量是一个常量,只能被赋值一次。 内部类只能访问被final修饰的局部变量(JDK8之前)。 //final修饰...

    final可以修饰类,方法,变量。

    • final修饰的类不可以被继承。
    • final修饰的方法不可以被覆盖。
    • final修饰的变量是一个常量,只能被赋值一次。
    • 内部类只能访问被final修饰的局部变量(JDK8之前)。

     

    //final修饰的类不可以被继承
    final class Person
    {
    	String name;
    	int age;
    	
    	void show()
    	{
    		System.out.println("person...");
    	}
    }
    
    class Student extends Person //子类无法继承被final修饰的父类
    {
    	void study()
    	{
    		System.out.println("study...");
    	}
    }
    
    public class FinalClass
    {
    	public static void main(String[] args)
    	{
    		Student s = new Student();
    		s.study();
    	}
    }
    /*
    Exception in thread "main" java.lang.Error: 无法解析的编译问题:
    	类型 Student 不能成为终态类 Person 的子类
    */

     

    //final修饰方法不能被覆写
    class Person
    {
    	String name;
    	int age;
    	
    	final void show()
    	{
    		System.out.println("person...");
    	}
    }
    
    class Student extends Person
    {
    	void show() //final修饰的方法不能被覆写
    	{
    		System.out.println("student...");
    	}
    }
    
    public class FinalClass
    {
    	public static void main(String[] args)
    	{
    		Student s = new Student();
    		s.study();
    	}
    }
    /*
    Exception in thread "main" java.lang.VerifyError: 
    class Student overrides final method show.()
    */

     

    //final修饰的变量只能赋值一次
    class Person
    {
    	String name;
    	final int AGE = 24;
    	
    	void show()
    	{
    		System.out.println("person...");
    	}
    }
    
    class Student extends Person
    {
    	void show()
    	{
    		System.out.println("student...");
    	}
    }
    
    public class FinalClass
    {
    	public static void main(String[] args)
    	{
    		Student s = new Student();
    		s.AGE = 20; //final变量重复赋值
    		s.show();
    	}
    }
    /*
    Exception in thread "main" java.lang.Error: 无法解析的编译问题:
    	不能对final字段 Person.AGE 赋值
    */

     

    //内部类只能访问被final修饰的局部变量
    class Person 
    {
    	String name;
    	int age;
    	
    	void display()
    	{
    		int x = 10; //JVM隐式添加final,不初始化会报错
    		class Inner
    		{
    			void show()
    			{
                               //x = 5;//出错,final变量不能重复赋值
    				System.out.println(x);
    			}
    		}
    		new Inner().show();
    	}
    }
    
    public class InnerFinal
    {
    	public static void main(String[] args)
    	{
    		Person p = new Person();
    		p.display();
    	}
    }
    /*
    //局部内部类(定义在方法中的内部类)Inner中的show()访问了外部类中的局部变量x。
    //这里x并没有用final修饰(1.8之后java隐式的将x修饰为final)
    10
    */

     

    展开全文
  • 常见的修饰变量的关键字

    千次阅读 2018-01-04 15:22:00
    (1) 当一个共享变量被volatile修饰时,它会保证修改的值会立即被更新到主存,当有其他线程需要读取时,它会去内存中读取新值。 (2)禁止进行指令重排序。 (3)参考:http://www.importnew.com/18126.html 关于...
  • *******************************概念***************************************************************************************************************************首先得明白全局变量、静态全局变量、局部变量...
  • final修饰的特点: 修饰类,类不能被继承 修饰变量,变量就变成了常量,只能被赋值一次 修饰方法,方法不能被重写
  • 使用Final修饰修饰的类、对象、方法和变量特点 一、使用Final修饰修饰的类的特点:该类不能有子类 ; 二、使用Final修饰修饰的对象的特点:该对象的引用地址不能改变,只能赋值一次; 三、使用Final修饰符...
  • static修饰变量特点

    2020-11-13 10:43:46
    static修饰的成员变量又称为类变量。 不加static修饰的成员变量又叫对象变量。 成员变量和类变量的区别: 1、两个变量的生命周期不同 成员变量随着对象的创建而存在,随着对象的回收而释放。 静态变量随着类的...
  • (也就是说,多个对象在访问或修改static修饰的成员变量时,其中一个对象将static成员变量值进行了修改,其他对象中的static成员变量值跟着改变,即多个对象共享同一个static成员变量) 代码演示: class Demo { ...
  • 平时在项目中可能经常会用到一些常量,一般都定义成static final的,有时候可能会突然想到,到底staitc,final,static final定义的变量到底有什么关系呢? 通过以下例子一起看一下: /** * @Description: 变量...
  • ...在C语言中,static的字面意思很容易把我们导入歧途,其实它的作用有三条。...(1)先来介绍它的第一条也是最重要的...当我们同时编译多个文件时,所有未加static前缀的全局变量和函数都具有全局可见性。为理解这
  • /* final可以修饰类,方法,变量 ... final可以修饰变量,该变量不能被重新赋值。因为这个变量其实是常量。 常量: A:字面值常量 "hello",10,true B:自定义常量 final int x = 10; */ //final cla
  • const 具体使用! 1,const int p; //是一个常整型数,只读变量,不能通过p修改对应内存里的值 ... //去掉类型int, const修饰*p, (*p)++不可以,p所指向空间的值不可以改变,p++是对的,p指针可以后移...
  • 一、使用Final修饰修饰的类的特点:该类不能有子类;二、使用Final修饰修饰的对象的特点:该对象的引用地址不能改变;...四、使用Final修饰修饰变量特点:该变量会变成常亮,值不能被改变。...
  • 1、static修饰变量和方法,在类加载时即被初始化,可直接通过类名.变量名和类型.方法名进行调用。 2、static修饰变量,在类加载时会被分配到数据区的方法区。类的实例可共享方法区中的变量。如果static修饰的...
  • package Tets08;... * 修饰变量,变量就变成了常量,只能被赋值一次 * 修饰方法,方法不能被重写 * C:案例演示 * final修饰特点*/ class Test6_Final { public static void main(String[]args){ Gri...
  • static 修饰局部变量 - 静态局部变量 static 修饰全局变量 - 静态全局变量 static 修饰函数 - 静态函数 static 关键字的三种用法1. static 修饰局部变量 - 静态局部变量2. static 修饰全局变量 - 静态全局变量3. ...
  • (1)Static关键字作用修饰符 可以修饰成员(成员属性 成员方法)(2)Static修饰成员的特点a 生命周期长 跟类相同b 用Static修饰的变量 所有对象共享c Static修饰变量 可以通过对象(.)点的形式调用 还可以通过类名...
  • static变量特点介绍

    千次阅读 2015-09-21 00:08:34
    static修饰变量  1. 全局静态变量  在全局变量之前加上关键字static,全局变量就被定义成为一个全局静态变量。  1)内存中的位置:静态存储区(静态存储区在整个程序运行期间都存在)  2)初始化:未经...
  • Java final修饰类/方法/变量特点

    千次阅读 2016-07-10 00:32:48
    * 修饰变量,变量就变成了常量,只能被赋值一次 * 修饰方法,方法不能被重写 * C:案例演示 * final修饰特点*/ //final class Father6{ //final修饰的类不能够被继承,例如String类就是final 修饰的类,String...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 112,061
精华内容 44,824
关键字:

修饰变量的特点