java 允许类定义与类同名的成员变量吗

……不在方法中定义的变量为成员变量。成员变量有两种，有static修饰的为静态成员变量，没有static的为实例变量

成员变量的意思：指定维度的成员变量，用于标识某个维度成员。由Analysis Services内部使用的值，以标识某个维度成员。MemberKeyColumn属性指定维度的成员变量。例如：1到12之间的某个数字可以是相应于年中的某个月的成员变量。Clothes类的成员变量：package ch05.sample。public class Clothes。String id; //实例变量。private String colorType; //实例变量。private int size; //实例变量。private static String depart; //类变量。final String design="yangzi"; //常量。

类变量属于成员变量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值的变化

一个类的类体一部分是变量的定义;一部分是方法的定义(一个类中可以有多个方法)方法内定义的变量叫局部变量，因为只能在方法内部使用，固不可以用private，public，protect来修饰。成员变量（也叫全局变量）：它分为实例变量（类的对象.变量或类的对象.方法）和类变量(static静态变量)classA{inta;//实例变量必须是......答案就在这里：局部变量，全局变量，成员变量，实例变量，类变量的区别----------------------你好，人类，我是来自CSDN星球的问答机器人小C，以上是依据我对问题的理解给出的答案，如果解决了你的问题，望采纳。

局部变量和成员变量主要看作用域，而作用域就是看花括号。作用于整个类的，就是只被类的花括号包含的，就是全局变量（成员变量）。相对而言被方法或者其他域包含的就是局部变量。而类变量就是被static修饰的变量，也叫做静态变量。

java成员变量和方法成员变量：在类体的变量部分中定义的变量，也称为属性。我们先来看一个Clothes类的成员变量：packagech05.sample;publicclassClothes{Stringid;//实例变量privateStringcolorType;//实例变量privateintsize;//实例变量privatestaticStringdepart;//类变量finalStringdesign="yangzi";//常量}代码中的实例变量、类变量、常量都属于成员变量，那么其区分的依据是什么？这与变量的修饰符有关系，也就是上面代码中的private、static、final等修饰符。成员变量的修饰符见表5-1。表5-1成员变量的修饰符修饰符说明public成员变量可以被项目中的任何方法访问，建议尽量少用protected不在同一个包中的类不能访问，但子类可以访问private只能在同一个类中使用static类变量，其值为该类的所有对象共享，不会因类的对象不同而不同final最终成员变量，其值保持不变，即常量transient当对象被持久化时（例如写入数据库），该成员变量的值不需要保存volatile同步多线程访问的成员变量的值，以便使不同的线程总是得到该成员变量的同一个值。基本类型的成员变量java的基本类型可以分为三类，字符类型char，布尔类型boolean以及数值类型byte、short、int、long、float、double。数值类型又可以分为整数类型byte、short、int、long和浮点数类型float、double。JAVA中的数值类型不存在无符号的，它们的取值范围是固定的，不会随着机器硬件环境或者操作系统的改变而改变。被以上八种基本类型修饰的变量为基本类型的成员变量

就是你在类中定义的全局变量

变量一个很简单的解释，只要出了该变量声明的大括号，这个变量就没用了！

通过函数自己能控制外界的输入，必要时返回错误。如果直接暴漏内部变量，会让你无法控制赋值不当带来的问题。另外如果内部变量改名称或结构，还可以在函数中添加转换，只要改此函数即可，否则，你不得不找出所有引用改变量的地方，然后做更改。

例如类的成员变量：intOriginData[4];在构造函数里面初始化百时，添加：intTemp[4]={1,2,3,4};memcpy(OriginData,Temp,sizeof(Temp));Temp临时变量初始化，度然后把这个内存拷贝到类的成员变量就可以了，构造函数执行完毕之后，Temp的内存会由操作系统自动被释放掉，不会占多余的内存。而在执行构造函数过程中，OriginData早就成功拥有这份数据了，直到销毁对象才会被释放掉。new的方法也可以，但是用完之后有时候内需要手动释放内存，否则，在程序未执行完之前，程序在做其他方面的工作，粗心容大意，有可能会发生难以预测的错误。

子类继承父类之后，可以继承父类的public和protected类型的成员变量。

可以的，内部类

如果变量和方法是静态的就直接类名.变量名或类名.方法名非静态的话,本类中访问直接this.变量名或者this.方法名,外部其它类如果要调用的话就需要先创造出该类然后再.变量名或.方法名

是

C++中“类”的static成员，只有一个实例。也就是所有的类的实例都用同一个变量。如果这个变量是public的，那类的外部能够直接访问，方法是类名“变量名”。代码中的实例变量、类变量、常量都属于成员变量，这与变量的修饰符有关系，也就是上面代码中的private、static、final等修饰符。首先类的静态成员变量为类的全局变量，并不为类的对象所拥有。而类的普通成员变量通过类生成对象后是属于生成对象的变为此对象所特有，不能与其它生成的对象所共有。如下图所示，两个对象a,b的成员变量x并不是相同的。静态成员变量需要在全局定义，普通成员变量是属于某个对象的，不需进行全局定义。访问类的静态成员变量可以通过如下形式，如类A中定义了静态成员变量x,形式为类名，变量名，类的静态成员变量在对象还没有产生前就已经存在了。

//当前类中写一个方法HWND gethWnd(void){ return hWnd;}需要调用的地方直接调用这个类的这个方法 要么把这个方法定义静态要么把hWnd定义静态就可以直接调用

可以在定义A类时，把成员变量设置为公有（public）,否则A的私有变量是不可以在其他类或函数中使用的，当设置成公有后，A.a，A.b，A.c就可以在B中引用，这种方法在B中可以改变a,b,c的值。或给A设Geta(){return a;}的成员函数，在B中调用A.Geta();但是这种方法，不能改变a,b,c。

对象指非基本类型的实例，变量则是基本类型的实例，基本类型就是int ，float ， double，bool，long等

java易混淆概念之类变量、实例变量、局部变量类变量、实例变量、局部变量类变量是类中独立于方法之外的变量，用static 修饰。实例变量也是类中独立于方法之外的变量，不过没有static修饰。局部变量是类的方法中的变量。看下面的伪代码说明：public class Variable{ static int allClicks=0; //类变量 String str="hello world"; //实例变量 public void method(){ int i =0; //局部变量 }}实例变量也称为:“域”，“成员变量”，在实体类或数据类中被称为“属性”或“字段”。当实例变量可以改变时，被称为对象的状态。2. final用于常量的声明，规范要求常量的变量名是大写的。3. statci 在java 里面用于对类方法和属性进行修饰，其作用是什么呢？有两种情况是non-static无法做到的，这时你就要使用statice。第一种：你希望不论产生了多少个对象，或不存在任何对象的情形下，那些特定数据的存储空间都只有一份；第二种：你希望某个函数不要和class object绑在一起。即使没有产生任何object，外界还是可以调用其static函数，或是取用其static data

内存被他为栈区和堆区，程序的全局变量和局部变量这些数据是存放在栈中，因为一个子程序或函数调用结束后，函数或子程序使用的内存全被回收，这人实现的方法就是栈。函数在调用编译器会在栈中分配足够的空间，然后将数据全部压入栈中，等调用结束会自动清空栈，这样函数所使用的内存就消失了。 但我们知道动态内存是可以夸函数使用的，这是因为动态内存是分配在堆中，不受栈这个条件的限制，所以动态内存需要我们自己去释放，如果我们自己不释放就会造成内存泄漏，但操作系统会在程序结束后回收程序使用的所有内存。 至于代码区，数据区，栈区，这些在8086中是很重要的，这是因为8086CPU的问题。现在的32位CPU和16位CPU在对这些区的定义不一样。32位CPU可以不用去管这些区，但在进行32汇编时还是要需要，不同区会有不同的属性，但对程序的整体影响不大。建议你去看罗云彬的win32汇编，这本书对这些说得很清楚，只是书有点厚，难懂。

类是数据类型，实体是定义该类的对象。你说的应该是引用该类的对象作为类成员函数的变量，这个是经常使用的。如通过this指针就可以访问该类的对象。

不完全一样，string类重载了很多运算符，使得他的行为和字符串很相似，但是两者并不是一个类型。strings1；char*s2=new；前者是string对象，后者是char指针。简单举两个例子：strcpy(s1,s2);//错，strcpy函数只能接受char*/constchar*

局部变量是在函数或方法中的变量，实例变量指的是类的一个实例，就是一个对象, 成员变量就是类中的变量(不是方法中的变量!), 类变量是类中的静态变量。局部、实例、成员变量的作用域和生存周期同局部变量一样，而类变量如果用public声明则作用域同全局变量，如果是private则作用域只在类的内部，生存周期同全局变量.成员方法和类方法跟局部变量和类变量的关系一样.

C语言的变量可以分成两种级别：全局变量和局部变量全局变量，在该变量之后定义的函数都可以访问局部变量，只能在定义的函数中访问而C++中多出了成员变量，成员变量通常是私有。成员变量依附于对象存在，有了对象，成员变量才有内存而成员变量的可以被本类的所有成员函数直接访问的。

抽象类 和普通类最大区别在于 至少有一个未被实现的方法 其他没有区别

前面有static后面没有，over

成员变量定义一般是修饰符 参数的类型 变量名。参数的类型可以是基本类型，和引用类型，而引用类型又包括类、数组、接口、集合等。ClassTest是一个自定义的类，而ClassTest name是一个ClassTest类型名为name的成员变量

面向对象一 、面向过程与面向对象的区别：前者是一种谓语和宾语的关系；后者是一种主语和谓语的关系 。二、面向对象的三个特征：??封装 ??继承 ??多态三、类与对象：对象又称作实例，是实际存在的该类事物的每个个体。类是对某一类事物的描述，是抽象的、概念上的 定义。 *面向对象的设计的重点是类的设计。四、对象的比较：1 “= =”运算符与equals()方法的区别： 前者辨别实质是否相等；后者辨别长相是否相等。五、 实现类的封装性：1不能让外面的类随意修改一个类的成员变量；2在定义一个类的成员（包括变量和方法），使用private关键字说明这个成员的访问权限，只能被这个类的其他成员方法调用，而不能被其他的类中的方法所调用； 3为实现封装性，常将类的成员变量声明为private,再通过public的方法来对这个变量进行访问。对一个变量的操作，一般都有 读取和赋值操作，我们一般定义两个方法来实现这两种操作，即：getXxx()与setXxx();4一个类就是一个模块，我们应该让模块仅仅公开必须要让外界知道的内容，而隐藏其他的一切内容。再进行程序设计时，应尽量避免一个模块直接修改或操作另一个模块的数据，模块设计追求强内聚（许多功能尽量在类的内部独立完成，不让外面干预），弱耦合（提供给外部尽量少的方法调用）。六、构造函数的定义与作用：1、 特征：??名称与类相同；??不含返回值；??不能在方法中用return返回一个值注意：构造方法里不含返回值的概念是不同与void的，在定义构造方法时加了void，结果这个方法就不再被自动调用了。2作用：当一个类的实例对象刚产生时，这个类的构造方法就会被自动调用，我们可以在这个方法中加入要完成初始化工作的代码。七、若类中已定义了一个构造方法，编译器就不再自动产生类似public Person(){ }的构造方法。八、this引用句柄的应用：1、 类的成员名和对其进行赋值的成员方法的形参变量同名时，使用this便于理解；2、 假设我们有一个容器类和一个部件类，在容器类的某个方法中要创建部件类的实例对象，而部件类的构造方法要接收一个代表其所在容器的参数。3、 构造方法是在产生对象时被java系统自动调用的，我们不能在程序中象调用其他方法一样去调用构造方法。不是用构造方法名，而是用this的形式，根据其中的参数列表，选择相应的构造方法。九 、 垃圾回收过程分析：java中的finalize()方法；System.gc的作用。Finalize()的调用是在无用对象被回收前发生的。一○、 static 静态方法：1、 在静态方法中只能直接调用同类中其他的静态成员，而不能直接访问类中的非静态成员。原因是对于非静态的方法和变量，需要先创建类的实例对象后才可使用，而静态方法在使用前不用创建任何对象；2、 静态方法不能以任何方式引用this和super关键字；3、 main（）方法是静态的，因此，JVM在执行main方法时不创建main方法所在的类的实例对象，因此在main()方法中，我们不能直接访问该类中的非静态成员，必须创建该类的一个实例对象后，才能通过这个对象去访问类中的非静态成员。一一、 JVM在程序执行时，只有在调用其他类的时候，才加载这个类并将其初始化（即将构造方法及静态变量进行加载并初始化。一二、 单态设计模式：采取一定的方法保证在整个的软件系统中，对某个 类只能存在一个对象实例，并且该类只能产生严格取得其对象实例的方法。若我们要让类在一个虚拟机中只能产生一个对象，我们首先必须将类的构造方法的访问权限设置为private，这样，就不能用new操作符在类的外部产生类的对象了，但在类的内部仍可以产生该类的对象。一三、 内部类： 1、在类中直接定义的内部类??*嵌套类可直接访问嵌套他的类的成员，包括private成员，但嵌套类的成员却不能被嵌套它的类直接访问； * 在内部类对象保存了一个对外部类对象的引用，当内部类的成员方法中访问某一变量时，若在该方法和内部类中都没有定义过这个变量，内部类中对this 的引用会被传递给那个外部类对象的引用； * 若用 static 修饰一个外部类，这个类就相当于是一个外部定义的类，所以 static 的内部类中可声明static 成员，但非static 的内部类中的成员是不能声明为 static 的，static 的内部类不能再使用外层封装类的非 static 的成员变量。例：若函数的局部变量，内部类的成员变量，外部类的成员变量重名，则应该按下面的程序代码所使用的方式来明确指出我们真正要访问的变量。public class Outer{private int size;public class i

弟子规大概意思是什么

有相关的函数，自己到MSDN中找吧。

不会是成员变量有大小限制的原因，一定是其他地方出错了

private可以使在一个类中定义的成员变量只能被同一包中的类访问

private表示这个变量是私有的，不让外面类直接访问

可以把任何一个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来得到具体的通知对象。 然后在控件中进行绑定，如，对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.Start(); 虽说比较丑，但没法子啊，没这么多精力再去整了，先让它工作起来吧。

成员变量、成员方法，说的是java类中的普通变量、普通方法。在创建出对象之后，成员变量、成员方法才能被使用。类变量、类方法，这个是先于对象存在的，在java类被加载到运行环境中的时候，就存在的了，用static关键字修饰的。可以用‘类名.类方法"‘‘类名.类变量"的语法来调用。

通过set和get方法

如果java类中的成员变量可以随着对象的创建而存在，随着对象的回收而释放。成员变量是类中的属性，每个对象都有一份属性。一个对象中的属性就是成员变量。在类内部，任何地方都可以访问成员变量。

可以

基本类型就是int，byte，short等8个，对象类型就是类的变量

私有成员变量，即定义在private区域的成员变量。对于本类成员函数来说，该变量与其它成员变量并无区别。使用上和作用上也都相同。对于通过对象访问，私有成员变量无法通过对象访问。通过这一方式可以起到保护一些数据不被随意修改的效果。另外，在出现继承时，基类的私有成员变量不会被继承。所以，如果存在想保护不被对象引用，或者不想被继承的成员变量，需要定义为私有。

例如定义一个类：classText{publicstaticintnumber;publicinttemp;}如果你想访问temp属性，你就必须先创建一个Text的对象，才能访问：Textb=newText（）；b.temp;这就是实例成员变量。而你想访问number的话，不用创建Text的实例就可以访问，就像这样：Text.number.这就是类成员变量。主要区别就是访问是需不需要创建对象，而对于类成员变量，所有对象是共享一个变量的。

类定义里面的成员变量和函数默认都是private型 类本身默认为public型 全局成员默认也都是public型

成员变量：成员变量是指定维度的成员变量，用于标识某个维度成员。由 Analysis Services 内部使用的值，以标识某个维度成员。MemberKeyColumn 属性指定维度的成员变量。例如，1 到 12 之间的某个数字可以是相应于年中的某个月的成员变量。类变量：在java中，类变量（也叫静态变量）是类中独立于方法之外的变量，用static 修饰。（static表示“全局的”、“静态的”，用来修饰成员变量和成员方法，或静态代码块（静态代码块独立于类成员，jvm加载类时会执行静态代码块，每个代码块只执行一次，按顺序执行））。成员方法：类包括成员变量和方法两部分。成员变量表示类的属性，一数据域的形式表达，方法是数据的操作的定义。在JAVA中，方法只能作为类的成员，也称为成员方法。方法操作类所定义的数据，以及提供对数据的访问的代码。大多数情况下，程序的其他部分都是通过类的方法和其他类的实例进行交互的。类方法：类方法这不是一个名词，只是单纯的类中描述的一个方法。加了static的方法，在程序中只运行一次，比如你两次实例化对象了，但你实际上只调用了一次static标识的方法。

直接定义数组，，，初始化的时候，new~~~~~~

可以。8种基本类型有对应的包装类。

作用域 一般以 块 来限定也就是编程中常见的 {}类变量--类中适用成员变量--类中的属性成员实例变量--new 初始化内存空间的对象,实现引用传递局部变量--类中,实现值传递的对象,并不是类的对象,而是由8大数据类型声明,只在相应的作用域中作用

就是不能被其他类引用的变量。通常不放在放在头文件中申明

设置友元

另外可以 类的成员函数可以访问这个类的所有成员