C++中成员变量初始化有两种方式的区别

C++中成员变量初始化有两种方式的区别

构造函数初始化列表和构造函数体内赋值两种方式有何不同？

成员变量初始化的顺序是按照在类中定义的顺序。

1 内部数据类型（char，int……指针等）

class Animal{

public:

Animal(int weight,int height): //A初始化列表

m_weight(weight),

m_height(height)

{

}

Animal(int weight,int height) //B函数体内初始化

{

m_weight = weight;

m_height = height;

}

private:

int m_weight;

int m_height;

};

对于这些内部类型来说，基本上是没有区别的，效率上也不存在多大差异。当然A和B方式不能共存的。

2 无默认构造函数的继承关系中

class Animal{

public:

Animal(int weight,int height): //没有提供无参的构造函数

m_weight(weight),

m_height(height)

{

}

private:

int m_weight;

int m_height;

};

class Dog: public Animal{

public:

Dog(int weight,int height,int type) //error 构造函数父类Animal无合适构造函数

{

}

private:

int m_type;

};

这种必须在派生类中构造函数中初始化提供父类的初始化，因为对象构造的顺序是：

父类——子类——……

所以必须：

class Dog: public Animal{

public:

Dog(int weight,int height,int type):

Animal(weight,height) //必须使用初始化列表增加对父类的初始化{

;

}

private:

int m_type;

};

3 类中const常量，必须在初始化列表中初始，不能使用赋值的方式初始化

class Dog: public Animal{

public:

Dog(int weight,int height,int type):

Animal(weight,height),

LEGS(4) //必须在初始化列表中初始化

{

//LEGS = 4; //error

}

private:

int m_type;

const int LEGS;

};

4 包含有自定义数据类型（类）对象的成员初始化

class Food{

public:

Food(int type = 10){

m_type = 10;

}

Food(Food &other) //拷贝构造函数

{

m_type = other.m_type;

}

Food & operator =(Food &other) //重载赋值=函数

{

m_type = other.m_type;

return *this;

}

private:

int m_type;

};

（1）构造函数赋值方式初始化成员对象m_food

class Dog: public Animal{

public:

Dog(Food &food)

//:m_food(food)

{

m_food = food; //初始化成员对象

}

private:

Food m_food;

};

//使用

Food fd;

Dog dog(fd); //

Dog dog(fd);结果：

先执行了对象类型构造函数Food(int type = 10)——>

然后在执行对象类型构造函数Food & operator =(Food &other)

想象是为什么？

（2）构造函数初始化列表方式

class Dog: public Animal{

public:

Dog(Food &food)

:m_food(food) //初始化成员对象

{

//m_food = food;

}

private:

Food m_food;

};

//使用

Food fd;

Dog dog(fd); //

Dog dog(fd);结果：执行Food(Food &other)拷贝构造函数完成初始化

不同的初始化方式得到不同的结果：明显构造函数初始化列表的方式得到更高的效率。

成员方法成员变量

成员变量 成员变量是指类的一些属性定义，标志类的静态特征，它的基本格式如下：访问修饰符修饰符类型属性名称=初始值; ?访问修饰符：可以使用四种不同的访问修饰符中的一种，包括public(公共的)、protected（受保护的），无修饰符和private（私有的）。public 访问修饰符表示属性可以从任何其它代码调用。private 表示属性只可以由该类中的其它方法来调用。protected 将在以后的课程中讨论。 ?修饰符：是对属性特性的描述，例如后面会学习到的：static、final 等等。 ?类型：属性的数据类型，可以是任意的类型。 ?属性名称：任何合法标识符 ?初始值：赋值给属性的初始值。如果不设置，那么会自动进行初始化，基本类型使用缺省值，对象类型自动初始化为null。 成员变量有时候也被称为属性、实例变量、域，它们经常被互换使用。 成员方法 成员方法就是对象所具有的动态功能。Java 类中方法的声明采用以下格式：访问修饰符修饰符返回值类型方法名称(参数列表) throws 异常列表{方法体} ?访问修饰符：可以使用四种不同的访问修饰符中的一种，包括public、protected、无修饰符和private。public 访问修饰符表示方法可以从任何其它代码调用。private表示方法只可以由该类中的其它方法来调用。protected 将在以后的课程中讨论。 ?修饰符：是对方法特性的描述，例如后面会学习到的：static、final、abstract、synchronized 等等。 ?返回值类型：表示方法返回值的类型。如果方法不返回任何值，它必须声明为void(空)。Java 技术对返回值是很严格的，例如，如果声明某方法返回一个int值，那么方法必须从所有可能的返回路径中返回一个int值（只能在等待返回该int值的上下文中被调用。） ?方法名称：可以是任何合法标识符，并带有用已经使用的名称为基础的某些限制条件。 ?参数列表：允许将参数值传递到方法中。列举的元素由逗号分开，而每一个元素包含一个类型和一个标识符。在下面的方法中只有一个形式参数，用int类型和标识符days 来声明：public void test(int days){} ?throws 异常列表：子句导致一个运行时错误（异常）被报告到调用的方法中，以便以合适的方式处理它。异常在后面的课程中介绍。 ?花括号内是方法体，即方法的具体语句序列。 示例：比如现在有一个“车”的类——Car，“车”具有一些基本的属性，比如四个轮子，一个方向盘，车的品牌等等。当然，车也具有自己的功能，也就是方法，比如车能够“开动”——run。

