成员变量

final修饰的变量实例化后就不能改了，private修饰的变量或者方法只能类内的方法调用

这是因为你的listener实际上是使用了内部类，内部类当然不知道外部方法的变量了。但是外部类的变量是可以看到的，如果要在方法内让其内部类看见该方法的变量就要加上final来保证在改方法中只有一个ll，包括它的内部类。不知道你明白没有~~

您好，提问者： final是最终的，不可修改的。 final可以说是一个常量，而不是变量。必须将其赋值！！！！

dui

你是在线程中操作此变量吧，线程中必须是final 类型

他们看起来一样，实质是不一样的。A (int a,int b): num(a), total(b)是在预编译时就告诉了编译器的，属于初始化。num = a;total = b;另一个就不用说了。

用mutable修饰成员变量

java易混淆概念之类变量、实例变量、局部变量类变量、实例变量、局部变量类变量是类中独立于方法之外的变量，用static 修饰。实例变量也是类中独立于方法之外的变量，不过没有static修饰。局部变量是类的方法中的变量。Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。JDK（Java Development Kit）称为Java开发包或Java开发工具，是一个编写Java的Applet小程序和应用程序的程序开发环境。JDK是整个Java的核心，包括了Java运行环境（Java Runtime Envirnment），一些Java工具和Java的核心类库（Java API）。Java看起来设计得很像C++，但是为了使语言小和容易熟悉，设计者们把C++语言中许多可用的特征去掉了，这些特征是一般程序员很少使用的。例如，Java不支持go to语句，代之以提供break和continue语句以及异常处理。Java还剔除了C++的操作符过载（overload）和多继承特征，并且不使用主文件，免去了预处理程序。

