成员变量

重写和重载是针对方法的子类的变量可以覆盖父类的变量，但是不能改变父类的变量

局部变量

derived类中的成员变量i和base类中的成员变更i不是同一个变量，如果去掉，base类中的成员变更i就不能初始化了。而且，base类也没有默认的构造函数base()。

class Superclass { int x; Superclass() { x = 3; System.out.println("in Superclass:x=" + x); //打印信息 in Superclass:x=3 } void dosomething() { System.out.println("in Superclass.dosomething()"); //打印信息 in Superclass.dosomething() }}class Subclass extends Superclass { int x; Subclass() { super();// 调用Subclass的父类Superclass的构造方法 x = 5;// B System.out.println("in Subclass:x=" + x); //打印信息 in Subclass:x=5 } void dosomething() { super.dosomething(); // 调用父类的dosomething方法 System.out.println("in Subclass.dosomething()"); //打印信息 in Subclass.dosomething() System.out.println("super.x=" + super.x + " sub.x=" + x); // super.x=3 sub.x=5 }}public class Li4_06 { public static void main(String[] args) { Subclass Subc = new Subclass(); //声明并定义一个对象，此时调用Subclass类的构造方法Subclass() Subc.dosomething(); // 调用Subclass的方法dosomething }}

1.classa中的intx是成员变量，类中的doublex是成员函数voidf(doublex)的局部变量，当此成员函数运行结束退出的时候，doublex内存就自动回收了。2.另外一个问题，这两个函数中的doublex分配的内存空间大小相同，都是在栈里分配。

可以的；子类和父类不冲突

2.要在多个文件中共享类得成员变量怎么实现呢？包含静态成员变量定义的头文件即可

堆,向下分配内存(new,malloc等)-----------------------------------浮动栈,向上分配内存(函数内部变量,对象的内部成员变量等.一般都有生命周期)-----------------------------------基栈.(也叫静态存储区,包括代码段,静态变量,全局变量,const常量等,程序一调入内存至少要占这么多空间)

子类可共享。实现方式一：class A{public: static int a;};class B:public A{};可直接访问a。-----------------------实现方式二：class A{private: static int a;public: int get_a(){return a;} //读 void set_a(int b){a=b;} //写};class B: public A{};需要通过接口函数get_a()和get_b()访问静态变量a

空间环境和

看书最好，仔细看定义和例子

更快是什么意思？ （成员变量就是全局变量）

静态方法的最明显的特点就是 类名直接调用方法和属性 不需要实例化方法的话 对成员变量也要求是静态的

//如何才能在类中的静态函数中使用类的成员变量 可以通过给静态函数加参数来实现,比如static void loop(test * argslist );{ argslist->a=10; argslist->a=b;}在类外可这样实现test a;test::loop(&test);//或者有没有办法在启动线程的时候使用类的成员函数？ 将类的成员函数声明成tatic DWORD WINAPI StartThread()就可以调用了,注意beginthread这个函数中的一个参数,通过它可以将你类中的一些信息传到线程中.

原因如下;　　和静态数据成员一样，静态成员函数是类的一部分，而不是对象的一部分。如果要在类外调用公用的静态成员函数，要用类名和域运算符“∷”。　　如 Box∷volume( ); 实际上也允许通过对象名调用静态成员函数，如 a.volume( ); 但这并不意味着此函数是属于对象a的，而只是用a的类型而已。 静态成员函数的作用是为了能处理静态数据成员。 可以说，静态成员函数与非静态成员函数的根本区别是：非静态成员函数有this指针，静态成员函数并不属于某一对象，它与任何对象都无关，静态成员函数没有this指针。　　由此决定了静态成员函数不能访问本类中的非静态成员。 在C++程序中，静态成员函数主要用来访问静态数据成员，而不访问非静态成员。假如在一个静态成员函数中有以下语句： cout<<height<<endl; //若height已声明为static，则引用本类中的静态成员，合法 cout<<width<<endl; //若width是非静态数据成员，不合法。但是，并不是绝对不能引用本类中的非静态成员，只是不能进行默认访问，因为无法知道应该去找哪个对象。如果一定要引用本类的非静态成员，应该加对象名和成员运算符“.”。如 cout<<a.width<<endl; //引用本类对象a中的非静态成员

在方法里的变量属于局部变量，局部变量必须附初值！

不行，因为java中静态的东西是类级别的，也就是说用类名就可访问，也可以用任何对象名访问，无论以哪种形式访问的都是同一个东西。而一般我们所说的成员变量，是指对象级别的，也就是说每一个对象所拥有的成员变量都是独立的不同的变量，是属于对象自己拥有的。相对于来说访问范围，无疑是静态的更大，静态的可以被任何对象所访问且是同一个，而成员变量是每个对象各自拥有的。那么，为什么“静态方法不能调用类成员变量”，因为要想访问成员变量你必须有个“已经实例化好的对象”，除非你在静态方法里创建一个当前类的实例对象，否则你是无法直接调用成员变量的，因为它不知道这个成员变量属于哪个实例对象的。而在成员方法里，所有属于成员的变量、方法已经可以确定是同一个对象的，并且可以用this表示当前对象。

mark先坐下，等大神，因为我也想知道～

同类中的静态方法只能调用同类中的 静态变量

实例方法既可以操作实例变量,又可以操作类变量.

是！

生命周期不同,被static修饰的属性跟方法会随着的类的加载而存在.而非静态成员变量则是在该类被创建对象是才会初始化,如果类只是被加载而没有创建实例对象,则无法访问非静态成员.

类内只是声明。类外才是定义。所以不是一定要初始化，而是一定要在类外定义。不然系统认为这个是未定义的。

static MVEC m_vec;只是在类中进行了声明，而规则是需要在类外定义class b{public: static MVEC m_vec;};MVEC b::m_vec;...

楼上正解 遇到问题 要多想 然后测试一下自己的想法 才能提高自己 共勉

static CSingleton* m_pInstance;改为static CSingleton* m_pInstance = NULL;声明时候顺便初始化为NULL即可。你这里只声明未定义啊。

是的，静态方法中的成员变量也必须都是静态的，不然编译就会报错。原因也正如你说的，静态方法不依赖与对象的存在，所以如果有非静态的成员变量就会引发歧义

必须在类外初始化

因为类的静态成语变量对于该类的对象们来说是共享的，而类内的成员变量在创建对象时会被构造函数初始化，假如该静态变量在类内，每创建一个对象该静态变量就被重新初始化，那把它定义为静态的目的何在？

在类外初始化。格式: 类型 类::变量名例子：class Ctest{public:static int S_m_a; //声明};int Ctest::S_m_a =100 ; //初始化

不行的，只能在静态方法里面用静态变量。

不行，因为java中静态的东西是类级别的，也就是说用类名就可访问，也可以用任何对象名访问，无论以哪种形式访问的都是同一个东西。而一般我们所说的成员变量，是指对象级别的，也就是说每一个对象所拥有的成员变量都是独立的不同的变量，是属于对象自己拥有的。相对于来说访问范围，无疑是静态的更大，静态的可以被任何对象所访问且是同一个，而成员变量是每个对象各自拥有的。那么，为什么“静态方法不能调用类成员变量”，因为要想访问成员变量你必须有个“已经实例化好的对象”，除非你在静态方法里创建一个当前类的实例对象，否则你是无法直接调用成员变量的，因为它不知道这个成员变量属于哪个实例对象的。而在成员方法里，所有属于成员的变量、方法已经可以确定是同一个对象的，并且可以用this表示当前对象。

静态成员函数不能访问非静态成员变量，这是规定。 但是你可以换下解决问题的思路。线程的入口函数除了可以锁静态成员函数，也可是全局函数。 在全局函数里获取主窗口的句柄之后，接下来可以访问各种成员变量。

页面还可以定义静态变量，我咋不知道呢。。。。:( 多次传过来的参数。不懂。。。。。可以用局部刷新啊。

类中的静态成员变量的初始化必须在类外实现！！并且静态变量定义的关键是：static const int aaa; 再类外初始化的格式是：const 数据类型 【类名】：：变量名=数字 例如该程序中：const int a::aaa=10;

static是类级别方法也就是可以类名.方法调用不加static是实例级别的也就是必须先有实例（对象）才能调用其方法如newA().test()除了把成员加static修饰还有别的办法吗 可以new个对象再调用

因为静态变量只在类的空间中保存了一份，它是属于类的，当你第一次加载类的时候，静态变量就会随着一起加载，再往后即便你创建对象了，由于创建时根本就没把静态变量拷贝给对象，当然这个变量也就只初始化一次了。

静态成员变量当作参数传给其他函数时仅仅是个值，函数调用不就是传个值么，为什么不能？

What？？？？？？？？？？？？？！

public class Demo {public static void main(String[] args) {new inner1().setDemo("456");String demo1 = new inner1().getDemo();String demo2 = new inner2().getDemo();System.out.println(demo1);System.out.println(demo2);}}class inner1{private static String demo = "123";public static String getDemo() {return demo;}public static void setDemo(String demo) {inner1.demo = demo;}}class inner2{private static String demo;public static String getDemo() {return demo;}public static void setDemo(String demo) {inner2.demo = demo;}}结果是：456 null

是的，静态方法中的成员变量也必须都是静态的，不然编译就会报错。原因也正如你说的，静态方法不依赖与对象的存在，所以如果有非静态的成员变量就会引发歧义

是的，静态变量是成员变量中的一种，成为静态成员变量，还有一种是实例成员变量

JAVA成员变量和静态变量的区别：1，成员变量所属于对象。所以也称为实例变量。静态变量所属于类。所以也称为类变量。2，成员变量存在于堆内存中。静态变量存在于方法区中。3，成员变量随着对象创建而存在。随着对象被回收而消失。静态变量随着类的加载而存在。随着类的消失而消失。4，成员变量只能被对象所调用 。静态变量可以被对象调用，也可以被类名调用。所以，成员变量可以称为对象的特有数据，静态变量称为对象的共享数据。

成员变量和静态变量的区别1、两个变量的生命周期不同成员变量随着对象的创建而存在，随着对象被回收而释放。静态变量随着类的加载而存在，随着类的消失而消失。2、调用方式不同成员变量只能被对象调用。静态变量可以被对象调用，还可以被类名调用。3、别名不同成员变量也称为实例变量。静态变量也称为类变量。4、数据存储位置不同成员变量存储在堆内存的对象中，所以也叫对象的特有数据。静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。成员变量和静态变量的区别1、两个变量的生命周期不同成员变量随着对象的创建而存在，随着对象被回收而释放。静态变量随着类的加载而存在，随着类的消失而消失。2、调用方式不同成员变量只能被对象调用。静态变量可以被对象调用，还可以被类名调用。3、别名不同成员变量也称为实例变量。静态变量也称为类变量。4、数据存储位置不同成员变量存储在堆内存的对象中，所以也叫对象的特有数据。静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

静态构造器在静态成员第一次被访问之前调用。示例代码如下：编译运行后就会看到这样的结果 using System;namespace Test{ public class Program { public static void Main() { Console.WriteLine("外部函数调用静态属性，其值为: {0}", TestClass.Name); } } public class TestClass { private static string _name; public static string Name { get { return _name; } set { _name = value; } } static TestClass() { _name = "abc"; Console.WriteLine("静态变量 name 在静态构造去中被初始化, 初始值为: {0}", _name); } }}

不是，私有变量只能在它的类中进行引用，而静态成员变量可在不同的成员方法中进行引用

局部变量表是一组变量值存储空间，用于存放方法参数和方法内部定义的局部变量。在Java程序被编译成Class文件时，就在方法的Code属性的max_locals数据项中确定了该方法所需要分配的 最大局部变量表的容量。 局部变量表的容量以变量槽（Slot）为最小单位，32位虚拟机中一个Slot可以存放一个32位以内的数据类型（boolean、byte、char、short、int、float、reference和returnAddress八种）。

定义：在全局变量前，加上关键字 static 该变量就被定义成为了一个静态全局变量。特点：A、该变量在全局数据区分配内存。B、初始化：如果不显式初始化，那么将被隐式初始化为0（自动变量是随机的，除非显式地初始化）。C、访变量只在本源文件可见，严格的讲应该为定义之处开始到本文件结束。例（摘于C++程序设计教程---钱能主编P103）：　//file1.cpp//Example 1#include <iostream.h>void fn();static int n; //定义静态全局变量void main(){n=20;cout < <n < <endl;fn();}void fn(){n++;cout < <n < <endl;}D、文件作用域下声明的const的常量默认为static存储类型。静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。对于一个完整的程序，在内存中的分布情况如下图：代码区全局数据区堆区栈区一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静态局部变量）也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。细心的读者可能会发现，Example 1中的代码中将static int n; //定义静态全局变量改为：int n; //定义全局变量程序照样正常运行。的确，定义全局变量就可以实现变量在文件中的共享，但定义静态全局变量还有以下好处：静态全局变量不能被其它文件所用；（好像是区别extern的）其它文件中可以定义相同名字的变量，不会发生冲突；您可以将上述示例代码改为如下：//Example 2//File1#include <iostream.h>void fn();static int n; //定义静态全局变量（只能在本文件中使用）void main(){n=20;cout < <n < <endl;fn();}//File2#include <iostream.h>extern int n；（可在别的文件中引用这个变量）void fn(){n++;cout < <n < <endl;}编译并运行Example 2，您就会发现上述代码可以分别通过编译，但link时出现错误。试着将 static int n; //定义静态全局变量改为int n; //定义全局变量再次编译运行程序，细心体会全局变量和静态全局变量的区别。 定义：在局部变量前加上static关键字时，就定义了静态局部变量。我们先举一个静态局部变量的例子， 如下：//Example 3#include <iostream.h>void fn();void main(){fn();fn();fn();}void fn(){static int n=10;cout < <n < <endl;n++;}通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。特点：A、该变量在全局数据区分配内存。B、初始化：如果不显式初始化，那么将被隐式初始化为0，以后的函数调用不再进行初始化。C、它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或　语句块结束时，其作用域随之结束。 注意与类的静态成员函数区别定义：在函数的返回类型前加上static关键字，函数即被定义成静态函数。特点：A、静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。静态函数的例子：//Example 4#include <iostream.h>static void fn();//声明静态函数void main(){fn();}void fn()//定义静态函数{int n=10;cout < <n < <endl;}定义静态函数的好处：静态函数不能被其它文件所用；其它文件中可以定义相同名字的函数，不会发生冲突；

让b 继承 a 就可以了

楼主是否对类的概念已经清楚了？如果是的话，就很好解释了。成员变量是类的一个组成部分，和类的方法处于同一级别；而局部变量是为了让方法/功能正常运行设立的一些临时存储单元，是专门服务于方法的。从概念上说，两者是完全没有关系的，但从应用上说，成员变量可能临时做为局部变量存在，而局部变量也可能依赖或者干脆引用成员变量完成工作。打个不太合适的比方，你的主机是一个类，你的CPU、硬盘、内存等等必然和你主机同时存在，同时消失的就是成员变量。而你机器里装的软件就是这个类所能提供出的方法，局部变量就是组成这些软件的文件。

从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。从变量在内存中的存储方式来看:如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。从变量在内存中的存储方式来看:如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。从变量在内存中的存储方式来看:如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

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

从语法形式上看:成员变量是属于类的，而局部变量是在方法中定义的变量或是方法的参数；成员变量可以被 public,private,static 等修饰符所修饰，而局部变量不能被访问控制修饰符及 static 所修饰；但是，成员变量和局部变量都能被 final 所修饰。从变量在内存中的存储方式来看:如果成员变量是使用static修饰的，那么这个成员变量是属于类的，如果没有使用static修饰，这个成员变量是属于实例的。而对象存在于堆内存，局部变量则存在于栈内存。从变量在内存中的生存时间上看:成员变量是对象的一部分，它随着对象的创建而存在，而局部变量随着方法的调用而自动消失。成员变量如果没有被赋初值:则会自动以类型的默认值而赋值（一种情况例外:被 final 修饰的成员变量也必须显式地赋值），而局部变量则不会自动赋值。

成员变量和局部变量的区别：1.在类中的位置不同：成员变量在类中，方法外。局部变量在方法声明上，方法中。2.在内存中的位置不同：成员变量属于对象，进堆内存。局部变量属于方法，进栈内存。3.生命周期不同：成员变量随着对象的创建而存在，随着对象的消失而消失。局部变量随着方法的调用而存在，随着方法的调用完毕而消失。4.初始化值不同：成员变量有默认的初始化值， a.引用数据类型初始化值为null； b.整数初始化值为0； c.小数初始化值为0.0； d.布尔初始化值为false； e.字符初始化值为‘u0000" 局部变量没有默认初始化值，必须先定义，再赋值，然后再能使用。

局部变量只能在某个方法里使用成员变量能在所有类中使用

成员变量的作用域是：整个类局部变量的作用域是：所属的方法或者代码块

在局部变量定义的函数或复合语句内

我们简单写个demo,在我们定义的类HPWPerson里放了name，age属性，还有_hobby成员变量 首先我们考虑两个问题，类方法是放在哪里？成员变量是放在哪里？带着这两个问题我们进行深入的探究下。 我们通过上篇结尾的分析其实知道，实例方法，成员属性，协议等都是存放在class_rw_t这个结构体里，如下面源码所示， 我们继续在class_rw_t结构体源码里找下，发现有class_ro_t这个结构体，这个结构体是干什么的呢？ 我们通过打印得到如下： @property (nonatomic ,copy) NSString *name;这个会生成下划线的成员变量_name, @property (nonatomic ,assign) int age;这个会生成下划线的成员变量_age, 发现我们再打印class_ro_t里发现有上图所示的成员变量，所以其中“_hobby”，“_age”,"_name"这些是存在class_ro_t这个结构里的。 通过上面我们发现，成员变量的值是放在对象里，成名变量名字以及一些大小信息放在类里面，这个是为什么呢？其实类里面的结构体它就好比一个模板，通过这个模板就可以生成各个成员变量信息，但是成员变量的值是不同的所以成员变量的值要存放在实例对象里，成员变量名及大小信息放在类里面就可以。 接着我们再继续探究下，在class_rw_t这个结构体里有class_ro_t这个结构体，那这两个结构体有什么关系呢？ 1.class_ro_t是在编译的时候生成的（只读），是一个纯净的空间，不能被修改的 我们知道苹果的runtime可以动态的修改属性和方法，但是ro里又不支持修改的，那它是如何实现的呢？ 我们先看下WWDC里的一个视频讲解： WWDC讲解ro，rw链接 通过上面的视频我们知道，ro在编译的时候生成，在内存不够的时候就会进行移除，当要使用的时候就会重新从磁盘里去加载。在objc源码里我们发现有个叫class_rw_ext_t的结构体，简称为rwe。class_rw_ext_t这个也不是每个类里都生成的，因为生成class_rw_ext_t是有条件的：或者有分类，或者runtime API修改的时候会生成这个rwe结构体。runtime是无法修改成员变量的，rwe在对ro里进行拷贝出的也是其中一部分，一般ro里也就10%的内容需要修改。接着我们看rwe源码如下，也验证了我们这点：如果有rwe就直接返回里面的methods，没有就返回ro里的baseMethods。 属性存放在rw里源码：如果有rwe就直接返回里面的properties，没有就返回ro里的baseProperties。 协议存放在rw里源码：如果有rwe就直接返回里面的protocols，没有就返回ro里的baseProtocols。 设计元类只是单独为了存放我们的类方法吗？ 其实其目的是为了复用消息机制。在OC中调u2f64u2f45法，其实是在给某个对象发送某条消息。 消息的发送在编译的时候编译器就会把u2f45法转换为objc_msgSend这个函数。 id objc_msgSend(id self, SEL op, ...) 这个函数有俩个隐式的参数：消息的接收者，消息的u2f45法 名。通过这俩个参数就能去找到对应u2f45法的实现。 objc_msgSend函数就会通过第u2f00个参数消息的接收者的isa指针，找到对应的类，如果我们是通过 实例对象调u2f64u2f45法，那么这个isa指针就会找到实例对象的类对象，如果是类对象，就会找到类对 象的元类对象，然后再通过SELu2f45法名找到对应的imp，然后就能找到u2f45法对应的实现。 那如果没有元类的话，那这个objc_msgSendu2f45法还得多加俩个参数，u2f00个参数u2f64来判断这个u2f45法 到底是类u2f45法还是实例u2f45法。u2f00个参数u2f64来判断消息的接受者到底是类对象还是实例对象。 消息的发送，越快越好。那如果没有元类，在objc_msgSend内部就会有有很多的判断，就会影响 消息的发送效率。 所以元类的出现就解决了这个问题，让各类各司其职，实例对象就u2f32存储属性值的事，类对象存储 实例u2f45法列表，元类对象存储类u2f45法列表，符合设计原则中的单u2f00职责，u2f7d且忽略了对对象类型的 判断和u2f45法类型的判断可以u2f24u2f24的提升消息发送的效率，并且在不同种类的u2f45法u2f9b的都是同u2f00套流 程，在之后的维护上也u2f24u2f24节约了成本。 所以这个元类的出现，最u2f24的好处就是能够复u2f64消息传递这套机制。不管你是什么类型的u2f45法，都 是同u2f00套流程。 接着我们如何证明我们上面所说的呢？下面我们来看下在源码里设置断点调试： 首先我们打开objc的源码， 我们一直按上面去打印，最后会打印一个classMethod这个类方法，在我们设置HPWPerson这个类里也有这个方法，如下，所以证明了类方法是存放在元类里面的。 接着我们看些runtime的api方法的实现： 上面这些我们是用runtime的api把成员变量，实例方法，类方法等打印出来。 通过上面总结： 1）ro里存放成员变量，实例方法，属性，协议，类对象 2）类方法存放在元类里面

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

public成员变量 必须必~

友元,或者通过接口访问,

各位小伙伴们大家好，这次小编要讲的是Java当中，成员变量和局部变量的区别，小编先来讲一下什么是成员变量？在Java当中，对象的属性也称为成员变量。那么什么是局部变量呢？在成员方法中定义一个变量，那么这个变量就被称为局部变量。接下来，小编要介绍的是成员变量和局部变量的区别。定义的位置不同成员变量：在方法的外部，直接写在类当中。局部变量：方法的内部。作用的范围不同成员变量：整个类可以通用。局部变量：只有在方法中才可以使用，出了方法就不可以使用。默认值不一样成员变量：如果没有进行赋值，会有默认值，规则和数组一样。局部变量：没默认值，需要赋值才可以使用。内存位置不一样成员变量：位于堆当中。局部变量：位于栈当中。生命周期不同成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失。局部变量：随着方法进栈而诞生，随着方法出栈而消失。相对于成员变量，一般来说局部变量存在的时间更短一点。代码如下：public class one {String author;//成员变量的位置public void method(){int num=1;//局部变量的位置System.out.println(num);//1System.out.println(author);//null}public void method1(int age){//方法的参数是局部变量System.out.println(age);//参数在方法调用的时候会被赋值，所以可以使用double score;//System.out.println(score);未赋值，不可以使用//System.out.println(num);写法错误}}关于Java当中，成员变量和局部变量，小编就先说到这里，希望这篇文章可以帮到大家，也欢迎各位小伙伴补充和纠错。

你试试换成pravite，我不确定【我不觉得哪里有错(ΦωΦ)】，一般成员变量都设成pravite

c++17新标准，前面写个inline就在类内初始化了。本质上还是类中的static和普通的static的语义不一样。类的成员变量是全局作用域，加了static也是如此。但是普通的static是文件作用域，必须通过一些方法区分他们。

成员变量放在class类中，不是在方法里的局部变量

->是通过对象的指针调用.是通过对象调用调用时没有成员变量和成员函数的区别，只和调用者的类型有关

1.beforechangvar，调用getxyz()方法，输出的是成员变量的初始值1,1,1;2.inchangevar，调用changevar方法，输出的x是成员变量，x=a，a是传进来的值为10；y和z都是局部变量，分别对应传进来的b，和9，所以结果是10,10,9;3.afterchangevar，再次调用getxyz()方法，输出的仍然是成员变量，在第2步中，x变为了10，y没有变化，但是z被赋予了c的值，而c是10，所以结果是：10,1,10

建立一个Javaproject——点右键新建一个类，类名字最好是大写开头，LZ 我给你写一个简单的类x0dx0apublic class Test{x0dx0a//定义成员变量x0dx0aint width=10;x0dx0aint height=10;x0dx0a// 成员方法x0dx0apublic area(){x0dx0a return width*height ;x0dx0a }x0dx0a}

Class A{}Class B{A a; //另一个类A的对象a作为B类的成员变量public B(){a=new A();}}

应该在代码区吧

把那个类的成员变量和方法设为public或静态

区分成员变量两种形式？哪两种啊》成员变量是属于对象的。你直接使用类名点 是不能引用的。 在本身类中，成员变量是不能在静态方法中直接引用，如public static void main(String[] args){}还有什么啊？就是成员的属性就是一顶属于特定的对象。就比如 数组的length 属性。你数组都没定义，那你有什么属性啊。String[] strArray = null; System.out.println(strArray.length);这就会报空指针了。这个length就是成员的么。你就比如，Action.SUCCESS 这个就是静态的啊。(这个是常量，static final) 你就可以直接使用啊。

先说好了 我不知道c++ 只是猜测 上边这种用单例模式会用到 c++也有单例模式 所以.

成员变量会自动初始化，数组名也是一个引用，所以初始化值是null，如果你要初始化数组里面的元素的话int [] a = {1,2,2,3,3}这样就可以静态的初始化

如果是public属性,那么类外任何对象,都可以随意改变,对象创建出来,在任何地方,任何时候都是能改变的举个简单的例子:如果你一个游戏类 ,你创建一个角色,属性如果是public的,别人可以通过内存获取你对象,通过对象去修改基本属性,这样不是就毫无安全感,如果是函数接口,函数调用时栈内存,调用完后就直接释放了.不存在固定地址.

默认的是本包的类都可以访问

不是的 我不明白 你想问什么 但是我知道肯定不是自动初始化为零，你再 好好看看构造函数跟变量那部分

默认---同包内可访问a类的子类继承了这个变量，子类的实例中包含父类的实例所以是可以访问的