精华内容
下载资源
问答
  • 题目:下列关于构造方法的叙述中,错误的是( ) A.Java语言规定构造方法名与类名必须相同 B.Java语言规定构造方法没有返回值,但不用void声明 C.Java语言规定构造方法不可以重载 D.Java语言规定构造方法只能通过...

    题目:下列关于构造方法的叙述中,错误的是( )

    A.Java语言规定构造方法名与类名必须相同

    B.Java语言规定构造方法没有返回值,但不用void声明

    C.Java语言规定构造方法不可以重载

    D.Java语言规定构造方法只能通过new自动调用

    结果:C

    解释:

    本题考查的是构造方法的使用。在Java语言中,构造方法是一种特殊的方法,是为对象初始化操作编写的方法,用它来定义对象的初始状态。Java中的每个类都有构造方法,如果你没要看到,那说明这是隐式声明的无参构造,它也是由方法名、参数和方法体组成的。构造方法有如下特点:

    • 构造方法的名字必须与类名相同。
    • 构造方法不返回任何数据,但不用void来声明。
    • 用户不能直接调用构造方法,必须通过关键字new自动调用,无论是直接新建对象,还是通过反射、克隆等新建对象都需要调用构造方法,但是都不是我们去调用的构造方法
    • 在构造方法实现中,可以进行方法重载,即定义多个构造方法。重载构造方法的目的是使类具有不同的初始值,为类对象的初始化提供方便。

    根据上述构造方法的特点可知,C项错误

    展开全文
  • 一、单选题 2-1在类的定义中,用于为对象分配内存空间,对类的数据成员进行初始化并执行其他内部...2-4下列关于类和对象的叙述中,错误的是 A A 一个类只能有一个对象 B 对象是类的具体实例 C 类是对某一类对象的抽象

    一、单选题
    2-1在类的定义中,用于为对象分配内存空间,对类的数据成员进行初始化并执行其他内部管理操作的函数是 C
    A 友元函数
    B 虚函数
    C 构造函数
    D 析构函数

    2-2类的析构函数的作用是 D
    A 一般成员函数的初始化
    B 类的初始化
    C 对象的初始化
    D 删除类创建的对象

    2-3下列函数中,( C )不能重载。
    A 成员函数
    B 非成员函数
    C 析构函数
    D 构造函数

    2-4下列关于类和对象的叙述中,错误的是 A
    A 一个类只能有一个对象
    B 对象是类的具体实例
    C 类是对某一类对象的抽象
    D 类和对象的关系是一种数据类型与变量的关系

    2-5下列属于类的析构函数特征的是 A
    A 一个类中只能定义一个析构函数
    B 析构函数名与类名不同
    C 析构函数的定义只能在类体内
    D 析构函数可以有一个或多个参数

    2-6下列关于类定义的说法中,正确的是 A
    A 类定义中包括数据成员和函数成员的声明
    B 类成员的缺省访问权限是保护的
    C 数据成员必须被声明为私有的
    D 成员函数只能在类体外进行定义

    2-7假设MyClass是一个类,则该类的拷贝初始化构造函数的声明语句为( ) C
    A MyClass&(MyClass x);
    B MyClass(MyClass x);
    C MyClass(MyClass &x);
    D MyClass(MyClass *x);

    2-8下列关于类的构造函数的描述中,错误的是 D
    A 类的构造函数可以重载
    B 类可以没有构造函数
    C 类的构造函数可以缺省
    D 类的构造函数可以作为其它类型向本类类型进行转换的函数
    此答案报错

    2-9下列对重载函数的描述中,( A )是错误的。
    A 重载函数中不允许使用默认参数
    B 重载函数中编译根据参数表进行选择
    C 不要使用重载函数来描述毫无相干的函数
    D 构造函数重载将会给初始化带来多种方式

    2-10建立一个类对象时,系统自动调用 A
    A 构造函数
    B 析构函数
    C 友元函数
    D 成员函数

    2-11下面程序的运行结果为 C

    #include<iostream.h>
    class A
    {
    public:    
       A(){cout<<"1";}
       ~A(){cout<<"2";}
    };
    class B:public A
    {
    public:
         B(){cout<<"3";}
         ~B(){cout<<"4";}
    };
    void main()
    {  B b; }
    

    A 1234
    B 1324
    C 1342
    D 3142

    2-12类的析构函数是在什么时候调用的? C
    A 类创建时
    B 创建对象时
    C 删除对象时
    D 不自动调用

    2-13 C++提供的可有效分配对象空间的运算符是( ) B

    A delete
    B new
    C pos
    D auto

    2-14对于任意一个类,析构函数的个数最多为( ) B
    A 0
    B 1
    C 2
    D 3

    二、函数题
    6-1 实现数组类(C++ 拷贝构造函数、拷贝函数) (10分)
    裁判测试程序样例中展示的是一段实现“数组类”的代码,其中缺失了部分代码,请补充完整,以保证测试程序正常运行。

    函数接口定义:

    提示:要想程序正确运行,至少需要补充以下函数(可能还需要补充其他函数):
    1. 带参构造函数
    2. 拷贝构造函数
    3. 拷贝函数(赋值运算符重载)
    

    裁判测试程序样例:

    #include <iostream>
    using namespace std;
    class ArrayIndexOutOfBoundsException{  // 异常类
    public:
        int index;
        ArrayIndexOutOfBoundsException(int k){
            index = k;
        }
    };
    class Array{
    private:
        int *data;
        int size;
        static const int dSize = 10;   // 数组默认大小
    public:
        Array( ){  // 无参构造
            size = dSize;
            data = new int[size]( );
        }
    		
    /** 你提交的代码将被嵌在这里(替换本行内容) **/		
    		
        int& operator [] (int k){     // 运算符 [ ] 重载,以方便数组的使用
            if(k<0 || k>=size) throw ArrayIndexOutOfBoundsException(k);
            return data[k];
        }
        friend ostream& operator << (ostream& o, const Array& a);   // 运算符 << 重载,以方便输出
    };
    ostream& operator << (ostream& o, const Array& a){
        o << '[' ;
        for(int i=0; i<a.size-1; i++)
            o << a.data[i] << ',' ;
        o << a.data[a.size-1] << ']';
        return o;
    }
    // 注意:实际测试程序中,在此处之前的代码与样例中相同
    // 注意:实际测试程序中,在此处之后的代码(即main函数)可能与样例中不同
    int main(){
        int n, k;
        cin >> n >> k;
        Array a(n);  // 构造数组,大小为 n
        for(int i=0; i<n; i++) a[i] = i;
        Array b = a;  // 拷贝构造数组
        b[n/2] = k;
        cout << a << endl;
        cout << b << endl;
        Array c;  // 构造数组,默认大小
        c = a; // 拷贝数组
        c[n/2] = k;
        cout << a << endl;
        cout << c << endl;
        a = a;
        a[n/2] = 2223;
        cout << a << endl;
        return 0;
    }
    

    输入样例:

    15 666
    

    输出样例:

    [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
    [0,1,2,3,4,5,6,666,8,9,10,11,12,13,14]
    [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
    [0,1,2,3,4,5,6,666,8,9,10,11,12,13,14]
    [0,1,2,3,4,5,6,2223,8,9,10,11,12,13,14]
    
    Array(int n) 
    {
        size = n;
        data = new int[size]();
    }
    Array(const Array& a) 
    {
        size = a.size;
        data = new int[size];
        for (int i = 0; i < size; i++) 
        {
            data[i] = a.data[i];
        }
    }
    ~Array() 
    {
        delete[] data;
    }
    Array& operator=(const Array& a) 
    {
        if (a.size != size) 
        {
            delete[] data;
            size = a.size;
            data = new int[size];
        }
        for (int i = 0; i < size; i++) 
        {
            data[i] = a.data[i];
        }
        return *this;
    }
    
    展开全文
  • 近期在网上搜寻了一下关于C++派生构造函数的调用... Lippman的>一书(主要是其中5.2节“继承体系下的对象构造”的叙述),对于一个派生的构造函数,其中包含了基类构造、成员构造自定义的代码等部分(忽略与本

        近期在网上搜寻了一下关于C++派生类构造函数的调用问题,大部分博文给出的顺序是:

    1、基类构造

    2、成员构造

    3、派生构造。

    这个顺序严格来讲是错误的,对新手极具误导性!


        依据侯捷翻译的Stanley B. Lippman的<<深度探索C++对象模型>>一书(主要是其中5.2节“继承体系下的对象构造”的叙述),对于一个派生类的构造函数,其中包含了基类构造、成员构造和自定义的代码等部分(忽略与本讨论不太相关的this指针、虚函数表指针等),其代码安排顺序为:

    1、(虚继承的)基类构造

    2、(普通继承的)基类构造

    3、设定虚表指针

    4、成员构造

    5、自己写的代码


    真正生成的派生类的构造函数的形式如下:(忽略关于this指针、虚函数表指针的代码)

    //CDerive为派生类,CVBase为虚继承的基类,CBase为基类,member为CMember类型的成员

    CDerive::CDerive()

    {

        CVBase::CVBase();

        CBase::CBase();

        member.CMember::CMember();

        //自己的代码

    }


    由此可以看出,基类构造的调用是在派生构造之中而不是之后,派生构造的调用与基类构造的调用是包含关系而不是先后关系。对“函数调用”的理解通常是:跳转到函数入口地址并执行其后的代码,若以此说来,真正的调用顺序为:

    1、派生构造

    2、基类构造

    3、成员构造


    经调试,实际的代码执行结果符合Lippman的描述,函数调用的堆栈顺序:

    1、派生构造进入

    2、基类构造进入

    3、基类构造返回

    4、成员构造进入

    5、成员构造返回

    6、派生构造返回


    下面贴几张调试时的图片:(OS: Win7x64  IDE: VS2010)


    继承关系如图


    1、首先进入派生类构造函数的断点


    2、进入了虚继承的基类构造的断点。按照继承时的顺序,CVBase在CBase之后的,但因为是虚继承所以先执行它的构造


    3、执行完CVBase的构造后接着执行CBase的构造


    4、最后执行CInner的构造


    5、后面将执行CDerive构造中自己写的代码了,但调试时忘了给这一步截图,这里也就没图可贴了 0.0~



    展开全文
  • 面向对象程序设计C++期末考试试卷 一选择题(每小题 3 分共 48 分) ...02下列关于类和对象的叙述错误的是( ) A)一个类只能有一个对象 B)对象是类的具体实例 C)类是对某一类对象的抽象 D)类和对象的关系是一种数据类型
  • 面向对象程序设计 C++期末考试试卷 一选择题 ( 每小题 3 分共 48 分 ) 01下列关于 C++函数的...02下列关于类和对象的叙述错误的是 ( ) A) 一个类只能有一个对象 B) 对象是类的具体实例 C) 类是对某一类对象的抽象 D)
  • 答案为博主本人自作或查询,仅供参考 2-1 ...下列关于类和对象的叙述中,错误的是 一个类只能有一个对象 对象是类的具体实例 类是对某一类对象的抽象 类和对象的关系是一种数据类型与变量的关系 2-5

    答案为博主本人自作或查询,仅供参考

    2-1
    在类的定义中,用于为对象分配内存空间,对类的数据成员进行初始化并执行其他内部管理操作的函数是

    友元函数
    虚函数
    构造函数
    析构函数

    2-2
    类的析构函数的作用是

    一般成员函数的初始化
    类的初始化
    对象的初始化
    删除类创建的对象

    2-3
    下列函数中,( )不能重载。

    成员函数
    非成员函数
    析构函数
    构造函数

    2-4
    下列关于类和对象的叙述中,错误的是

    一个类只能有一个对象
    对象是类的具体实例
    类是对某一类对象的抽象
    类和对象的关系是一种数据类型与变量的关系

    2-5
    下列属于类的析构函数特征的是

    一个类中只能定义一个析构函数
    析构函数名与类名不同
    析构函数的定义只能在类体内
    析构函数可以有一个或多个参数

    2-6
    下列关于类定义的说法中,正确的是

    类定义中包括数据成员和函数成员的声明
    类成员的缺省访问权限是保护的
    数据成员必须被声明为私有的
    成员函数只能在类体外进行定义

    2-7
    假设MyClass是一个类,则该类的拷贝初始化构造函数的声明语句为( )

    MyClass&(MyClass x);
    MyClass(MyClass x);
    MyClass(MyClass &x);
    MyClass(MyClass *x);

    2-8
    下列关于类的构造函数的描述中,错误的是

    类的构造函数可以重载
    类可以没有构造函数
    类的构造函数可以缺省
    类的构造函数可以作为其它类型向本类类型进行转换的函数

    2-9
    下列对重载函数的描述中,( )是错误的。

    重载函数中不允许使用默认参数
    重载函数中编译根据参数表进行选择
    不要使用重载函数来描述毫无相干的函数
    构造函数重载将会给初始化带来多种方式

    2-10
    建立一个类对象时,系统自动调用

    构造函数
    析构函数
    友元函数
    成员函数

    2-11
    下面程序的运行结果为

    #include<iostream.h>
    class A
    {
    public:    
       A(){cout<<"1";}
       ~A(){cout<<"2";}
    };
    class B:public A
    {
    public:
         B(){cout<<"3";}
         ~B(){cout<<"4";}
    };
    

    void main()
    { B b; }
    1234
    1324
    1342
    3142

    2-12
    类的析构函数是在什么时候调用的?

    类创建时
    创建对象时
    删除对象时
    不自动调用

    2-13
    C++提供的可有效分配对象空间的运算符是( )

    delete
    new
    pos
    auto

    2-14
    对于任意一个类,析构函数的个数最多为( )

    0
    *1
    2
    3

    6-1 实现数组类(C++ 拷贝构造函数、拷贝函数) (10分)
    裁判测试程序样例中展示的是一段实现“数组类”的代码,其中缺失了部分代码,请补充完整,以保证测试程序正常运行。

    函数接口定义:
    提示:要想程序正确运行,至少需要补充以下函数(可能还需要补充其他函数):
    1. 带参构造函数
    2. 拷贝构造函数
    3. 拷贝函数(赋值运算符重载)

    裁判测试程序样例:

    #include <iostream>
    using namespace std;
    class ArrayIndexOutOfBoundsException{  // 异常类
    public:
        int index;
        ArrayIndexOutOfBoundsException(int k){
            index = k;
        }
    };
    class Array{
    private:
        int *data;
        int size;
        static const int dSize = 10;   // 数组默认大小
    public:
        Array( ){  // 无参构造
            size = dSize;
            data = new int[size]( );
        }
    		
    /** 你提交的代码将被嵌在这里(替换本行内容) **/		
    		
        int& operator [] (int k){     // 运算符 [ ] 重载,以方便数组的使用
            if(k<0 || k>=size) throw ArrayIndexOutOfBoundsException(k);
            return data[k];
        }
        friend ostream& operator << (ostream& o, const Array& a);   // 运算符 << 重载,以方便输出
    };
    ostream& operator << (ostream& o, const Array& a){
        o << '[' ;
        for(int i=0; i<a.size-1; i++)
            o << a.data[i] << ',' ;
        o << a.data[a.size-1] << ']';
        return o;
    }
    // 注意:实际测试程序中,在此处之前的代码与样例中相同
    // 注意:实际测试程序中,在此处之后的代码(即main函数)可能与样例中不同
    int main(){
        int n, k;
        cin >> n >> k;
        Array a(n);  // 构造数组,大小为 n
        for(int i=0; i<n; i++) a[i] = i;
        Array b = a;  // 拷贝构造数组
        b[n/2] = k;
        cout << a << endl;
        cout << b << endl;
        Array c;  // 构造数组,默认大小
        c = a; // 拷贝数组
        c[n/2] = k;
        cout << a << endl;
        cout << c << endl;
        a = a;
        a[n/2] = 2223;
        cout << a << endl;
        return 0;
    }
    

    输入样例:
    15 666
    输出样例:
    [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
    [0,1,2,3,4,5,6,666,8,9,10,11,12,13,14]
    [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
    [0,1,2,3,4,5,6,666,8,9,10,11,12,13,14]
    [0,1,2,3,4,5,6,2223,8,9,10,11,12,13,14]

    答案

    #include <iostream>
    using namespace std;
    class ArrayIndexOutOfBoundsException {  // 异常类
    public:
        int index;
        ArrayIndexOutOfBoundsException(int k) {
            index = k;
        }
    };
    class Array {
    private:
        int* data;
        int size;
        static const int dSize = 10;   // 数组默认大小
    public:
        Array() {  // 无参构造
            size = dSize;
            data = new int[size]();
        }
    
        Array(int n)
        {
            size = n;
            data = new int[size]();
        }
        Array(const Array& a)
        {
            size = a.size;
            data = new int[size]();
            for (int i = 0; i < size; i++)
            {
                data[i] = a.data[i];
            }
        }
        Array& operator=(const Array& a)//重载“=”,便于类对象的data数组赋值
        {
            if (a.size != size)
            {
                delete[]data;
                size = a.size;
                data = new int[size];
            }
            for (int i = 0; i < size; i++)
            {
                data[i] = a.data[i];
            }
            return *this; //this指针返回本函数本身的Array
        }
        ~Array()
        {
            delete[]data;//写析构函数是个好习惯,节约内存
        }
        int& operator [] (int k) {     // 运算符 [ ] 重载,以方便数组的使用
            if (k < 0 || k >= size) throw ArrayIndexOutOfBoundsException(k);
            return data[k];
        }
        friend ostream& operator << (ostream& o, const Array& a);   // 运算符 << 重载,以方便输出
    };
    ostream& operator << (ostream& o, const Array& a) {
        o << '[';
        for (int i = 0; i < a.size - 1; i++)
            o << a.data[i] << ',';
        o << a.data[a.size - 1] << ']';
        return o;
    }
    // 注意:实际测试程序中,在此处之前的代码与样例中相同
    // 注意:实际测试程序中,在此处之后的代码(即main函数)可能与样例中不同
    int main() {
        int n, k;
        cin >> n >> k;
        Array a(n);  // 构造数组,大小为 n
        for (int i = 0; i < n; i++) a[i] = i;
        Array b = a;  // 拷贝构造数组
        b[n / 2] = k;
        cout << a << endl;
        cout << b << endl;
        Array c;  // 构造数组,默认大小
        c = a; // 拷贝数组
        c[n / 2] = k;
        cout << a << endl;
        cout << c << endl;
        a = a;
        a[n / 2] = 2223;
        cout << a << endl;
        return 0;
    }
    
    展开全文
  • 1. 以下关于面向对象设计的叙述中,错误的是(1)。 A. 的属性用于封装数据,的方法用于封装行为 B. 面向对象设计的基本思想包括抽象、封装可扩展性 C. 对象继承多态可用来实现可扩展性 D. 对象持久化是...
  • 程序的功能 参考答案B 使用白盒测试方法时确定测试数据应根据程序的内部逻辑指定的覆盖标准 第2题 在面向对象软件的集成测试中下列关于基干集成的叙述错误的是( ) A.基干测试最大的优点是无须设
  • c++试题

    2014-10-18 19:43:01
    山东理工大学2012--2013年 《面向对象程序设计C++》期末考试试卷   ... 一、选择题(每小题3分,共48分。...01、下列关于C++函数的叙述中,正确的是( C )。...02、下列关于类和对象的叙述中,错误的是
  • Java错题集(十五)

    2021-02-19 10:18:34
    下列叙述错误的是() 在java7中,下列不能做switch()的参数类型是? volatile关键字的说法错误的是 有如下一段代码,请选择其运行结果() 在hibernate开发中,关于POJO类对象的状态说法正确的是()。...
  • flash shiti

    2014-03-14 10:32:41
    25.Flash锁定编辑对象的快捷操作是? A. Ctrl+Down B. Ctrl+Shift+Down C. Ctrl+Alt+L D. Ctrl+Alt+Shift+L 26.放大显示比例可使用什麽方式? A. 点选式 B. 框选式 C. 鼠标式 D. AB都正确 27.以下不是...
  • HND pentest

    2016-09-20 00:20:31
    关于动态联编的下列叙述中, ______ 是错误的。 A.动态联编是以虚函数为基础的 B.动态联编调用虚函数操作是指向对象的指针或引用 C.动态联编是在运行时确定所调用的函数代码的 D.动态联编是在编译时确定操作...
  • 牛客网刷题--选择题

    2020-07-26 21:15:25
    1,下面关于构造方法的说法不正确的是() A构造方法也属于的方法,可以创建对象的时候给成员变量赋值 B构造方法不可以重载 C构造方法没有返回值 D构造方法一定要类名相同 解析:B 构造方法是可以重载的 2,...
  • 软考真题练02+编程

    2018-10-10 23:09:04
    2.以下关于面向对象方法中继承的叙述中,错误的是(D)。 A.继承是父类子类之间共享数据方法的机制 B.继承定义了一种类与之间的关系 C.继承关系中的子类将拥有父类的全部属性方法 D.继承仅仅允许单重...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    第九章 面向对象的程序设计 .101 9.1 面向对象的基本概念.101 9.2 对象的模型技术 .103 9.3 面向对象的分析 .105 9.4 面向对象的设计 .107 9.5 小 结 .110 第十章 .112 10.1 的 声 明 .112 ...
  • JAVA复习题及答案

    2019-01-12 17:00:21
    4、对于int a[ ]=new int[3],下列叙述错误的是( )。 A. a.length的值是3 B. a[1]的值是1 C. a[0]的值是0 D. a[a.length-1]的值等于a[2]的值 5、用下列哪个代码替换程序标注的【代码】会导致编译错误? A.m-->0...
  • C#微软培训资料

    2014-01-22 14:10:17
    第九章 面向对象的程序设计 .101 9.1 面向对象的基本概念.101 9.2 对象的模型技术 .103 9.3 面向对象的分析 .105 9.4 面向对象的设计 .107 9.5 小 结 .110 第十章 .112 10.1 的 声 明 .112 ...
  • 15.4.3 类对象的构造与析构 367 15.4.4 typeid扩展的类型信息 368 15.4.5 rtti的使用误用 370 15.5 指向成员的指针 371 15.5.1 基类派生 373 15.6 自由存储 374 15.6.1 数组分配 375 15.6.2 虚构造...
  • 面向对象的开发方法包括面向对象的分析、面向对象的设计面向对象的程序设计。( √) 7. 软件危机的主要表现是软件的需求量迅速增加,软件价格上升。(×) 8. 软件工具的作用是为了延长软件产品的寿命。(×) 9. ...
  • (25) 下面对对象概念描述错误的是(A) 注:P55 A. 任何对象都必须有继承性 B. 对象是属性方法的封装体 C. 对象间的通讯靠消息传递 D. 操作是对象的动态性属性 (26) 下面不属于软件工程的3个要素的是(D) 注:P62 A. ...
  • 15.4.3 类对象的构造与析构 367 15.4.4 typeid扩展的类型信息 368 15.4.5 rtti的使用误用 370 15.5 指向成员的指针 371 15.5.1 基类派生 373 15.6 自由存储 374 15.6.1 数组分配 375 15.6.2 虚构造...
  • C) Java中的封装就是将对象的数据操作数据的方法相结合,通过方法将对象的数据实现细节保护起来。 D) Java语言中的多态的含义可以表达为:对外一个接口,内部多种实现。Java语言支持两种多态:运行时多态编译...
  • C++程序设计语言(特别版)--源代码

    热门讨论 2012-04-23 07:33:51
    15.4.3 类对象的构造与析构 367 15.4.4 typeid扩展的类型信息 368 15.4.5 rtti的使用误用 370 15.5 指向成员的指针 371 15.5.1 基类派生 373 15.6 自由存储 374 15.6.1 数组分配 375 15.6.2 虚构造...
  • Visual C++ 2008入门经典--详细书签版

    热门讨论 2013-02-02 16:07:15
    7.2 数据类型、对象类和实例 293 7.2.1 类起源 294 7.2.2 类操作 295 7.2.3 术语 295 7.3 理解类 295 7.3.1 定义类 296 7.3.2 声明类的对象 296 7.3.3 访问类数据成员 297 7.3.4 类成员函数 299 ...
  • Visual C++ 2005 入门经典 详细书签版

    热门讨论 2013-02-02 16:39:43
    7.2 数据类型、对象类和实例 303 7.2.1 类起源 305 7.2.2 类操作 305 7.2.3 术语 306 7.3 理解类 306 7.3.1 定义类 307 7.3.2 声明类的对象 307 7.3.3 访问类数据成员 308 7.3.4 类成员...
  • 7.2 数据类型、对象类和实例 303 7.2.1 类起源 305 7.2.2 类操作 305 7.2.3 术语 306 7.3 理解类 306 7.3.1 定义类 307 7.3.2 声明类的对象 307 7.3.3 访问类数据成员 308 7.3.4 类成员...
  • 1.下列特点中,哪个是Java 虚拟机执行的特点之一? A、字节代码 B、多进程 C、静态连接 D、编译 2.Java语言的类型是 A、面向对象语言 B、面向过程语言 C、汇编程序 D、...18.下面关于沙箱模型的叙述错误的是
  • 7.2 数据类型、对象类和实例 293 7.2.1 类起源 294 7.2.2 类操作 295 7.2.3 术语 295 7.3 理解类 295 7.3.1 定义类 296 7.3.2 声明类的对象 296 7.3.3 访问类数据成员 297 7.3.4 类成员函数 299 ...
  • (25) 下面对对象概念描述错误的是______。(A) A. 任何对象都必须有继承性 B. 对象是属性方法的封装体 C. 对象间的通讯*消息传递 D. *作是对象的动态性属性 (26) 下面不属于软件工程的3个要素的是______。(D) A. ...
  • 7.2 数据类型、对象类和实例 301 7.2.1 类起源 303 7.2.2 类操作 303 7.2.3 术语 303 7.3 理解类 304 7.3.1 定义类 304 7.3.2 声明类的对象 305 7.3.3 访问类数据成员 305 7.3.4 类成员函数 307 ...

空空如也

空空如也

1 2 3
收藏数 41
精华内容 16
关键字:

关于类和对象的叙述错误的是