精华内容
下载资源
问答
  • 2022-04-26 10:16:05

    目录

    公有属性

    静态数据成员

    静态成员函数

    公有属性

    一些类对象可能会具有一些相同的属性,如果用普通数据成员来描述这些相同的属性,这意味着我们需要给每个对象的这个数据成员设定相同的值,如果改变类对象相同的属性,那么意味着我们需要对它们统一操作,这就有可能出现它们的值会不一样的情况,如果用全局变量来描述它们相同的属性,就会破坏类的独立性。

    我们需要一个成员为所有对象所公有,而且在需要更新这个公有属性的时候只需修改一次。

    因此,C++提供了静态数据成员来描述类对象相同的属性。

    静态数据成员

    类的静态数据成员是属于这个类的,而不是属于某个对象的。

    我们定义一个手机类来说明一下:

    class redmik30pro
    {
    	private:
    		int old;
    		static int battery;
    	public:
    		static void change();
    		void use();
    };

    我们先不关注这个类的成员函数,先来看它的数据成员,对于一款特定的手机,那么它的电池容量一般情况下是大家都一样的,所以我们将它定义成了静态数据成员。

    在类定义的时候非静态数据成员是不分配内存的,只有在创建类对象的时候才分配内存,但静态数据成员是要分配内存的,因为它是属于类的,只有一块内存,所以要初始化它,而且不能在类的声明中初始化,必须要在类外初始化,写成这样:

    int redmik30pro::battery;

    这是不赋初始值的情况,系统会默认给它赋初始值为0,下面是赋初始值的写法:

    int redmik30pro::battery=4700;

    如果你不初始化静态数据成员,系统会报编译错误。

    静态数据成员的访问受类的访问权限控制。如果定义为私有,则可以在类内访问到。

    静态成员函数

    一般都是在静态成员函数中修改静态数据成员,在刚刚的手机类声明中的成员函数:

    		static void change();

    就是静态成员函数。

    我们给它来一个类外定义:

    void redmik30pro::change()
    {
    	battery-=10;
    }

    要注意的是,静态成员函数只能访问静态数据成员和静态成员函数,不能访问非静态数据成员,如果要访问非静态数据成员,可以通过类对象名加下标点这种方式访问。

    但是非静态成员函数可以任意地访问静态成员函数和静态数据成员。

    那静态成员函数存在的意义是什么?

    首先,可能你在做题的时候,题目要求你使用静态成员函数完成任务……

    开个玩笑啦……

    静态成员函数没有this指针,因为它在类创建的时候就存在了,在没有创建类对象的时候就已经存在静态成员函数,而普通函数必须在类对象被创建的时候才能被使用,但静态成员函数可以在类对未创建之前使用,像这样:

    int main()
    {
    	redmik30pro::change();	
    }

    合法。

    简而言之,静态成员函数是服务于类的,而不是某个类对象,它的方便在于不需要定义类对象就能使用。

    更多相关内容
  • C++中的——静态成员

    千次阅读 2018-09-03 16:04:20
    、声明静态成员 ...2、的静态成员存在于任何对象之外,对象中不包含任何与静态数据成员有关的数据,静态数据成员被所有该类型的对象共享。 3、静态成员函数也不与任何对象绑定在一起,它们不包...

    一、声明静态成员

    1、通过在成员的声明之前加上关键字static使得其与类关联在一起。和其他成员一样,静态成员可以是public的或private的。静态数据成员的类型可以是常量、引用、指针、类类型等。

    二、使用类的静态成员

    2、类的静态成员存在于任何对象之外,对象中不包含任何与静态数据成员有关的数据,静态数据成员被所有该类型的对象共享。

    3、静态成员函数也不与任何对象绑定在一起,它们不包含this指针。作为结果,静态成员函数不能声明成const的,而且我们也不能在static函数体内使用this指针。这一限制即适用于this的显示使用,也对调用非静态成员的隐式使用有效。

    4、具体使用方法

       4.1、使用作用域运算符直接访问静态成员

       4.2、虽然静态成员不属于类的某个对象,但是我们仍然可以使用类的对象、引用或指针来访问静态成员

       4.3、成员函数不用通过作用域运算符就能直接使用静态成员

    三、定义静态成员

    5、当在类的外部定义静态成员时,不能重复static关键字,该关键字只出现在类内部的声明语句中。

       5.1、可以在类的内部或外部定义静态成员函数,定义在外部的静态成员函数,必须指明成员所属的类名。

       5.2、一般来说,不能在类的内部初始化静态成员。相反的,必须在类的外部定义和初始化每个静态成员。和其他对象一样,一个静态数据成员只能定义一次因为静态数据成员不属于类的任何一个对象,所以它们并不是在创建类的对象时被定义的。这意味着它们不是由类的构造函数初始化的。类似于全局变量,静态数据成员定义在任何函数之外。因为一旦它被定义,就将一直存在于程序的整个生命周期中。

    class part

    {

    static int x();                      //成员函数声明

    static int i;                       //数据成员的声明

    };

    int part::i=x();    //数据成员的定义和初始化(一旦遇到类名和作用域运算符,则后面部分均在类的作用域内

    int part::x(){//函数体}                     //成员函数定义

    6、静态数据成员应该保证只定义一次,因此应把静态数据成员的定义与其他非内联函数的定义放在同一个文件中。

    7、通常情况下,类的静态成员不应该在类的内部初始化。然而,当声明该静态成员类型为const或constexpr类型,并保证初始值为常量表达式时才允许类内初始化(这里并不代表具有const或constexpr修饰的数据成员必须类内初始化)。带有类内初始值设定项的静态数据成员必须具有不可变的常量整型,也就是说其他例如string类型是不可以的。所以它们能用在所有适合于常量表达式的地方。例如,我们可以用一个初始化了的静态数据成员指定数组成员的维度。

    class part

    {

       static int x();//成员函数声明

       static constexpr int i=8;//数据成员的声明

       constexpr static int j=8;//数据成员的声明

       constexpr static string s="hello";   //错误:带有类内初始值设定项的静态数据成员必须具有不可变的常量整型

       int data[i];

    };

    constexpr int i;

       即使一个常量静态数据成员在类内部被初始化了,也应该在类的外部定义一下该成员(虽然一些情况下程序不会出错),并且类内和类外使用的常量修饰符要一致。

    四、静态数据成员不同于普通成员

    8、静态数据成员可以是不完全类型。特别的,静态数据成员的类型可以就是它所属的类类型。而非静态数据成员则受到限制,只能声明成它所属类的指针或引用。

    class part

    {

       static part i;//静态数据成员可以是不完全类型

       part *j;//指针成员可以是不完全类型

       part k;//数据成员必须是完全类型

    };

    9、可以使用静态成员作为默认实参。非静态数据成员则不能作为默认实参,因为它的值本身属于对象的一部分,这么做的结果是无法真正提供一个对象以便从中获取成员的值,最终将引发错误。

    class part

    {

    public:

       void print(int j= i) { cout << j << endl; }

    private:

        const static int i=8;

    };

    展开全文
  • 根据成员内部的定义: 首先生成外部的实例... //对于final修饰的成员变量,说明该变量是只读变量,只能进行次赋值操作,只能存在以下两种赋值情况,在这两地方我们必须给它们赋初值。 //1)声明该成员变量...

    根据成员内部类的定义:

    1. 首先生成外部类的实例对象
    2. 然后生成绑定到外部类实例对象的成员内部类实例对象

    外部类实例对象的生成一定要先于成员内部类实例对象的生成

    public class InnerClassDemo{
         //对于final修饰的成员变量,说明该变量是只读变量,只能进行一次赋值操作,只能存在以下两种赋值情况,在这两个地方我们必须给它们赋初值。
         //1)声明该成员变量时赋值:
         //  a)如果表达式的值是常量表达式(返回基本类型数据),则编译器编译时就计算出该表达式的值,知道该值,那么编译器就可能会在编译时期优化程序
         //  b)如果不是常量表达式(返回引用类型数据),则编译器编译时,就不知道该值。
         //2)在构造方法中赋值,运行时赋值,则编译器编译时,就不知道该值
    
         //实例成员被默认初始化为0
         int x;
    
         //static final修饰的变量必须被显示初始化,要么在声明时赋值初始化,要么在静态块中初始化。
         //否则,语法错误
         static final int i;
         static int y;//可以不用初始化,系统会默认赋值0
         static final int j=2;
         //静态块,当类被JVM加载到内存时,静态块的静态代码执行。
         static{
              i=1;
              System.out.println("i="+i);
              System.out.println("j="+j);
          }
    
          public static void main(String[] args){
              InnerClassDemo innerclassdemo=new InnerClassDemo();
              InnerClass innerClass=innerclassdemo.new InnerClass();
              System.out.println("innerclassdemo中x和y的默认值分别是是:"+innerclassdemo.x+y);
              System.out.println("innerClass中i="+innerClass.i);
      System.out.println("innerClass中str="+innerClass.str);
              System.out.println("Welcome!");
          }
    
    class InnerClass{
          //1.在成员内部类中,只有编译器在编译的时候赋值号右边是常量表达式(编译时,可以计算出表达式的基本类型值),
          //左边是只读静态常量的情况才可以存在静态只读常量
          //然后编译器把它当做编译器常量来使用,其实说白了就是和这个外部类的实例无关。
          static final int i=50;
          static final String str='s';
    
         //2.以下均不可以
         //2.1虽然static final为只读静态变量,但是是在构造方法中运行时赋值,编译时不知道其值。
         //static final int i;
         //static final String str
         //2.2虽然static final为只读静态变量,但是赋值号右边不是常量表达式(返回引用类型数据),编译时并不知道其引用的实例值。
         //static final String str=new String("");
    
         //3.没有外部类实例,此内部类不需要外部类实例就初始化了变量,与成员内部类的定义相悖。
         //static InnerClass innerClass=new InnerClass();
    
        //4.静态方法中,但是没有外部类实例
        //static void method(){
        //     InnerClass innerClass=new InnerClass();
        //    }
    
     

    综上,其实内部类并不是完全不能出现static这样的修饰的,只要符合第一种情况的就是可以的。

    编译器其实无法区分第二种,第三种情况的,第三种的情况肯定是不行的与内部成员类的定义相驳,所以第二种情况在语法上也被禁止了。

    第三种情况,根据初始化的流程我们知道,在类加载的时候,static变量就必须被显式初始化,那么我们InnerClass成员内部类的实例对象在没InnerClassDemo外部类的实例对象的时候便生成了。这样这个成员内部类就脱离了外部类的掌控,不需要外部类的对象就可以生成内部类的对象,这与成员内部类的定义就相驳了,因为我们知道成员内部类的对象必须是先有外部类的对象才能创建,成员内部类的对象 脱离了其外部类的对象 就不会存在,并且是绑定在一起的,所以成员内部类不可以定义静态变量。

    第四种情况与第三种情况相同原因。

    程序运行结果:
    在这里插入图片描述

    展开全文
  • 的静态成员函数和静态数据成员

    千次阅读 2015-10-10 21:31:27
    各个对象都拥有中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少对象无关。静态方法就是与该相关的,是的一种行为,而不是与该的实例对象相关。静态数据成员的用途之一是统计有...

    一、基本知识

    当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少类对象无关。静态方法就是与该类相关的,是类的一种行为,而不是与该类的实例对象相关。

    静态数据成员的用途之一是统计有多少个对象实际存在。

    静态数据成员不能在类中初始化,实际上类定义只是在描述对象的蓝图,在其中指定初值是不允许的。也不能在类的构造函数中初始化该成员,因为静态数据成员为类的各个对象共享,否则每次创建一个类的对象则静态数据成员都要被重新初始化。

    静态成员不可在类体内进行赋值,因为它是被所有该类的对象所共享的。你在一个对象里给它赋值,其他对象里的该成员也会发生变化。为了避免混乱,所以不可在类体内进行赋值。

    静态成员的值对所有的对象是一样的。静态成员可以被初始化,但只能在类体外进行初始化。

    一般形式:

        数据类型  类名::静态数据成员名=初值

    注意:不能用参数初始化表对静态成员初始化。一般系统缺省初始为0。

    静态成员是类所有的对象的共享的成员,而不是某个对象的成员。它在对象中不占用存储空间,这个属性为整个类所共有,不属于任何一个具体对象。所以静态成员不能在类的内部初始化,比如声明一个学生类,其中一个成员为学生总数,则这个变量就应当声明为静态变量,应该根据实际需求来设置成员变量。

    #include <iostream>
    
    using namespace std;
    class test
    {
    private:
        int x;
        int y;
    public:
        static int num;
        static int GetNum()
        {
            //x += 5; //错误,静态成员函数不能调用非静态数据成员,要通过类的对象来调用。
            num += 15;
            return num;
        }
    };
    int test::num = 10;//在类体外对静态数据成员初始化
    int main()
    {
        test a;
        cout<<test::num<<endl;//10
        test::num = 20;//在类体外对静态数据成员再次赋值
        cout<<test::num<<endl;//20
        cout<<test::GetNum()<<endl;//35
        cout<<a.GetNum()<<endl;//50
        return 0;
    }
    

    通过上例可知:

    x+=5;   // 这行代码是错误的
    静态函数成员必须通过对象名来访问非静态数据成员。
    另外,静态成员函数在类外实现时候无须加static关键字,否则是错误的。

    若在类的体外来实现上述的那个静态成员函数,不能加static关键字,这样写就可以了:

      int test::Getnum()
      {
          .........
      }

    1、static成员的所有者是类本身和对象,但是多有对象拥有一样的静态成员。从而在定义对象是不能通过构造函数对其进行初始化。
    2、静态成员不能在类定义里边初始化,只能在class body外初始化。
    3、静态成员仍然遵循public,private,protected访问准则。
    4、静态成员函数没有this指针,它不能返回非静态成员,因为除了对象会调用它外,类本身也可以调用。
    5、静态成员函数可以直接访问该类的静态数据和函数成员,而访问非静态数据成员必须通过参数传递的方式得到一个对象名,然后通过对象名来访问。
    6、设定了静态成员变量,必须要为其赋初值。

    二、静态成员函数访问非静态成员

    类的静态成员(变量和方法)属于类本身,在类加载的时候就会分配内存,可以通过类名直接去访问;非静态成员(变量和方法)属于类的对象,所以只有在类的对象产生(创建类的实例)时才会分配内存,然后通过类的对象(实例)去访问。

    在一个类的静态成员中去访问其非静态成员之所以会出错,是因为在类的非静态成员不存在的时候类的静态成员就已经存在了,访问一个内存中不存在的东西当然会出错。

    C++会区分两种类型的成员函数:静态成员函数和非静态成员函数。这两者之间的一个重大区别是,静态成员函数不接受隐含的this自变量。所以,它就无法访问自己类的非静态成员。

    例1:

    #include <iostream>
    
    using namespace std;
    class test
    {
    private:
        int x;
        int y;
    public:
        static int GetX()
        {
            //x += 5; //错误,静态成员函数不能调用非静态数据成员,要通过类的对象来调用。
            test *p = new test;// new一个类的对象!!!!
            p->x = 222;//使用类的对象调用非静态数据成员!!!!
            p->func();//使用类的对象调用非静态成员函数!!!!
            return p->x;
            delete p;//使用完后delete!!!!
        }
        void func(){cout<<"func()被静态成员函数调用"<<endl;}
    };
    int main()
    {
        test a;
    
        cout<<a.GetX()<<endl;
    
        return 0;
    }
    

    结果:

    func()被静态成员函数调用
    222
    
    Process returned 0 (0x0)   execution time : 0.212 s
    Press any key to continue.

    例2:

    #include <iostream>
    using namespace std;
    
    class M
    {
    public:
         M(int a) {A = a; B += a;}
         ~M(){}
         static void f1();
    private:
         int A;
         static int B;
    };
    
    void M::f1()
    {
         M m(5); //定义并初始化类对象
         cout<<"A="<<m.A<<endl; //静态成员函数中通过对象来引用非静态成员
         cout<<"B="<<B<<endl;
    }
    int M::B=5; //静态数据成员初始化的格式<数据类型><类名>::<静态数据成员名>=<值>
    
    int main()
    {
         M::f1(); //静态成员函数调用时不用对象名
         return 0;
    }
    

    结果:

    A=5
    B=10
    
    Process returned 0 (0x0)   execution time : 0.273 s
    Press any key to continue.

    三、访问私有静态成员数据

    如果把静态成员数据设为私有,可以通过公有静态成员函数!!!!!访问。

    #include <iostream>
    
    using namespace std;
    
    class Cat
    {
    public:
        Cat(int age):itsAge(age){HowManyCats++;}
        virtual ~Cat(){HowManyCats--;}
        virtual int getAge(){return itsAge;}
        virtual void setAge(int age){itsAge=age;};
        static int getHowMany()
        {//公有静态成员函数!!!!!!!!
            return HowManyCats;//访问私有静态成员数据!!!!!
        }
    private:
        int itsAge;
        static int HowManyCats;
    };
    int Cat::HowManyCats=0; //对静态成员数据如此赋值
    int main()
    {
        const int maxCats =5;
        Cat *catHouse[maxCats];
    
        for(int i=0; i<maxCats; i++)
            catHouse[i]=new Cat(i);
        for(int i=0; i<maxCats; i++)
        {
            cout<<"there are "<<Cat::getHowMany();//公有静态成员函数!!!
            cout<<" cats left!"<<endl;
            if(!Cat::getHowMany()) break;
            cout<<"delete the cat which is "<<catHouse[i]->getAge()<<" years old."<<endl;
            delete catHouse[i];
            catHouse[i] = 0;
        }
        return 0;
    }

    结果:

    there are 5 cats left!
    delete the cat which is 0 years old.
    there are 4 cats left!
    delete the cat which is 1 years old.
    there are 3 cats left!
    delete the cat which is 2 years old.
    there are 2 cats left!
    delete the cat which is 3 years old.
    there are 1 cats left!
    delete the cat which is 4 years old.
    
    Process returned 0 (0x0)   execution time : 0.409 s
    Press any key to continue.
    展开全文
  •  中的数据成员声明前加上static,则表示该数据成员为静态数据成员。除了与其他数据具有相同的public/private/protect访问属性外,还有一些其他的属性:  1、不能在中进行初始化,只能在外。  因为静态数据...
  • c++之静态数据成员与静态成员函数

    千次阅读 2020-05-11 09:28:20
    什么是静态数据成员? 数据成员我们之前学过,是对象的属性...为此,我们需要一个类公有的数据成员,就是静态数据成员 每个对象与静态数据成员关系如下图 静态数据成员的定义以及初始化 静态数据成员用关键字 “static
  • 设计包含静态数据成员的Student

    千次阅读 2018-10-19 11:27:31
    设计包含静态数据成员的Student,在该定义中包括: 数据成员:学号,年龄,分数score,及静态数据成员学生人数count; 定义成员函数用于设置和读取及显示学号,年龄,分数,累计学生人数;静态成员函数...
  • 如果某个属性为整个类所共有,不属于任何一个具体对象,则采用static关键字来声明为静态数据成员,例如:银行账户的利率 静态数据成员中只有一个拷贝,不占用对象的存储空间,由该的所有对象共同维护和使用 3....
  • 个静态数据成员total(总分)和count(学生人数)。成员函数scoretotalcount(float s)用于设置每学生的分数;静态成员函数sum()用于返回总分;静态成员函数average()用于求分数平均值。在main函数中,输入...
  • 静态成员,所有对象共享

    千次阅读 2021-06-02 17:21:55
    静态成员函数只能访问静态成员变量
  • 定义一个Box(盒子),在该定义中包括数据成员: length(长),width(宽)和height(定义一个Box(盒子),在该定义中包括数据成员: length(长),width(宽)和height(定义一个Box(盒子),在该定义中包括数据成员: ...
  • C++ 静态数据成员与静态成员函数

    千次阅读 2017-05-12 14:40:11
    中的数据成员或成员函数定义或声明前以static关键词开头,即构成静态数据成员与静态成员函数。静态数据成员1.静态数据成员的实现class Time { public : void showtime(); private: static int hour; //定义...
  • 1、什么是静态类和非静态类 (1)、静态类的建立上加上static关键词 比如我们在看C#视频中使用的File,就是静态类。...比如在FileStream,定义这个类的时候,如下示 public class FileStream : St...
  • C#面向对象——静态类静态成员

    千次阅读 2020-04-02 18:07:57
    使用 static 修饰符声明属于类型本身而不是属于特定对象的静态成员。 static 修饰符可用于、字段、方法、属性、运算符、事件和构造函数,但不能用于索引器、析构函数或以外的类型。如, static class ...
  • 在声明一个类时使用static关键字,具有两个方面的意义:首先,它防止程序员写代码来实例化该静态类;其次,它防止在的内部声明任何实例字段或方法。 静态类是自C# 2.0才引入的,C# 1.0不支持静态类声明。程序员...
  • 2)静态成员数据必须有确定的值,但由于在的定义中不能对成员数据直接进行初始化,故必须在定义的外部对静态成员数据再声明次,并进行初始化,此时,前面不需要加关键字static。同时为了保持静态成员数据取值...
  • C++静态成员函数和静态数据成员

    千次阅读 2014-08-05 22:47:10
    各个对象都拥有中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少对象无关。静态方法就是与该相关的,是的一种行为,而不是与该的实例对象相关。  静态数据成员的用途之一是...
  • 各个对象都拥有中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少的对象无关。静态方法就是与该相关的,是的一种行为,而不是与该的实例对象相关。  静态成员变量不能在中...
  • C++ :中的静态私有数据成员

    千次阅读 2016-08-03 22:24:55
    C++中,中的静态私有数据成员不要指望(默认)构造函数来初始化,必须在.cpp文件中自己定义(class中只是声明)构造函数:初始化对象的非static数据成员,以及一些其他的工作; 析构函数:释放对象使用的资源,并...
  • C++对象的生存周期和静态成员

    千次阅读 2018-01-04 19:22:50
    对象的生存周期 静态生存周期:全局变量具有静态生存周,局部变量的...第一,静态数据成员一个类的所有对象公有的属性 静态成员在每个中只有一个副本,由该的所有对象共同维护和使用,从而实现了同一的不同
  • 创建一个SavingAccount

    千次阅读 2021-02-03 22:56:13
    的每个对象都包含一个private数据成员savingsBalance,用以指示存款者目前的存款金额。该提供成员函数calculateMonthlyInterest,它将余额乘以annualInterestRate再除以12来计算月利息,这个利息应该加到savi...
  • 设计一个 Person ∶ 1、私有数据成员∶姓名,学号,面向对象编程成绩;静态成员count,用于记录对象的个数。。 2、构造函数(3个参数)实现数据初始化,并实现Person对象个体加1;复制构造函数;析构函数,实现 ...
  • 举个例子才好理解:有一个学生Student,里面有name、age、count(班级学生数量)等的属性。这里的name和age是一个学生特有的,但是count呢?它不是,我们不希望每一个学生拥有不同的学生的数量,所以我们把count...
  • 定义一个学生CStudent,私有数据成员包括name (姓名)、id(学号)、math (数学成绩) t题目要求 #include<iostream> #include<string.h> using namespace std; class CStudent { private: int id; ...
  • C++中的静态数据成员的初始化

    千次阅读 2016-05-16 14:49:24
    每个只有一个存储单元,静态数据成员为该的所有对象共有,不属于某个对象。静态数据成员的初始化必须在以外进行定义性说明。 形式为: :: =值 静态成员注意以下几点: 1、静态成员必须初始化,如果其...
  • c++ 静态成员变量用static 关键字来声明,是整个数据成员,其存储不占用某个具体对象的空间,其存储在静态存储区。 c++ 静态成员函数用static 关键字来声明,用于处理静态成员变量,可以用类名来调用,也可以用...
  • 3-6 静态数据成员与静态成员函数

    千次阅读 2016-09-20 19:07:06
    3-6 静态数据成员与静态成员函数 Time Limit: 1000MS Memory Limit: 65536KB Submit Statistic Problem Description 通过本题目的练习可以掌握静态数据...和一个静态数据成员count ,用以记录系统中创建点对
  • 各个对象都拥有中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少对象无关。静态方法就是与该相关的,是的一种行为,而不是与该的实例对象相关。  静态数据成员的用途之一是...
  • 的声明中,属性是用变量来表示的。这种变量就称为实例变量,是在声明的内部但是在的其他成员方法之外声明的。 当一个对象被实例化之后,每个实例变量的值就跟着确定; 实例变量在对象创建的时候创建,在对象...
  • 并拥有静态数据成员册数,记录图书的总册数,在构造方法中利用此静态变量为对象的编号赋值,在主方法中定义对象数组,并求出总册数. class Book{ private String name; private static int id=0; private float ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 240,096
精华内容 96,038
关键字:

一个类的静态数据成员所表示属性