成员变量

类方法就是用static修饰的方法，static修饰的方法是类所共有的，由系统自动完成加载，而实例成员变量需要通过系统默认或用户定义的构造器来进行初始化，但是构造器此时并未进行初始化，所以类方法中不能直接操作实例成员变量，只有通过创建实例才能够操作实例成员。

Encapsulation of behavior associated with getting or setting the property - this allows additional functionality (like validation) to be added more easily later.Hiding the internal representation of the property while exposing a property using an alternative representation.Insulating your public interface from change - allowing the public interface to remain constant while the implementation changes without affecting existing consumers.Controlling the lifetime and memory management (disposal) semantics of the property - particularly important in non-managed memory environments (like C++ or Objective-C).Providing a debugging interception point for when a property changes at runtime - debugging when and where a property changed to a particular value can be quite difficult without this in some languages.Improved interoperability with libraries that are designed to operate against property getter/setters - Mocking, Serialization, and WPF come to mind.Allowing inheritors to change the semantics of how the property behaves and is exposed by overriding the getter/setter methods.Allowing the getter/setter to be passed around as lambda expressions rather than values.Getters and setters can allow different access levels - for example the get may be public, but the set could be protected.

把实例成员变量也变成静态的

定义时怎么嵌套的就在初始化时怎么嵌套数据！