不一样的，例如publicclassA{Stringid;//实例变量privateStringTel;//实例变量privateintsize;//实例变量privatestaticStringdepart;//类变量finalStringdesign="样式";//常量}其中实例变量、类变量、常量都是属于成员变量的，成员变量又被称为全局变量，成员变量的范围比实例变量更宽泛

不一样的，例如x0dx0apublic class A{x0dx0a String id; //实例变量x0dx0a private String Tel; //实例变量x0dx0a private int size; //实例变量x0dx0a private static String depart; //类变量x0dx0a final String design="样式"; //常量x0dx0a}x0dx0a x0dx0a其中实例变量、类变量、常量都是属于成员变量的，成员变量又被称为全局变量，x0dx0a成员变量的范围比实例变量更宽泛

因为m_edit1是一个对象，一个类可以有多个类似的对象。在使用成员变量的时候需要指明是调用哪个对象的函数。所以要m_edit1.

可以，任何属性的

这个时候，需要其它类提供修改成员变量的接口：提供方法函数，或把成员变量修改为public或把该类做为友元类添加到修改内中（不推荐，破坏封装性）

自然不可，你的实验不是已经得到结论了吗？做个public的get方法来获取y属性即可。

public class Rectangle{ private double length; private double width; public void setEdge() { this.length=3; this.width=4; } public double getArea() { return(this.length*this.width); } public double getCircumference() { return((this.length+this.width)*2); } public static void main(String args[]) { Rectangle b=new Rectangle(); b.setEdge(); System.out.println("the area is "+b.getArea()); System.out.println("the circumference is "+b.getCircumference()); }}

把p强制转换为class A类型指针即可，即(（A*）p)->b=某个值

很多的话，那不是每个函数都要初始化类成员？比如@interface MainController : UIViewController{@privatebool a;}------解决方案--------------------------------------------------------没有构造函数啊，肯定继承了父类的构造函数，只是没对 a 赋值，自己写个public 函数来------解决方案--------------------------------------------------------你这个类可以在viewDidLoad 中初始化a------解决方案--------------------------------------------------------在-(void)viewDidLoad 中对相关变量初始化，当加载这个 controller 得时候，会自动调用viewDidLoad 方法，有些类，可以写在init 等等中，比如Class *class = [[Class alloc] init];当你创建Class 类时，给它分配内存时就会调用init initWith..等几个方法------解决方案--------------------------------------------------------

成员变量在类中方法外,局部变量在方法中,不区分是main方法或者其他方法

两种方式：一、把成员变量m_btn放在public里面，能被类外调用二、或者在类里定义该函数，前面加上friend，即友元函数，可以调用该类的私有成员CButtonSt类里m_btn应为public，公用数据成员，调用abc(m_btn)应改为abc(CButtonSt.m_btn),类外调用都要指明类

成员变量和方法分为静态和实例变量和方法x0dx0a例如定义一个类：x0dx0aclass Textx0dx0a{x0dx0a public static int number;x0dx0a public int temp;x0dx0a public static void method(){}x0dx0apublic void method2(){}x0dx0a}x0dx0a如果你想访问temp属性，你就必须先创建一个Text的对象，才能访问：Text b = new Text（）；x0dx0ab.temp;这就是实例成员变量。实例变量也是一样x0dx0a而你想 访问number的话，不用创建Text的实例就可以访问，就像这样：Text.number.这就是类成员变量。实例方法也是一样x0dx0a主要区别就是访问是需不需要创建对象，而对于类成员变量，所有对象是共享一个变量的。

举个简单例子，比如建一个类User 则类名为User，同样如果用User user=new User();则user的数据类型也是User

类的成员变量只能通过该类声明的对象进行引用;因为类的成员变量在没有对象时,是不存在的抽象的一个数据;比如,我声明一个骆驼的类, 如果我要引用这个骆驼的体重,那只能先定义一个实际存在的骆驼,才可以得到体重这个数据;如果并不存在这个骆驼实体,那体重是没办法确定的;

1.定义的时候并没有分配哦 你所定义的是一个实例变量,而不是静态变量,2.你的类中没有写构造方法,所以会有一个默认的构造方法完成对象的实例创建,在对象创建后,通过对象实例即可访问到m那个对象了

变量在栈...实例在堆。。

在运行过程中,成员变量(包括静态变量和实例变量)以及静态方法都和引用变量的声明类型绑定, 实例方法将和实例绑定.举例如下:class Father{private int private_var;static int static_var;public int public_var;private void private_method(){}static void static_method(){}public void public_method(){}}class Son extends Father{private int private_var;static int static_var;public int public_var;private void private_method(){}static void static_method(){}}以上代码中,子类Son和父类Father具有同名的变量和方法.对于以下代码,引用变量f声明为Father类型,实际引用的是Son的实例,那么通过变量f来访问成员变量和方法,绑定关系如下:Father f=new Son();int v1=f.private_var; //bind with father"s private_varint v2=f.static_var; //bind with father"s static_varint v3=f.public_var; //bind with father"s public_varf.private_method(); //bind with father"s private_methodf.static_method(); //bind with father"s static_methodf.public_method(); //bind with son"s public_method 我个人的理解是方正就是把子类强制转换成父类对象，这样当你有多个不同的继承自父类的子类时，实际用的时候用的方法和变量都会是各自对应的子类

javaclone会拷贝父类的私有成员变量的，对于对象变量，使用clone仅能实现浅拷贝仅复制对象的在栈中的reference所以可以拷贝父亲的私有变量。

C++类体声明的私有成员仅供类体内成员访问，其它地方不可访问。

private就是只能类内的成员存取

通过A类中的set方法设置变量值，get方法获取变量

公有：可以被外部访问私有：禁止被外部访问

调用子类构造方法时，还会调用父类的构造方法，应该有个父类A的实例

反射方法

呃呃。。。在h中声明相当于把这个属性暴露出去，外面是可以使用和修改的（如果你愿意让别人修改），但是在m文件中声明的属性那就属于私有变量，只能在本类使用，外面无法访问

呵呵，头文件里确实不是初始化的地儿。引用类型是在初始化列表里赋值的。比如你在头文件里这样写：class C{public: C();public: int &x; int y;};然后在源文件中写：C::C() : x(y){}这样就可以将x跟y关联上了。

LZ知道类吧 类体由2部分构成:一部分是变量的定义;一部分是方法的定义(一个类中可以有多个方法)在变量定义部分定义的变量叫做类的成员变量,成员变量在整个类中都有效.(全局变量应该是成员变量的俗称)在方法体中定义的变量叫做局部变量,局部变量只在定义它的方法中有效.成员变量又分为 实例变量 和 类变量(static静态变量).class One{ float x; //x为实例变量 static int y; //只要有关键字static,y为类变量}⊕

这是因为查找变量的顺序是：先在函数中查找，如果没有则继续在类中查找。 按照这种顺序，如果形参变量与成员变量同名，不用this找到的就是形参变量。

对于Spark UDF引用成员变量这个问题，我们需要了解几个关键点。首先，UDF是Spark中用于构建自定义函数的机制。其次，UDF代码在集群中的每个分区中独立地运行，所以不能依靠成员变量来实现状态的共享。最后，为了在分布式计算环境中实现状态共享，必须使用Spark的累加器。因此，如果需要在Spark UDF中引用成员变量，可以考虑使用Spark累加器来实现。累加器允许多个并发任务在计算过程中更新共享状态，从而实现分布式状态共享和累计计算。编写Spark UDF时，可以将累加器声明为全局变量，然后在函数中使用它来记录状态。这样，就可以在分布式计算环境中有效地维护状态和共享状态。

不初始化

m 和sum是成员变量你也没在类里面定义过啊

和动态创建的是一样的利用GetDlgItem(IDC_EDIT1)获取控件指针后强制转换一下，应该没问题类的成员变量就是类中的变量与控件关联的变量是通过DDX 实现的

成员变量和局部变量的区别在于其有效范围不同。成员变量在整个类内都有效，而局部变量只在定义它的成员方法内才有效。

当然可以,用static修饰,也就是我们平时所说的类变量

成员变量无论类型是基本数据类型还是引用类型，一律存放在堆中。当然成员变量的引用依然存放在栈中。

根据变量的作用域来决定的。 局部的，全局的，静态的，成员变量等。 具体可以参考一本C++的教材，相信会得到很好的答案， public的可以直接调用，友元类也可以调用；私有的，不能直接调用，要通过成员函数调用。

构造函数试用于动态创建对象。基于对象编程的思想，是不赞成直接给类里面的变量直接赋值的。

恩,VC里面有这个习惯

指针就是地址例如p＝&a

会取到q，两者是联系到一起的

结构类型变量是一些组合成一个整体的不同类型的数据变量，虽然各个变量分别属于不同的数据类型，但是它们之间密切相关，各种信息都属于同一个人。这时，可以声明一个结构类型，由多种变量组成。变量可以是基本数据类型，也可以是自定义的数据类型。结构类型变量与结构体成员变量区别为：内存单元不同、编译不同、赋值不同。一、内存单元不同1、结构类型变量：系统为结构类型变量分配实际的内存单元，并在其中存放具体的数据。2、结构体成员变量：结构体成员变量系统不为之分配实际的内存单元。二、编译不同1、结构类型变量：在编译时，系统不为结构类型变量的类型分配空间。2、结构体成员变量：在编译时，系统为结构体成员变量的类型分配空间。三、赋值不同1、结构类型变量：不同结构类型的变量不允许相互赋值，即使它们有相同的成员。2、结构体成员变量：结构体成员变量的为。不同结构体只要有相同的成员，允许相互赋值。

问题中写的很清楚啊。一个是函数，执行一定功能的函数。一个是变量，就是类似intdoublechar等变量啊。

对的, 没问题! 定义成员变量, 放哪儿都可以! 与方法前后无关! 就算类的最后面也没问题!

1点击开始菜单。2点击visual studio 2013。3点击打开项目。4点击目标文件夹。5点击目标文件。6点击项目。7点击类向导。8选择项目。9选择类名10点击成员变量。11点击添加自定义。12输入变量类型，变量名，私有性，点击确定。13点击确定。14已添加

堆管对象，栈管运行。普通成员变量在堆空间

存在堆里

Java类的两种成员变量：一种没有 static 修饰，为实例变量；一另种是被static关键字修饰的变量，叫类变量或者静态变量。所以实例变量属于成员变量。

java中没全局变量这个说法 就有 成员变量 和局部变量（在方法中定义，和方法的参数）

字段就是成员变量，注意是成员变量，不是局部变量。字段也就是属性了，一个类的属性。只是叫法不同，java的API中一般叫成员变量就字段，有时也叫域。而我们一般的编程的时候，就字段叫成员变量补－－－－－－－－－－－－out就是一个字段，也就是是System类的一个成员变量。只不过个这成员变量是一个对象，也就是out是一个PrintStream类的对象。这就是在一个类里执有其它类的对象的用法

从使用者的角度看没有什么区别，都是依附在对象上的数据。从类设计的角度看，属性是通过方法访问的数据，写一个属性，可能会影响多个数据，而读属性，得到的是方法的返回结果，也可能是多个数据运算得到的值。成员变量直接就是对象的数据，用户代码可直接读写。

final才代表是不可变的，private只是表示这个成员是私有的，在调用这个对象的时候它对你并不可见。

不一样的，例如public class A{ String id; //实例变量 private String Tel; //实例变量 private int size; //实例变量 private static String depart; //类变量 final String design="样式"; //常量}其中实例变量、类变量、常量都是属于成员变量的，成员变量又被称为全局变量，成员变量的范围比实例变量更宽泛

package com.text;public class Animal {//动物方类 private String Name;//成员变量 名字 私有的 private int Age;//成员变量 年龄 私有的 private String Color;//成员变量 颜色 私有的----------------------------- public void Cry(){//成员方法（成员函数） 下面是方法体 System.out.println("我是一只"+this.Name+"，颜色是"+this.Color+"，我今年"+this.Age+"岁了。"); }--------------------------------------------通常情况下一个类还要有构造函数 作用是给成员变量附初始值----------------------------------------------------------- public Animal(String Name,int Age,String Color){//动物类的构造函数 this.Name=Name; this.Age=Age; this.Color=Color; }

不是的，，成员变量相当于程序集变量，，而全局变量是指在这个整个的程序内都可以使用这一个变量。而成员变量如果切换到另一个程序集后就不能使用了，纯属手打望最佳

成员变量也叫类的属性，一般带有访问控制属性的，而全局变量虽然也有类的属性，但全局变量严重影响了封装和模块化，一般的全局变量前面要加上static和 fina属性其中，static使该变量任何类都可用(方法 ClassName.全局变量名) ，而 fina则使得变量不可更改，基本上算是常量了，这也在一定程度上防止对变量的非法修改

C语言中的成员变量是指结构体、联合体、枚举中的变量。

类变量属于成员变量java的类中有两种成员变量 一种就是类变量或静态变量 这类变量前面加油static关键字修饰 这类变量一旦赋值它的值就在你new出来的任何一个实例中具有相同的值另一种叫做实例变量 前面不加static关键字修饰，每一个new出来的新实例都可以对他赋予自己需要的值例子class example{ static int a = 0; int b = 1;}a是类变量，b是实例变量example e1 = new exzample();example e2 = new exzample();改变e1中a的值会使e2中的a值也改变而e1中b值的变化不会带来e2中a值的变化

定义了一个类，在这个类里面定义得函数就叫成员函数，定义的变量就叫成员变量。

在A类的构造函数里写即可。当然如果B的构造函数若有，则定义时已对b初始化了。

你问的是成员函数麽？在自定义类型里的成员函数可以直接访问对象的数据元素。而非成员函数是不可以直接访问自定义类型里的私有数据元素的。

首先创先一个实体类 public class MyClass : INotifyPropertyChanged { private static string _myString = "sdfdsfssdfsdfsdfdsf"; public string MyString { get { return _myString; } set { _myString = value; OnPropertyChanged("MyString"); } }public event PropertyChangedEventHandler PropertyChanged; [NotifyPropertyChangedInvocator] protected virtual void OnPropertyChanged(string propertyName) { PropertyChangedEventHandler handler = PropertyChanged; if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName)); } }//然后把这个实体类绑定到页面的 DataContext<TextBox Text="{Binding MyString}"/>

①绑定到某个控件的依赖属性DependencyProperty ②绑定到定义了INotifyPropertyChanged的类（ObservableCollection就是实现了该接口） 先看DependencyProperty。可以把任何一个CLR对象绑定为DependencyProperty。在VS2010下输入propdp，按Tab，会生成一个模板public int MyProperty { get { return (int)GetValue(MyPropertyProperty); } set { SetValue(MyPropertyProperty, value); } } // Using a DependencyProperty as the backing store for MyProperty. This enables animation, styling, binding, etc... public static readonly DependencyProperty MyPropertyProperty = DependencyProperty.Register("MyProperty", typeof(int), typeof(ownerclass), new UIPropertyMetadata(0));MyProperty就是你要绑定的成员，修改它之后按Tab，后面的自动都会改变，如：public string Test { get { return (string)GetValue(TestProperty); } set { SetValue(TestProperty, value); } } // Using a DependencyProperty as the backing store for Test. This enables animation, styling, binding, etc... public static readonly DependencyProperty TestProperty = DependencyProperty.Register("Test", typeof(string), typeof(ownerclass), new UIPropertyMetadata(0));这里的ownerclass是拥有此成员的类名（如：class ownerclass {//...}）。最后一个参数VS自动生成的有问题，因为它放入了一个参数0。实际上应该是UIPropertyMetadata(Object, PropertyChangedCallback, CoerceValueCallback, Boolean)，用于设置UI中的数据更改后回调的函数。一般删除之或者用默认构造函数就行。如果需要它，一个简单的定义如下： public static readonly DependencyProperty IsNetworkChangedProperty = DependencyProperty.Register("IsNetworkChanged", typeof(bool), typeof(MainWindow), new UIPropertyMetadata(false, new PropertyChangedCallback(MainWindow.OnIsNetworkChanged))); private static void OnIsNetworkChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { //MessageBox.Show(d.GetType().ToString()); }注意这里是静态函数，由DependencyObject d来得到具体的通知对象。 然后在控件中进行绑定，如<TextBlock Text="{Binding ElementName=MainWin, Path=Test}"/>，对Test变量的使用一如普通变量。 注意：①使用DependencyProperty比INotifyPropertyChanged的方法性能要高。因为它用Hash实现，不需要反射，而且是WPF系统中相当底层的一个基类 ②DependencyObjects are not marked as serializable ③The DependencyObject class overrides and seals the Equals() and GetHashCode() methods ④A DependencyObject has thread affinity –it can only be accessed on the thread on which it was created。（这一点很重要，特别是当程序中用到注册事件时，因为这些往往要开新线程。比如我的这个软件中，将bool型IsNetworkAvailabe用DependencyProperty绑定到控件，然后注册事件NetworkAvailabilityChanged，在NetworkAvailabilityChangedEventHandler中更新IsNetworkAvailabe值，这样就会抛出异常）在需要多线程 中操作的绑定变量，则需要用INotifyPropertyChanged再看如何用INotifyPropertyChanged：这里要将待绑定的变量包装在一个类中： class MyTest : INotifyPropertyChanged { private string test; public string Test { get { return this.test; } set { if (this.test != value) { this.test = value; this.NotifyPropertyChanged("Test"); } } } public event PropertyChangedEventHandler PropertyChanged; private void NotifyPropertyChanged(String info) { if (PropertyChanged != null) { PropertyChanged(this, new PropertyChangedEventArgs(info)); } } } 其中test就是我们要绑定的变量。（绑定一个变量写这么多一堆，有点不值，我另开一篇，做一个snippet模板，用来快速生成）。 绑定时不知为何上面的绑定方法不灵了，于是换成代码绑定吧： MyTest Test; public MainWindow() { InitializeComponent(); this.Test = new MyTest(); Test.test = "thy"; TestBox.DataContext = this.Test; } 最终，在我的应用场景中，这两者都没能有用，我注册了事件NetworkAvailabilityChanged，在其中去修改一个绑定到ListBox的ObservableCollection，让其实现UI自动更新。但是总是会引起异常，我想可能是跨线程的原因吧。于是我试着用DependencyProperty绑定一个变量，在NetworkAvailabilityChanged事件中修改，还是不行，INotifyPropertyChanged也一样，BackgroundWorker也不行。最终没辙，在MainWindow中开了一个DispatcherTimer来轮询一个普通的bool变量： private DispatcherTimer _timer = new DispatcherTimer(DispatcherPriority.ContextIdle); _timer.Interval = TimeSpan.FromMilliseconds(100); _timer.Tick += new EventHandler(_timer_Tick); _timer.Start(); 虽说比较丑，但没法子啊，没这么多精力再去整了，先让它工作起来吧。

因为auto是根据初始化表达式来推断变量的类型的，如：auto n=100;，因为100是int类型的常量，所以，可推断出n的类型为int。但c++类中的成员变量是不能在声明的时候进行初始化的，如：class C{auto a=1;};以上auto a=1;是不允许的，因为它在声明a的时候初始化了a。如果改成这样：auto a;又会因为没有初始化表达式，无法推断出a的类型，这也是不被允许的。所以，auto不能用于类成员变量的类型推导中。

成员变量个是类内部；局部变量是定义其的方法体内部（或者方法体内部的某一程序块内——大括号，主要看定义的位置）。另外，成员变量可以不显式初始化，它们可以由系统设定默认值；局部变量没有默认值，所以必须设定初始赋值。还有，在内存中的位置也不一样。成员变量在所在类被实例化后，存在堆内存中；局部变量在所在方法调用时，存在栈内存空间中。

直接修改就可以了。比如你的成员变量为String a=“yes” ； 然后在内部类里直接修改为 a = “no”；

展开全部内部类中访问成员变量不一定要设为final，如果是static也行；不过要看是内部类还是匿名内部类内部类：要将成员变量设为static；匿名内部类：要将成员变量设为staticfinal；内部类中访问变量是默认this.变量;而this代表：内部类；所以要static或final；

你应该用的是jdk1.8吧，jdk1.8以后已经不需要在内部类引用局部变量时加final关键字了，其实就是个语法糖。还有纠正一点问题，Java1.8以下内部类引用局部变量时需要加final，引用成员变量也不需要加的，成员变量就是在类里面定义的变量，局部变量是在方法里定义的变量。

1、局部变量：在方法内定义的变量称为“局部变量”或“临时变量”，方法结束后局部变量占用的内存将被释放。2、成员变量：在类体的变量部分中定义的变量，也称为字段。3、全局变量：全局变量，又称“外部变量”，它不是属于哪个方法，作用域从定义的地址开始到源文件结束。

public class Test { private String name;//成员变量，也是全局变量 public void changeName() { String n = "tomoya";//n就是局部变量 name = n; }}总的来说，定义在类里的，也就是name那个位置，就是成员变量，在JAVA里全局变量和成员变量是一个意思。定义在方法里或域里就叫做局部变量，所谓域就是{}里面，比如public void show() { int b = 2;//局部变量 if(true) { int a = 1;//局部变量 } //这个位置访问a，无效}//这个位置，或其他方法里访问b，无效他的作用范围：局部变量离开了他的域{}就无效成员变量的范围依赖他的访问修饰符，什么是访问修饰符呢？public protectedprivate默认，你定义时不给他访问修饰符就是默认至于他们的范围，请自行查资料，不动脑筋是不行滴这种东西确实如1L所说的，再烂的书也会有介绍

Java类成员变量分为实例变量和静态变量，语法格式如下：1、实例变量语法格式 [public private protected final] 类型名称 属性名称； 该变量属于实例对象的变量2、静态变量语法格式 [public private protected final] static 类型名称 属性名称； 该变量属于整个类所有对象共享，所以也称类成员变量你明白了吗？

我也不懂本地变量 和 成员变量不过变量的作用域我是明白的简单的讲就是，大括号‘{}"内定义的变量可以在{}内以及他所嵌套的{}内使用，这就是变量的作用域但是！当其嵌套内的{}中有同名变量的时候以本括号内的变量为准列子就是：哈哈，我老师就是这么讲的宪法和地方法律宪法是全局变量，地方法律是局域变量地方法律大于宪法 就是局域变量和全局变量冲突时服从局域变量