成员变量 订阅
成员变量是指定维度的成员变量,用于标识某个维度成员。 展开全文
成员变量是指定维度的成员变量,用于标识某个维度成员。
信息
属    性
指定维度的成员变量
外文名
Member Variables
中文名
成员变量
目    的
标识某个维度成员
成员变量简介
由 Analysis Services 内部使用的值,以标识某个维度成员。MemberKeyColumn 属性指定维度的成员变量。例如,1 到 12 之间的某个数字可以是相应于年中的某个月的成员变量。
收起全文
精华内容
下载资源
问答
  • 编程语言的三大发展阶段:面向机器语言、面向过程语言、面向对象语言 ; 其中面向对象语言主要体现三个特征:封装性、继承、...2、类声明的变量称为对象变量,也简称 对象 ; 3、class 关键字是用来定义类 ; 4、...

    编程语言的三大发展阶段:面向机器语言、面向过程语言、面向对象语言 ;

    其中面向对象语言主要体现三个特征:封装性、继承、动态 ;

    类的定义:类声明和类体。基本格式如下:

    class 类名{

       类体

    }

    特点:

    1、类是Java程序的基本要素,一个Java应用程序就是由若干个类所构成;

    2、类声明的变量称为对象变量,也简称 对象 ;

    3、class 关键字是用来定义类 ;

    4、类的目的是抽象出一类事物共有的属性和行为,并用一定的语法格式来描述所抽象出的属性和行为;

    4、类名必须是合法的Java标识符;

    Java标识符详细说明:(以及中文标识符的说明)

    https://blog.csdn.net/LagerSwan/article/details/104081548


    类的声明:

    如下所示:

    class Number {

    .....

    }

    class 数字 {

    .....

    }

    其中 class Number 与 class 数字 称为类的声明,而 Number 和 数字 则为类名 ;


    类体,即 { } 中的内容:

    类体的内容由如下两部分构成:

    • 变量的声明:用来存储属性的值 ;(体现了对象的属性)
    • 方法的定义:方法可以对类中声明的变量进行操作;(体现了对象的行为)

    如下代码演示:

    public class Class_Test {
    	int number = 10;
    	double numberd = 11.111;
    	double TestDouble() {
    		double numbers = 100 ;
    		numbers += numberd;
    		return numbers;
    	}
    	public static void main(String[] args) {
    		Class_Test test = new Class_Test();
    		System.out.println(test.TestDouble());
    	}
    }

    在以上代码中,声明了一个类 Class_Test ,两个变量 number 与 numberd ,一个方法 TestDouble() ,一个主方法 main () ;


    成员变量的定义:

    一、成员变量的类型:

    成员变量的类型可以是Java中的任何一种数据类型,包括了基本数据类型:整形、浮点型、逻辑类型、字符类型 ;引用类型中的:数组、对象和接口;  

    如下代码演示:

    public class Class_Test {
    
    	public static void main(String[] args) {
    		
    		//成员变量的说明
    		//基本数据类型的成员变量
    		int testt = 11 ;
    		float testf = 11.111f ;
    		double testd = 11.11111 ;
    		//引用类型的变量
    		int a [] ;
    		Class_Test test ;
    		
    	}
    }

    在以上代码中,成员变量:testt,testf,testd 是基本数据类型的变量;a [ ] ,test是引用类型的变量,a [ ] 为数组的变量,test 为类声明的变量,即类对象;

    二、成员变量的有效范围:

    成员变量在整个类内都是有效的,其有效性与它在类体中声明的先后位置是不关的;

    如下代码演示:   最终输出: 110

    public class Class_Test {
    	
    	//成员变量的有效范围:
    	int number = 11 ;
    	int Int_Test(){
    		int int1 = number * digit ;
    		return int1;
    	}
    	int digit = 10 ;
    
    	public static void main(String[] args) {
    		//类体的说明
    		Class_Test test = new Class_Test();
    		System.out.println(test.Int_Test());	
    	}
    }
    

    不建议大家这样编写程序,当代码量多时,对代码的可读性有一定的影响,建议先声明成员变量,再定义方法;

    三、成员变量的编写风格:

    建议大家在声明成员变量时,变量的名字使用驼峰规则,即变量名由多个单词组成时,从第二个单词开始的其他单词的首字母大学;如:computerArea 、ClassExceptionShow 


    方法的使用:

    在类体中,方法的定义包括两部分:方法头、方法体 ;  一般格式如下:

    方法头 {

       方法体

    }

    一、方法头说明

    方法头由方法的类型、名称、名称后面的 () 以及 ()里面的参数列表所构成;

    如下代码演示:

    //无参数的方法头
    double testd (){
        return 11.111;
    }
    
    //有参数的方法头, x 和 y 即为参数
    double testd (double x,double y){
        return x+y;
    }

    二、方法体说明:

    方法体即 方法()后面的 { } 以及 { } 里面的内容;

    在方法体中声明的变量为局部变量,而不是成员变量,局部变量只在方法体内有效,而且与声明时的前后位置有关;

    如下代码演示:

    double testd = 10 ;
    double testd (double x,double y){      //参数 x,y是局部变量
       double sum;                         //参数 sum 是局部变量
       sum = x + y ;
    
       if(sum>x){
           sum += testd ;         //参数 testd 是成员变量(全局变量)
    }
    
        return sum;        //return 语句,返回 sum 的值
    }

    局部变量的介绍:

    1、局部变量不同与成员变量,局部变量只在方法中有效,而且与其声明的位置顺序有关;

    2、若局部变量声明在一个复合语句中,那么该局部变量的有效范围只在复合语句中有效;

    double testd (double x,double y){      //参数 x,y是局部变量
    	   double sum;                         //参数 sum 是局部变量
    	   sum = x + y ;
    	   if(sum != 0){
    	       int ints = 1;        // ints 为复合语句中的局部变量
    	       sum += ints ;
    	}
            double bottom = 1.1;
            bottom += ints ;         //程序报错:ints cannot be resolved to a variable
    	    return sum;
    	}

    3、若局部变量声明在一个循环语句中,那么该局部变量的有效范围只在循环语句中有效;和以上复合语句是一样的;


    总结:成员变量与局部变量的区别

    1、局部变量不同与成员变量,局部变量只在方法中有效,而成员变量在整个类中都有效;

    2、局部变量与其声明的位置顺序有关,而成员变量与其声明的位置顺序无关;

    3、若局部变量的名字和成员变量的名字相同,那么成员变量会被隐藏,即在方法体中成员变量暂时是无效的,如下代码演示:

    class Test_Variable {
        int x = 10 , y ;
       void tests () {
          int x = 5 ;
          y = x + 10 ; //y的值为 15 ,而不是20,此时成员变量 x = 10 在该方法体中,暂时失效;
       }
    
    }

    4、当想使用方法中被隐藏的成员变量,可以使用关键字 this 进行调用,如下代码演示:

    class Test_Variable {
        int x = 10 , y ;
       void tests () {
          int x = 5 ;
          y = this.x + 10 ; //此时 y 的值为 20 ,而不是15,this.x调用的为成员变量 x = 10 ;
       }
    
    }

    5、成员变量有默认值,而局部变量没有默认值,因此在使用局部变量时,要确保该局部变量是有初始值的,否则程序报错;

    class Test_Variable {
    
               int  y ;
    	   void tests () {
    	      int x;       //报错:The local variable x may not have been initialized
    	      y = x + 10 ; 
    	   }
    
    }

     

     

     

    展开全文
  • 成员变量和局部变量详解

    千次阅读 多人点赞 2020-06-10 10:19:53
    文章目录1、考点:2、局部变量和成员变量的区别3、具体的测试代码4、过程分析(重点)5、补充 1、考点: 就近原则 变量的分类 成员变量:类变量、实例变量 局部变量 非静态代码块的执行:每次执行实例对象都会...

    好吧,我承认我有赌的成分。我以为我能赌出答案,结果赌输了。


    还得利用JVM的知识点进行运算。




    1、考点:

    • 就近原则
    • 变量的分类
      • 成员变量:类变量、实例变量
      • 局部变量
    • 非静态代码块的执行:每次执行实例对象都会执行
    • 方法的调用规则:调用一次执行一次



    2、局部变量和成员变量的区别

    1、声明位置

    1. 局部变量:方法体{}中、形参、代码块{}中
    2. 成员变量:类中方法外
      • 类变量:有static修饰
      • 实例变量:没有static修饰

    2、修饰符

    1. 局部变量:final
    2. 成员变量:public、protect、private、final、static、volatile、transient(序列化)

    3、存储位置:

    1. 局部变量:栈
    2. 实例变量:堆
    3. 类变量:方法区

    4、作用域

    1. 局部变量:从声明处开始,到所属的 } 结束
    2. 实例变量:在当前类中 “this.” (有时this.可以省略),在其他类中 “对象名.” 访问
    3. 类变量:在当前类中 “类名.” (有时类名. 可以省略),在其他类中“类名.” 或 “对象名.” 访问

    5、生命周期

    1. 局部变量:每一个线程,每一次调用执行行都是新的生命周期
    2. 实例变量:随着对象的创建而初始化,随着对象的被回收而消亡,每一个对象的实例化变量是独立的
    3. 类变量”随着类的初始化而初始化,随着类的卸载而消亡,该类的所有对象的类变量是共享的

    补充:

    堆(Heap):

    此内存区域的唯一目的就是存放实例对象,几乎所有的实例对象都在这里分配内存。这一点在Java虚拟机规范中的描述是:所有的对象实例以及数组都要在堆上分配

    栈(Stack):

    通常说的栈是指虚拟机栈**。虚拟机栈用于存储局部变量表等。局部变量表存放了编译期可知长度的各种基本数据类型(8大基本数据类型)、对象引用(reference类型,它不等同于对象本身,是对象在堆内存的首地址)。方法执行完,自动释放。

    方法区(Method Area):

    用于存储已被虚拟机加载的类信息、常量、静态变量、即使编译器编译后的代码等数据




    3、具体的测试代码

    测试代码:

    package pers.mobian.questions06;
    
    public class Test01 {
        static int s;//成员变量,类变量
        int i;//成员变量,实例变量
        int j;//成员变量,实例变量
    
        {
            int i = 1; //局部变量
            i++; //局部变量 如果此处想要成为成员变量,就需要在变量前面添加一个this关键字
            j++; //成员变量
            s++; //成员变量
        }
    
        public void test(int j) {
            j++; //局部变量 如果此处想要成为成员变量,就需要在变量前面添加一个this关键字
            i++; //成员变量
            s++; //成员变量
        }
    
        public static void main(String[] args) {
            Test01 test01 = new Test01();
            Test01 test02 = new Test01();
            test01.test(10);
            test01.test(20);
            test02.test(30);
            System.out.println(test01.i + "," + test01.j + "," + test01.s);
            System.out.println(test02.i + "," + test02.j + "," + test02.s);
        }
    }
    
    

    执行结果:

    2,1,5
    1,1,5
    




    4、过程分析(重点)

    Test01 test01 = new Test01();
    Test01 test02 = new Test01();

    执行这两句以后,对应的信息变化为下图:

    补充:

    1. 先对该类进行初始化,即会调用对应的clint方法,在方法区中为s开辟一块空间
    2. 实例化对象的时候,会调用对应的init方法,其中init方法由非静态实例变量显示赋值代码非静态代码块对应构造器代码组成
    3. 非静态实例变量显示赋值代码:i = 0, j = 0
    4. 非静态代码块:执行 {} 中的代码块(在栈中开辟一个栈帧),其中代码块中的 i 为局部变量,代码块执行完毕消失。但是 j 为成员变量,所以会进行对应的 +1 操作(就近原则),成员变量 i 结果不变。
    5. 对应构造器代码:此处无参构造没有任何效果,所以可以忽略

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M9bdbPfj-1591754744864)(06_成员变量和局部变量.assets/image-20200607205942615.png)]


    test01.test(10)
    test01.test(20)
    test02.test(30)

    执行这三行代码以后内存的分配情况,如下图:

    补充:

    1. test01调用对应的test方法的时候,j 是局部变量所以 j 值为11,注意区分此处的 j 和堆内存中的 j 值。
    2. test方法中的 i 值为成员变量,所以会在堆内存中被修改为1
    3. test方法中的 s 值也是成员变量,并且其是static变量,所以 s 变量会在方法区中进行 +1 操作
    4. 再次执行test01中的test方法,重复1-3的步骤
    5. 执行test02对象中的test方法,i 的 +1 在堆中完成,s 的 +1 操作在方法区中完成,j 的 +1 操作在栈中完成 j = 31(由于 j 变量是局部变量,所以在执行对应的操作以后,失效)




    5、补充

    当局部变量与xx变量重名时,如何区分:

    1. 局部变量与实例变量重名
      • 在实例变量前面提添加 “this.” 关键字
    2. 局部变量与类变量重名:
      • 在类变量前面加 “类名.”
    展开全文
  • c++ 静态成员变量用static 关键字来声明,是整个类的数据成员,其存储不占用某个具体对象的空间,其存储在静态存储区。 c++ 静态成员函数用static 关键字来声明,用于处理静态成员变量,可以用类名来调用,也可以用...

    前言

    c++ 静态成员变量用static 关键字来声明,是整个类的数据成员,其存储不占用某个具体对象的空间,其存储在静态存储区
    c++ 静态成员函数用static 关键字来声明,用于处理静态成员变量,可以用类名来调用,也可以用对象名来调用。

    使用静态成员变量的目的:静态成员变量是整个类的数据成员,使用静态成员变量可以实现多个对象共享数据

    测试1:

    #include <iostream>
    using namespace std;
    
    class Point{
    public:
        Point(int xx,int yy):x(xx),y(yy){count++;}
        Point():Point(0,0){}
        Point(const Point &p);
        ~Point(){count--;}
        void show(){cout<<x<<" "<<y<<endl;}
        static void showcount();  //用static来声明静态成员函数
    private:
        int x,y;
        static int count; //用static来声明静态成员变量
    };
    
    int Point::count = 0;   //静态成员变量的定义,定义时前面不可以再有static, 且它必须要在类外面来初始化,不能在类内部初始化。静态成员变量在初始化时分配内存。
    
    void Point::showcount() {    //静态成员函数的定义,前面不可以再有static,可以在类内部定义,也可以在类外定义。此例为在类外面进行定义。
        cout<<"count="<<count<<endl;
    }
    
    Point::Point(const Point &p){  //复制构造函数
        x = p.x;
        y = p.y;
        count++;
    }
    
    Point fun(Point m){ 
        return m;
    }
    
    int main(){
        Point::showcount(); //用     类名::函数名      来调用静态成员函数
        Point a(1,2);
        a.show();
        a.showcount();//也可用    对象名.函数名   来调用静态成员函数
        Point b(a);
        b.show();
        b.showcount();
        Point c;
        c.show();
        c.showcount();
        Point d = fun(c);
        d.show();
        d.showcount();
        return 0;
    }
    

    运行结果:
    $ ./a.out
    count=0
    1 2
    count=1
    1 2
    count=2
    0 0
    count=3
    0 0
    count=4

    在这里插入图片描述
    如图,对象a占用8个字节(成员x,y的空间,count不在里面),对象a是局部对象,存放在栈上0x7fffffffdde0的位置处。
    在这里插入图片描述
    count存放在静态存储区的 0x555555756134,不存储在对象中。count属于整个类,不属于某一个具体的对象。
    静态成员函数也是一样,属于整个类,不属于某一个对象,所以静态成员函数可以用类名来调用,比如:Point::showcount() 。

    static 成员变量必须在类声明的外部初始化,具体形式为:

     type class::name = value;
    

    如本例:int Point::count = 0;
    静态成员变量在初始化时不能再加 static,但必须要有数据类型。

    static 成员变量的内存既不是在声明类时分配,也不是在创建对象时分配,而是在(类外)初始化时分配。没有在类外初始化的 static 成员变量不能使用,因为没分配空间。

    测试2:

    #include <iostream>
    #include <cmath>
    using namespace std;
    
    class Point{
    public:
        Point(int xx,int yy):x(xx),y(yy){count++;}
        Point():Point(0,0){}
        Point(const Point &p);
        ~Point(){count--;}
        void show(){cout<<x<<" "<<y<<endl;}
        static void showcount();
    public:
        static int count;   //此例为public属性
    private:
        int x,y;
    };
    
    int Point::count = 0;
     
    void Point::showcount() {
        cout<<"count="<<count<<endl;
    }
    
    Point::Point(const Point &p){
        x = p.x;
        y = p.y;
        count++;
    }
    int main(){
        Point::showcount();
        Point a(1,2);
        cout<<a.count<<endl;  //通过对象a来访问静态成员变量。若count不是public属性,不能用对象来访问,编译时就会报错
        Point::showcount();
        Point b(3,4);
        Point::showcount();
    
        return 0;
    }
    

    用GDB来查看静态成员变量的存储:
    在这里插入图片描述
    可以看到,当b中count变为2,a中count也变为2,即a和b中的count是共享的。查看a.count和b.count的地址,可以发现是同一个地址,即是同一个存储空间。且这个存储空间是全局存储区(静态存储区),不在对象a和对象b的栈(stack)存储区。
    此例中count是public,修改为protected和private,编译报错。

    protected:
        static int count;
    

    在这里插入图片描述

    private:
        static int count;
    

    在这里插入图片描述
    如上图,也就是说,想通过对象来访问静态成员变量,静态成员变量只能是public属性。这一点和对象去访问普通的成员变量一样。类外面,对象只能访问public成员变量,不能访问protected和private的成员变量。

    测试3:

    void Point::showcount() {
        cout<<"count="<<count<<endl;
        cout<<x<<endl; //新增,尝试在静态成员函数中去访问普通的成员变量,编译报错。
    }
    

    在这里插入图片描述
    也即是说,在静态成员函数中,不能去访问普通的成员变量。原因是没有this指针,不知道普通成员变量x放在哪里。
    原因分析:
    编译器在编译一个普通成员函数时,会隐式地增加一个形参 this,并把当前对象的地址赋值给 this,所以普通成员函数只能在创建对象之后通过对象来调用,因为它需要当前对象的地址。也即是有了对象,才有对象的this指针,没有对象,就无法调用普通成员函数。由于类没有this指针,所以不能用类名去调用普通成员函数,只能用实际的对象去调用普通成员函数

    而静态成员函数可以通过类来直接调用,编译器不会为它增加形参 this,它不需要当前对象的地址,所以不管有没有创建对象,都可以调用静态成员函数。因为静态成员函数要访问的是静态成员变量(存储在全局存储区,和this指针没毛关系)。
    由于静态成员函数没有 this 指针,不知道指向哪个对象,无法访问对象的成员变量,所以静态成员函数不能访问普通成员变量,只能访问静态成员变量

    总结:

    1. 一个类中可以有一个或多个静态成员变量,所有的对象都共享这些静态成员变量,都可以引用它。注意,是共享,共享,共享,也即是只会占同一份静态存储空间
    2. static 成员变量和普通 static 变量一样,都在内存分区中的全局数据区分配内存,到程序结束时才释放。这就意味着,static 成员变量不随对象的创建而分配内存,也不随对象的销毁而释放内存。而普通成员变量在对象创建时分配内存,在对象销毁时释放内存。根本原因是静态成员变量和对象的存储空间不同,是在不同的时期去分配的
    3. 静态成员变量必须初始化,而且只能在类体外进行。例如:
      int Point::count = 0;
      初始化时可以赋初值,也可以不赋值。如果不赋值,那么会被默认初始化为 0
      全局数据区的变量都有默认的初始值 0,而**动态数据区(堆区、栈区)**变量的默认值是不确定的,一般认为是垃圾值。
    4. 静态成员变量既可以通过对象名访问,也可以通过类名访问,但要遵循 private、protected 和 public 关键字的访问权限限制。
      当在类外面通过对象名访问时,静态成员变量属性必须是public,对于不同的对象时,访问的是同一份内存(本质是共享)。
    5. 静态成员函数在声明时要加 static,在定义时不能加 static 。静态成员函数只能访问静态成员变量,去访问普通成员变量,编译就报错。
    展开全文
  • 成员变量、类变量(静态变量)、局部变量的区别

    千次阅读 多人点赞 2017-08-03 20:31:04
    如果局部变量的名字和成员变量的名字相同, 要想在该方法中使用成员变量,必须使用关键字this [java] view plain copy class People {   String name = "类体重定义的name";
    变量名首写字母使用小写,如果由多个单词组成,从第2个单词开始的其他单词的首写字母使用大写。
    

    如果局部变量的名字和成员变量的名字相同, 要想在该方法中使用成员变量,必须使用关键字this

    [java]  view plain  copy
    1. class People {  
    2.     String name = "类体重定义的name";         //类中的成员变量并赋值  
    3.   
    4.     People(){  
    5.     }  
    6.       
    7.     public void speak() {  
    8.         String name = "类体方法中定义的name";       //在方法speak中定义和成员变量名字相同的name并赋值  
    9.         System.out.println(name);  
    10.         System.out.println(this.name);      //通过this来访问类中的成员变量  
    11.           
    12.     }  
    13. }  
    14.   
    15.   
    16. public class TestThis {                              //源文件中只能有一个类是public类,并且源文件的名字必须与这个类的名字完全相同,如  
    17.                                                          //果没有public类,那么源文件的名字只要和某个类的名字相同就可以了。  
    18.     public static void main(String[] args) {         
    19.         People myPeople = new People();  
    20.         myPeople.speak();  
    21.     }  
    22.   
    23. }  
    输出结果:

    成员变量和局部变量的区别

           成员变量:

              1、成员变量定义在类中,在整个类中都可以被访问。

              2、成员变量随着对象的建立而建立,随着对象的消失而消失,存在于对象所在的堆内存中。

              3、成员变量有默认初始化值。

          局部变量:

              1、局部变量只定义在局部范围内,如:函数内,语句内等,只在所属的区域有效。

              2、局部变量存在于栈内存中,作用的范围结束,变量空间会自动释放。

              3、局部变量没有默认初始化值 

          在使用变量时需要遵循的原则为:就近原则

          首先在局部范围找,有就使用;接着在成员位置找。



    成员变量和类变量的区别


    由static修饰的变量称为静态变量,其实质上就是一个全局变量。如果某个内容是被所有对象所共享,那么该内容就应该用静态修饰;没有被静态修饰的内容,其实是属于对象的特殊描述。

    不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量。


    [java]  view plain  copy
    1. class MyAdd {  
    2.     int count = 0;          //成员变量计数器  
    3.     static int sum = 0;     //静态变量计数器  
    4.     String name;  
    5.       
    6.   
    7.     MyAdd(String name){  
    8.         this.name = name;  
    9.     }  
    10.       
    11.     public void myAddMethod() {    
    12.         count++;  
    13.         System.out.println(name+"调用成员变量后的值:"+count);  
    14.     }  
    15.       
    16.     public void staticAddMethod() {    
    17.         sum++;  
    18.         System.out.println(name+"调用类后变量的值:"+sum);  
    19.     }  
    20.       
    21.       
    22. }  
    23.   
    24.   
    25. public class TestThis {  
    26.   
    27.     public static void main(String[] args) {  
    28.         MyAdd add1 = new MyAdd("add1");  
    29.         MyAdd add2 = new MyAdd("add2");  
    30.           
    31.         add1.myAddMethod();  
    32.         add2.myAddMethod();  
    33.         add1.myAddMethod();  
    34.         add1.staticAddMethod();  
    35.         add2.staticAddMethod();  
    36.         add1.staticAddMethod();  
    37.     }  
    38.   
    39. }  

    输出结果:



    成员变量和类变量的区别:

       1、两个变量的生命周期不同

          成员变量随着对象的创建而存在,随着对象的回收而释放。

          静态变量随着类的加载而存在,随着类的消失而消失。

       2、调用方式不同

          成员变量只能被对象调用。

          静态变量可以被对象调用,还可以被类名调用。

       3、别名不同

          成员变量也称为实例变量。

          静态变量也称为类变量。

       4、数据存储位置不同

          成员变量存储在堆内存的对象中,所以也叫对象的特有数据。

          静态变量数据存储在方法区(共享数据区)的静态区,所以也叫对象的共享数据。



    static:★★★ 关键字,是一个修饰符,用于修饰成员(成员变量和成员函数)。

       特点:

       1、想要实现对象中的共性数据的对象共享。可以将这个数据进行静态修饰。

       2、被静态修饰的成员,可以直接被类名所调用。也就是说,静态的成员多了一种调用方式。类名.静态方式。

        3、静态随着类的加载而加载。而且优先于对象存在。

     

    弊端:

       1、有些数据是对象特有的数据,是不可以被静态修饰的。因为那样的话,特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以,在定义静态时,必须要明确,这个数据是否是被对象所共享的。

       2、静态方法只能访问静态成员,不可以访问非静态成员。

          因为静态方法加载时,优先于对象存在,所以没有办法访问对象中的成员。

       3、静态方法中不能使用this,super关键字。

          因为this代表对象,而静态在时,有可能没有对象,所以this无法使用。

     

    什么时候定义静态成员呢?或者说:定义成员时,到底需不需要被静态修饰呢?

    成员分两种:

       1、成员变量。(数据共享时静态化)

          该成员变量的数据是否是所有对象都一样:

          如果是,那么该变量需要被静态修饰,因为是共享的数据。 

          如果不是,那么就说这是对象的特有数据,要存储到对象中。 

       2、成员函数。(方法中没有调用特有数据时就定义成静态)

          如果判断成员函数是否需要被静态修饰呢?

          只要参考,该函数内是否访问了对象中的特有数据:

          如果有访问特有数据,那方法不能被静态修饰。

          如果没有访问过特有数据,那么这个方法需要被静态修饰。


    成员变量和静态变量的区别:

       1、成员变量所属于对象。所以也称为实例变量。

          静态变量所属于类。所以也称为类变量。

       2、成员变量存在于堆内存中。

          静态变量存在于方法区中。

       3、成员变量随着对象创建而存在。随着对象被回收而消失。

          静态变量随着类的加载而存在。随着类的消失而消失。

       4、成员变量只能被对象所调用 。

          静态变量可以被对象调用,也可以被类名调用。

       所以,成员变量可以称为对象的特有数据,静态变量称为对象的共享数据。



    成员变量:包括实例变量和类变量,用static修饰的是类变量,不用static修饰的是实例变量,所有类的成员变量可以通过this来引用。
    局部变量:包括形参,方法局部变量,代码块局部变量,存在于方法的参数列表和方法定义中以及代码块中。
     
    1.成员变量可以被public,protect,private,static等修饰符修饰,而局部变量不能被控制修饰符及 static修饰;两者都可以定义成final型。
     
    2.成员变量存储在堆,局部变量存储在栈。局部变量的作用域仅限于定义它的方法,在该方法的外部无法访问它。成员变量的作用域在整个类内部都是可见的,所有成员方法都可以使用它。如果访问权限允许,还可以在类的外部使用成员变量。
     
    3.局部变量的生存周期与方法的执行期相同。当方法执行到定义局部变量的语句时,局部变量被创建;执行到它所在的作用域的最后一条语句时,局部变量被销毁。类的成员变量,如果是实例成员变量,它和对象的生存期相同。而静态成员变量的生存期是整个程序运行期。
     
    4.成员变量在累加载或实例被创建时,系统自动分配内存空间,并在分配空间后自动为成员变量指定初始化值,初始化值为默认值,基本类型的默认值为0,复合类型的默认值为null。(被final修饰且没有static的必须显式赋值),局部变量在定义后必须经过显式初始化后才能使用,系统不会为局部变量执行初始化。
     
    5.局部变量可以和成员变量 同名,且在使用时,局部变量具有更高的优先级,直接使用同名访问,访问的是局部变量,如需要访问成员变量可以用this.变量名访问


    先看下面两段程序:

    程序一:
    public class Variable
    {
    int i;
    void test()
    {
       int j=8;
       if(j==i)
        System.out.println("相等");
       else
        System.out.println("不相等");
    }
    public static void main(String[] args)
    {
       Variable v=new Variable();
       v.test();
    }
    }

    程序二:
    public class Variable
    {
       void test()
    {
       int i;
       int j=8;
       if(j==i)
        System.out.println("相等");
       else
        System.out.println("不相等");
    }
    public static void main(String[] args)
    {
       Variable v=new Variable();
       v.test();
    }
    }

    ----------------------------------------------------------------------------------------------------------

    第一个程序很正常,编译时不会出错。第二个程序编译时会提示如下错误:

    D:\Program\java\test>javac Variable.java
    Variable.java:9: 可能尚未初始化变量 i
                    if(j==i)
                          ^
    1 错误

    之所以会出现这样的错误是因为:成员变量有默认值,(被final修饰且没有static的必须显式赋值),局部变量不会自动赋值

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

    类体分为两部分。变量定义部分所定义的变量被称为类的成员变量,在方法体中定义的变量和方法的参数都被称为局部变量

    java中成员变量和局部变量的区别

    1.成员变量可以被public,protect,private,static等修饰符修饰,而局部变量不能被控制修饰符及static修饰;两者都可以定义成final型
    2.成员变量存储在堆,局部变量存储在栈
    3.存在时间不同
    4.成员变量有默认值,(被final修饰且没有static的必须显式赋值),局部变量不会自动赋值
    -------------------------------------------------------------------------------------------------------------
    顾名思意了
    什么是局部,方法内部,块内部都是局部,执行指令退出那个局部,局部变量自动清除

    比如方法中,不用说
    块中
    {
      int i=0; //这是一个局部变量,它的作用范围就在其中 
    }

    成员变量就会涉及到谁的成员,类的成员?实例的成员?

    class A{
    int i=0; //实例的成员
    static j=1;//类的成员
    }

    static 的差别,是否依赖于实例而存在
    ----------------------------------------------------------------------------------------------------------

    成员变量:作为类的成员而存在,直接存在于类中。

    局部变量:作为方法或语句块的成员而存在,存在于方法的参数列表和方法定义中。

    局部变量在使用前必须被程序员主动的初始化,和此形成对比,系统中的成员变量则会被系统提供一个默认的初始值。所以在语法上,类的成员变量能够定义后直接使用,而局部变量在定义后先要赋初值,然后才能使用。

     

    所有类的成员变量可以通过this来引用。成员变量又分成俩中类型:实例变量和静态变量。静态变量在定义时要使用static关键字。



    展开全文
  • Java中成员变量的隐藏

    千次阅读 2019-05-31 16:21:47
    Java中成员变量的隐藏 前几天看一篇文章,里面提到了成员变量的"重写"问题,刚看到的时候我非常疑惑,难道成员变量不是和方法一样的重写机制吗?结果当然是啪啪打脸。这个知识点确实是我的知识误区,因为我记得当初...
  • 实例变量(成员变量) 在类的声明中,属性是用变量来表示的。这种变量就称为实例变量,是在类声明的内部但是在类的其他成员方法之外声明的。 当一个对象被实例化之后,每个实例变量的值就跟着确定; 实例变量在对象...
  • 如果我们在成员变量前边加上static关键字,这个变量就成为静态成员变量,我们又把这种变量叫做“类变量”,因为这样的变量在这个类的所有对象里只有一个,这个类的所有对象“共享”同一个类变量。
  • 转载:https://blog.csdn.net/qq_24644517/article/details/82288493 package deep; public class DefaultValue { // 实例成员变量 private boolean bool; private byte b; private short s; private ...
  • Java成员变量与成员方法

    千次阅读 2019-05-27 10:28:49
    在Java中对象的属性成为成员变量, 有时候很多人也喜欢把成员变量等同于全局变量, 因为成员变量在某一个类中都有效 (成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中...
  • 不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量...
  • Kotlin的类(成员方法、成员变量

    千次阅读 2018-03-31 12:28:36
    先看一下Java中的类和成员变量、方法 package net.println.kotlin.chapters; /** * @author :wangdong * @description : Java中的类与成员变量 */ public class JavaPerson { private ...
  • Java中成员变量和局部变量区别

    千次阅读 2021-03-19 10:18:38
    掌握Java的成员变量和局部变量 学习内容: 1、变量分类 变量的定义语法 数据类型 变量名 = 初始值; 根据变量定义位置的不同,分成两大类 成员变量: 直接定义在类中,方法外面。又称之为字段(Field),不要称...
  • Java之成员变量、局部变量和静态变量的区别

    千次阅读 多人点赞 2017-12-04 11:30:24
    之前在刚开始学习Java的时候,就谈了谈Java基础中的变量(见 http://www.linuxidc.com/Linux/2015-02/113862.htm),虽然知道这货以后会经常用到,但没想到了基本语法这里,竟然有...先从成员变量下刀。 成员变量
  • 根据定义的位置不同,把类分为成员变量(在类里定义的变量)和局部变量(在方法里定义的)。 成员变量: 被分为 类变量(static)和实例变量(木有static)。 有static则为类变量,没有就是实例变量。 局部变量:...
  • 成员变量:作用在整个类中(除静态方法不能使用,静态方法没有隐式的this),被对象调用。 如果没有实例化那么变量是放在栈中;实例化了对象放在堆中,栈中放的是指向堆中对象的引用地址。 在对象被创建时而存在,当...
  • 成员变量成员变量又叫实例变量,它是类的实例,所作用于所在的整个类。 局部变量:只在某个范围有效(例如方法中)。 类变量:有效性主要和变量前的修饰符有关,例如private修饰就只对此类有效,public对所有包都...
  • Java中关于子类成员变量与父类成员变量同名的问题: 下面代码为我写的一个简单的测试类,很有意思: public class TestDemo2 { /** * @param args */ public static void main(String[] args) { Animals a =...
  • java 成员变量和类变量的区别

    千次阅读 2018-03-16 11:13:09
    不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量...
  • 类的成员变量和成员方法

    千次阅读 2019-12-27 10:48:07
    成员变量 成员变量的修饰 (1) public 公共变量,可被任何包中的任何类访问,只有在确认任何外部访问都不会带来不良后果的情况下才将成员声明为公共的,公共变量对任何类可见,不具有数据保护功能。 (2)private...
  • 参数传递,成员变量和局部变量

    千次阅读 2019-05-15 15:13:13
    1.参数传递 基本数据类型作为方法的参数传递时,形参改变不影响实参 ...2.成员变量和局部变量的区别 1)在类中的位置不同 成员变量在类中,方法外。 局部变量在方法中或者方法内 2)在内存中的位置不同 成...
  • python类成员变量和实例成员变量

    千次阅读 2017-05-12 14:52:39
    # python code class Vehicle:  def __init__(self,... self.speed = speed #speed实例成员变量  def drive(self,distance):  print 'need %f hour(s)'% (distance/self.speed) class Bike(Vehicle
  • 成员变量和局部变量的区别

    万次阅读 多人点赞 2018-07-22 19:56:44
    成员变量和局部变量的区别  (1)在类中的位置不同  成员变量:类中方法外  局部变量:方法定义中或者方法声明上  (2)在内存中的位置不同  成员变量:在堆中  局部变量:在栈中  (3)生命周期不同  成员变量:...
  • 成员变量和类变量(Java)

    千次阅读 2019-12-29 09:33:18
    成员变量是定义在类中,方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。 类变量:类变量也声明在类中,方法体之外,但必须声明为static类型。 ...
  • idea 抽取成员变量快捷键 工作中有时后会需要将局部变量写成成员变量,快捷键是 ctrl+alt+f 光标放在变量上 ctrl+alt+f ; 导入我的setting文件 链接:https://pan.baidu.com/s/1exKknWhoKof0bxU9ad_Ueg 提取...
  • Java成员变量初始化顺序

    千次阅读 2018-11-24 22:28:49
    Java中成员变量分为两类:1、类变量 2、实例变量 1、类变量初始化 类变量简单来说就是被static修饰的变量,类变量属于类本身 1.1 初始化时机 定义类变量时指定初始化 静态代码块中对类变量指定初始化 1.2 初始化...
  • C++静态成员变量初始化和赋值

    万次阅读 2019-03-07 14:29:57
    这里说一下C++静态成员变量,在C++中,静态成员是属于整个类的而不是某个对象,静态成员变量只存储一份供所有对象共用。所以在所有对象中都可以共享它。使用静态成员变量实现多个对象之间的数据共享不会破坏隐藏的...
  • 成员变量和类变量的区别

    千次阅读 2018-11-14 15:12:26
    不同的对象的实例变量将被分配不同的内存空间, 如果类中的成员变量有类变量,那么所有对象的这个类变量都分配给相同的一处内存,改变其中一个对象的这个类变量会影响其他对象的这个类变量,也就是说对象共享类变量...
  • 成员方法中调用成员变量语法格式 : …self .变量名 例: 成员方法中调用成员方法格式 : …self . 方法名(实参1 , 实参2, …) 例 : self : 仅出现在成员方法中 , 指代执行该方法的对象 ...
  • java方法 成员变量 局部变量概述

    千次阅读 2017-12-23 20:37:58
    成员变量被分为类变量和实例变量两种,定义成员变量时没有static修饰的就是实例变量,有static修饰的就是类变量。 变量的初始值 成员变量: 默认是有初始值的 局部变量: 没有初始值,所以必须先初始化才能...
  • ctrl+alt+f 抽取成员变量快捷键 提取局部变量:Ctrl+Alt+V 提取全局变量:Ctrl+Alt+F 提取方法:Shit+Alt+M 导入我的setting文件 链接:https://pan.baidu.com/s/1exKknWhoKof0bxU9ad_Ueg 提取码:top9 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,128,416
精华内容 451,366
关键字:

成员变量