结构体成员运算符。->指针运算符。1、如果结构体中的成员均为一般变量（包括结构体变量），则使用“.”，如果成员变量为指针（不管指向什么，包括结构体），则使用“->”。2、如果定义了结构体数组指针，则可分别使用“.”和“->”，区别在于指针带下标时，以是数组形式访问，此时用“.”，如果不带下标（或使用偏移），此时用“->”。如：structmyT{inti;

必须将结构体指针传递给函数，才能用。当然你直接将该成员变量本身当参数也行。。或者你这个成员变量本身就是全局的，这样可以直接访问。

在交换两个变量的内容等算法的时候可以整体引用、在输入和输出没有重载《《和》》的时候，就必须引用结构体变量成员。

一个是控件变量，一个是控件的数据变量~可以手动写，也可以在对话框上，选中控件右键添加变量,然后分别选一次类型就行

操作如下：1.点击编辑框选择classwizard；2.点击addvariable按钮；3.变量类型指定为value，选择int型；输入变量名即可。

对象是被销毁了不存在了，对象的”遗体“是否可用就不知道了……

局部变量，存在于定义其的作用域内，如此例，则它的存活区域就是main函数内部，函数跳出后它就被销毁成员变量，存在于定义其的对象存活区域内，如此例，则它的存活期由一个类A的对象实例化开始到销毁这个对象结束补充： 看错，我说的此例，就是1楼那个例子，我以为问题里发的……

属性可以用dot(.)语法，比如self.xxx，在外部调用也同样可以someClass.xxx。属性实际上是对一组set和get方法的简单封装(oc的get方法没有get前缀)，同样会自动生成一个私有的成员变量(名称为：下划线+属性名)。成员变量无论是全局还是局部的，都只能在本类或当前函数中使用，在其之外的地方无法直接调用(可以通过间接的方式调用)。在本类使用时，属性self.xxx会给私有的_xxx变量增加一次引用计数，相当于多retain了一次。如果不使用ARC，分别给普通变量和属性赋值，打印一下引用计数你就明白了。如果你使用ARC，完全不需要考虑引用计数相关的东西。总而言之，如果你当前类需要被外部调用，而且需要方便访问某个变量，那就应该把这个变量设为属性。如果只是在类内部使用，使用普通变量和使用属性没有任何区别，就看个人习惯了。

成员变量：又叫属性、字段，是用于定义类的具体内容的，一般设置为private的，通过setter/getter对其进行获取，修改，成员方法：是一个类对外提供的某种功能的调用入口，构造函数：这是一个类实例化的手段之一，通常有一个默认构造函数(内容空的)。其次就是具体的构造函数，它就是在实例化的时候给类的成员变量进行赋值的

我们把Objective-C中写在类声明的大括号中的变量称之为成员变量(也称为属性，实例变量)。 我们无法从外界(比如其他类和文件中)直接访问定义在类中的成员变量。为了能够从外界操作成员变量，我们需要为调用者提供相应的方法来对成员变量进行访问、赋值等操作。而定义这些方法都需要有一个有意义的名字，所以就有了getter-setter方法。 getter-setter方法格式和写法是固定的，这也是程序员之间的一种规范，只要有人想要访问成员变量或给成员变量赋值，就会立刻想到getter-setter方法，这样就降低了程序员之间的沟通成本。 如果给成员变量提供了getter和setter方法，就可以通过 点语法 来访问成员变量

在{ }中声明的变量都是成员变量； 按照上面的例子：button count data都是成员变量； 实例变量本质上就是成员变量，只是实例是针对类而言，实例是指类的声明； 按照上面的例子：button是实例变量 data也是实例变量，因为id是OC特有的类，本质上来说id等同于(void *)； 实例变量的英文翻译为 Instance Variable (object-specific storage) 实例的英文翻译为 Instance (manifestation of a class) 说的是"类的表现"，说明实例变量应该是由类定义的变量！ 除去基本数据类型int float ....等，其他类型的变量都叫做实例变量； 实例变量 + 基本数据类型变量 = 成员变量 根据成员变量的私有性，为了方便访问，所以就有了属性变量； 属性变量是用于与其他对象交互的变量； 属性变量的好处就是允许让其他对象访问到该变量，因为属性创建过程中自动产生了set方法和get方法；当然，你可以设置只读或者可写等，设置方法也可自定义。所以，属性变量是用于与其他对象交互的变量。 但是，现在大家似乎都不怎么喜欢用成员变量来定义类的变量，都喜欢用属性变量来定义类的变量。把需要与外部接触的变量定义在.h文件中，只在本类中使用的变量定义在.m文件中。 OC的分类允许给分类添加属性，但不会自动生成getter、setter方法，不过最好还是不要使用； 如果声明了属性，在实现文件中编译器会提示用 @dynamic 属性名字 来告诉开发者自己来写属性的setter方法和getter方法，而这里实现setter和getter需要用到声关联对象(存取方法在运行时动态创建绑定)。 在声明property属性后，有2种实现选择 @synthesize 编译器期间，让编译器自动生成getter/setter方法。 当有自定义的存或取方法时，自定义会屏蔽自动生成该方法 @dynamic 告诉编译器，不自动生成getter/setter方法，避免编译期间产生警告； 然后由自己实现存取方法或存取方法在运行时动态创建绑定：主要使用在CoreData的实现NSManagedObject子类时使用，由Core Data框架在程序运行的时动态生成子类属性

函数内部调用：HANDLE hThread1=CreateThread(NULL,0,Fun1Proc,(LPVOID)this,0,NULL);HANDLE hThread0=CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)thread,&m_prog,0,NULL);CloseHandle(hThread0);CloseHandle(hThread1);）Sleep(100);} DWORD WINAPI ListenThreadFunc(LPVOID lpParameter){CTestDlg *pDlg=(CTestDlg *)lpParameter;//把传过来的参数再强制转换回CTestDlg *类型pDlg->GetDlgItem(IDC_EDIT1)->SetWindowText("abc");//就可以了} thread(CProgressCtrl *pro)//更新进度条{int i=0;for(;i<100;){pro->SetPos(i);Sleep(200);i=i+5;if(i>94)i=1;else;if(stopmark==1){pro->SetPos(0);break;}}return 0;}DWORD WINAPI Fun1Proc(LPVOID lpParameter)//调用程序{CCOTSDlg *pDlg=(CCOTSDlg *)lpParameter;//把传过来的参数再强制转换回CTestDlg *类型pDlg->Modeprocess();//就可以了return 0;} 控制多线程，开启、暂停、继续、终止（实例）我们这些文盲以前一听到多线程这么几个字，以为非常的高级，难搞！！昨天翻阅了一下MSDN，发现，其实也没那么难，关键在于全面的理解，也许是用多了API了，慢慢的会看懂了一些！！！我总结了几个易于理解的出来，一起共享！我们先不讲如何使用线程过程中的参数；先来个简单的；下篇文章我们在讲如何使用线程过程的参数来实现交互！AfxBeginThread　创建线程函数原型：CWinThread* AfxBeginThread( AFX_THREADPROC pfnThreadProc,LPVOID pParam,int nPriority = THREAD_PRIORITY_NORMAL,UINT nStackSize = 0,DWORD dwCreateFlags = 0,LPSECURITY_ATTRIBUTES lpSecurityAttrs = NULL);该函数用于创建线程；返回值类型为：CWinThread*，一个指向新线程的线程对象参数：pfnThreadProc 线程的入口函数,声明一定要如下: UINT MyThreadFunction( LPVOID pParam );　　pParam : 传递入线程的参数,注意它的类型为:LPVOID,所以我们可以传递一个结构体入线程.　nPriority : 线程的优先级,一般设置为 0 .让它和主线程具有共同的优先级.　　nStackSize : 指定新创建的线程的栈的大小.如果为 0,新创建的线程具有和主线程一样的大小的栈　　dwCreateFlags : 指定创建线程以后,线程有怎么样的标志.可以指定两个值:　　CREATE_SUSPENDED : 线程创建以后,会处于挂起状态,直到调用:ResumeThread　　0 : 创建线程后就开始运行.lpSecurityAttrs : 指向一个 SECURITY_ATTRIBUTES 的结构体,用它来标志新创建线程的安全性.如果为 NULL ,那么新创建的线程就具有和主线程一样的安全性.如果要在线程内结束线程,可以在线程内调用 AfxEndThread.结束线程的两种方式当你在后台用线程来打印一些图形时.有时在打印一部分后,你希望可以停下来,那么此如何让线程停止呢.下面会详细的向你解释要结束线程的两种方式1 : 这是最简单的方式,也就是让线程函数执行完成,此时线程正常结束.它会返回一个值,一般0是成功结束,当然你可以定义自己的认为合适的值来代表线程成功执行.在线程内调用AfxEndThread将会直接结束线程,此时线程的一切资源都会被回收.2 : 如果你想让别一个线程B来结束线程A,那么,你就需要在这两个线程中传递信息.不管是工作者线程还是界面线程,如果你想在线程结束后得到它的确结果,那么你可以调用:::GetExitCodeThread函数SuspendThread 挂起（暂停）线程函数原型：DWORD SuspendThread(HANDLE hThread //指定线程的句柄);这个函数的返回值：DWORD类型，如果这个函数成功,返回值是线程的前停止计数,否则,它(表示)- 1。ResumeThread 继续执行线程函数原型：DWORD ResumeThread(HANDLE hThread //指定线程的句柄);这个函数的返回值：DWORD类型，如果这个函数成功,返回值是线程的前停止计数,否则,它(表示)- 1。WaitForSingleObject 终止线程DWORD WaitForSingleObject(HANDLE hHandle,DWORD dwMilliseconds);参数hHandle是一个事件的句柄dwMilliseconds在指定暂停区间,在毫秒。这个函数将返回如果区间流逝,即使该对象的状态是nonsignaled。如果dwMilliseconds是零,功能测试对象的状态和回报。如果dwMilliseconds是INFINITE的,这个函数的暂停区间从不流逝。

这很正常啊SystemOut和num--不是原子操作啊。在某一时刻，num=8，线程1SystemOut:8，然后被中断，执行线程2，也是SystemOut:8，然后又被中断执行线程3，再线程4，这时候4个线程都输出了8，最后回到线程1执行num--。即使是一条语句，也不能保证是原子操作，除非调用的对象说明是线程安全的，或者使用锁、队列，否则都不能保证并发的安全。

有两种方法：a. 定义线程函数为全局函数 b. 定义线程函数为类的静态成员函数针对线程函数为类的静态成员进行说明。如果是静态数据成员，当然可以直接访问，但是如果要访问非静态数据成员，直接访问是做不到的。如果要想在线程函数中访问和操作类的非静态成员变量，可以把线程函数作为一个适配器，在适配器中调用类的非静态成员函数。

还是把Java基础好好看看吧；变量的生存周期、内存管理这两部分的知识点把握的不够啊；

package example;public class Student { private String name; private double score1; private double score2; private double score3; public String getName() { return name; } public void setName(String name) { this.name = name; } public double getScore1() { return score1; } public void setScore1(double score1) { this.score1 = score1; } public double getScore2() { return score2; } public void setScore2(double score2) { this.score2 = score2; } public double getScore3() { return score3; } public void setScore3(double score3) { this.score3 = score3; } public Student(String name,double score1,double score2,double score3){ this.setName(name); this.setScore1(score1); this.setScore2(score2); this.setScore3(score3); } public double getMaxScore(){ double max=0; max=this.getScore1()>this.score2?this.getScore1():this.getScore2(); max=this.getScore3()>max?this.getScore3():max; return max; } public double getAverage(){ return (this.getScore1()+this.getScore2()+this.getScore3())/3.0; } public static void main(String[] args) { Student s=new Student("Tom", 60, 85, 90); System.out.println(s.getMaxScore()); }}

代码贴出来

public class Student { private String number; private int age; private String name; Student(String number,String name){ this.number = number; this.name = name; } Student(String number,String name,int age){ this.number = number; this.name = name; this.age = age; } public String getNumber() { return number; } public void setNumber(String number) { this.number = number; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; }}

首先，看一下为什么要用构造器？1、Java类的成员变量在被修饰为public、protected和包访问权限时，可以在不同层次上直接给成员变量赋值。但是，赋值的前提是：必须存在持有成员变量的对象。而对象的初始化必须调用构造函数，所以构造函数是必不可缺的。至于使用构造函数还是直接声明时给成员变量赋值，那就要看情况而定。如果创建的这个对象是不可变的，那么就必须使用构造函数初始化成员变量，反之，就无所谓。另外，直接给成员变量赋值，Java是不推荐的，因为这样会破坏它的封装性。所以，建议在构造函数或提供setters方法对变量赋值。2、成员变量的赋值一般通过构造函数；直接赋值一般的话都是一些常成员变量，final关键字开头的。3、其他的时候基本上都是用构造函数构造函数试用于动态创建对象。基于对象编程的思想，是不赞成直接给类里面的变量直接赋值的。类变量、实例变量的初始化比较相似，对于实例变量有一个例子public class RAMTest { {price = 3.4;//①--非静态语句块}public RAMTest(double price) {this.price = price;//②--构造函数}double price = 2.0;//③--声明语句并赋值}本例中对实例变量price的初始化有三处执行顺序为：③中price变量声明[price=0.0]--①中price变量赋值[price=3.4]--③中price变量赋值[price=2.0]--②中price构造函数赋值需要注意的是，虽然非静态语句初始块中的price变量的赋值在声明之前，但实际上执行的时候会先执行变量的声明，再按代码顺序执行变量值的赋值动作，然后再进行构造函数对实例的初始化构造。这三种实例变量的初始化语句经过编译器处理后，都会合并到构造器中去，其中定义变量语句转换得到的赋值语句、初始化块中的语句转化得到的赋值语句，总是位于构造器的所有语句之前。合并后两种赋值语句的顺序保持他们在源码中的顺序。

看看行不?不行再说package a;import java.util.Scanner;public class LeapYear { private int year; // 年 private int month; // 月 private int day; // 日 public void setdata(int a, int b, int c) { year = a; month = b; day = c; } public void getdata() { System.out.println("您输入的是：" + year + "年" + month + "月" + day + "日"); } public void isLeapYear() { if ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) { System.out.print(year+"是润年"); } else { System.out.print(year+"不是润年"); } } public static void main(String[] args) { System.out.println("请输入要查询的年月日(输入加空格):"); Scanner input = new Scanner(System.in); int[] nianyueri = new int[3]; for (int i = 0; i < nianyueri.length; i++) { nianyueri[i] = input.nextInt(); } LeapYear lY = new LeapYear(); lY.setdata(nianyueri[0], nianyueri[1], nianyueri[2]); lY.getdata(); lY.isLeapYear(); }}

public Class(field1,field2){ this.field1=field1; this.field2=field2;}

不一定，如果你的目的不是在构造对象时初始化成员变量，完全不需要传入参数。

Java内部类分四种：成员内部类、局部内部类、静态内部类和匿名内部类。1、成员内部类：即作为外部类的一个成员存在，与外部类的属性、方法并列。注意：成员内部类中不能定义静态变量,但可以访问外部类的所有成员。publicclassOuter{privatestaticinti=1;privateintj=10;privateintk=20;publicstaticvoidouter_f1(){//domoresomething}publicvoidout_f2(){//domoresomething}//成员内部类classInner{//staticintinner_i=100;//内部类中不允许定义静态变量intj=100;//内部类中外部类的实例变量可以共存intinner_i=1;voidinner_f1(){System.out.println(i);//外部类的变量如果和内部类的变量没有同名的，则可以直接用变量名访问外部类的变量System.out.println(j);//在内部类中访问内部类自己的变量直接用变量名System.out.println(this.j);//也可以在内部类中用"this.变量名"来访问内部类变量//访问外部类中与内部类同名的实例变量可用"外部类名.this.变量名"。System.out.println(k);//外部类的变量如果和内部类的变量没有同名的，则可以直接用变量名访问外部类的变量outer_f1();outer_f2();}}//外部类的非静态方法访问成员内部类publicvoidouter_f3(){Innerinner=newInner();inner.inner_f1();}//外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样publicstaticvoidouter_f4(){//step1建立外部类对象Outerout=newOuter();//***step2根据外部类对象建立内部类对象***Innerinner=out.newInner();//step3访问内部类的方法inner.inner_f1();}publicstaticvoidmain(String[]args){outer_f4();}}成员内部类的优点：⑴内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为PRIVATE，但是对于处于其内部的内部类还是可见的。）⑵用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。2、局部内部类：即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。注意：局部内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的。publicclassOuter{privateints=100;privateintout_i=1;publicvoidf(finalintk){finalints=200;inti=1;finalintj=10;classInner{//定义在方法内部ints=300;//可以定义与外部类同名的变量//staticintm=20;//不可以定义静态变量Inner(intk){inner_f(k);}intinner_i=100;voidinner_f(intk){System.out.println(out_i);//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量System.out.println(k);//*****可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的*****//System.out.println(i);System.out.println(s);//如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量System.out.println(this.s);//用"this.变量名"访问的也是内部类变量System.out.println(Outer.this.s);//用外部"外部类类名.this.变量名"访问的是外部类变量}}newInner(k);}publicstaticvoidmain(String[]args){//访问局部内部类必须先有外部类对象Outerout=newOuter();out.f(3);}}注意：在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。3、静态内部类：静态内部类定义在类中，任何方法外，用static定义。注意：静态内部类中可以定义静态或者非静态的成员publicclassOuter{privatestaticinti=1;privateintj=10;publicstaticvoidouter_f1(){}publicvoidouter_f2(){}//静态内部类可以用public,protected,private修饰//静态内部类中可以定义静态或者非静态的成员staticclassInner{staticintinner_i=100;intinner_j=200;staticvoidinner_f1(){System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员outer_f1();//包括静态变量和静态方法}voidinner_f2(){//System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员//outer_f2();//包括非静态变量和非静态方法}}publicvoidouter_f3(){//外部类访问内部类的静态成员：内部类.静态成员System.out.println(Inner.inner_i);Inner.inner_f1();//外部类访问内部类的非静态成员:实例化内部类即可Innerinner=newInner();inner.inner_f2();}publicstaticvoidmain(String[]args){newOuter().outer_f3();}}注意：*******生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Innerin=newOuter.Inner()；而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。静态内部类不可用private来进行定义。*******例子：对于两个类，拥有相同的方法：classPeople{run();}classMachine{run();}此时有一个robot类：classRobotextendsPeopleimplementMachine.此时run()不可直接实现。注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。4、匿名内部类匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口。IA被定义为接口。IAI=newIA(){};匿名内部类的特点：1，一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。2，只是为了获得一个对象实例，不需要知道其实际类型。3，类名没有意义，也就是不需要使用到。publicclassOuter{privatestaticinti=1;privateintj=10;publicstaticvoidouter_f1(){}publicvoidouter_f2(){}//静态内部类可以用public,protected,private修饰//静态内部类中可以定义静态或者非静态的成员staticclassInner{staticintinner_i=100;intinner_j=200;staticvoidinner_f1(){System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员outer_f1();//包括静态变量和静态方法}voidinner_f2(){//System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员//outer_f2();//包括非静态变量和非静态方法}}publicvoidouter_f3(){//外部类访问内部类的静态成员：内部类.静态成员System.out.println(Inner.inner_i);Inner.inner_f1();//外部类访问内部类的非静态成员:实例化内部类即可Innerinner=newInner();inner.inner_f2();}publicstaticvoidmain(String[]args){newOuter().outer_f3();}}注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。因他是局部内部类，那么局部内部类的所有限制都对其生效。匿名内部类是唯一一种无构造方法类。大部分匿名内部类是用于接口回调用的。匿名内部类在编译的时候由系统自动起名Out$1.class。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。因匿名内部类无构造方法，所以其使用范围非常的有限。当需要多个对象时使用局部内部类，因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。________________________________________________________________________________内部类总结：1.首先，把内部类作为外部类的一个特殊的成员来看待，因此它有类成员的封闭等级：private,protected,默认(friendly),public它有类成员的修饰符:static,final,abstract2.非静态内部类nestedinnerclass,内部类隐含有一个外部类的指针this,因此，它可以访问外部类的一切资源（当然包括private）外部类访问内部类的成员，先要取得内部类的对象,并且取决于内部类成员的封装等级。非静态内部类不能包含任何static成员.3.静态内部类：staticinnerclass,不再包含外部类的this指针，并且在外部类装载时初始化.静态内部类能包含static或非static成员.静态内部类只能访问外部类static成员.外部类访问静态内部类的成员，循一般类法规。对于static成员，用类名.成员即可访问，对于非static成员，只能用对象.成员进行访问4.对于方法中的内部类或块中内部类只能访问块中或方法中的final变量。类成员有两种static,non-static，同样内部类也有这两种non-static内部类的实例，必须在外部类的方法中创建或通过外部类的实例来创建(OuterClassInstanceName.newinnerClassName(ConstructorParameter)),并且可直接访问外部类的信息,外部类对象可通过OuterClassName.this来引用static内部类的实例,直接创建即可，没有对外部类实例的引用。内部类不管static还是non-static都有对外部类的引用non-static内部类不允许有static成员方法中的内部类只允许访问方法中的final局部变量和方法的final参数列表，所以说方法中的内部类和内部类没什麽区别。但方法中的内部类不能在方法以外访问，方法中不可以有static内部类匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递

不能访问吧

您好，一、成员变量（类或对象的状态）1、认识成员变量（类或对象的状态）、类变量、实例变量、局部变量、方法参数之间的区别成员变量（field）是没有定义在代码块（包括初始化块、成员方法）中的变量。成员变量是类变量还是实例变量取决于在其声明中是否使用了static关键字。类变量在声明是用了static关键字，它的另一个名字叫静态变量、静态成员变量(static field) 。实例变量是在声明时没有使用static关键字的成员变量，它的另一个名字叫非静态成员变量（non-static field）。定义在代码块里的变量被称为局部变量（local variable）。定义在方法声明中的变量叫方法参数。[java] view plaincopyprint?public class Lesson08 { // 类变量 static String s1 = "类变量"; // 实例变量 String s2 = "实例变量"; // 初始化代码块里的局部变量 { String s3 = "初始化代码块里的局部变量"; System.out.println(s3); } // 静态初始化代码块里的局部变量 static { String s4 = "静态初始化代码块里的局部变量"; System.out.println(s4); } // 方法的参数和方法里的局部变量 public void printString(String s5) { String s6 = "方法里的局部变量"; System.out.println("方法的参数:"+s5); System.out.println(s6); } // 类方法 public static void printString() { String s7="类方法里的局部变量"; System.out.println(s7); } // main方法 public static void main(String[] args) { //调用类方法 Lesson08.printString(); //打印类变量 System.out.println(s1); //创建对象 Lesson08 lesson = new Lesson08(); //打印实例变量 System.out.println(lesson.s2); //调用实例方法 lesson.printString("参数的值"); } } 对于他们之间的区别，我们在以后的学习中你会越来越清晰的。2、变量的初始化实例变量一经定义就会有初始值，局部变量定义时不赋初值而直接使用，编译器会报错[java] view plaincopyprint?public class Lesson08_1 { int i; static int j; { int k; System.out.println(k); } static { int l; System.out.println(l); } public void print(String m){ System.out.println(m); } // main方法 public static void main(String[] args) { int n; System.out.println(n); Lesson08_1 lesson =new Lesson08_1(); lesson.print("m"); } } 运行程序，查看结果：然后我们再给局部变量都附上初值，再把实例变量和类变量都打印出来看看，代码如下：[java] view plaincopyprint?public class Lesson08_1 { int i; static int j; { int k=2; System.out.println(k); } static { int l=2; System.out.println(l); } public void print(String m){ System.out.println(m); } // main方法 public static void main(String[] args) { System.out.println(j); int n=2; System.out.println(n); Lesson08_1 lesson =new Lesson08_1(); lesson.print("m"); System.out.println(lesson.i); } } 运行程序，查看结果：我们看到类变量和实例变量没赋值照样有值打印出来，我们也看到int的初始值是0 。实例变量和类变量的类型 初始值 整数 0 浮点类型 0.0 字符类型 ‘/u0000′ 布尔类型 boolean false 引用数据类型(譬如数组、接口、类) null 二、方法（类或对象的行为）1、方法Java中类的行为由类的成员方法来实现。类的成员方法由方法的声明和方法体两部分组成。修饰符，可选，用于指定谁有权限访问此方法。返回值类型，必选，用于指定该方法的返回值数据类型；如果该方法没有返回值，则要用关键字 void 进行标示。方法的返回值只能有一个。参数列表，可以有0到多个，多个参数之间要用逗号隔开，参数的写法形如：String[] args, int age 这样。方法名，必选，这个……，好吧命名规则是方法名和变量名的首字母要小写，别丢我人，弄个大写方法名出来。方法体，可选，这个……，大括号，大括号不写的方法叫抽象方法。2、属性和方法之间的关系有句绕口令是这么说的：“状态影响行为，行为影响状态”。你有没有想过这问题，如果每个对象都是从同一个类中生成出来，每个对象如果都一摸一样，那么这个世界是不是太无趣了。好在，我们看到前面的例子中，小狗的大小属性影响了他叫的方式。通过设置狗大小的方法又改变了它的状态。这些属性和方法的细节上的不同导致了，多姿多彩的对象，我们后面还会讲到更多的技术，也会导致更多的多样性。三、方法重载 overloadJava里可以提供同一个方法的多个不同参数的版本供我们调用，譬如上面的小白，它叫 bark() 的方法有两种，一种是很随意的叫，无拘无束的叫，还有一种是根据它心情的不同来叫，当然我还可以再定义一个方法可以让他根据主人的脸色来叫，我们也可以再定义一个方法，穿的参数是食物，那么它的叫声可能就是边吃边幸福的吼叫了…… 这样一个bark方法就带来了丰富多彩的变化。在Java 中允许类定义中多个方法的方法名相同，只要它们的参数声明不同即可。这种情况下，该方法就被称为重载（overloaded ），这种方式就叫做方法重载（method overloading ）。方法重载是实现程序多样性的一个重要手段。也可以称作多态的一种表现方式。

字段分私有字段和公有字段，私有字段是定义在类的方法里的，公有字段是定义在方法外的；成员变量和公有字段意思相同

看不太懂啊，你所说的“对应的test”是个什么东西？

通常在OnInitDialog函数或者对话框构造函数中，设置对话框对象的成员变量值。在对话框将要显示的前一刻，框架的DDX机制立即将成员变量值传输到对话框的控件中，而当用DoModal（创建Mode对话框）或者Create（创建Modeless对话框）创建对话框并显示时，即可看到那些控件值。对话框成员函数OnInitDialog缺省实现是：调用CWnd的成员函数UpdateData(FALSE)以初始化对话框的控件。当用户单击了“确定”按钮时，或者在任何时候以参数TRUE调用UpdateData时，DDX机制就会把数据从控件传输到成员变量中。此时，DDV机制按照事先指定的验证规则对传输的数据进行验证。控制的种类很多，每一种的交换方法都不一样，如CEdit是GetWindowText()和SetWindowText()，而CButton等的处理方法就更复杂了，好在MFC帮了你的忙。GetWindowText()是获取控件当前内容(Caption或者thetextwithinthecontrol—forthecontrol，具体可以查看MSDN)值，是对单个控件而言；而UpdateData()是作用于整个CWnd的DDX数据交换机制之中的，是控件和数据的双向通道。controlID就是一个标识啊，标识你的这个控件用的，如果你要获取一个控件，你就可以用getdlgitem(idnumber）来获取。member是一个关联变量而已，用时不要获取id号，直接用变量调用内部函数就行了。比如说你要求两个控件里面输入的数字的和。下面两种方式来求sum=getdlgitemint(idone)+getdlgitemint(idtwo);//idoneidtwo为两控件的id号。

不可以 。。

顶：回答者： Rucky浪

我估计你没有创建对象吧,反射,只是分析这个类的功能(具备的方法和属性),他是死的.只有创建了对象后,才有生命,才是获得,才能拿到里面的值

强制对象转换了

对

6.8.2 final方法之所以要使用final方法，可能是出于对两方面理由的考虑。第一个是为方法“上锁”，防止任何继承类改变它的本来含义。设计程序时，若希望一个方法的行为在继承期间保持不变，而且不可被覆盖或改写，就可以采取这种做法。采用final方法的第二个理由是程序执行的效率。将一个方法设成final后，编译器就可以把对那个方法的所有调用都置入“嵌入”调用里。只要编译器发现一个final方法调用，就会（根据它自己的判断）忽略为执行方法调用机制而采取的常规代码插入方法（将自变量压入堆栈；跳至方法代码并执行它；跳回来；清除堆栈自变量；最后对返回值进行处理）。相反，它会用方法主体内实际代码的一个副本来替换方法调用。这样做可避免方法调用时的系统开销。当然，若方法体积太大，那么程序也会变得雍肿，可能受到到不到嵌入代码所带来的任何性能提升。因为任何提升都被花在方法内部的时间抵消了。Java编译器能自动侦测这些情况，并颇为“明智”地决定是否嵌入一个final方法。然而，最好还是不要完全相信编译器能正确地作出所有判断。通常，只有在方法的代码量非常少，或者想明确禁止方法被覆盖的时候，才应考虑将一个方法设为final。类内所有private方法都自动成为final。由于我们不能访问一个private方法，所以它绝对不会被其他方法覆盖（若强行这样做，编译器会给出错误提示）。可为一个private方法添加final指示符，但却不能为那个方法提供任何额外的含义。6.8.3 final类如果说整个类都是final（在它的定义前冠以final关键字），就表明自己不希望从这个类继承，或者不允许其他任何人采取这种操作。换言之，出于这样或那样的原因，我们的类肯定不需要进行任何改变；或者出于安全方面的理由，我们不希望进行子类化（子类处理）。

不能啊final的成员和变量不可以改变的

private static final String number = 0; （对于static 和final 位置可以相互调换）

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

1.首先将标志位设为Non-blocking模式，准备在非阻塞模式下调用connect函数2.调用connect，正常情况下，因为TCP三次握手需要一些时间；而非阻塞调用只要不能立即完成就会返回错误，所以这里会返回EINPROGRESS，表示在建立连接但还没有完成。3.在读套接口描述符集(fd_set rset)和写套接口描述符集(fd_set wset)中将当前套接口置位（用FD_ZERO()、FD_SET()宏），并设置好超时时间(struct timeval *timeout)4.调用select( socket, &rset, &wset, NULL, timeout )返回0表示connect超时如果你设置的超时时间大于75秒就没有必要这样做了，因为内核中对connect有超时限制就是75秒。网络编程中socket的分量我想大家都很清楚了，socket也就是套接口，在套接口编程中，提到超时的概念，我们一下子就能想到3个：发送超时，接收超时，以及select超时（注： select函数并不是只用于套接口的，但是套接口编程中用的比较多），在connect到目标主机的时候，这个超时是不由我们来设置的。不过正常情况下这个超时都很长，并且connect又是一个阻塞方法，一个主机不能连接，等着connect返回还能忍受，你的程序要是要试图连接多个主机，恐怕遇到多个不能连接的主机的时候，会塞得你受不了的。我也废话少说，先说说我的方法，如果你觉得你已掌握这种方法，你就不用再看下去了，如果你还不了解，我愿意与你分享。本文是已在Linux下的程序为例子，不过拿到Windows中方法也是一样，无非是换几个函数名字罢了。Linux中要给connect设置超时，应该是有两种方法的。一种是该系统的一些参数，这个方法我不讲，因为我讲不清楚:P，它也不是编程实现的。另外一种方法就是变相的实现connect的超时，我要讲的就是这个方法，原理上是这样的：1．建立socket2．将该socket设置为非阻塞模式3．调用connect()4．使用select()检查该socket描述符是否可写（注意，是可写）5．根据select()返回的结果判断connect()结果6．将socket设置为阻塞模式（如果你的程序不需要用阻塞模式的，这步就省了，不过一般情况下都是用阻塞模式的，这样也容易管理）

成员变量是属于特定的对象的变量,你在定义类的时候只是说明此类对象应该具有哪些数据结构,不同的对象的属性不一定完全相同吧?还有,在定义静态的变量的时候是可以赋初值的,因为它是属于整个类的,为整个类的对象所使用

在类向导中直接添加成员变量，其实就是让VC系统帮你找到合适的位置，在类声明中写入一个代码：CImageList m_imagelist两者没有本质区别，如果说区别，那就是在.H文件的类声明中，可能写入的位置不同，这个没有太大区别，除非你手工写入位置有误。

用B类继承A类就可以了

就拿你的例子来说一，int a; //类的成员变量，当类实例化后占用内存空间float b; //同上static int c; //处于静态数据内存区，程序运行后同一分配，与类的实例化与否无关二，函数的地址存在于代码区，不占用对象内存。但是对于含有虚函数的类来说，实例化后的对象中必定会有一个指向虚函数表的指针，占用一个指针的空间。三，MyClass *myClass; //在栈上分配一个指针，但你不知道它指向哪里，因为没有给它赋值。如果是MyClass *myClass = new MyClass; 这样，在堆内存上创建了一个MyClass类型的对象，完成了内存的分配，就可以通过这个指针访问int a,float b,以及fun1()之类的成员变量了。四，占用空间大小的话class和struct应该是相同的，不过这里有个字节对齐的概念typedef struct{int a;char b;int c;}MyStruct;和typedef struct{int a;int c;char b;}MyStruct;实例化后所占的内存空间是不一样的，有兴趣可以去了解一下。

那要看你的控件变量是什么什么类型，按照你说的情况，你的控件变量本身就是一个成员对象，那就可以用对应的类成员。

都2013年啦，哈哈

成员变量注：本文演示的Demo，是基于《OC学习备忘录：类的定义》中的Demo下面在WZKPerson类中定义姓名、年龄、民族、身高四个成员变量。#import <Foundation/Foundation.h>@interface WZKPerson : NSObject{ @private NSString *_name; NSInteger _age; @protected NSString *_nation; @public float height;}@end下面对上述代码稍作解释。成员变量定义在.h文件中，并且必须定义在类后面的{}中；@private、@protected、@public三个关键字可以控制成员变量的可访问性；@private表示变量为私有，只能在当前类中访问；@protected表示变量为受保护，只能在当前类或子类中访问（默认为@protected）；@public便是变量为公共，所有类都可以访问；通常声明@private、@protected的成员变量名称时，建议变量名前加下划线，而@public的成员变量名称前不需要；变量名一般首字母小写，而类名一般首字母大写；方法的声明和实现上面已经声明好了成员变量，假设现在需要一个初始化姓名和年龄的对象方法、一个显示信息的对象方法、一个打印信息的类方法。-(id)initWithName:(NSString *)name age:(NSInteger)age;-(void)sayMyInfo;+(void)printMessage:(NSString *)message;下面对上述代码稍作解释。-号用来标识属于对象方法（类似于C#中的public方法），+号标识属于类方法（类似于C#中的static关键字）；(id)和(void)是返回值类型的标识（C#中不需要括号来标识返回值，方法最后需要括号标识）；OC方法的参数类型也需要放到()中，并且参数前必须使用冒号（冒号是方法名的一部分）；如果一个方法在.h中声明，则表示该方法为公共方法，如果直接在.m文件中定义则该方法是私有方法，外部无法进行访问；另外需要注意，OC当中方法名的表示方法和C#完全不一样，以上述三个方法为例，方法名分别表示为：-initWithName:age:-sayMyInfo+printMessage:.h文件中方法声明好之后，就需要在.m文件中进行实现方法了。#import "WZKPerson.h"@implementation WZKPerson-(id)initWithName:(NSString *)name age:(NSInteger)age{ self=[super init]; if (self) { _name=name; _age=age; } return self;}-(void)sayMyInfo{ NSLog(@"我叫 %@，今年 %li 岁",_name,_age);}+(void)printMessage:(NSString *)message{ NSLog(@"已经打印出：%@",message);}@end上述代码中-initWithName:age:方法返回值类型为id，id在OC中其实就是一个指针，指向任何一个继承了Object（或者NSObject）类的对象，因此任意一个Object对象都可以是一个id。注意：在使用id的时候不需要加星号，例如：id a＝nil；通常什么时机用id作为返回值类型呢？当不确定一个函数返回值能不能正常返回时使用，例如：-initWithName:age:方法中[super init]可能返回nil，而不是NSObject对象。-initWithName:age:方法的返回值类型id可以用instancetype进行代替，instancetype是在clang3.5时提供的关键字，表示某个方法返回的未知类型的OC对象。

@Service用于标注业务层组件比如，用在service的实现类中，表示注入该对象的意思@Servicepublic class VentorServiceImpl implements iVentorService { }这样写相当于xml配置中得bean id = VentorServiceImpl 也可以不指定

可以在类向导里面添加，这个变量可以代替指针，直接调用该类的成员函数。比如对话框类的一个button，id为id_btn，那如果你获取这个button的指针就要用到getdlgitem(id_btn)，然后再setwindowtext之类的。但如果你给这个button增加一个控件变量m_btn，那你就可以直接用m_btn->setwindowtext了

当前对象 　　　　

在C++和Java中，静态成员变量是指在程序运行时分配内存，并且在整个程序生命周期内都存在的变量。它们通常用于保存应用程序中的共享状态，例如计数器、配置信息等。静态成员变量可以通过类名来访问，例如：class MyClass {public:static int count;static void increaseCount() {count++;}};在上面的示例中，count是静态成员变量，它在程序运行时被分配内存，并且在整个程序生命周期内都存在。increaseCount是静态方法，它通过类名MyClass来访问count变量，并且可以在整个应用程序中多次调用。Java中也有类似的静态成员变量和静态方法。例如：public class MyClass {public static int count = 0;public static void increaseCount() {count++;}}在Java中，静态成员变量和静态方法通常使用关键字static来声明。静态成员变量在类加载时被分配内存，并且在整个应用程序期间都存在。静态方法通常在类加载时被调用，并且可以在整个应用程序期间多次调用。

凡是被public修饰的成员变量，都称为公共变量，它可以被任何类所访问。即允许该变量所属的类中所有方法访问，也允许其他类在外部访问。公共变量使用示例。public class declarePublic{public int publicVar=10; //定义一个公共变量

1.C的结构体和C++结构体的区别1.1 C的结构体内不允许有函数存在，C++允许有内部成员函数，且允许该函数是虚函数。所以C的结构体是没有构造函数、析构函数、和this指针的。1.2 C的结构体对内部成员变量的访问权限只能是public，而C++允许public,protected,private三种。1.3 C语言的结构体是不可以继承的，C++的结构体是可以从其他的结构体或者类继承过来的。以上都是表面的区别，实际区别就是面向过程和面向对象编程思路的区别：C的结构体只是把数据变量给包裹起来了，并不涉及算法。而C++是把数据变量及对这些数据变量的相关算法给封装起来，并且给对这些数据和类不同的访问权限。C语言中是没有类的概念的，但是C语言可以通过结构体内创建函数指针实现面向对象思想。2.C++的结构体和C++类的区别2.1 C++结构体内部成员变量及成员函数默认的访问级别是public,而c++类的内部成员变量及成员函数的默认访问级别是private。2.2 C++结构体的继承默认是public，而c++类的继承默认是private。

static是为了将某个成员变量/方法关联到类（class）而非实例（instance）。 x0dx0ax0dx0a你不需要创建一个对象就可以直接使用这个类的static成员， x0dx0ax0dx0a在A类中调用B类的static成员可以使用B.staticMember的写法。 x0dx0ax0dx0a注意一个类的static成员变量是唯一的，被所有该类对象所共享的。x0dx0ax0dx0a比如说有一个类Dog;x0dx0a 属性:clolor,狗狗可以有好多颜色;x0dx0a munberOfLegs =4 每只狗狗只有4条腿,这个就应该是静态的;x0dx0ax0dx0a静态的属性不依赖于类的存在而存在,简单说,你可以定义x0dx0aDog dog1 = new Dog();x0dx0aDog dog2 = new Dog();x0dx0aDog dog3 = new Dog();x0dx0a这里定义了三条狗狗,狗狗的颜色依赖于类本身,即dog1,dog2,dog3;三条狗狗可以有不同的颜色;x0dx0a而狗狗的腿的数量不依赖于dog1,dog2,dog3;所有的狗狗都是4条腿

RECT 是M$ windows API中定义的一个结构体类型用来描述 矩形范围 上下左右的 坐标typedef struct _RECT { LONG left; LONG top; LONG right; LONG bottom; } RECT, *PRECT; 你可以去查msdn或者直接打开头文件windef.h看windows提供给你一个叫做GetWindowRect的函数（这里是mfc CWnd类的成员函数，其实就是同名API函数包装下）你去调用这个函数 这个函数就可以返回一个RECT类型的数据但是你需要自定定义一个RECT类型的变量并且把这个变量的地址传给这个函数，这个函数会把返回值写入到这个传入地址对应的内存变量中LZ C语言估计没学好，不然不会看不明白这是典型的 指针和结构体的综合运行这个加5神马你得先宝明白神马是窗口的客户区，客户区坐标怎样的举例：一个窗口中有一个按钮这个按钮相对窗口 客户区左上角坐标是 水平100，垂直50 ，按钮大小 宽80，搞35，那么你写代码得到这个按钮的“RECT” 就是 left 100 ，top 50 ，right 180 ，bottom 85（ 窗口关系问题，tab的子窗口item 的坐标相对父窗口tab的左上角，父子窗口关系，还有一种是相对屏幕左上角的坐标关系）希望LZ 能明白

不知道你说什么。是这样吗？public class aa{int n;public static void main(String a[]){int n;this.n=0;n=this.n+5;System.out.println(n);}}是以上连个n的区别？一个是类中的n一个是函数/方法中的n 所作用范围不同如要使用类中的n就用this

我的天啊，你知道这么多名词应该学过编程吧要么百度一下，不就又比较全面精确的解释算了，我复制几个吧变量分为局部与全局，局部变量又可称之为内部变量。由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。一个局部变量在被其它对象引用时，会是一个空值。但全局变量却不会出现这种情况成员变量是指定维度的成员变量，用于标识某个维度成员语言无关的通用定义：与程序有着相同生命周期（英语：Object lifetime）的变量；C族语言特有的定义：以static存储类声明的变量。

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

其实类成员变量如果不是通过构造函数赋值的而是通过getter和setter就是不稳定的。因为在多线程情况下，任何一个线程都可以随时改编这个user的值。private是表示它不能从外部直接访问被修改，但是有了get和set之后是可变的。相当于是public定义了。

没有遇到过这个问题，我理解共享成员变量应该是类变量也就是类静态变量

结构类型变量的定义 在定义某个结构类型后，程序员就可以说明该结构类型的内存变量。它的说明形式与前面介绍的简单数据类型的变量说明基本上一致。其定义格式如下： [变量名]　结构名　<[字段值表]>

static 是修饰静态变量的 他可以不经过声明对象就可以通过类打点变量就可以取得的

类变量、实例变量、局部变量类变量是类中独立于方法之外的变量，用static 修饰。实例变量也是类中独立于方法之外的变量，不过没有static修饰。局部变量是类的方法中的变量。

类方法就是在类上面，不需要初始化对象就能用的方法一般就像常识一样的东西，比如数学的一些计算像成员方法就是每个对象自己的方法，只是在类上面做了声明，比如说睡觉，吃饭都是具体到人就是具体到这个对象上面的一个行为，我觉得理解到这里就足够了

类变量就是在类中声明的变量，成员变量就是类变量，实力变量就是方法中的变量，也就是局部变量，其实就是这样地。

加入static修饰后 变量在本次使用时可以改变 使用后恢复初始值 而const修饰的变量 始终无法改变

程序结束。c#成员变量这里面的内存块和程序的声明周期是一样的，也就是说程序结束的时候，这部分的内存才会得到释放。

结构体成员运算符。->指针运算符。1、如果结构体中的成员均为一般变量（包括结构体变量），则使用“.”，如果成员变量为指针（不管指向什么，包括结构体），则使用“->”。2、如果定义了结构体数组指针，则可分别使用“.”和“->”，区别在于指针带下标时，以是数组形式访问，此时用“.”，如果不带下标（或使用偏移），此时用“->”。如：struct myT{ int i;

没错啊，编译都通过了，会不会是你的编译器的问题？

输入一个参数...不是应该给那么_0么

没错啊，编译都通过了，会不会是你的编译器的问题？

按正常指针赋值就可以。

使用&取变量的地址，赋值给指针。如果值是指针类型了，可以直接使用=赋值了。

它是应用在对位进行操作时 对一个字节进行分段（位段） is_unknown为位段名，1为位的个数

类的成员作用域为类作用域，即类的内部（包括类的命名空间内部以及类的成员函数内部）。类的静态变量成员生存期和全局变量相同，为整个进程。类的非静态成员变量生存期为所在类实例对象创建至销毁（构造函数开始至析构函数结束）。====原创回答团

。

final修饰的成员和成员变量，可以被继承。final修饰的方法可以被继承不能被重写final修饰的类，不能被继承

final修饰类时为最终类,任何类不能再继承它.修改函数时该方法在类里是最终方法,继承它的方法不能去重写它.修饰变量时被修饰的变量是常量或者叫终态变量,一旦初始化后就不能再改变变量的值.多态和这个没关系。