C++类的成员变量和成员函数

类可以看做是一种数据类型，它类似于普通的数据类型，但是又有别于普通的数据类型。类这种数据类型是一个包含成员变量和成员函数的集合。 类的成员变量和普通变量一样，也有数据类型和名称，占用固定长度的内存。但是，在定义类的时候不能对成员变量赋值，因为类只是一种数据类型或者说是一种模板，本身不占用内存空间，而变量的值则需要内存来存储。 类的成员函数也和普通函数一样，都有返回值和参数列表，它与一般函数的区别是：成员函数是一个类的成员，出现在类体中，它的作用范围由类来决定；而普通函数是独立的，作用范围是全局的，或位于某个命名空间内。 上节我们在示例中给出了Student 类的定义，如下所示： 1.class Student{ 2.public: 3.//成员变量 4.char*name; 5.int age; 6.float score; 7. 8.//成员函数 9.void say(){ 10.cout<

1.class Student{ 2.public: 3.//成员变量 4.char*name; 5.int age; 6.float score; 7. 8.//成员函数 9.void say();//函数声明 10.}; 11. 12.//函数定义 13.void Student::say(){ 14.cout<

JAVA的两种成员变量

介绍java类的两种成员变量 个人分类：转载文章关键词：java两种介绍成员变量 （鉴于该文看到的同学比较多，现在回过头又认真审查了一边，在结尾处更新了一些比较易于掌握的信息，希望能对各位同学有所帮助） java类的两种成员变量：一种没有static修饰，为实例变量，一另种是被static关键字修饰的变量，叫类变量或者静态变量。在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。 顺序运行时的区别：实例变量属于某个对象的属性。其中的实例变量才会被分配空间，必需创立了实例对象。才干使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要顺序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了总之，实例变量必需创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。 例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar 变量，并且每创建一个实例对象，这个staticVar 就会加1;但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。 类的静态变量在内存中只有一个，java虚拟机在加载类的过程中为静态变量分配 内存，静态变量位于方法区，被类的所有实例共享。静态变量可以直接通过类名进行访问，其生命周期取决于类的生命周期。 而实例变量取决于类的实例。每创建一个实例，java虚拟机就会为实例变量分配一次

内存，实例变量位于堆区中，其生命周期取决于实例的生命周期。 结果为： 1 0 (成员变量具有缺省值而局部变量则没有) 把代码改为： 结果则为 1 静态变量和实例变量的区别，可参考以下代码，

静态成员函数一般情况下只能访问静态成员变量

静态成员函数一般情况下只能访问静态成员变量，因为不接受隐含的this指针。另外作为类的静态成员函数，不用声明对象，便可直接调用，例如类A的静态成员函数fun(); A::fun(); 1、主要用于封装全局变量和全局函数。以避免在文件作用域内包含带外部连接的数据。 例如全局变量：int path;int para1; 解决办法：设计一个全局类，并将这些全局名称声明为静态变量，并编写静态函数来调用这些变量。 class Global{ static int s_path; static int s_para; private: Global();//不实现，避免无意中的实例化 public: //manipulators static void setPath(int path){s_path = path;} static void setPara(int para){s_para = para;} //accessors static int getPath(){return s_path;} static int getPara(){return s_para;} } 2、对自由函数的封装 在.h文件的文件作用域内避免使用自由函数（运算符函数除外）；在.c文件中避免使用带有外部连接的自由函数，因此可以使用静态成员函数进行处理。 例如：int getPara();int getPath();我们可以通过声明一个结构的静态方法代替： struct SysUtil{ static int getPath(); static int getPara(); }这样，唯一有冲突危险的就是出现类名SysUtil了。

Java 继承之子父类中的成员变量和函数

本文由我司收集整编，推荐下载，如有疑问，请与我司联系 Java 继承之子父类中的成员变量和函数 2015/05/09 102 //父类。class Fu{ int num = 3;}class Zi extends Fu{ int num = 4; void show() { System.out.println(“num= “+this.num);}}class ExtendsDemo { public static void main(String[] args) { Zi z = new Zi(); z.show(); }}从一张图来看它的原理： 图有点乱，看一下顺序吧。在代码中，super 和this 的用法很相似，this 代表的 是本类对象的引用，super 代表的是父类的内存空间。 成员函数：【子父类中成员函数的特点】特殊情况：子父类中的定义了一模一 样的函数。运行的结果:子类的函数在运行。这种情况在子父类中，是函数的另一个 特性：override(重写，覆盖，复写) 重写什么时候用？举例： //描述手机。class Phone{ int number; //打电话。void call(){} //来电显示。void show() { sop(“电话号码..”+number); }}Phone p = new Phone();p.show();随着电话的升级，只显示号码不爽，希望显示姓名，照片。修改源码，虽然费劲但是可以解决， 不利于后期的维护和扩展。为了扩展方便。新功能是不是新的电话具备呢？单独描 述单独封装。新电话也是电话中的一种。继承。直接获取父类中的功能。但是新电 话的来显功能已经变化了。需要重新定义。那么定义一个新功能合适吗？比如newShow，不合适，因为父类已经将来显功能定义完了，子类完全不需要重新定义 新功能。直接用就可以了。如果子类的来显功能内容不同。直需要保留来显功能， 定义子类的内容即可：这就是重写的应用！class NewPhone extends Phone{ String name; String picPath;//图片路径。void show() { //sop(“电话号码”);super.show();//如果还需要父类中原有的部分功能，可以通过super 调用。System.out.print(“姓名”+name);System.out.print(“照片”+picPath); }}【重写(覆盖)的注意事项】1，子类 覆盖父类，必须保证全要大于或者等于父类的权限。Fu: private void show(){} Zi:

类、方法、成员变量和局部变量的可用修饰符 !!!

类的修饰符整合 一．类 类的修饰符： Public:可以在其他任何类中使用，默认为统一包下的任意类。 Abstract:抽象类，不能被实例化，可以包含抽象方法，抽象方法没有被实现，无具体功能，只能衍生子类。 Final:不能被继承。

二．变量 变量修饰符： 一个类的成员变量的声明必须在类体中，而不能在方法中，方法中声明的是局部变量。 1. 可访问修饰符： 2. static：类变量：一个类所拥有的变量，不是类的每个实例有的变量。类变量是指不管类创建了多少对象，系统仅在第一次调用类的时候为类变量分配内存，所有对象共享该类的类变量，因此可以通过类本身或者某个对象来访问类变量。 3. final：常量。 4. volatile：声明一个可能同时被并存运行的几个线程所控制和修改的变量。 实例变量：和类变量对应，即每个对象都拥有各自独立的实例变量。 三．方法：（和变量对象分为实例方法和类方法，并用有无static修饰区别） 类方法：使用static关键字说明的方法 1.第一次调用含类方法的类是，系统只为该类创建一个版本，这个版本被该类和该类的所有实例共享。 2.类方法只能操作类变量，不能访问实例变量。类方法可以在类中被调用，不必创建实例来调用，当然也可以通过对象来调用。 实例方法：实例方法可以对当前对象的实例变量操作，而且可以访问类变量。 方法可以重载，要求：方法名相同，但是参数必须有区别。（参数不同可以使类型不同，顺序不同，个数不同） 方法的返回类型：若无返回类型，则声明为void. 方法中的变量作用域： 1. 成员变量：整个类。 2. 局部变量：定义起到方法块结束为止。 3. 方法参数：整个方法或者构造方法。 4. 异常处理参数：参数传递给异常处理方法。

java成员变量和方法的public等访问限定符的访问权限

在学习java的过程中，我写类经常会用到public，private 和protected 的，我的基本经验就是一般类的成员变量都是用private，方法用public，类内部用的方法用protected，如果是存在子类的，那我就会把父类中的成员变量变为protected。（其余的看具体实际情况而定） 不过在一些公司的笔试题中，他们会要求你具体的写出像public这些访问限定符的作用域。其实，平常我都没去系统的考虑这些访问限定符的作用域，特别是包内包外的情况，OK，笔试不行了。 这是java基本的知识，也是公司看重的，那没办法啦，我的脑袋记不住东西，那我只能把这些东西写下来方便自己温故知新。 貌似默认（无）是friendly 如果你看到这里还不是很了解上面的表，或者是很久就没看书了，忘记了上面的表的内容的意义，那下面的例子就是帮助你温故知新的好东东。 例如，有一个包demo中的类P，它有一个private 成员变量data，一个public 默认构造方法，一个public 访问方法getData()，一个protected修改方法setData()，还有一个默认访问方式的辅助方法print()。 package demo; public class P{ private int data; public P(){ setData(0); } public int getData(){ return data;

} protected void setData(int v){ data = v; } void print(){ System.out.println("used!") } } 本类的不用说了，在本类里面才不管什么访问限定符呢。 如有类Q，扩展了P，所以可以调用P的默认构造方法、访问方法getData()和修改方法 setData()。但类Q不能直接访问P的成员变量data，辅助方法print()也不行（可以把默认，也就是没加任何访问限定符，理解为"包访问 "，在子类中不能直接访问，但在同包中的类却可以访问）。 import demo.P public class Q extends P{ public Q(){ super(); <---------------------------Q可以访问父类的默认构造方法 } public Q(int v){ setData(v); <------------------------Q可以访问父类的protected的方法 } public String toString(){ int v = getData(); <--------------------Q 可以访问父类的public的方法

Java接口中成员变量和成员方法的介绍

接口类型的定义类似于类的定义。 接口定义的形式如下： [修饰符] interface 接口名[extends] [接口列表] { 接口体 } 像类那样，编译好的接口被保存在class 文件中。 1．接口说明 interface 前的修饰符是可选的。当没有修饰符的时候，表示此接口的访问只限于同包的 类。如果使用修饰符，则只能用public 修饰符，表示此接口是公有的，在任何地方都可以引用它，这一点和类是相同的。 接口说明中的extends 关键词和类说明中的extends 一样，用来定义直接的父接口。和类不同，一个接口可以继承多个父接口，当extends 后面有多个父接口时，它们之间用逗号隔开，例如，下面是一个最简单的接口说明：public interface boy extends person, man 2. 接口体就是用大括号括起来的那部分。接口体说明接口的成员，包括常量和抽象方法。 例3.11 接口的定义实例。 interface boy { final int MAX=50; void increment( ); void decrement( ); int currentcount( );

} 像类一样，接口可以有两种成员：成员变量和成员方法。 （1）接口中的成员变量 接口中所有的成员变量都隐含的是public、static、final 的，因此接口中的成员变量都是静态最终变量。在接口中成员变量声明的形式如下： [修饰符] 类型名变量名列表； 例如，在接口中有下面这行代码：“int i=5;”等同于：“public stat ic final int i=5;”。 （2）接口中的方法 接口中说明的方法都是抽象方法，其声明的形式为 [修饰符] 方法返回值类型方法名（参数列表）； 由于接口中的方法都是抽象方法，所以方法体仅仅有一个分号“；”（连“{”和“}”都 没有）。修饰符可选，美国服务器租用商提醒您它只能是public 和abstract。接口中的所有方法都隐含的是public 和abstract 的，接口的方法不能是带static、final 等其他修饰符的。 3. 接口的实现 接口的声明仅仅给出了抽象方法，而具体地实现接口所定义的方法需要某个类为接口中 的每个抽象方法定义具体的操作。 在类的声明部分，用implements 关键字来声明这个类实现某个接口，一个类可以实现多个接口，在implements 子句中用逗号隔开。 如果实现某接口的类不是abstract 修饰的抽象类，则必须在类的定义部分实现指定接口

Static成员变量,static成员函数解析 -电脑资料.

Static成员变量，static成员函数解析 -电脑资料 2019-01-01 最近看Effective C++经常看到一些和static相关的内容，希望综合整理一下，如果有不全，还望补充： 1 类中的Static成员变量 static成员它不像普通的数据成员，static数据成员独立于该类的任意对象而存在，每个static数据成员是与类关联的对象，并不与该类的对象相关联！ 一般为类申请一个对象，是对类中成员变量申请一个副本，各个对象之间的成员变量和函数互不影响，但是static成员变量不是在栈空间而是在静态存储区，所有的类对象共享static变量， 。静态成员是可以独立访问的，无需创建任何对象就可以访问 只是定义一个static变量，这个变量不能在类当中进行初始化，当然包括类的构造函数，static成员的初始化在类的外部进行。 静态数据成员实际上是类域中的全局变量。所以，静态数据成员的定义(初始化)不应该被放在头文件中（在VS中也不报错）。 注：不要试图在头文件中定义(初始化)静态数据成员。在大多数的情况下，这样做会引起重复定义这样的错误。即使加上#ifndef #define #endif或者#pragma once也不行。 #include "static.h"#includeusing namespace std; class Person { private: string name; static int age; public: Person(const string&nm):name(nm) {} void Print() { cout<

C++中成员变量初始化有两种方式的区别

C++中成员变量初始化有两种方式的区别 构造函数初始化列表和构造函数体内赋值两种方式有何不同？ 成员变量初始化的顺序是按照在类中定义的顺序。 1 内部数据类型（char，int……指针等） class Animal{ public: Animal(int weight,int height): //A初始化列表 m_weight(weight), m_height(height) { } Animal(int weight,int height) //B函数体内初始化 { m_weight = weight; m_height = height; } private: int m_weight; int m_height; }; 对于这些内部类型来说，基本上是没有区别的，效率上也不存在多大差异。当然A和B方式不能共存的。 2 无默认构造函数的继承关系中 class Animal{ public: Animal(int weight,int height): //没有提供无参的构造函数 m_weight(weight), m_height(height) { } private: int m_weight; int m_height; }; class Dog: public Animal{ public: Dog(int weight,int height,int type) //error 构造函数父类Animal无合适构造函数 { } private: int m_type; }; 这种必须在派生类中构造函数中初始化提供父类的初始化，因为对象构造的顺序是：

父类——子类——…… 所以必须： class Dog: public Animal{ public: Dog(int weight,int height,int type): Animal(weight,height) //必须使用初始化列表增加对父类的初始化{ ; } private: int m_type; }; 3 类中const常量，必须在初始化列表中初始，不能使用赋值的方式初始化 class Dog: public Animal{ public: Dog(int weight,int height,int type): Animal(weight,height), LEGS(4) //必须在初始化列表中初始化 { //LEGS = 4; //error } private: int m_type; const int LEGS; }; 4 包含有自定义数据类型（类）对象的成员初始化 class Food{ public: Food(int type = 10){ m_type = 10; } Food(Food &other) //拷贝构造函数 { m_type = other.m_type; } Food & operator =(Food &other) //重载赋值=函数 { m_type = other.m_type; return *this; } private: int m_type; }; （1）构造函数赋值方式初始化成员对象m_food

类、对象、方法、变量、属性定义

类、对象、变量、方法及属性 (2007-05-22 00:15:34) 转载▼ 类：类是组成java程序的基本要素。类封装了一类对象的属性和方法。类是用来定义产生对象的模板。类的实现包括两部分：类声明和类体。 类体分为两部分：成员变量和局部变量。 1、成员变量和局部变更的类型可以是java中的任何一种数据类型.变量定义部分所定义的变更被称为类的成员变量，在方法体中定义的变量和方法的参数被称为局部变量。 2、成员变量在整个类内都有效，局部变量只在定义它的方法内有效。 3、成员变量又分为实例成员变量（实例变量）和类变量（静态变量）。、 4、如果局部变量的名字和成员变量的名字相同，则成员变量被隐藏，即这个成员变量在这个方法内暂时失效。 5、如果局部变量的名字和成员变量的名字相同，则成员变量被隐藏。这时如果想在该方法内使用成员变量，必须使用关键字this. 方法：一个类的类体由两部分组成：变量的定义和方法的定义。方法定义包括两部分：方法声明和方法体。例如：一个汽车的加速、减速、转弯、制动这些都是 该对象的方法。 方法重载：一个类中可以有多个方法具有相同的名字，但这些方法的参数必须不同，即或者参数个数不同，或者参数的类型不同。 构造方法：是一种特殊方法，它的名字必须与它所在的类的名字完全相同，而且没有类型，构造方法也可以重载。 类方法和实例方法 成员变量可分实例变量和类变量。类中的方法也分为实例方法和类方法。 1、对成员变量的操作只能放在方法中，方法可以对成员变量和方法体中自己定义的局部变量进行操作。 2、实例方法既能对类变量操作也能对实例变量操作，而类方法只能对类变量进行操作。 3、一个类中的方法可以互相调用，实例方法可以调用该类中的其他方法；类中的类方法只能调用该类的方法，不能调用实例方法。 对象：类是创建对象的模板。当使用一个类创建了一个对象时，也就是说给出了这个类的一个实例。“对象”其实我们并不陌生，天天都在和我们打交道，我们写字用的笔，骑的“宝马”等，太多了，世界万物，一切皆时对象！ 属性：就是一个对象自用拥有的特性。例如：一辆汽车的颜色、重量、轮子数目、运行速度等这些都是该对象自身的属性。 好了，了解了概念还不行。还得自己再动手多写写代码。要学习java编程就必须学会怎样去编写类，怎么用java的语法去描述一类事物共有的属性和功能。属性通过变量来刻画，功能通过方法来体现，即方法操纵属性形成一定的算法来实现一个具体的功能。类把数据和对数据操作封装成一个整体。

详解JAVA成员变量和局部变量

我们首先要理解下概念： 成员变量指的是类范围里定义的变量，也就是前面所说的属性；局部变量指的是一个方法内定义的变量。不管是成员变量、还是局部变量，都应该遵守相同的命名规则：从语法角度来看，只要一个合法的标识符即可，但我们应该知道，从程序可读性角度来看，应该是多个意义的单词连缀而成，其中一个单词首字母小写，后面每个单词首字母大写。 如图： 成员变量被分为类属性和实例属性两种，定义一个属性时不使用static修饰的就是实例属性，使用static修饰的就是类属性。其中类属性从这个类的准备阶段起开始存在，直到系统完全销毁这个类，类属性的作用域与这个类的生存范围相同；而实例属性则从这个类的实例被创建开始起存在，直到系统完全销毁这个实例，实例属性的作用域与对应实例的生存范围相同。 提醒大家注意的是：一个类在使用之前要经过类加载、类验证、类准备、类解析、类初始化等几个阶段。 正是基于这个原因，我们把类属性和实例属性统称为成员变量，其中类属性可以理解为类成员变量，它作为类的一个成员，与类共存亡；实例属性则可理解为实例成员变量，它作为实例的一个成员，与实例共存亡。 （1）只要类存在，程序就可以访问该类的类属性，在程序中访问类属性通过如下格式：类.类属性； （2）只要实例存在，程序就可以访问该实例属性，在程序中访问实例属性通过如下格式：实例.实例属性

（3）当然，类属性也可以让该类的实例来访问，通过实例来访问类属性的语法格式： 实例.类属性 但这个实例访问并不是这个实例的属性，依然是访问它对应类的类属性。也就是说，如果通过一个实例修改了类属性的值，由于这个类属性并不属于实例，而是属于实例对应的类。因此，修改的依然是类的类属性，与通过该类来修改类属性的结果完全相同，这会导致该类的其他实例来访问这个类属性时也将获得这个被修改过的值。 通过了理论理解，现在看代码： class Person { //定义一个实例Field, 因为代码没有被static修饰 public String name; //定义一个类Field public static int eyeNum; } public class PersonTest { public static void main(String[] args) { //Person类已经初始化了，则eyeNum变量起作用了，输出0 System.out.println("Person的eyeNum类Field值:" + Person.eyeNum+"\n"); //因为是类的field(eyeNum)所以可以直接调用 //创建Person对象 Person p = new Person(); //用来调用非static修饰的属性 //通过Person对象的引用p来访问Person对象name实例Field //并通过实例访问eyeNum类Field System.out.println("p变量的name Field值是：" + https://www.wendangku.net/doc/7b13990447.html, + " p对象的eyeNum Field值是：" + p.eyeNum+"\n"); //直接为name实例Field赋值 https://www.wendangku.net/doc/7b13990447.html, = "孙悟空"; //通过p访问eyeNum类Field，依然是访问Person的eyeNum类Field p.eyeNum = 2; //再次通过Person对象来访问name实例Field和eyeNum类Field

Java成员变量、局部变量、静态变量、成员方法、全局方法等概念的区别

Java成员变量、局部变量、静态变量、成员方法、全局方法等概念的区别 在Java中，一个类体由2部分构成: 一部分是变量的定义; 一部分是方法的定义(一个类中可以有多个方法) Java中的变量可以分为成员变量，全局变量 成员变量和局部变量的区别 成员变量：(类似于C中的全局变量的概念，所以也可以说是全局变量) ①成员变量定义在类中，在整个类中都可以被访问。 ②成员变量随着对象的建立而建立，随着对象的消失而消失，存在于对象所在的堆内存中。 ③成员变量有默认初始化值。 局部变量： ①局部变量只定义在局部范围内，如：函数内，语句内等，只在所属的区域有效。 ②局部变量存在于栈内存中，作用的范围结束，变量空间会自动释放。 ③局部变量没有默认初始化值 在使用变量时需要遵循的原则为：就近原则 首先在局部范围找，有就使用；接着在成员位置找。 静态变量（也叫做类变量，类属性） 由static修饰的变量称为静态变量，其实质上就是一个全局变量。如果某个内容是被所有对象所共享，那么该内容就应该用静态修饰；没有被静态修饰的内容，其实是属于对象的特殊描述。 成员变量和静态变量的区别 1、两个变量的生命周期不同 成员变量随着对象的创建而存在，随着对象被回收而释放。 静态变量随着类的加载而存在，随着类的消失而消失。 2、调用方式不同 成员变量只能被对象调用。 静态变量可以被对象调用，还可以被类名调用。 3、别名不同 成员变量也称为实例变量。 静态变量也称为类变量。 4、数据存储位置不同 成员变量存储在堆内存的对象中，所以也叫对象的特有数据。 静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。列表对比：

实例成员与类成员

实例成员与类成员。 ?实验要求： 按程序模板的要求编写源文件，要特别注意程序的输出结果，并能正确解释输出的结果。 ?程序运行效果示例： 程序运行效果如下图所示： ?程序模板： Example.java class A { float a;//声明一个float型实例变量a static float b; //声明一个float型类变量b,即static变量b void setA(float a) { this.a=a; //将参数a的值赋值给成员变量a } void setB(float b) { this.b=b; //将参数b的值赋值给成员变量b } float getA() { return a; } float getB() { return b; } void inputA() { System.out.println(a); } static void inputB() { System.out.println(b);

} } public class Example { public static void main(String args[]) { A.b=100; //通过类名操作类变量b,并赋值100 A.inputB(); //通过类名调用方法inputB() A cat=new A(); A dog=new A(); cat.setA(200); //cat象调用方法setA(int a)将cat的成员a的值设置为200 cat.setB(400); //cat调用方法setB(int b)将cat的成员b的值设置为400 dog.setA(150); //dog象调用方法setA(int a)将dog的成员a的值设置为150 dog.setB(300); //dog调用方法setB(int b)将dog的成员b的值设置为300 cat.inputA(); //cat调用inputA()。 cat.inputB(); //cat调用inputB()。 dog.inputA(); //dog调用inputA()。 dog.inputB(); //dog调用inputB()。 } } 实验后的练习： 1. 将inputA()方法中的System.out.println(a);改写为 System.out.println(a+b);编译是否出错？为什么？ 程序将正常运行，不会出错。因为变量可以引用非静态变量 2. 将inputB()方法中的System.out.println(b);改写为 System.out.println(a+b);编译是否报错？为什么？ 会出错。因为无法从静态上下文中引用非静态变量a。

成员变量可分为静态的和非静态的

System.out.println("var2="+var2); } //显示方法结束 static //初始化静态变量 { System.out.println("现在对变量进行初始化..."); var1=128; //为变量var1赋初值 var2=var1*8; //为变量var2赋初值 System.out.println("变量的初始化完成!!!"); } //初始化器结束 public static void main(String [] args) //主方法 { display(); //显示属性值 } //主方法结束 } 请读者运行程序，查看程序的执行结果。当系统把类装入到内存时，自动完成静态初始化器。本章小结 本章主要讲述了面向对象的程序设计的基本概念，面向对象的程序设计是以类为基础的。一个类包含两种成份，一种是数据成份（变量），一种是行为成份（方法）。根据这两种成份，在定义类时，数据成份被声明为类的成员变量，行为成份被声明为类的成员方法。 本章详细讨论了类的构成。类由类的声明部分和类体组成。类体包含以下内容： 成员变量可分为静态的和非静态的。静态的成员变量也被称为类变量，它属于类可以被类的所有对象共享；非静态的成员变量也被称为实例变量，它只属于具体的对象。 2）成员方法

方法可分为构造方法和一般方法： 构造方法是一种特殊的方法，它用于构造对象。 一般方法又可分为静态方法和非静态方法。静态方法也被称为类方法，可以在不创建对象的情况下，直接使用类名引用；非静态方法也被称为实例方法，只能由对象引用。 此外还讨论了方法的重载。 本章重点：面向对象程序设计的概念，类的定义方法、各种数据成员和方法成员的概念及定义，对象的定义、创建及引用，方法的重载，方法参数的传递等。 本章是面向对象程序设计基础，必须切实掌握，才能更好地学习后边的内容。 思考与练习 1．举例说明类和对象的关系。 2．定义一个描述电话的类，至少描述电话类的两种属性和一种功能。 3．为什么说构造方法是一种特殊的方法，它与一般的成员方法有什么不同？为第2题的电话类定义构造方法，创建一个具体的电话对象并对其成员进行引用。 4．什么是方法的重载？编写一个类，定义3个重载的方法，并编写该类的测试程序。5．举例说明类方法和实例方法以及类变量和实例变量的区别。

成员变量、实例变量、类变量、成员方法、实例方法、类方法的区别

成员变量、实例变量、类变量、成员方法、实例方法、类方法的区别 2010-04-11 15:18 简单来说： 类体的定义包括成员变量的定义和方法的定义。 1、成员变量包括实例变量和类变量；而成员方法包括实例方法、类方法，当然还有一种特殊的构造方法。 2、类变量、类方法就是类中的变量、方法，必须是静态的，要加static；故其又称静态变量、静态方法。 3、成员变量、成员方法是对象或实例中的变量、方法，不加static； 类变量：静态域，静态字段，或叫静态变量，它属于该类所有实例共有的属性，在内存中只有一个地方存储这个变量。而且所有的实例都可以修改这个类变量的值（前提是这个类变量没有被final修饰，否则是常量了），而且访问类变量的时候不用实例，直接用类就可以了。类方法：和类变量一样，可以不用实例，直接用类就可以调用类方法。 实例变量：实例域，实例字段，或叫成员变量。 实例方法：或叫成员方法，必须先有实例，然后才能通过实例调用该实例方法。 使用方法：类方法可以直接调用类变量和类方法 类方法不可以直接调用实例变量和实例方法 类方法中没有this，因为没有实例，this不知道调用哪个实例 类方法可以从类里面直接访问类成员 实例方法可以调用类方法，访问类变量，但是不提倡这样做，会把类方法和类变量混淆成实例方法和实例变量 程序实例： class AnIntegerNamedX { int x; //这个是成员变量 public int x() { //成员方法 return x; } public void setX(int newX) { //成员方法 x = newX; } } public class Practice{ public static void main(String args[]){ AnIntegerNamedX myX = new AnIntegerNamedX(); AnIntegerNamedX anotherX = new AnIntegerNamedX(); myX.setX(1); anotherX.x = 2; System.out.println("myX.x = " + myX.x()); System.out.println("anotherX.x = " + anotherX.x()); } } 2：

成员变量与局部变量的区分

1:成员变量和局部变量的区别(理解) (1)在类中的位置不同 成员变量：类中方法外 局部变量：方法定义中或者方法声明上 (2)在内存中的位置不同 成员变量：在堆中 局部变量：在栈中 (3)生命周期不同 成员变量：随着对象的创建而存在，随着对象的消失而消失 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失 (4)初始化值不同 成员变量：有默认值 局部变量：没有默认值，必须定义，赋值，然后才能使用 2:类作为形式参数的问题?(理解) (1)如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。 3:匿名对象(理解) (1)没有名字的对象 (2)应用场景 A:调用方法，仅仅只调用一次的时候。 b:可以作为实际参数传递。 4:封装(理解)

(1)隐藏实现细节，提供公共的访问方式 (2)好处： A:隐藏实现细节，提供公共的访问方式 B:提高代码的复用性 C:提高代码的安全性 (3)设计原则 把不想让外界知道的实现细节给隐藏起来，提供公共的访问方式 (4)private是封装的一种体现。 封装：类，方法，private修饰成员变量 5:private关键字(掌握) (1)私有的意义，可以修饰成员变量和成员方法 (2)特点： 被private修饰的后的成员只能在本类中被访问 (3)private的应用： 以后再写一个类的时候： 把所有的成员变量给private了 提供对应的getXxx()/setXxx()方法 6:this关键字(掌握) (1)代表当前类的引用对象 记住：哪个对象调用方法，该方法内部的this就代表那个对象 (2)this的应用场景： A:解决了局部变量隐藏成员变量的问题

CRecordset类的常用成员函数 成员变量 以及操作实例

CRecordset类的常用成员函数成员变量以及操作实例 分类：MFC2011-12-11 14:00 1307人阅读评论(0) 收藏举报数据库querydeletesqlmfcbutton Open（）: 打开记录集，在CRecordse类负责的一个表中，将该表看做是一个记录集，即一个数据库中的表的元组对应一个记录，表的所有元组就是一个记录的集合。 AddNew（）：将一个新的记录插入到表中 Update() ：完成AddNew() 或Edit()操作之后，调用该函数在内存中的数据保存到磁盘数据库中。 MoveNext() ：将当前记录设置到下一个记录 MovePrev() ：将当前记录设置到上一个记录 MoveFrist（）将当前记录设置到记录集的第一个记录 MoveLast() 将当前记录设置到记录集的最后一个记录 IsBOF() 判断是否定位于第一个记录之前 IsEOF() 判断是否定位于最后一个记录之后 Edit() 执行对当前记录的修改 Delete() 删除当前记录 GetDefaultConnect() 获得数据源的默认连接字符串 GetDefaultSQL() 获取默认的SQL字符串 DoFieldExchange() 在记录集和数据源之间进行数据交换 GetStatus() 获取当前记录的索引 GetRecordCount() 获取用户在记录集中移动时所经过的记录数目 GetODBCFieldInfo() 获取域信息 GetODBCFieldCount() 获取记录集对象中的域的数目 Data Members m_hstm t Contains the ODBC statement handle for the recordset. Type HSTMT. m_nFie lds Contains the number of field data members in the recordset. Type UINT. m_nPar ams Contains the number of parameter data members in the recordset. Type UINT. m_pDat abase Contains a pointer to the CDatabase object through which the recordset is connected to a data source.