精华内容
下载资源
问答
  • C++派生类中如何初始化基类对象

    千次阅读 2018-08-26 16:41:42
    关于派生类中如何初始化基类对象,我在想派生类对于构造函数不都是先构造基类对象,然后在构造子类对象,但是如果我们在成员初始化列表先初始化派生类的私有成员,在函数内去调用基类的构造函数,编译通过吗?...

    C++派生类中如何初始化基类对象

    今天收到盛大的面试,问我一个问题,关于派生类中如何初始化基类对象,我在想派生类对于构造函数不都是先构造基类对象,然后在构造子类对象,但是如果我们在成员初始化列表先初始化派生类的私有成员,在函数内去调用基类的构造函数,能编译通过吗?或者当我们定义了基类的默认构造函数,而没有去在派生类的构造函数中显示的去调用基类的构造函数,会出现什么状况,我想派生类肯定会自动去调用基类的默认构造函数,那么析构函数又怎么样呢?我们都知道派生类的析构函数会先被调用,然后基类的析构函数后被调用,但是我不知道我们是否需要在派生类的析构函数中显示的去调用基类的析构函数吗?这个有待我去验证。

    代码一:在派生类中成员初始化列表先初始化派生类的私有成员,不显示的调用基类的构造函数

     

    #include <iostream>
    using namespace std;
    
    class Base
    {
    private:
        int n;
    
    public:
        Base(int m):n(m){ cout<<"constructor is called\n";}
        ~Base(){}
    };
    
    class Derive:public Base
    {
    private:
        int n;
    
    public:
        Derive(int m):n(m)
        {
        }
        ~Derive(){}
    };
    
    int main()
    {
        Derive* a = new Derive(10);return 0;
    }

     

    结果:编译错误,error C2512: “Base”: 没有合适的默认构造函数可用

     

    代码二:在派生类中成员初始化列表先初始化派生类的私有成员,显示的调用基类的构造函数

     

    #include <iostream>
    using namespace std;
    
    class Base
    {
    private:
        int n;
    
    public:
        Base(){ cout<<"default constructor is called\n"; n = 8;}
        Base(int m):n(m){ cout<<"constructor is called\n";}
        ~Base(){}
    };
    
    class Derive:public Base
    {
    private:
        int n;
    
    public:
        Derive(int m):Base(m),n(m)
        {
        }
        ~Derive(){}
    };
    
    int main()
    {
        Derive* a = new Derive(10);return 0;
    }

     

    运行结果:

     

    代码三:在派生类中成员初始化列表先初始化派生类的私有成员,不显示的调用基类的构造函数,则会调用默认的构造函数

     

    #include <iostream>
    using namespace std;
    
    class Base
    {
    private:
        int n;
    
    public:
        Base(){ cout<<"default constructor is called\n"; n = 8;}
        Base(int m):n(m){ cout<<"constructor is called\n";}
        ~Base(){}
    };
    
    class Derive:public Base
    {
    private:
        int n;
    
    public:
        Derive(int m):n(m)
        {
        }
        ~Derive(){}
    };
    
    int main()
    {
        Derive* a = new Derive(10);
        return 0;
    }

     

    运行结果:

     

    代码四:派生类析构函数的调用过程中会不会自动去调用基类的析构函数呢?答案是,肯定的,所以千万不要在派生类的析构函数中再去调用基类的析构函数,这种去释放已经释放的内存,系统是不允许的。

     

    #include <iostream>
    using namespace std;
    
    class Base
    {
    private:
        int n;
    
    public:
        Base(){ cout<<"default constructor is called\n"; n = 8;}
        Base(int m):n(m){ cout<<"constructor is called\n";}
        ~Base(){ cout<<"Base distructor is called\n"; }
    };
    
    class Derive:public Base
    {
    private:
        int n;
    
    public:
        Derive(int m):Base(m),n(m)
        {
        }
        ~Derive(){ cout<<"Derive distructor is called\n"; }
    };
    
    int main()
    {
        Derive* a = new Derive(10);
        delete a;
        return 0;
    }

     

    运行结果:

     

    代码5:如果我们去试试在派生类的析构函数中去调用基类的析构函数,看看结果如何?当我想这么做的时候,我突然发现这个代码我写出来,因为我们都知道,对于C++的一个对象要么将对象分配在栈中,要么将对象分配在堆中,而对于分配在栈中的对象我们过程结束后,自动调用类的析构函数,而分配在堆中的对象,得我们去delete,但是你必须拿到指向对象在堆中内存的句柄,也就是指针,但是我发现不可能拿得到,除非你在派生类的构造函数中去new基类对象,但是又有个问题,在派生类构造函数中去new出这个基类对象,那么基类对象是派生类的局部变量,还是派生类继承而来的呢?我发现肯定是派生类的局部变量,那么也就是说,如果new出一个派生类对象,那么派生类本身的私有成员是在堆中,而继承而来的属性,也就是基类的东西分配的栈中,好吧,这样,难道派生对象在内存上竟然不是连续的?

     

    #include <iostream>
    using namespace std;
    
    class Base
    {
    private:
        int n;
    
    public:
        Base(){ cout<<"default constructor is called\n"; n = 8;}
        Base(int m):n(m){ cout<<"constructor is called\n";}
        ~Base(){ cout<<"Base distructor is called\n"; }
    };
    
    class Derive:public Base
    {
    private:
        int n;
    
    public:
        Derive(int m):Base(m),n(m)  // 在这里构造继承属性,即派生类的基类部分
        {
            new Base(m);    //这个仅仅在派生类中创建了一个基类的变量而已
        }
        ~Derive(){ cout<<"Derive distructor is called\n"; }
    };
    
    int main()
    {
        Derive* a = new Derive(10);
        delete a;
        return 0;
    }

     

    运行结果如下:

    构造两次基类,一次构造派生类中的基类成分,还有一次仅仅是派生类的变量而已。同时析构派生类,自动调用基类析构函数。

     

    代码六:在派生类构造函数中用new分配一个基类对象,然后析构掉,在main函数中去调用基类的成员函数,发现仍可调度,说明在派生类构造函数中用new分配基类对象,不是派生类的基类成分。

     

     

    #include <iostream>
    using namespace std;
    
    class Base
    {
    private:
        int n;
    
    public:
        Base(){ cout<<"default constructor is called\n"; n = 8;}
        Base(int m):n(m){ cout<<"constructor is called\n";}
        void get(){ cout<<"get() is called\n"; }
        ~Base(){ cout<<"Base distructor is called\n"; }
    };
    
    class Derive:public Base
    {
    private:
        int n;
    
    public:
        Derive(int m):Base(m),n(m)  // 在这里构造继承属性,即派生类的基类部分
        {
            Base* a =new Base(m);    //这个仅仅在派生类中创建了一个基类的变量而已
            delete a;
        }
        ~Derive(){ cout<<"Derive distructor is called\n"; }
    };
    
    int main()
    {
        Derive* a = new Derive(10);
        a->get();
        delete a;
        return 0;
    }

     

    运行如下:

     

    下面我就有一个疑问了,派生类中只能将基类成分分配在栈中吗?而如果去new出派生类对象,那么岂不内存不连续了,这是个问题?我验证了一下,与我的想法并非一致,内存还是连续的。只不过在派生类构造基类的过程中(new出派生类方式),只是在堆中去分配基类的成分,虽然使用非new来创建基类对象。

    代码如下:

     

    #include <iostream>
    using namespace std;
    
    class Base
    {
    public:
        int n;
    
    public:
        Base(){ cout<<"default constructor is called\n"; n = 8;}
        Base(int m):n(m){ cout<<"constructor is called\n";}
        void get(){ cout<<"get() is called\n"; }
        ~Base(){ cout<<"Base distructor is called\n"; }
    };
    
    class Derive:public Base
    {
    private:
        int n;
    
    public:
        Derive(int m):Base(m),n(m)  // 在这里构造继承属性,即派生类的基类部分
        {
            cout<<"Base address: "<<&(Base::n)<<endl;  //地址
            cout<<"Derive address: "<<&n<<endl;   //地址
        }
        ~Derive(){ cout<<"Derive distructor is called\n"; }
    };
    
    int main()
    {
        Derive* a = new Derive(10);
        delete a;
        return 0;
    }

     

    运行结果如下:

    以上可以看出地址连续,说明派生类中基类成分和派生类成分地址是连续的。

    展开全文
  • 命名空间System.Collections.Generic中有两个非常重要,而且常用的泛型集合类,它们分别是Dictionary字典和List列表。Dictionary字典通常用于...下面来总结一下,用代码来演示怎么初始化,增加,修改,删除和遍历元素。

    命名空间System.Collections.Generic中有两个非常重要,而且常用的泛型集合类,它们分别是Dictionary<TKey,TValue>字典和List<T>列表。Dictionary字典通常用于保存键/值对的数据,而List列表通中用于保存可通过索引访问的对象的强类型列表。下面来总结一下,用代码来演示怎么初始化,增加,修改,删除和遍历元素。

    namespace DictionaryDemo1
    {
        class Program
        {
            static void Main(string[] args)
            {
                //创建Dictionary<TKey,TValue>对象
                Dictionary<string, string> openWith = new Dictionary<string, string>();
    
                //添加元素到对象中,共有两种方法。注意,字典中的键不可以重复,但值可以重复。
                //方法一:使用对象的Add()方法
                openWith.Add("txt", "notepad.exe");
                openWith.Add("bmp", "paint.exe");
                openWith.Add("dib", "paint.exe");
                openWith.Add("rtf", "wordpad.exe");
    
                //方法二:使用索引器Indexer
                //openWith["txt"] = "notepad.exe";
                //openWith["bmp"] = "paint.exe";
                //openWith["dib"] = "paint.exe";
                //openWith["rtf"] = "wordpad.exe";
    
                //增加元素,注意增加前必须检查要增加的键是否存在使用ContainsKey()方法
                if (!openWith.ContainsKey("ht"))
                {
                    openWith.Add("ht", "hypertrm.exe");//或openWith["ht"] = "hypertrm.exe";
                    Console.WriteLine("增加元素成功!Key={0},Value={1}","ht",openWith["ht"]);
                }
    
                //删除元素,使用Remove()方法
                if (openWith.ContainsKey("rtf"))
                {
                    openWith.Remove("rtf");
                    Console.WriteLine("删除元素成功!键为rtf");
                }
    
                if (!openWith.ContainsKey("rtf"))
                {
                    Console.WriteLine("Key=\"rtf\"的元素找不到!");
                }
    
                //修改元素,使用索引器
                if (openWith.ContainsKey("txt"))
                {
                    openWith["txt"] = "notepadUpdate.exe";
                    Console.WriteLine("修改元素成功!Key={0},Value={1}", "txt", openWith["txt"]);
                }
    
                //遍历元素,因为该类实现了IEnumerable接口,所以可以使用foreach语句,注意元素类型是 KeyValuePair(Of TKey, TValue)
                foreach (KeyValuePair<string, string> kvp in openWith)
                {
                    Console.WriteLine("Key={0},Value={1}",kvp.Key,kvp.Value);
                }
    
                Console.WriteLine("遍历元素完成!");
                Console.ReadKey();
            }
        }
    }

      程序输出结果:

    C# Dictionary 的几种遍历方法

    网上看到的,记录下来,供参考,备忘

    Dictionary<string, int> list = new Dictionary<string, int>();

     

                list.Add("d", 1);

     

                //3.0以上版本

                foreach (var item in list)

                {

                    Console.WriteLine(item.Key + item.Value);

                }

                //KeyValuePair<T,K>

                foreach (KeyValuePair<string, int> kv in list)

                {

                    Console.WriteLine(kv.Key + kv.Value);

                }

                //过键的集合取

                foreach (string key in list.Keys)

                {

                    Console.WriteLine(key + list[key]);

                }

                //直接取值

                foreach (int val in list.Values)

                {

                    Console.WriteLine(val);

                } 

                //非要采用for的方法也可

                List<string> test = new List<string>(list.Keys);

     

                for (int i = 0; i < list.Count; i++)

                {

                    Console.WriteLine(test[i] + list[test[i]]);

                }

    Dictionary( TKey , TValue )

     

    表示键和值的集合。

     

    Dictionary( TKey, TValue) 泛型类提供了从一组键到一组值的映射。字典中的每个添加项都由一个值及其相关联的键组成。通过键来检索值的速度是非常快的,接近于 O(1),这是因为 Dictionary( TKey, TValue) 类是作为一个哈希表来实现的。(检索速度取决于为 TKey 指定的类型的哈希算法的质量。)

     

     

    只要对象用作 Dictionary( TKey, TValue) 中的键,它就不能以任何影响其哈希值的方式更改。使用字典的相等比较器比较时,Dictionary( TKey, TValue) 中的任何键都必须是唯一的。键不能为 null  但是如果值类型 TValue 为引用类型,该值则可以为空。

     

    Dictionary( TKey, TValue) 需要一个相等实现来确定键是否相等。可以使用一个接受 comparer 参数的构造函数来指定IEqualityComparer( T) ) 泛型接口的实现;如果不指定实现,则使用默认的泛型相等比较器 EqualityComparer( T) ) . Default。如果类型 TKey 实现 System. IEquatable< (Of < ( T> ) > ) 泛型接口,则默认相等比较器会使用该实现。

     

     

     

    Dictionary( TKey, TValue) 的容量是 Dictionary( TKey, TValue) 可以包含的元素数。当向 Dictionary( TKey, TValue) 中添加元素时,将通过重新分配内部数组来根据需要自动增大容量。

     

    对于枚举而言,字典中的每一项都被视为一个表示值及其键的 KeyValuePair( TKey, TValue) 结构进行处理。项返回的顺序未定义。

     

    C# 语言的 foreach 语句(在 C++ 中为 for each ,在 Visual Basic 中为 For Each )需要集合中每个元素的类型。由于Dictionary( TKey, TValue) 是键和值的集合,因此元素类型并非键类型或值类型。相反,元素类型是键类型和值类型的KeyValuePair( TKey, TValue) 。例如:

     

    此类型的公共静态(在 Visual Basic 中为 Shared )成员是线程安全的。但不能保证任何实例成员是线程安全的。

     

    只要不修改该集合,Dictionary( TKey, TValue) 就可以同时支持多个阅读器。即便如此,从头到尾对一个集合进行枚举本质上并不是一个线程安全的过程。当出现枚举与写访问互相争用这种极少发生的情况时,必须在整个枚举过程中锁定集合。若要允许多个线程访问集合以进行读写操作,则必须实现自己的同步。

    ///summary ///通过DictionaryK,V传递参数 summary ///paramname=sql/param ///paramname=parms/param ///returns/returns public static SqlDataReaderExecuteReader( string sql,Dictionary string , string parms) { SqlDataReadersqlReader= null ;
     

    /// <summary> 

            /// 通过Dictionary<K,V>传递参数 

            /// </summary> 

            /// <param name="sql"></param> 

            /// <param name="parms"></param> 

            /// <returns></returns> 

            public static SqlDataReader ExecuteReader(string sql, Dictionary<stringstring> parms) 

            { 

                SqlDataReader sqlReader = null

                SqlConnection sqlConn = new SqlConnection(conStr); 

                SqlCommand sqlCmd = new SqlCommand(sql, sqlConn); 

                foreach (string key in parms.Keys) 

                { 

                    sqlCmd.Parameters.Add("@" + key, parms[key]); 

                } 

                sqlConn.Open(); 

                sqlReader = sqlCmd.ExecuteReader(CommandBehavior.CloseConnection); 

                return sqlReader; 

            } 

     

      

     

    调用如下: 

     

    ============= 

     

     public UserRole GetRoleByID(int roleId) 

            { 

                string sql = string.Format("select id roleid,rolename from userrole where id=@ID",roleId); 

                Dictionary<string,string> sqlParams = new Dictionary<string,string>(); 

                sqlParams.Add("ID",roleId.ToString()); 

     

                UserRole ur=null

                using (SqlDataReader sqlReader = DBHelper.ExecuteReader(sql,sqlParams)) 

                { 

                    while (sqlReader.Read()) 

                    { 

                        ur = new UserRole((int)sqlReader["roleid"], sqlReader["rolename"].ToString()); 

                    } 

                    sqlReader.Close(); 

                } 

                return ur; 

            } 



    List<T>列表

    namespace ListDemo1
    {
        class Program
        {
            static void Main(string[] args)
            {
                //创建List<T>列表对象
                List<string> dinosaurs = new List<string>();
    
                //增加元素到列表(或称为初始化),注意初始化时不能使用索引器,因为没有增加元素之前list列表是空的
                dinosaurs.Add("Tyrannosaurus");
                dinosaurs.Add("Amargasaurus");
                dinosaurs.Add("Mamenchisaurus");
                dinosaurs.Add("Deinonychus");
                dinosaurs.Add("Compsognathus");
    
                //一个重要属性
                Console.WriteLine("列表中的元素数为: {0}", dinosaurs.Count);//获取 List 中实际包含的元素数
                
    
                //插入元素,使用Insert()方法
                dinosaurs.Insert(2, "Compsognathus");//将元素插入到指定索引处,原来此位置的元素后移
                Console.WriteLine("在索引为2的位置插入了元素{0}",dinosaurs[2]);
    
                //删除元素,使用Remove()方法
                dinosaurs.Remove("Compsognathus");//从 List 中移除特定对象的第一个匹配项
                Console.WriteLine("删除第一个名为Compsognathus的元素!");
    
                //修改元素,使用索引器
                dinosaurs[0] = "TyrannosaurusUpdate";
                Console.WriteLine("修改索引为0的元素成功!");
    
                //遍历元素,使用foreach语句,元素类型为string
                foreach (string dinosaur in dinosaurs)
                {
                    Console.WriteLine(dinosaur);
                }
    
                Console.WriteLine("遍历元素完成!");
                Console.ReadKey();
            }
        }
    }

    程序输出结果:



    展开全文
  • 命名空间System.Collections.Generic中有两个非常重要,而且常用的泛型集合类,它们分别是Dictionary<TKey,TValue>字典和List<...下面来总结一下,用代码来演示怎么初始化,增加,修改,...

    转载于:https://www.cnblogs.com/hgmyz/p/5996060.html

    展开全文
  • 00构造方法构造器也叫构造方法(constructor),用于对象初始化。构造器是一个创建对象时被自动调用的特殊方法,目的是对象初始化。构造器的名称应与类的名称一致。Java通过new关键字来调用构造器,从而返回该类的...

    dfcb1e9f1704a714d5a4a7ff8dc71788.png

    00构造方法

    构造器也叫构造方法(constructor),用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法,目的是对象的初始化。构造器的名称应与类的名称一致。Java通过new关键字来调用构造器,从而返回该类的实例,是一种特殊的方法。

    [修饰符] 类名(形参列表){
        //n条语句
    }

    知识点

    1. 通过new关键字调用!!
    2. 构造器虽然有返回值,但是不能定义返回值类型(返回值的类型肯定是本类),不能在构造器里使用return返回某个值。
    3. 如果我们没有定义构造器,则编译器会自动定义一个无参的构造函数。如果已定义则编译器不会自动添加!
    4. 构造器的方法名必须和类名一致!

    配套练习:

    1. 定义一个“点”(Point)类用来表示二维空间中的点(有两个坐标)。要求如下:

    (1) 可以生成具有特定坐标的点对象。

    (2) 提供可以设置坐标的方法。

    (3)提供可以计算该“点”距另外一点距离的方法。

    class Point {
        double x, y;
        public Point(double _x, double _y) {
            x = _x;
            y = _y;  
        }
        public double getDistance(Point p) {
            return Math.sqrt((x - p.x) * (x - p.x) + (y - p.y) * (y - p.y));
        }
    }
    public class TestConstructor {
        public static void main(String[] args) {
            Point p = new Point(3.0, 4.0);
            Point origin = new Point(0.0, 0.0);
            System.out.println(p.getDistance(origin));
        }
    }

    代码导读一下:

    1-6 :

    行声明了一个构造器

    7-9 :

    行声明了方法

    11-17 :

    13:创建了一个点的对象并给予坐标

    14:声明原点坐标

    15:调用方法输出距离

    01构造方法的重载

    构造方法也是方法,只不过有特殊的作用而已。与普通方法一样,构造方法也可以重载。

    public class User {
        int id; // id
        String name; // 账户名
        String pwd; // 密码
        public User() {
     
        }
        public User(int id, String name) {
            super();
            this.id = id;
            this.name = name;
        }
        public User(int id, String name, String pwd) {
            this.id = id;
            this.name = name;
            this.pwd = pwd;
        }
        public static void main(String[] args) {
            User u1 = new User();
            User u2 = new User(101, "超哥");
            User u3 = new User(100, "超超哥哥", "123456");     
        }
    }

    注意点:

    如果方法构造中形参名与属性名相同时,需要使用this关键字区分属性与形参。如上面代码所示:

    this.id 表示属性id;id表示形参id

    展开全文
  • 左值引用的话,必须在初始化的时候就进行绑定,C++初始化要么在声明的时候就定义,要么在初始化列表中进行初始化。所以就要求你重写构造函数,而且编译器会默认把赋值成员函数operator=给删除了。像const成员变量也...
  • 一、构造方法 **1.概念:**是一个特殊的方法,特殊在这个方法名和类名相同。作用:专门用完成对象的创建或者初始化。可以存在方法方法重载的现象。 **2.语法:**修饰符 类名([参数列表]...//1,创建对象吗?–可以,会
  • 用你的参数对象去执行init初始化函数。init函数中先进行了大量的参数初始化操作<pre><code>this.xxx = blabla</code></pre>,然后剩下这么几行代码(后文所有的英文注释是尤雨溪所写,中文是...
  • o 5.4 我有个函数,它应该接受并初始化一个指针 void f(int *ip) { static int dummy = 5; ip = &dummy;} 但是当我如下调用时: int *ip; f(ip); 调用者的指针却没有任何变化。 o 5.5 我能否用 void** 指针作为参数,...
  • 19.8.6 持久化对象:ProductSpecification 19.8.7 Store-crecte()的协作图 19.9 从表示层到领域层的连接 19.10 小结 第20章 判定可见性 20.1 导言 20.2 对象之间的可见性 20.3 可见性 20.3.l ...
  • c++基础问题

    2019-08-29 18:57:21
    C++11的特性(构造函数的初始化列表,智能指针,lambda) 析构函数能否抛出异常 c与c++ 面向对象的三个基本特征是:封装、继承、多态 多态、 RTTI、RAII 析构函数为什么要虚函数? 构造函数为什么不是虚函数...
  • 2021-01-13

    2021-01-13 19:25:56
    作用 : 创建对象,初始化成员属性 方法声明 : [修饰符列表] 返回值类型 方法名(参数) {方法体} 方法名符合命名规则即可 : 字母,下划线,美元符号,数字,不数字开头,不使用关键字和保留字,建议望文知义, 驼峰命名...
  • 疯狂JAVA讲义

    2014-10-17 13:35:01
    5.3.2 成员变量的初始化和内存中的运行机制 128 5.3.3 局部变量的初始化和内存中的运行机制 130 5.3.4 变量的使用规则 130 5.4 隐藏和封装 132 5.4.1 理解封装 132 5.4.2 使用访问控制符 132 5.4.3 package和...
  • ThinkInJava

    2013-05-28 14:36:27
    4.1 由构建器保证初始化 4.2 方法过载 4.2.1 区分过载方法 4.2.2 主类型的过载 4.2.3 返回值过载 4.2.4 默认构建器 4.2.5 this关键字 4.3 清除:收尾和垃圾收集 4.3.1 finalize()用途何在 4.3.2 必须执行清除 4.4 ...
  • 4.1 由构建器保证初始化 4.2 方法过载 4.2.1 区分过载方法 4.2.2 主类型的过载 4.2.3 返回值过载 4.2.4 默认构建器 4.2.5 this关键字 4.3 清除:收尾和垃圾收集 4.3.1 finalize()用途何在 4.3.2 必须执行清除 4.4 ...
  • Java初学者入门教学

    2012-03-14 21:17:15
    4.1 由构建器保证初始化 4.2 方法过载 4.2.1 区分过载方法 4.2.2 主类型的过载 4.2.3 返回值过载 4.2.4 默认构建器 4.2.5 this关键字 4.3 清除:收尾和垃圾收集 4.3.1 finalize()用途何在 4.3.2 必须执行清除 4.4 ...
  • java 编程入门思考

    2012-03-30 17:50:08
    4.1 由构建器保证初始化 4.2 方法过载 4.2.1 区分过载方法 4.2.2 主类型的过载 4.2.3 返回值过载 4.2.4 默认构建器 4.2.5 this关键字 4.3 清除:收尾和垃圾收集 4.3.1 finalize()用途何在 4.3.2 必须执行清除 4.4 ...
  • JAVA_Thinking in Java

    2011-12-02 17:58:15
    4.1 由构建器保证初始化 4.2 方法过载 4.2.1 区分过载方法 4.2.2 主类型的过载 4.2.3 返回值过载 4.2.4 默认构建器 4.2.5 this关键字 4.3 清除:收尾和垃圾收集 4.3.1 finalize()用途何在 4.3.2 必须执行清除 4.4 ...
  • thinkinjava

    2011-11-30 11:47:28
    4.1 由构建器保证初始化 4.2 方法过载 4.2.1 区分过载方法 4.2.2 主类型的过载 4.2.3 返回值过载 4.2.4 默认构建器 4.2.5 this关键字 4.3 清除:收尾和垃圾收集 4.3.1 finalize()用途何在 4.3.2 必须执行清除 4.4 ...
  • 4.1 由构建器保证初始化 4.2 方法过载 4.2.1 区分过载方法 4.2.2 主类型的过载 4.2.3 返回值过载 4.2.4 默认构建器 4.2.5 this关键字 4.3 清除:收尾和垃圾收集 4.3.1 finalize()用途何在 4.3.2 必须执行清除 4.4 ...
  • 4.1 由构建器保证初始化 4.2 方法过载 4.2.1 区分过载方法 4.2.2 主类型的过载 4.2.3 返回值过载 4.2.4 默认构建器 4.2.5 this关键字 4.3 清除:收尾和垃圾收集 4.3.1 finalize()用途何在 4.3.2 必须执行清除 4.4 ...
  • Thinking in java(中文)

    2007-09-30 15:42:35
    收尾和垃圾收集 4.3.1 finalize()用途何在 4.3.2 必须执行清除 4.4 成员初始化 4.4.1 规定初始化 4.4.2 构建器初始化 4.5 数组初始化 4.5.1 多维数组 4.6 总结 4.7 练习 <br>第5章 ...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 135
精华内容 54
关键字:

初始化列表能初始化对象吗