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

实验4：静态变量、静态方法与包

实验4：静态变量、静态方法与包实验目的 1、熟练静态变量、静态方法、实例变量、实例方法的概念 2、掌握包的概念与应用。 实验内容 一、静态变量 1.阅读下列程序，并按照要求完成后续功能。 class Point { private int x,y; Point (int xValue, int yValue) { x=xValue; y=yValue; }; public int GetX() { return x; } public int GetY() { return y; } public void SetY(int value) { y=value; } public void SetX(int value) { x=value; } } class Managerpoint { static int count=0; Point createPoint(int x,int y)

{ 提示：在此处加入代码，完成程序的输出要求 } } public class one { public static void main(String[] args) { // TODO Auto-generated method stub Managerpoint mPoint =new Managerpoint(); for(int i=0;i<9;i++){ Point p=mPoint.createPoint(i,20); System.out.print("当前点的总数为："+Managerpoint.count); System.out.println("当前点的x值为："+p.GetX()); } } } 注意：本例中使用的“20”仅仅是作为一个测试数据。 在提示处加入代码，要求： ●除提示处代码，其他代码保持不变 ●Main方法的执行结果为： 当前点的总数为：1当前点的x值为：0 当前点的总数为：2当前点的x值为：1 当前点的总数为：3当前点的x值为：2 当前点的总数为：4当前点的x值为：3 当前点的总数为：5当前点的x值为：4 当前点的总数为：6当前点的x值为：5 当前点的总数为：7当前点的x值为：6 当前点的总数为：8当前点的x值为：7 当前点的总数为：9当前点的x值为：8 2．改错。 理解静态方法可访问静态变量，但在静态方法中不能直接访问实例变量。 提示： 阴影处为需要修改的代码。 public class one { int x=8; int y=9; final int i=10; static int getY(){ return y; } static int getI(){ return i;

成员方法成员变量

成员变量 成员变量是指类的一些属性定义，标志类的静态特征，它的基本格式如下：访问修饰符修饰符类型属性名称=初始值; ?访问修饰符：可以使用四种不同的访问修饰符中的一种，包括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。

Java中的static变量、方法、代码块

1、static变量 按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。 对于实例变量，每创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。 2、static方法 静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！ 因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。 3、static代码块 static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。 例子： class A{ static{ System.out.println("A static block"); // (3)运行 } { System.out.print("Q"); // (5)运行 } public A (){ System.out.println("x"); // (6)运行 } } class B extends A{ static{ System.out.println("B static block"); // (4)运行 } { System.out.print("W"); // (7)运行 }

Java 中的 static 使用之静态方法

Java 中的static 使用之静态方法 与静态变量一样，我们也可以使用 static 修饰方法，称为静态方法或类方法。其实之前我们一直写的 main 方法就是静态方法。静态方法的使用如： 需要注意： 1、静态方法中可以直接调用同类中的静态成员，但不能直接调用非静态成员。如： 如果希望在静态方法中调用非静态变量，可以通过创建类的对象，然后通过对象来访问非静态变量。如： 、在普通成员方法中，则可以直接访问同类的非静态变量和静态变量，如下所示：

3、静态方法中不能直接调用非静态方法，需要通过对象来访问非静态方法。如： ava 中的static 使用之静态初始化块 Java 中可以通过初始化块进行数据赋值。如： 在类的声明中，可以包含多个初始化块，当创建类的实例时，就会依次执行这些代码块。如果使用 static 修饰初始化块，就称为静态初始化块。 需要特别注意：静态初始化块只在类加载时执行，且只会执行一次，同时静态初始化块只能给静态变量赋值，不能初始化普通的成员变量。 我们来看一段代码：

运行结果： 通过输出结果，我们可以看到，程序运行时静态初始化块最先被执行，然后执行普通初始化块，最后才执行构造方法。由于静态初始化块只在类加载时执行一次，所以当再次创建对象 hello2 时并未执行静态初始化块。 封装 1、概念： 将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问 2、好处 a:只能通过规定的方法访问数据 b:隐藏类的实例细节，方便修改和实现。 什么是Java 中的内部类 问：什么是内部类呢？ 答：内部类（ Inner Class ）就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。 问：那为什么要将一个类定义在另一个类里面呢？清清爽爽的独立的一个类多好啊！！ 答：内部类的主要作用如下：

Java静态方法、静态变量,初始化顺序

Java静态方法、静态变量、初始化顺序 成员变量分为实例变量和静态变量。其中实例变量属于某一个具体的实例，必须在类实例化后才真正存在，不同的对象拥有不同的实例变量。而静态变量被该类所有的对象公有（相当于全局变量），不需要实例化就已经存在。南京Java软件培训机构 方法也可分为实例方法和静态方法。其中，实例方法必须在类实例化之后通过对象来调用，而静态方法可以在类实例化之前就使用。与成员变量不同的是：无论哪种方法，在内存中只有一份——无论该类有多少个实例，都共用同一个方法。南京Java软件培训机构 实例方法的调用： 1.ClassA a = new ClassA(); //必须经过实例化，用对象名访问 2. a.instanceMethod(); 静态方法的调用： 1. 1. a.staticMethod(); //无需经过实例化，用类名或者对象名访问 2. 静态方法的声明和定义 定义一个静态方法和定义一个实例方法，在形式上并没有什么区别，只是在声明的头部，需要加上一个关键字static。南京Java软件培训机构 3.静态方法和实例方法的区别 静态方法和实例方法的区别主要体现在两个方面： · 在外部调用静态方法时，可以使用“类名.方法名”的方式，也可以使用“对象名.方法名”的方式。而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象。 · 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制。 实例代码：静态方法访问成员变量示例： 1.class accessMember{ 2.private static int sa; //定义一个静态成员变量 3.private int ia; //定义一个实例成员变量 4.//下面定义一个静态方法 5.static void statMethod(){ 6.int i = 0; //正确，可以有自己的局部变量 7.sa = 10; //正确，静态方法可以使用静态变量 8.otherStat(); //正确，可以调用静态方法 9.ia = 20; //错误，不能使用实例变量 10.insMethod(); //错误，不能调用实例方法 11.}

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中的静态变量、静态方法、静态块与静态类 在Java中，static是一个关键字，我们不能用它来作为类名或包名，static主要有四种用途，即作为静态变量、静态方法、静态块和静态类。 1、静态变量Java static variables 静态变量就是类变量，它并不属于类的实例，仅属于类本身。在所有能访问该类的地方，也就可能访问或修改该变量，它是非线程安全的，因此，静态变量通常是和final关键字结合在一起，用来标识该变量是一个公共资源和常量。 只要静态变量不是private私有的，那么我们可通过ClassName.variableName的方式进行访问。 2、静态方法Java static methods 静态方法与静态变量一样，也是属于类本身而不属于类的实例对象。在一个静态方法中，除了局部变量外，它能访问的外部变量也必须是静态的，能访问的外部方法也必须是静态的，实例变量和实例方法均不能访问。

3、静态块Java static Block 静态块是由一些语句组成的段落，它在类被加载进内存时执行，且无论类被使用多少次它都只会执行一次。一个类的静态块可以有多个，其执行顺序由它在代码中的顺序决定。 4、静态类Java static methods 静态类都是内部类，static不能用于修饰顶级的类。对于单例模式用静态类来实现就是一个很不错的选择。 5、完整示例

//static variable example private static int count; //kept private to control it's value through setter public static String str; public int getCount() { return count; } //static method example public static void setCount(int count) { if(count > 0) StaticExample.count = count; } //static util method public static int addInts(int i, int...js){ int sum=i; for(int x : js) sum+=x; return sum; } //static class example - used for packaging convenience only public static class MyStaticClass{ public int count; } }

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:

static变量和static函数的各自的特点

static变量和static函数的各自的特点 static变量大致分为三种用法 一、用于局部变量中,成为静态局部变量. 静态局部变量有两个用法,记忆功能和全局生存期. 二、用于全局变量,主要作用是限制此全局变量被其他的文件调用. 三、用于类中的成员.表示这个成员是属于这个类但是不属于类中任意特定对象 static 声明的变量. 在C语言中有两方面的特征： 1、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。 2、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。 Tips: A.若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度； B.若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度； C.设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题； D.如果我们需要一个可重入的函数，那么，我们一定

要避免函数中使用static变量(这样的函数被称为：带“内部存储器”功能的的函数) E.函数中必须要使用static变量情况:比如当某函数的返回值为指针类型时，则必须是static的局部变量的地址作为返回值，若为auto类型，则返回为错指针。 函数前加static使得函数成为静态函数。但此处“static”的含义不是指存储方式，而是指对函数的作用域仅局限于本文件(所以又称内部函数)。使用内部函数的好处是：不同的人编写不同的函数时，不用担心自己定义的函数，是否会与其它文件中的函数同名。 扩展分析:术语static有着不寻常的历史.起初，在C中引入关键字static是为了表示退出一个块后仍然存在的局部变量。随后，static在C中有了第二种含义：用来表示不能被其它文件访问的全局变量和函数。为了避免引入新的关键字，所以仍使用static关键字来表示这第二种含义。最后，C++重用了这个关键字，并赋予它与前面不同的第三种含义：表示属于一个类而不是属于此类的任何特定对象的变量和函数(与Java中此关键字的含义相同)。

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

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

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

静态变量用法

JAVA的静态变量相当于类字段，而不用理解为对象字段。 java类的成员变量有俩种：一种是被static关键字修饰的变量，叫类变量或者静态变量；另一种没有static修饰，为实例变量。 在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。 在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。 静态变量位于方法区，被类的所有实例共享。静态变量可以直接通过类名进行访问，其生命周期取决于类的生命周期。 而实例变量取决于类的实例。每创建一个实例，java虚拟机就会为实例变量分配一次内存，实例变量位于堆区中，其生命周期取决于实例的生命周期。 结果为： 1 0 （成员变量具有缺省值而局部变量则没有） 把代码改为： 结果则为 1

Java中的静态变量和静态函数 静态变量： 在JAVA中类在声明的时候，其实并没有申请和产生内存空间，就如同我们的一个切实可行的想法，但其实并没有去实施这个想法。而类只有在用这种数据类型创建一个类的对象的时候，才能在内存中申请和产生类大小的内存空间，这一块内存空间是用来存放成员变量和成员函数的备份。所以在类声明的时候，是不可以对成员变量进行初始化的，只有用类创建的对象时，才能通过对象对变量初始化，SO，便产生的静态变量!!!它对所有的类对象都是很公共的，对每一个类的对象都具有相同的值。静态变量的关键字是static，它的语法是: Static<数据类型><静态变量名>=<初始化静态变量>; 静态变量在声明的时候就同时初始化，并且只能初始化一次，它有自己的变量作用域，但具有全局的生命周期，可以随时被调用。它声明的时候内存中就从开始一直保留一份值。在类的对象没有被创建之前可以使用类名调静态成员变量，它的语法是： <类名>.<静态成员变量>; 静态函数： 既然有了静态变量那就会有静态函数，静态函数只有访问静态变量，其它非静态的函数是不被允许的，但在静态成员函数中可以声明它自身的变量，它也是一个函数也具有其它函数的特性!静态函数的声明和静态变量的声明所差无几： Static<数据类型><静态函数名>(变量表); 和静态变量一样，静态函数在声明的时候就在内存中存在（即使没有创建对象这和其它的非静态函数是不一样的），也具有全局的生命周期。 下面给出一个静态函数和静态变量的例子: import java.io.*; //导入io流 public class Text_Static { int iNum1; static int iNum2; Text_Static(int iNum1,int iNum2) { this.iNum1=iNum1; this.iNum2=iNum2; this.iNum1++; this.iNum2++; } public void Display1(String str)

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的方法

C++静态成员变量和静态成员函数

数据成员可以分静态变量、非静态变量两种. 静态成员：静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员. 非静态成员：所有没有加Static的成员都是非静态成员,当类被实例化之后,可以通过实例化的类名进行访问..非静态成员的生存期决定于该类的生存期..而静态成员则不存在生存期的概念,因为静态成员始终驻留在内存中.. 一个类中也可以包含静态成员和非静态成员,类中也包括静态构造函数和非静态构造函数.. 分两个方面来总结，第一方面主要是相对于面向过程而言，即在这方面不涉及到类，第二方面相对于面向对象而言，主要说明static在类中的作用。 一、在面向过程设计中的static关键字 1、静态全局变量 定义：在全局变量前，加上关键字static 该变量就被定义成为了一个静态全局变量。 特点： A、该变量在全局数据区分配内存。 B、初始化：如果不显式初始化，那么将被隐式初始化为0(自动变量是随机的,除非显式地初始化)。 C、访变量只在本源文件可见，严格的讲应该为定义之处开始到本文件结束。 例（摘于C++程序设计教程---钱能主编P103）：//file1.cpp //Example 1 #include void fn(); static int n; //定义静态全局变量 void main() { n=20; cout <

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静态变量的理解

C语言中，static的字面意思很容易把我们导入歧途，其实它的作用有三条。（1）先来介绍它的第一条也是最重要的一条：隐藏。 当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。为理解这句话，我举例来说明。我们要同时编译两个源文件，一个是a.c，另一个是main.c。 下面是a.c的内容 char a = 'A'; // global variable void msg() { printf("Hello\n"); } 下面是main.c的内容 int main(void) { extern char a; // extern variable must be declared before use printf("%c ", a); (void)msg(); return 0; } 程序的运行结果是： A Hello 你可能会问：为什么在a.c中定义的全局变量a和函数msg能在main.c中使用？前面说过，所有未加static前缀的全局变量和函数都具有全局可见性，其它的源文件也能访问。此例中，a是全局变量，msg是函数，并且都没有加static 前缀，因此对于另外的源文件main.c是可见的。 如果加了static，就会对其它源文件隐藏。例如在a和msg的定义前加上static，main.c就看不到它们了。利用这一特性可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。Static可以用作函数和变量的前缀，对于函数来讲，static的作用仅限于隐藏，而对于变量，static还有下面两个作用。（2）static的第二个作用是保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。虽然这种用法不常见，但我还是举一个例子。 #include int fun(void){ static int count = 10; // 事实上此赋值语句从来没有执行过 return count--; } int count = 1; int main(void) { printf("global\t\tlocal static\n"); for(; count <= 10; ++count)

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#静态方法与非静态方法的比较 C#的类中可以包含两种方法：C#静态方法与非静态方法。那么他们的定义有什么不同呢？他们在使用上会有什么不同呢？让我们来看看最直观的差别：使用了static 修饰符的方法为静态方法，反之则是非静态方法。 下面我们分四个方面来看看C#静态方法与非静态方法的差异： C#静态方法与非静态方法比较一、C#静态成员： ①静态成员属于类所有，非静态成员属于类的实例所有。 ②每创建一个类的实例，都会在内存中为非静态成员新分配一块存储； 非静态成员属于类所有，为各个类的实例所公用，无论类创建了多少实例， 类的静态成员在内存中只占同一块区域。 C#静态方法与非静态方法比较二、C#静态方法 1、C#静态方法属于类所有，类实例化前即可使用。 2、非静态方法可以访问类中的任何成员，静态方法只能访问类中的静态成员。 3、因为静态方法在类实例化前就可以使用，而类中的非静态变量必须在实例化之后才能分配内存， 这样，C#静态方法调用时无法判断非静态变量使用的内存地址,所以无法使用。而静态变量的地址对类来说是固定的，故可以使用。 C#静态方法与非静态方法比较三、C#静态方法是一种特殊的成员方法 它不属于类的某一个具体的实例，而是属于类本身。所以对静态方法不需要首先创建一个类的实例，而是采用类名.静态方法的格式。 1.static方法是类中的一个成员方法,属于整个类,即不用创建任何对象也可以直接调用!

static内部只能出现static变量和其他static方法!而且static方法中还不能使用this....等关键字..因为它是属于整个类! 2.静态方法效率上要比实例化高，静态方法的缺点是不自动进行销毁，而实例化的则可以做销毁。 3.静态方法和静态变量创建后始终使用同一块内存，而使用实例的方式会创建多个内存. 4.C#中的方法有两种:实例方法,静态方法. C#静态方法与非静态方法比较四、C#静态方法中获取类的名称 静态方法中用： string className = System.Reflection.MethodBase. GetCurrentMethod().ReflectedType.FullName; 非静态方法中还可以用： string className = this.GetType().FullName; C#静态方法与非静态方法的区别解析旨在诠释C#静态方法的含义，希望对你了解和学习C#静态方法与非静态方法有所帮助。