精华内容
下载资源
问答
  • //A.h #include "BDlg" class A { public: BDlg *m_blg; } ...如上所示,在A类中定义了B对话框的指针m_dlg,现在想在BDlg.cpp中通过m_dlg对B对话框 进行操作,请问BDlg.h该怎样写呀?
  • 今天写了个小程序,结果却很是出乎预料,搞了半天原来应该在内部成员变量写在了外面,这样的后果就导致了:每new一个内部的对象时,所有new出来的对象都共用外部一个成员变量,结果就导致了意外的效果,呵呵,...

      今天写了个小程序,结果却很是出乎预料,搞了半天原来应该在内部类的成员变量写在了外面,这样的后果就导致了:每new一个内部类的对象时,所有new出来的对象都共用外部一个成员变量,结果就导致了意外的效果,呵呵,经过一个小程序又让我进步了一点,基础不打好以后写程序就会处处碰壁的!

    展开全文
  • 关于java成员变量和局部变量

    万次阅读 多人点赞 2018-09-14 10:46:45
    在Java语言里,根据定义变量位置的不同,可以将变量分成两大成员变量(存在于堆内存,和一起创建)和局部变量(存在于栈内存,当方法执行完成,让出内存,让其他方法来使用内存)。二者的运行机制存在较大差异...

    1、成员变量和局部变量简述

    在Java语言里,根据定义变量位置的不同,可以将变量分成两大类:成员变量(存在于堆内存中,和类一起创建)和局部变量(存在于栈内存中,当方法执行完成,让出内存,让其他方法来使用内存)。二者的运行机制存在较大差异。

    1.1成员变量

    类变量从该类的准备阶段起开始存在,直到系统完全销毁这个类,类变量的作用域与这个类的生存范围相同;

    而实例变量则从该类的实例被创建起开始存在,直到系统完全销毁这个实例,实例变量的作用域与对应实例的生存范围相同。

    正是基于这个原因,可以把类变量和实例变量统称为成员变量。其中类变量可以理解为类成员变量,它作为类本身的一个成员,与类本身共存亡;实例变量则可以理解为实例成员变量,它作为实例的一个成员与实例共存亡。

    只要类存在,类就可以访问类变量         类.类变量

    只要实例存在,实例就可以访问实例变量        实例.实例变量

    当然实例也可以访问类变量。但是需要注意的是因为实例不拥有类变量,所以通过实例来访问类变量进行操作,实际上是对类变量进行操作 ,当有其他实例来访问类变量时,访问的类变量是被对象访问操作过的类变量。

    成员变量无需显示初始化,只要为一个类定义了类变量或实例变量,系统就会在这个类的准备阶段或创建该类的实例时进行默认初始化。

    1.2局部变量

    局部变量根据定义形式的不同,又可以分为如下三种:

    形参:在定义方法签名时定义的变量,形参的作用域在整个方法中都有效

    方法局部变量:在方法体内定义的局部变量,它的作用域是从定义该变量的地方生效,到该方法结束时失效

    代码块局部变量:这个局部变量的作用域从定义该变量的地方生效,到该代码结束时失效。

    一个变量只在一对{}中起作用。。

    java允许局部变量和成员变量同名,如果方法中局部变量和成员变量同名,局部变量就会覆盖成员变量,如果需要在这个方法中引用被覆盖成员变量,则可使用this(对于实例变量)或类名(对于类变量)作为调用者来限定访问成员变量。

    2、成员变量的初始化和内存中的运行机制

    接下来以下面代码来举例说明成员变量的初始化和内存中的运行机制

     

    复制代码

     1 public class Person {
     2     public int num;
     3     public String name;
     4     
     5     public static void main(String[] args) {
     6         Person p1 = new Person();
     7         Person p2 = new Person();
     8         p1.num = 2;
     9         p2.num = 3;
    10         p1.name = "张三";
    11         p2.name = "李四";
    12     }
    13     
    14 
    15 }

    复制代码

     

    当程序执行Person p1 = new Person();时,如果这行代码是第一次使用Person类,则系统通常会在第一次使用Person类时加载这个类,并初始化这个类,在类的准备 阶段,系统将会为该类的类变量分配内存空间,并指定默认初始值。当person类初始化完成后,系统内存中的存储示意图如下图所示。

     可以看出,当person类初始化完成后,系统将在堆内存中为Person分配一块内存空间,实际上是创建了一个类对象,在这块内存区里包含了保存num类变量的内存,并设置num的默认初始值为0。

    系统接着创建了一个Person对象,并把这个Person对象赋给p1变量,Person对象包含了名为name的实例变量,实例变量是在创建实例时分配内存空间并指定初始值的。当创建了第一个person对象后,系统内存中的存储示意图如下图所示。

    从上图可以看出num不属于对象,它属于类,所以创建第一个对象时并不需要为num分配内存空间,系统只是为name分配了内存空间,并指定初始值为null。

    创建第二个对象p2时,由于在创建第一个对象时已经对类进行了初始化,所以在创建p2时对类进行初始化,对象的创建过程与第一个对象的创建过程没有什么区别。

    第二个对象创建完成后,成员变量如上图所示在内存中存储。

    **当程序需要访问类变量时,尽量使用类来作为主调,不要使用对象作为主调,这个可以避免产生歧义。

    3、局部变量的初始化和内存中的运行机制

    *局部变量必须经过显示初始化之后才能使用,系统不会为局部变量执行初始化。定义了局部变量以后,系统并没有给局部变量进行初始化,直到程序给这个局部变量赋给初值时,系统才会为这个局部变量分配内存空间,并将初始值保存到这块内存中。

    *局部变量不属于任何类或者实例,因此它总是保存在方法的栈内存中。如果局部变量是基本数据类型,则该变量直接存储在方法的栈内存中,如果是引用变量则将引用的地址存储在方法的栈内存中。

    *栈内存中的变量无需系统垃圾回收,随着方法或者代码块的运行结束而结束。局部变量通常只保存了具体的值或者引用地址,所以所占的内存比较小。

    4、变量的使用规则

    能不使用成员变量就别使用成员变量

    能不使用方法局部变量就别使用方法局部变量

    使用代码块局部变量性能最好。

     

     

     

    展开全文
  • python中类的变量可分为变量、成员变量和局部变量 class Demo(): classVar = 50 #变量,类似静态变量,不同点,在实例改变只影响本实例 def __init__(self,x) self.numberVar = x def fuc(self): ...

    python中类的变量可分为类变量、成员变量和局部变量

    globalVar = 10                            #全部变量,作用时提前用global关键字声明
    class Demo():
    	classVar = 50                         #类变量,类似静态变量,不同点,在实例中改变只影响本实例
    	def __init__(self,x)
    		self.numberVar = x                #成员变量,用self标识
    	def fuc(self):
    		localVar = 20                     #局部变量
    		return self.numberVar + localVar
    	def show_gloabl_var(self):
    		global gloablVar                  #声明gloablVar为全局变量
    		return gloablVar
    
    t1 = Demo()
    t2 = Demo()
    print(t1.classVar)        #>>50
    print(t2.classVar)        #>>50
    print(Demo.classVar)      #>>50
    t1.classVar = 60
    print(t1.classVar)        #>>60
    print(t2.classVar)        #>>50
    print(Demo.classVar)      #>>50
    Demo.classVar = 80
    print(t1.classVar)        #>>80
    print(t2.classVar)        #>>80
    print(Demo.classVar)      #>>80
    

    python中的类相当于一个命名空间,object.attribute相当于由实例到类再到父类向上搜索的过程:

    • dict:实例或类或模块的属性空间
      • class:实例对应类对象(类对象非空间,object.class.__dict__可获所在类对象的属性空间)
        • bases(元组):用于类对象获取其父类/超类
          搜索属性的方法类似于:
    def findAttribute(obj , attr):
    	if attr in obj.__dict__:        #实例属性空间中有则返回
    		return obj.__dict__[attr]
    	cls = obj.__class__             #获取类对象
    	if attr in cls.__dict__:
     		return cls.__dict__[attr]
    	for super_cls in cls.__bases__: #获取类对象的父类(元组)
     		if attr in super_cls.__dict__:
     			return super_cls.__dict__[attr]
     return None
    
    展开全文
  • final在Java中并不常用,然而它却为我们提供了诸如在C语言中定义常量的功能,不仅如此...final成员当你在类中定义变量时,在其前面加上final关键字,那便是说,这个变量一旦被初始化便不可改变,这里不可改变的意思...

    final在Java中并不常用,然而它却为我们提供了诸如在C语言中定义常量的功能,不仅如此,final还可以让你控制你的成员、方法或者是一个类是否可被覆写或继承等功能,这些特点使final在Java中拥有了一个不可或缺的地位,也是学习Java时必须要知道和掌握的关键字之一。

    final成员

    当你在类中定义变量时,在其前面加上final关键字,那便是说,这个变量一旦被初始化便不可改变,这里不可改变的意思对基本类型来说是其值不可变,而对于对象变量来说其引用不可再变。其初始化可以在两个地方,一是其定义处,也就是说在final变量定义时直接给其赋值,二是在构造函数中。这两个地方只能选其一,要么在定义时给值,要么在构造函数中给值,不能同时既在定义时给了值,又在构造函数中给另外的值。下面这段代码演示了这一点:

    import java.util.List;

    import java.util.ArrayList;

    import java.util.LinkedList;

    public class Bat{

    final PI=3.14;            //在定义时便给址值

    final int i;              //因为要在构造函数中进行初始化,所以此处便不可再给值

    final List list;          //此变量也与上面的一样

    Bat(){

    i=100;

    list=new LinkedList();

    }

    Bat(int ii,List l){

    i=ii;

    list=l;

    }

    public static void main(String[] args){

    Bat b=new Bat();

    b.list.add(new Bat());

    //b.i=25;

    //b.list=new ArrayList();

    System.out.println("I="+b.i+" List Type:"+b.list.getClass());

    b=new Bat(23,new ArrayList());

    b.list.add(new Bat());

    System.out.println("I="+b.i+" List Type:"+b.list.getClass());

    }

    }

    此程序很简单的演示了final的常规用法。在这里使用在构造函数中进行初始化的方法,这使你有了一点灵活性。如Bat的两个重载构造函数所示,第一个缺省构造函数会为你提供默认的值,重载的那个构造函数会根据你所提供的值或类型为final变量初始化。然而有时你并不需要这种灵活性,你只需要在定义时便给定其值并永不变化,这时就不要再用这种方法。在main方法中有两行语句注释掉了,如果你去掉注释,程序便无法通过编译,这便是说,不论是i的值或是list的类型,一旦初始化,确实无法再更改。然而b可以通过重新初始化来指定i的值或list的类型,输出结果中显示了这一点:

    I=100 List Type:class java.util.LinkedList

    I=23 List Type:class java.util.ArrayList

    还有一种用法是定义方法中的参数为final,对于基本类型的变量,这样做并没有什么实际意义,因为基本类型的变量在调用方法时是传值的,也就是说你可以在方法中更改这个参数变量而不会影响到调用语句,然而对于对象变量,却显得很实用,因为对象变量在传递时是传递其引用,这样你在方法中对对象变量的修改也会影响到调用语句中的对象变量,当你在方法中不需要改变作为参数的对象变量时,明确使用final进行声明,会防止你无意的修改而影响到调用方法。

    另外方法中的内部类在用到方法中的参变量时,此参变也必须声明为final才可使用,如下代码所示:

    public class INClass{

    void innerClass(final String str){

    class IClass{

    IClass(){

    System.out.println(str);

    }

    }

    IClass ic=new IClass();

    }

    public static void main(String[] args){

    INClass inc=new INClass();

    inc.innerClass("Hello");

    }

    }

    final方法

    java中final方法的意义

    之所以要使用final方法,可能是出于对两方面理由的考虑。第一个是为方法“上锁”,防止任何继承类改变它的本来含义。设计程序时,若希望一个方法的行为在继承期间保持不变,而且不可被覆盖或改写,就可以采取这种做法。

    采用final方法的第二个理由是程序执行的效率。将一个方法设成final后,编译器就可以把对那个方法的所有调用都置入“嵌入”调用里。

    将方法声明为final,那就说明你已经知道这个方法提供的功能已经满足你要求,不需要进行扩展,并且也不允许任何从此类继承的类来覆写这个方法,但是继承仍然可以继承这个方法,也就是说可以直接使用。另外有一种被称为inline的机制,它会使你在调用final方法时,直接将方法主体插入到调用处,而不是进行例行的方法调用,例如保存断点,压栈等,这样可能会使你的程序效率有所提高,然而当你的方法主体非常庞大时,或你在多处调用此方法,那么你的调用主体代码便会迅速膨胀,可能反而会影响效率,所以你要慎用final进行方法定义。

    final类

    当你将final用于类身上时,你就需要仔细考虑,因为一个final类是无法被任何人继承的,那也就意味着此类在一个继承树中是一个叶子类,并且此类的设计已被认为很完美而不需要进行修改或扩展。对于final类中的成员,你可以定义其为final,也可以不是final。而对于方法,由于所属类为final的关系,自然也就成了final型的。你也可以明确的给final类中的方法加上一个final,但这显然没有意义。

    下面的程序演示了final方法和final类的用法:

    final class final{

    final String str="final Data";

    public String str1="non final data";

    final public void print(){

    System.out.println("final method.");

    }

    public void what(){

    System.out.println(str+"\n"+str1);

    }

    }

    public class FinalDemo {     //extends final 无法继承

    public static void main(String[] args){

    final f=new final();

    f.what();

    f.print();

    }

    }

    从程序中可以看出,final类与普通类的使用几乎没有差别,只是它失去了被继承的特性。final方法与非final方法的区别也很难从程序行看出,只是记住慎用。

    final在设计模式中的应用

    在设计模式中有一种模式叫做不变模式,在Java中通过final关键字可以很容易的实现这个模式,在讲解final成员时用到的程序Bat.java就是一个不变模式的例子。如果你对此感兴趣,可以参考阎宏博士编写的《Java与模式》一书中的讲解。

    展开全文
  • 1、当我在中将成员函数和成员变量都置为public属性,在的构造函数初始化成员变量,在成员函数直接使用成员变量,虽然程序运行起来没有问题,但是在我主动退出程序的时候,会报错:程序异常结束! class ...
  • 昨天谈了Java中成员变量的一些特点,知道了它的生存周期比局部变量长,但对成员变量如何初始化和其内部的运行却还没有说清楚。那么这篇文章主要解决的问题有:成员变量是如何初始化的?它在内存中是如何运行的?对比...
  • 关于java实体类成员变量命名的问题
  • 用本成员变量:this.成员变量名 用父类的成员变量:super.成员变量名 例子:↓ Father:父类定义了 int num=10; Child extends Father:子类继承父类,并且自有成员变量 int num=20; public class Child ...
  • class Example(object):def the_example(self):itsProblem ="problem"theExample = Example()print(theExample.itsProblem)如何访问类的变量?我试着加上这个定义:def return_itsProblem...标题编辑,关于类"静态"...
  • 类中的静态成员函数:1.函数的行为对所有派生类都一致时,可以声明为静态。2.因为静态成员函数只跟类有关跟类的实例无关,因此它不需要this指针3.静态成员函数由于是不与任何对象相关联的,所以是没有this指针的。从...
  • 在 c++ 对于的静态成员变量 想必大家都用的比较少,对于我来说,我是很少用,一般是在多线程或者debug时候会用。 现在对其作为成员变量,进行以下说明。 对于的静态成员变量初始化与普通的成员变量的...
  • 成员变量 类中方法外 局部变量 方法内或方法声明上 在内存中的位置不同 成员变量 堆内存 局部变量 栈内存 生命周期不同 成员变量 随着对象的存在而存在,随着对象的消失而消失 局部变量 随着方法的调用...
  • 关于python的类变量与成员变量的区别,先写下来,便于以后查阅。 类变量 类中的变量,不属于任何一个函数,也不要 self.。可以通过类名直接调用,也能通过类的实例对象调用。 类的成员变量 类的初始化函数中定义...
  • 类中的静态成员函数: 1.函数的行为对所有派生类都一致时,可以声明为静态。 2.因为静态成员函数只跟类有关跟类的实例无关,因此它不需要this指针 3.静态成员函数由于是不与任何对象相关联的,所以是没有this指针...
  • Java中关于子类成员变量与父类成员变量同名的问题: 下面代码为我写的一个简单的测试,很有意思: public class TestDemo2 { /** * @param args */ public static void main(String[] args) { Animals a =...
  • 一、变量、成员变量、局部变量的内存分布  结合前文,对变量、成员变量、局部变量三种变量的内存分布进行总结 1)变量:方法区。静态变量随加载到方法区。方法区存储已经被虚拟机加载的信息、常量...
  • class a {public: a(int x):m(x){} void outsee(a y); private: int m; } void a::outsee(a y) ...难道因为的成员函数都是公用的,所以不同对象可以通过成员函数实现访问不同对象的私有成员变量????
  • 其实对来说,就只有两种成员,一种是成员变量,另一种就是成员行为,或者说是成员函数了。这是我最初学c++的时候学到的。后来在学java的时候,就发现成员又多了好多种,不过其实那时候还是不是很理解。为什么要分...
  • 类中定义引用变量, 必须要在初始化列表中初始化该成员变量, 例如: [cpp] view plaincopy #include  using namespace std;  class A  {  private:   int &a;  public:...
  • 一个假如存在一个静态成员变量指针,在下面几种情况下动态分配内存。该怎样回收内存: 1)在外部函数动态分配内存,代码例如以下: test.cpp class Test { public: static char* m_pSZ; }; char* Test::m_...
  • 关于C#的dll中类的静态成员变量

    千次阅读 2016-07-12 18:37:40
    HsInterface.dll调用了DBAccessLib.dll,主程序调用了HsInterface.dll和DBAccessLib.dll,那么也就是说DBAccessLib.dll被主程序直接调用和间接调用,那么DBAccessLib.dll的static成员变量如果在主程序被赋值...
  • 一个假如存在一个静态成员变量指针,在以下几种情况下动态分配内存,该如何回收内存: 1)在外部函数动态分配内存,代码如下: test.cpp class Test { public: static char* m_pSZ; }; char* Test::m_pSZ =...
  • 在C++和JAVA,要创建一个一个的对象,就要注意对的数据成员(字段)要赋初值。  对于基本的数据类型的变量,Java提供自动初始化,具体初始化值如下:  基本类型  默认值 boolean false ...
  • final方法是在派生类中不能被覆盖的方法,final类是不能被覆盖的类。一个类可以含有final方法 * final类和final方法使用final声明 * 技巧:final static 类型成员变量。static使得变量只存在一个拷贝。final使得它...
  • c++类中成员变量的初始化总结 关于这个问题是引起来源于一则面试问题:引用型成员变量如何初始化?回答的不是很确定,于是对这个问题研究一下。1、普通的变量:一般不考虑啥效率的情况下 可以在构造函数中进行赋值。...
  • 2.其中在类中定义的成员变量,而在函数中定义的刚是局部变量。 3.局部变量只能在其声明的方法内部访问。 4.成员变量和局部变量在内存中的位置: 成员变量:在堆中,因为对象的存在而在内存中存在 局部变量:在栈...
  • 在项目发现了一个很严重的问题,到后来才发现是类成员初始化的问题,想起来Effictive C++曾经提到过这些。写在博客里以供提醒。templateclass Array {public:Array(int lowBound, int highBound);...private:...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,569
精华内容 1,027
关键字:

关于类中成员变量