精华内容
下载资源
问答
  • 1.静态成员函数 ...静态成员函数只能访问静态数据成员 2.静态成员变量 静态成员变量是一种特殊的成员变量,它被关键词 static修饰. 静态成员变量只能够在类外初始化,static 成员变量的内存不是在...

    1.静态成员函数

    1. 成员函数申明为静态,函数申明必须包含static,但是定义中不需要。但也可以在申明的时候就定义了。
    2. 不能用this指针,能通过类名和作用域解析符来调用它或者通过对象调用成员函数。
    3. 静态成员函数只能访问静态数据成员

    2.静态成员变量

    1. 静态成员变量是一种特殊的成员变量,它被关键词 static修饰.
    2. 静态成员变量只能够在类外初始化,static 成员变量的内存既不是在声明类时分配,也不是在创建对象时分配,而是在(类外)初始化时分配。反过来说,没有在类外初始化的 static 成员变量不能使用。
    3. static 成员变量不占用对象的内存,而是在所有对象之外开辟内存,即使不创建对象也可以访问。
    4. 访问静态成员变量的三种方法:
      既可以通过对象来访问,也可以通过类来访问,也可以通过对象访问
    //通过类类访问 static 成员变量
    Student::m_total = 10;
    //通过对象来访问 static 成员变量
    Student stu("小明", 15, 92.5f);
    stu.m_total = 20;
    //通过对象指针来访问 static 成员变量
    Student *pstu = new Student("李华", 16, 96);
    pstu -> m_total = 20;
    
    展开全文
  • 然而,实践中有时需要在对象间共享数据希望用一个内存区域保存一个特定数据,所有的对象共享该数据,或者不通过任何对象就能访问它。可以使用Java的static关键字解决该问题 在变量前加上static关键字,变量...

    静态变量与方法


    • 静态变量

      • 对于类的成员变量来说,每个对象在内存中都拥有自己的成员变量,对象的方法操作都是作用于对象本身的变量,各对象的数据是相互独立的。然而,实践中有时需要在对象间共享数据,既希望用一个内存区域来保存一个特定数据,所有的对象共享该数据,或者不通过任何对象就能访问它。可以使用Java的static关键字来解决该问题

      • 在变量前加上static关键字,变量就变成了静态变量,静态变量类似于一个全局性的变量,在内存中只存在它的一个副本,所有的对象共享它。

        class TickerSall{
        public static int totalTickers=100;
        public int sallNum; //代表一次卖掉的票数。
        public TickerSall(int num){
        sallNum=num;
        totalTickers-=num;
        }
        }
        class Static ValueTest{
        public static void main(string args[]){
        System.out.println("总票数为:"+TickerSall.totalTIckers);
        TickerSall t1 =new TickerSall(2);
        System.out.println("卖掉"+t1.sallNum+"张票"); //通过对象访问成员变量
        System.out.println("还剩下票数为:"+t1.totalTickers); //通过对象访问静态变量
        TIckerSall t2 =new TickerSall(3);
        System.out.print("卖掉"+t2.sallNum+"张票\t");
        System.out.print("还剩下票数为:"+t2.totalTickers);
        TickerSall t3=new TickerSall(1);
        System.out.print("卖掉"+t3.sallNum+"张票\t");
        //通过类名访问静态变量
        System.out.println("还剩下票数为:"+TickerSall.totalTIckers);
        }
        }
        

      程序在类TIckerSall中定义了一个静态变量totalTickers 和一个成员变量 sallNum,totalTIckers用来表示还剩下的总票数,sallNum用来存放每次卖掉的票数。在main()方法中,先后创建了三个TickSall对象,从程序运行结果可以看出,所有实例对象共同操作静态变量数据,每个对象对该静态变量的操作都反应给所有对象。

      ​ 可以用两种方式访问静态属性:

      ​ 类名.静态变量

      ​ 类对象.变量

    • 静态方法

      • 同样,也可以在方法前添加static关键字来定义静态方法,静态方法于静态变量类似,可以通过 类名.静态方法 的方式直接调用。静态方法不与类的任何对象关联,因此,静态方法不能访问属于某个对象的成员变量。静态方法常用于为应用程序中的其他类提供一些实用工具,,在java的类库中大量的静态方法正是出于此目的而定义的。如在Java.lang.math类中的许多方法都定义成静态方法,可以直接通过Math类名调用。
    • 封装与抽象

      • 面向对象的封装是指信息与实现细节的隐藏。与封装互为补充的一个概念是抽象(或称为类的接口),抽象位类定义了一个清晰的边界,即类提供给类的使用者的接口(数据与行为)。

      java的访问修饰符包括 public private 和 protected

      • public : 由public修饰的类的成员变量和成员方法可以被其他任何类访问。
      • private : 由private修饰的类的成员变量和成员方法不能被其他类直接访问,只能被声明它的类直接访问,只对被声明它的类所使用。使用private修饰符能实现数据与实现细节的隐藏。
      • protected:由protected修饰的成员变量和成员方法可悲他的子类以及同一个包中的类访问。
      • 没有访问修饰符的成员称为package(包)成员,可被声明它的类和同一个包中的其他类所访问。
    展开全文
  • 成员函数通过一个名为this的额外的隐式参数来访问调用它的那个对象,默认情况下this的类型是指向类类型非常量版本的常量指针 const关键字放在成员函数的参数列表之后,此时紧跟在参数列表后面的const表示this是一个...

    7.1 定义抽象数据类型

    • 成员函数的声明必须在类的内部,它的定义则既可以在类的内部也可以在类的外部
      • 定义在类内部的函数是隐式的inline函数
      • 成员函数通过一个名为this的额外的隐式参数来访问调用它的那个对象,默认情况下this的类型是指向类类型非常量版本的常量指针
      • const关键字放在成员函数的参数列表之后,此时紧跟在参数列表后面的const表示this是一个指向常量的指针,这样的成员函数称为常量成员函数
      • 常量对象,以及常量对象的引用或指针都只能调用常量成员函数
      • 类的处理分为两步:首先编译成员的声明,然后才轮到成员函数体,因此成员函数体可以随意使用类中的其他成员而无须在意这些成员出现的次序
    • 一般来说,如果非成员函数是类接口的组成部分,则这些函数的声明应该与类在同一个头文件内
    • 类通过一个或几个特殊的成员函数来控制其对象的初始化过程,这些函数叫做构造函数
      • 构造函数没有返回类型
      • 构造函数不能被声明成const的,当我们创建类的一个const对象时,直到构造函数完成初始化过程,对象才真正取得其"常量"属性,因此构造函数在const对象的构造过程中可以向其写值
      • 编译器创建的构造函数又称为合成的构造函数,编译器只有在发现类不包含任何构造函数的情况下才会替我们生成一个默认的构造函数

    7.2 访问控制与封装

    • 在c++语言中,我么使用访问说明符加强类的封装性:
      • 定义在public说明符之后的成员在整个程序内可被访问,public成员定义类的接口
      • 定义在private说明符之后的成员可以被类的成员函数访问,但是不能被使用该类的代码访问,private部分封装了类的实现细节
      • 每个访问说明符指定了接下来的成员的访问级别,其有效范围直到出现下一个访问说明符或者到达类的结尾为止
    • structclass的默认访问权限不太一样:
      • 如果我们使用struct关键字,则定义在第一个访问说明符之前的成员是public的;相反,如果我们使用class关键字,则这些成员是private
      • 当我们希望定义的类的所有成员是public的时,使用struct;反之,如果希望成员是private的,使用class
    • 类可以允许其他类或者函数访问它的非公有成员,方法是令其他类或者函数成为它的友元,只需增加一条以friend关键字开始的函数声明语句即可
      • 友元不是类的成员也不受它所在区域访问控制级别的约束,一般来说,最好在类定义开始或结束前的位置集中声明友元

    7.3 类的其他特性

    • 除了定义数据和函数成员之外,类还可以自定义某种类型在类中的别名。
      • 由于类定义的类型名字和其他成员一样存在访问限制,可以是public或者private中的一种,类型成员通常出现在类开始的地方(见例子一)
    • 一个可变数据成员永远不会是const,即使它是const对象的成员,因此一个const成员函数可以改变一个可变成员的值(见例子二)
    • 一个const成员函数如果以引用的形式返回*this,那么它的返回类型将是常量引用(见例子三)
    • 每个类定义了唯一的类型,对于类类型来说,只要名字不同则它们属于不同的类
      • 对于两个类来说,即使它们的成员完全相同,这两个类也是两个不同的类型
    • 和函数的声明一样,我们可以提前声明类但不定义类,这种声明称为前向声明,在前向声明之后定义之前该类还是一个不完全类型
      • 不完全类型只能在非常有限的情景下使用:可以定义指向这种类型的指针或引用,也可以声明以不完全类型作为参数或者返回类型的函数
      • 因为只有当类全部完成后类才算被定义,所以一个类的成员类型不能是该类自己,一旦一个类的名字出现后,它就被认为是声明过了,因此允许类包含指向它自身类型的引用或指针(见例子四)
    • 友元关系不存在传递性,每个类负责控制自己的友元类或友元函数
    • 友元函数可以定义在类的内部,但即使友元函数定义在类的内部,我们仍然需要在类的外部进行相应的声明(见例子五).
      • 友元声明的意义是使其对其它函数可见,友元未声明则其它函数无法调用它
    //例子一:定义一个类型成员
    class Screen{
        public:
            typedef std::string::size_type pos;
        private:
            pos cursor=0;
            pos height=0,width=0;
            std::string contents;
    };
    
    //例子二:可变数据成员
    class Screen{
        public:
            void some_member() const;
        private:
            mutable size_t access_ctr;  //定义一个可变数据成员
    };
    
    void Screen::some_member() const    //在const成员函数中可以改变可变数据成员
    {
        ++access_ctr;
    }
    
    //例子三:基于const的重载
    class Screen{
        public:
            Screen &display(std::ostream &os){
                do_display(os);
                return *this;
            }
            const Screen &display(std::ostream &os) const{
                do_display(os);
                return *this;
            }
        private:
            //该函数负责显示Screen的内容
            void do_display(std::ostream &os) const {
                os<<contents;
            }
    };
    
    //例子四:类的声明
    class Link_screen{
        Screen window;
        Link_screen *next;
        Link_screen *prev;
    };
    
    //例子五:定义在类内部的友元函数
    struct X{
        friend void f()
        {
            /* 友元函数可以定义在类的内部*/
        }
        X() { f(); }
        void g();
        void h();
    };
    void X::g() { return f(); }     //错误:f还没有声明
    void f();                       //声明那个定义在X中的函数
    void X::h() { return f(); }     //正确:现在f的声明在作用域中了
    

    7.4 类的作用域

    • 一个类就是一个作用域,一旦遇到了类名,定义的剩余部分就在类的作用域之内了,这里的剩余部分包括参数列表和函数体
      • 当成员函数定义在类的外部时,返回类型中使用的名字都位于类的作用域之外,此时,返回类型必须指明它是哪个类的成员(见例子一)
    • 类的定义分两步处理(编译器处理完类中的全部声明后才会处理成员函数的定义):
      • 首先编译成员的声明
      • 直到类全部可见后才编译函数体
    • 在类内部不能重新定义外部已定义的类型名字(见例子二)
    • 成员函数中的名字查找是先在成员函数内查找,之后在类内部最后在类外部查找
    //例子一:定义在类外部的成员函数
    class Window_mgr{
        public:
            //窗口中每个屏幕的编号
            using ScreenIndex=std::vector<Screen>::size_type;
            //向窗口添加一个Screen,返回它的编号
            ScreenIndex addScreen(const Screen&);
        private:
            std::vector<Screen> screens{Screen(24,80,' ')};
    };
    Window_mgr::ScreenIndex Windwo_mgr::addScreen(const Screen &s){
        screens.push_back(s);
        return screens.size()-1;
    }
    
    //例子二:重复定义类型名字
    typedef double Money;
    class Account{
        public:
            Money balamnce() { return bal; }
        private:
            typedef double Money;               //错误:不能重新定义Money
            Money bal;
            //...
    };
    

    7.5 构造函数再探

    • 如果成员是const、引用,或者属于某种未提供默认构造函数的类类型,我们必须通过构造函数初始值列表为这些成员提供初值
      • 在构造函数的初始值列表中,成员的初始化顺序与它们在类定义中的出现顺序一致,构造函数初始值列表中初始值的前后位置关系不会影响实际的初始化顺序
    • 如果一个构造函数为所有参数都提供了默认实参,则它实际上也定义了默认构造函数(见例子一)
    • c++11新标准扩展了构造函数初始值的功能,使得我们可以定义所谓的委托构造函数
      • 一个委托构造函数使用它所属类的其他构造函数执行它自己的初始化过程(见例子一)
    • 如果构造函数只接受一个实参,则它实际上定义了转换为此类类型的隐式转换机制,有时我们把这种构造函数称作转换构造函数
      • 只接受一个实参的构造函数需要判断一下是否需要抑制其隐式转换,我们可以通过将构造函数声明为explicit加以阻止(见例子三)
    //例子一
    class Sales_data{
        public:
            //定义默认构造函数
            Sales_data{std::string s=""}: bookNo(s) {}
            //定义委托构造函数
            Sales_data(std::string s):Sales_data(s,0,0){}
            Sales_data(std::string s,unsigned cnt,double rev):
                bookNo(s),units_sold(cnt),revenue(rev*cnt){}
            Sales_data(std::istream &is) { read(is,*this); }
        private:
            //...
    };
    
    //例子二:正确使用默认构造函数
    
    Sales_data obj();           //错误:声明了一个不接受任何参数的函数并且其返回值是Sales_data
    Sales_data obj2;            //正确:ojb2是一个对象而非函数
    
    //例子三
    class Sales_data{
        public:
            Sales_data()=default;
            Sales_data(const std::string &s,unsigned n,double p):
                bookNo(s),units_sold(n),revenue(p*n) { }
            //使用explicit阻止隐式转换
            explicit Sales_data(const std::string &s):bookNo(s) { }
            explicit Sales_data(std::istream&);
        private:
            //...
    };
    
    //explicit关键字只需要在类内的构造函数之前声明,在类外不需要再声明了
    Sales_data::Sales_data(std::istream& is){
        read(is,*this);
    }
    

    7.6 类的静态成员

    • 静态成员可以是public的或private的,静态数据成员的类型可以是常量、引用、指针、类类型等
    • 静态成员函数也不与任何对象绑定在一起,它们不包含this指针
      • 静态成员函数不能声明成const的,而且我们也不能在static函数体内使用this指针
      • 类的成员函数不同通过作用域运算符就能直接使用静态成员
      • 当在类的外部定义静态成员时,不能重复static关键字,该关键字只出现在类内部的声明语句
    • 一般来说,由于静态数据成员不属于类的任何一个对象,所以我们不能在类的内部初始化静态成员,相反,必须在类的外部定义和初始化每个静态成员
      • 我们可以为静态成员提供const整数类型的类内初始值,不过要求静态成员必须是字面值常量类型的constexpr(见例子一)
    //例子一:静态成员的类内初始化
    class Account{
        public:
            static double rate() { return interestRate; }
            static void rate(double);
        private:
            static constexpr int period=30;         //period是常量表达式
            double daily_tbl[period];
    };
    
    constexpr int Account::period;                  //初始值在类的定义内提供
    
    
    展开全文
  • static存储方式修饰符

    2011-07-17 12:02:45
    static既可以修饰数据成员,也可以修饰成员方法,表明所修饰的对象是静态的,可以被类的所有对象共享。也就是说它不依赖于特定的实例。static可以在任何对象被创建之前访问,无需任何对象引用。因此不能在其他类中...

    static修饰的变量或方法称为类变量或类方法,表明所修饰的对象是静态的,可以被类的所有对象共享。。没有被static修饰的变量则是实例变量,即在引用之前,需要被实例化。static可以在任何对象被创建之前访问,无需任何对象引用。

    1. 实例变量和类变量(静态变量)

    静态变量仅在生成第一个对象时分配内存,所有实例对象共享同一个静态变量。静态变量可以通过类名直接访问,而无须先生成一个实例对象,也可以通过实例对象访问类变量。

    实例变量:每个对象的实例变量都需要分配单独的内存,通过该对象来访问这些实例变量,不同的实例变量是不同的。

    2.实例方法和类方法(静态方法)

    实例方法可以对当前对象的实例变量进行操作,也可以对类变量进行操作,实例方法由实例对象调用。

          但是类方法不能访问实例变量,只能访问类变量。类方法可以有类名直接调用,也可以由实例对象进行调用。类方法中不能使用this 或super 关键字。


    在创建对象sumcat的过程中,先在stack空间创建对象引用sumcat,然后在heap区new一个Test内存区,里面有cat和number2。然后把number1++的值赋给number2=3,然后number1+1=4。在summouse调用number1时,number1即为4。

    如果number1不是static变量,则会在每个实例化对象分配的heap空间内都有不同的值,即在sumcat和summouse内,number1的值都为3。


    例如

    public class Test {

            private String cat;

            private static int number1 = 0;

            int number2;

            Test(String cat){

                    this.cat = cat;

                    number2 = number1++;

               }

             public void info(){

                System.out.println("There are "+number2+" "+cat+".");

            }

         public static void main(String args[]){

               Test.number1 = 3;

               Test sumcat = new Test("cats");

               Test summouse = new Test("mice");

               sumcat.info();

               summouse.info();

           }

    }

    输出:

    There are 3 cats.
    There are 4 mice.

    展开全文
  • 本文讲解了创建类、实例化类、类属性、特殊方法内建属性、静态变量属性、实例变量属性、方法...python的属性与Java和C++等面向对象语言不同,python的属性包括了数据成员还包括函数元素,通过句点符号来访问。 特...
  • 【05-面向对象(下)】

    2018-07-03 21:42:31
    于类成员,类Field可通过类来访问,也可以通过类的对象来访问。当通过对象来访问类属性时,系统会在底 层转换为通过该类来访问类 属性。 类成员规则 •类成员并不是属于实例,它是属于类本身的。只要...
  • 新手学习C++入门资料

    2008-12-28 23:58:50
    输入和输出是通过C++类实现的,cin和cout是这些类的实例,他们是在C++语言的外部实现。 在C++语言中,有了一种新的注释方法,就是‘//’,在该行//后的所有说明都被编译器认为是注释,这种注释不能换行。C++中...
  • 上面这三类代码都是获取string类型的Type,在取出string类型的Type引用t后,我们就可以通过t探测string类型的结构了。 string n = "grayworm"; Type t = n.GetType(); foreach (MemberInfo mi in t.GetMembers...
  • protected : 保护成员,该类内部和继承类中可以访问。 public : 公共成员,完全公开,没有访问限制。 internal: 在同一命名空间内可以访问。 2 .列举ASP.NET 页面之间传递值的几种方式。 答. 1.使用QueryString,...
  • 客户通过容器来访问真正的EJB组件。 24、Static Nested Class 和 Inner Class的不同。 Static Nested Class是被声明为静态(static)的内部类,它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类...
  • 什么是VLAN

    2013-10-23 09:59:12
    网络管理员可以通过配置VLAN之间的路由全面管理企业内部不同管理单元之间的信息互访。交换机是根据交换机的端口划分VLAN的。所以,用户可以自由的在企业网络中移动办公,不论他在何处接入交换网络,他都可以与...
  • c#学习笔记.txt

    2008-12-15 14:01:21
    结构与类很相似,都表示可以包含数据成员和函数成员的数据结构。与类不同的是,结构是值类型并且不需要堆分配。结构类型的变量直接包含结构的数据,而类类型的变量包含对数据的引用(该变量称为对象)。 struct 类型...
  • java 面试题 总结

    2009-09-16 08:45:34
    客户通过容器来访问真正的EJB组件。 21、Static Nested Class 和 Inner Class的不同。 Static Nested Class是被声明为静态(static)的内部类,它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例...
  • 还将学习友元函数,这些函数可以访问外部世界不可访问的类数据。同时还将了解一些构造函数和重 载操作符成员函数是如何被用来管理类的类型转换的。 第12章:类和动态内存分配 一般来说,让类成员指向动态分配的...
  • 面向对象的编程语言将客观事物看作具有属性和行为的对象,通过抽象找出同一类对象的共同属性(静态特征)和行为(动态特征),形成类。通过类的继承与多态可以很方便地实现代码重用,大大缩短了软件开发周期,并使得...
  • 还将学习友元函数,这些函数可以访问外部世界不可访问的类数据。同时还将了解一些构造函数和重 载操作符成员函数是如何被用来管理类的类型转换的。 第12章:类和动态内存分配 一般来说,让类成员指向动态分配的...
  • IIS6.0 IIS,互联网信息服务

    热门讨论 2010-08-23 21:20:55
    当按上步的方法建立好所有的Web站点后,对于做虚拟主机,可以通过给各Web站点设不同的端口号实现,比如给一个Web站点设为80,一个设为81,一个设为82……,则对于端口号是80的Web站点,访问格式仍然直接是IP地址就...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    11.3 静态和非静态的方法.129 11.4 方法的重载.130 11.5 操作符重载.134 11.6 小 结.137 第十二章 域 和 属 性 .139 12.1 域 .139 12.2 属 性 .143 12.3 小 结 .146 第十三章 事件和索引指示器 .148 ...
  • PT80-NEAT开发指南v1.1

    2014-06-24 18:38:34
    移动数据终端 版本记录 版本号 版本描述 发布日期 V 1.0 初始版本。 2012-04-12 V1.1 修改前三章内容 2012-09-25 目录 第一章 关于本手册...........................................................................
  • 还将学习友元函数,这些函数可以访问外部世界不可访问的类数据。同时还将了解一些构造函数和重 载操作符成员函数是如何被用来管理类的类型转换的。 第12章:类和动态内存分配 一般来说,让类成员指向动态分配的...
  • 还将学习友元函数,这些函数可以访问外部世界不可访问的类数据。同时还将了解一些构造函数和重 载操作符成员函数是如何被用来管理类的类型转换的。 第12章:类和动态内存分配 一般来说,让类成员指向动态分配的...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    如果要按照键值保存或者访问数据,使用什么数据结构? 要掌握Collection相关的接口和类的使用 56.使用StringBuffer类与String类进行字符串连接时有何区别? 57.调用Thread类的destroy()方法有什么后果? 58.多...
  • C#微软培训资料

    2014-01-22 14:10:17
    11.3 静态和非静态的方法.129 11.4 方法的重载.130 11.5 操作符重载.134 11.6 小 结.137 第十二章 域 和 属 性 .139 12.1 域 .139 12.2 属 性 .143 12.3 小 结 .146 第十三章 事件和索引指示器 .148 ...
  • 21天学通C++ (中文第五版)

    热门讨论 2010-06-23 16:57:03
    8.7 访问数据成员 8.8 在自由存储区中创建成员数据 8.9 this指针 8.10 迷途指针 8.11 使用const指针 8.11.1 const指针和const成员函数 8.11.2 使用const this指针 8.12 小结 8.13 问与答 8.14 作业 8.14.1...

空空如也

空空如也

1 2 3
收藏数 49
精华内容 19
关键字:

来访问静态数据成员既可以通过