精华内容
下载资源
问答
  •  内存条的构造: 首先看下内存的构造,这块电路板就是PCB,这块电路板上贴的一块块黑色的就是内存芯片或者叫内存颗粒,下面一排金色的就是金手指,它是插在主板上的内存插槽上的。内存PCB上还焊有电容,如果掉...

      一直以来电脑内存条都是至关重要的硬件之一,但是却还是有很多用户对电脑内存条了解不多,有关于内存条构造、内存条规格以及容量与颗粒都不是很了解。接下来就为大家带来电脑内存条的基础知识。

    765203b951a1d02533885d8f8664aab4.png

      内存条的构造:

      首先看下内存的构造,这块电路板就是PCB,这块电路板上贴的一块块黑色的就是内存芯片或者叫内存颗粒,下面一排金色的就是金手指,它是插在主板上的内存插槽上的。内存PCB上还焊有电容,如果掉了电容的话,内存是不能正常运行的。

      内存条手指中间的地方有个缺口,这个就是防呆口,是为了防止不同代的内存误差在内存槽上,以免烧毁的一个设计。

      这里要说一下,像图中DDR4的内存,他的金手指两边是带有一定弧度的,并不是平直的金手指,这是DDR4内存的独特设计,并不是质量问题。

      内存的规格:

      内存自诞生之日起,经历了SDRAM、DDR 、DDR2、 DDR3、 DDR3L、 DDR4 等数代更新。别看内存种类有这么多,其实内存很好辨认,只需要看内存上的标签贴纸,或者看缺口的位置就可以分辨了。

      不同内存的防呆口位置不同,因此不能混插,如果强行混插的话,会有烧坏内存条和主板的危险。另外,如果是不同类型内存,是不能在同一个主板上使用的。

      对于用户比较关心的内存能不能混用这个问题,《strong》相同规格相同频率(品牌不同)的内存条基本是可以混用的,相同规格不同频率,例如DDR4 2400和DDR4 2133一般情况下也是可以通用的,只不过内存实际的运行频率会向下看齐。

    1e41333bf12153007f3908481a67dfab.png

      内存容量与颗粒:

      再说说内存的容量,内存芯片的单颗容量,是可以通过内存芯片上的编号来识别的。不过由于编号命名明明的规则太过复杂,而且不同厂商和年代都有差别,对于大家来说没什么意义,我们可以对照编号直接百度就行了。

      一般来说内存的单颗容量,乘以它的颗粒个数,就是内存条的总容量,总容量越大,它可以同时运行的程序就越多。

      如果你只是OFFICE,PS,QQ,上网,看视频,那么4GB内存就勉强足够了。

      如果你是玩大型单机游戏,AE渲染,3DSMAX 、虚拟机等等操作,那么你至少需要8GB以上,而且越多越好。

      不同内存容量也要选择不同的系统,由于32位的家用系统最大只能识别4G的内存,而且最后显示出来大约能用的是3.75G左右。所以铅锤哥建议4G以及4G以上的内存的用户,建议装64位系统。

      常见的默认频率有这些(单位:MHZ)

      SDRAM: 100 133 166 200

      DDR: 200 266 333 400

      DDR2: 400 533 667 800 1066

      DDR3: 800 1066 1333 1600 1866 2133

      DDR4: 2133 2400 2666 3200 甚至更高

      在支持超频的主板上,我们可以手动提升内存的频率,内存工作在更高的频率,可以提升内存的带宽。尤其对核芯的显卡提升特别明显,由于核芯显卡是将一部分内存分配为显存,所以内存的频率就是显存的频率,内存的位宽就是显存的位宽。

      不同频率的内存,在多通道模式时,他们只会在最低的的频率工作运行,如果你以2400与2666频率的内存同时组成双通道,那么低频的那条就会拖你后腿,组成的双通道也是2400频率的。不过一般的情况下,很难感觉到2400和2666频率的内存的性能差距。

    ccab44df63d7fb62e136813376eb1ec5.png
    展开全文
  • 介绍SDRAM内部构造和驱动原理 虽然目前SDRAM 内存条价格已经接底线,内存开始向DDR 和Rambus内存过渡。但是由于DDR 内存 是在SDRAM基础上发展起来,所以...方面来详细阐述SDRAM 内存条和主板内存系统设计思路。
  • 本文主要向大家介绍了JAVA语言...String类的判断功能:断点设置、字符串、查看API文档、String类的构造方法、字符串的长度、内存结构图断点设置:一般情况下,需要在每个方法的第一有效语句设置断点。String类0、...

    本文主要向大家介绍了JAVA语言之String类的判断功能断点设置、字符串、查看API文档、String类的构造方法、字符串的长度、内存结构图介绍,通过具体的内容向大家展示,希望对大家学习JAVA语言有所帮助。

    String类的判断功能:断点设置、字符串、查看API文档、String类的构造方法、字符串的长度、内存结构图

    断点设置:一般情况下,需要在每个方法的第一条有效语句设置断点。

    String类

    0、String类所在的包:java.lang (所以不需要自己受到导入,系统自动导入)。

    1、字符串

    (1)字符串:就是由多个字符组成的一串数据,也可以看做是一个字符数组。

    2、查看API文档

    (1)字符串字面值常量"abcde"也可以看作是一个字符串对象。

    (2)字符串时常量,一旦被赋值,就不能被更改。

    3、String类的构造方法(学习其中的6个):

    (1)public String( )

    空构造方法,默认的无参构造方法

    (2)public String(byte[ ] bytes)

    把字节数组转换成字符串

    (3)public String(byte[ ] bytes,int offset,int length)

    把字节数组的一部分转换成字符串:从offset开始的length个字符转换为字符串

    (4)public String(char[ ] value)

    把字符数组转换成字符串

    (5)public String(char[ ] value,int offset,int count)

    把字符数组的一部分转换成字符串

    (6)public String(String original)

    把字符串常量值转换成字符串

    4、字符串的长度

    (1)public int length():返回此字符串的长度

    5、举例:构造方法、字符串长度

    package cn.itcast_01;

    public class StringDemo {

    public static void main(String[] args) {

    // public String()

    // 空构造方法

    String s1 = new String();

    System.out.println("s1=" + s1);

    System.out.println("s1.length()=" + s1.length());

    System.out.println("-------------");

    // public String(byte[] bytes)

    // 把字节数组转化为字符串

    byte[] bys = { 97, 98, 99, 100, 101 };

    String s2 = new String(bys);

    System.out.println("s2=" + s2);

    System.out.println("s2.length()=" + s2.length());

    System.out.println("-------------");

    // public String(byte[] bytes,int offset,int length)

    // 把字节数组的一部分转换成字符串

    // 我现在想得到字符串“bcd”

    String s3 = new String(bys, 1, 3);

    System.out.println("s3=" + s3);

    System.out.println("s3.length()=" + s3.length());

    System.out.println("-------------");

    // public String(char[] value)

    // 把字符数组转换成字符串

    char[] chs = { 'a', 'b', 'c', 'd', 'e', '爱', '林', '青' };

    String s4 = new String(chs);

    System.out.println("s4=" + s4);

    System.out.println("s4.length()=" + s4.length());

    System.out.println("-------------");

    // public String(char[] value,int offset,int count)

    // 把字符数组的一部分转换成字符串

    String s5 = new String(chs, 5, 3);

    System.out.println("s5=" + s5);

    System.out.println("s5.length()=" + s5.length());

    System.out.println("-------------");

    //public String(String original)

    //把字符串常量值转换成字符串

    String s6 = new String("abcabcabcabcabcabc");

    System.out.println("s6=" + s6);

    System.out.println("s6.length()=" + s6.length());

    System.out.println("-------------");

    //字符串字面值常量"abcde"也可以看作是一个字符串对象

    String s7 = "abcabcabcabcabcabc";

    System.out.println("s7=" + s7);

    System.out.println("s7.length()=" + s7.length());

    }

    }

    6、String的特点:一旦被赋值,其值就不能被改变。

    (1)字符串被赋值的方法:

    字符串直接被赋值的方法 是先到方法区中的字符串常量池中去寻找该字符串,若没找到,则创建字符串并返回地址值给字符串对象。

    一旦被赋值,就不能被改变。(是其值不能被改变,不是引用不能被改变!)

    (2)举例:字符串被赋值

    package cn.itcast_02;

    public class StringDemo {

    public static void main(String[] args) {

    String s = "hello";

    s += "world";

    System.out.println("s=" + s);

    System.out.println("s.length()="+s.length());

    }

    }

    (3)字符串被赋值的内存结构图:

    (4)面试题:

    String s = new String("hello"); 与 String s = "hello" 有没有区别?

    答案:有区别。前者会创建两个对象,后者会创建1个对象。

    (5)== 和 equals( ) 的区别:

    1)== :比较引用类型时,比较的是地址值是否相同。

    2)equals:比较引用类型时,默认比较的也是地址值是否相同,而String类已经重写了equals()方法,比较的是两个字符串内容是否相同。

    3)代码:

    package cn.itcast_02;

    public class StringDemo2 {

    public static void main(String[] args) {

    String s1 = new String("hello");

    String s2 = "hello";

    System.out.println(s1 == s2); // false

    System.out.println(s1.equals(s2)); // true

    }

    }

    4)内存结构图:

    (6)面试题:字符串变量相加、字符串常量相加

    A:如果是字符串变量相加,是 先开辟内存空间,再拼接。

    B:如果是字符串常量相加,是 先拼接,然后在常量池中寻找,如果有就直接返回,否则,就开辟内存空间去创建。

    package cn.itcast_02;

    public class StringDemo2 {

    public static void main(String[] args) {

    String s1 = new String("hello");

    String s2 = "hello";

    System.out.println(s1 == s2); // false

    System.out.println(s1.equals(s2)); // true

    System.out.println("------------");

    String str1 = new String("hello");

    String str2 = new String("hello");

    System.out.println(str1 == str2); // false

    System.out.println(str1.equals(str2)); // true

    System.out.println("------------");

    String str3 = new String("hello");

    String str4 = "hello";

    System.out.println(str3 == str4); // false

    System.out.println(str3.equals(str4)); // true

    System.out.println("------------");

    String str5 = "hello";

    String str6 = "hello";

    System.out.println(str5 == str6); // true

    System.out.println(str5.equals(str6)); // true

    System.out.println("------------");

    // 如果是字符串变量相加,是 先开辟内存空间,再拼接。

    // 如果是字符串常量相加,是 先拼接,然后在常量池中寻找,如果有就直接返回,

    // 否则,就开辟内存空间去创建。

    String str7 = "hello";

    String str8 = 

    本文由职坐标整理并发布,希望对同学们有所帮助。了解更多详情请关注编程语言JAVA频道!

    展开全文
  • C++ 对象构造与析构以及内存布局

    千次阅读 2013-03-25 13:20:42
    主要探讨对象的构造顺序与内存的布局,主要参考来源为《Exceptional C++ Style中文版》 文中第十四 顺序!顺序!根据文中的代码摘录如下,代码中添加了一些调试的信息。 #include struct classcomp { bool ...

    主要探讨对象的构造顺序与内存的布局,主要参考来源为《Exceptional C++ Style中文版》

    文中第十四条 顺序!顺序!根据文中的代码摘录如下,代码中添加了一些调试的信息。

    #include <map>
    
    struct classcomp {
        bool operator() (const __int64& lhs, const __int64& rhs) const
        {return lhs<rhs;}
    };
    
    std::multimap<__int64,std::string,classcomp> m_Construtor;
    
    class B1{ 
    public:
        B1()
        {
            std::cout<<"Constructor B1 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor B1 "));
        }
        virtual ~B1()
        {
            std::cout<<"Destructor B1 "<<this<<'\n';
        }
    };
    class V1:public B1{
    public:
        V1()
        {
            std::cout<<"Constructor V1 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor V1 "));
        }
        virtual ~V1()
        {
            std::cout<<"Destructor V1 "<<this<<'\n';
        }
    };
    class D1:virtual public V1{
    public:
        D1()
        {
            std::cout<<"Constructor D1 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor D1 "));
        }
        virtual ~D1()
        {
            std::cout<<"Destructor D1 "<<this<<'\n';
        }
    };
    
    class B2{
    public:
        B2()
        {
            std::cout<<"Constructor B2 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor B2 "));
        }
        virtual ~B2()
        {
            std::cout<<"Destructor B2 "<<this<<'\n';
        }
    };
    class B3{
    public:
        B3()
        {
            std::cout<<"Constructor B3 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor B3 "));
        }
        virtual ~B3()
        {
            std::cout<<"Destructor B3 "<<this<<'\n';
        }
    };
    class V2:public B1,public B2{
    public:
        V2()
        {
            std::cout<<"Constructor V2 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor V2 "));
        }
        virtual ~V2()
        {
            std::cout<<"Destructor V2 "<<this<<'\n';
        }
    };
    
    class D2:public B3,virtual public V2{
    public:
        D2()
        {
            std::cout<<"Constructor D2 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor D2 "));
        }
        virtual ~D2()
        {
            std::cout<<"Destructor D2 "<<this<<'\n';
        }
    };
    
    class M1{
    public:
        M1()
        {
            std::cout<<"Constructor M1 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor M1 "));
        }
        virtual ~M1()
        {
            std::cout<<"Destructor M1 "<<this<<'\n';
        }
    };
    class M2{
    public:
        M2()
        {
            std::cout<<"Constructor M2 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor M2 "));
        }
        virtual ~M2()
        {
            std::cout<<"Destructor M2 "<<this<<'\n';
        }
    };
    
    class X:public D1,public D2
    {
    
    public:
        X()
        {
            std::cout<<"Constructor X "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor X "));
        }
        virtual ~X()
        {
            std::cout<<"Destructor X "<<this<<'\n';
        }
    private:
        M1 _m1;
        M2 _m2;
    };
    
    
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        //B b;
        int  i;
    
        X *pX = new X;
        std::cout<<"--------------------------------------------"<<'\n';
        cout.setf(ios::showbase | ios::uppercase); //设置基指示符输出和数值中的字母大写输出
        std::multimap<__int64,std::string,classcomp> ::iterator iter;
        for (iter = m_Construtor.begin();iter != m_Construtor.end();++iter)//遍历
        {
            cout<<std::hex<<(*iter).first<<"  "<<(*iter).second<<endl;
        }
    
        std::cout<<"--------------------------------------------"<<'\n';
        delete pX;
        pX = NULL;
    
        std::cin>>i;
    	return 0;
    }
    以上程序的运行结果为:

    Constructor B1 005F7F94
    Constructor V1 005F7F94
    Constructor B1 005F7F98
    Constructor B2 005F7F9C
    Constructor V2 005F7F98
    Constructor D1 005F7F88
    Constructor B3 005F7F80
    Constructor D2 005F7F80
    Constructor M1 005F7F8C
    Constructor M2 005F7F90
    Constructor X 005F7F80
    --------------------------------------------
    0X5F7F80  Constructor B3
    0X5F7F80  Constructor D2
    0X5F7F80  Constructor X
    0X5F7F88  Constructor D1
    0X5F7F8C  Constructor M1
    0X5F7F90  Constructor M2
    0X5F7F94  Constructor B1
    0X5F7F94  Constructor V1
    0X5F7F98  Constructor B1
    0X5F7F98  Constructor V2
    0X5F7F9C  Constructor B2
    --------------------------------------------
    Destructor X 005F7F80
    Destructor M2 005F7F90
    Destructor M1 005F7F8C
    Destructor D2 005F7F80
    Destructor B3 005F7F80
    Destructor D1 005F7F88
    Destructor V2 005F7F98
    Destructor B2 005F7F9C
    Destructor B1 005F7F98
    Destructor V1 005F7F94
    Destructor B1 005F7F94


    可以看出对象的构造顺序和书中提示到的顺序一致

    类图



    1.首先构造虚基类子对象


    2.其次构造非虚基类子对象.


    3.构造成员本身


    4.构造对象本身

    以上同等级的构造顺序遵循从左到右的申明顺序。


    但是问题出现了

    问题1:这个对象X的对象内存分布是这个样子的。看上去地址是倒着分配的。首地址相近的并不是最先分配的那个对象。是个问题。。。大家可以考虑一下到底怎么分布啊???我的编译平台是VS2010

    问题2:假如说类B1中含有某个方法,那么X对象调用的是哪块内存上的函数呢??

    我猜是左边的那个。废话少说写测试代码。

    改造一下后编译竟然发现编译问题

    1>e:\opensource\exceptional c++ style\example_014class\example_014class.cpp(191): error C2385: ambiguous access of 'fun'
    1>          could be the 'fun' in base 'B1'
    1>          or could be the 'fun' in base 'B1'

    看样子编译器他决定不了X对象将会调用内存中哪块B1的函数。


    是否就没有办法了呢?

    想起对象模型的那本曾提到这种情况下使用 virtual的继承 。果然请看改造后的代码。

    #include <map>
    
    struct classcomp {
        bool operator() (const __int64& lhs, const __int64& rhs) const
        {return lhs<rhs;}
    };
    
    std::multimap<__int64,std::string,classcomp> m_Construtor;
    
    class B1{ 
    public:
        B1()
        {
            std::cout<<"Constructor B1 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor B1 "));
        }
        virtual ~B1()
        {
            std::cout<<"Destructor B1 "<<this<<'\n';
        }
        void fun()
        {
            std::cout<<"fun B1 "<<this<<'\n';
        }
    };
    class V1:virtual public B1{
    public:
        V1()
        {
            std::cout<<"Constructor V1 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor V1 "));
        }
        virtual ~V1()
        {
            std::cout<<"Destructor V1 "<<this<<'\n';
        }
    };
    class D1:virtual public V1{
    public:
        D1()
        {
            std::cout<<"Constructor D1 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor D1 "));
        }
        virtual ~D1()
        {
            std::cout<<"Destructor D1 "<<this<<'\n';
        }
    };
    
    class B2{
    public:
        B2()
        {
            std::cout<<"Constructor B2 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor B2 "));
        }
        virtual ~B2()
        {
            std::cout<<"Destructor B2 "<<this<<'\n';
        }
    };
    class B3{
    public:
        B3()
        {
            std::cout<<"Constructor B3 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor B3 "));
        }
        virtual ~B3()
        {
            std::cout<<"Destructor B3 "<<this<<'\n';
        }
    };
    class V2:virtual public B1,public B2{
    public:
        V2()
        {
            std::cout<<"Constructor V2 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor V2 "));
        }
        virtual ~V2()
        {
            std::cout<<"Destructor V2 "<<this<<'\n';
        }
    };
    
    class D2:public B3,virtual public V2{
    public:
        D2()
        {
            std::cout<<"Constructor D2 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor D2 "));
        }
        virtual ~D2()
        {
            std::cout<<"Destructor D2 "<<this<<'\n';
        }
    };
    
    class M1{
    public:
        M1()
        {
            std::cout<<"Constructor M1 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor M1 "));
        }
        virtual ~M1()
        {
            std::cout<<"Destructor M1 "<<this<<'\n';
        }
    };
    class M2{
    public:
        M2()
        {
            std::cout<<"Constructor M2 "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor M2 "));
        }
        virtual ~M2()
        {
            std::cout<<"Destructor M2 "<<this<<'\n';
        }
    };
    
    class X: public D1, public D2
    {
    
    public:
        X()
        {
            std::cout<<"Constructor X "<<this<<'\n';
            m_Construtor.insert(std::pair<__int64,std::string>((__int64)this,"Constructor X "));
        }
        virtual ~X()
        {
            std::cout<<"Destructor X "<<this<<'\n';
        }
    private:
        M1 _m1;
        M2 _m2;
    };
    
    
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
        //B b;
        int  i;
    
        X *pX = new X;
        std::cout<<"--------------------------------------------"<<'\n';
        pX->fun();
        std::cout<<"--------------------------------------------"<<'\n';
        cout.setf(ios::showbase | ios::uppercase); //设置基指示符输出和数值中的字母大写输出
        std::multimap<__int64,std::string,classcomp> ::iterator iter;
        for (iter = m_Construtor.begin();iter != m_Construtor.end();++iter)//遍历
        {
            cout<<std::hex<<(*iter).first<<"  "<<(*iter).second<<endl;
        }
    
        std::cout<<"--------------------------------------------"<<'\n';
        delete pX;
        pX = NULL;
    
        std::cin>>i;
    	return 0;
    }
    运行结果:

    Constructor B1 00127F94
    Constructor V1 00127F98
    Constructor B2 00127F9C
    Constructor V2 00127F9C
    Constructor D1 00127F88
    Constructor B3 00127F80
    Constructor D2 00127F80
    Constructor M1 00127F8C
    Constructor M2 00127F90
    Constructor X 00127F80
    --------------------------------------------
    fun B1 00127F94
    --------------------------------------------
    0X127F80  Constructor B3
    0X127F80  Constructor D2
    0X127F80  Constructor X
    0X127F88  Constructor D1
    0X127F8C  Constructor M1
    0X127F90  Constructor M2
    0X127F94  Constructor B1
    0X127F98  Constructor V1
    0X127F9C  Constructor B2
    0X127F9C  Constructor V2
    --------------------------------------------
    Destructor X 00127F80
    Destructor M2 00127F90
    Destructor M1 00127F8C
    Destructor D2 00127F80
    Destructor B3 00127F80
    Destructor D1 00127F88
    Destructor V2 00127F9C
    Destructor B2 00127F9C
    Destructor V1 00127F98
    Destructor B1 00127F94
    发现类B1还少构造了一次。哈哈~~果然很强大啊。。











































    展开全文
  • 接上一博客, 今天, 我们来谈谈java中的构造方法以及代码块1. 构造方法有一个问题: 一个对象的产生分为几步? 他是怎样产生的?答案为: 两步 1. 给对象分配内存; 2. 调用合适的构造方法那么什么是构造方法?构造方法是...

    接上一条博客, 今天, 我们来谈谈java中的构造方法以及代码块

    1. 构造方法

    有一个问题: 一个对象的产生分为几步? 他是怎样产生的?

    答案为: 两步 1. 给对象分配内存; 2. 调用合适的构造方法

    那么什么是构造方法?

    构造方法是一种特殊的的方法, 使用关键字new实例化对象的时候, 就会自动调用构造方法, 用于完成初始化的操作.

    构造方法的构造要求:

    构造方法名与类名相同, 并且没有返回值

    class Person {

    private String name;

    private int age;

    // 构造方法

    public Person () {

    System.out.println("person");

    }

    }

    public class Test {

    public static void main(String[] args) {

    Person person = new Person();

    }

    }

    构造方法可以是一个, 也可以是多个.

    若自己未在代码中定义构造方法, 编译器将会默认自带一个无参的构造方法. 若自己定义了构造方法, 编译器将不再赠送构造方法

    构造方法可以是无参的构造方法, 也可以是有参构造方法, 由构造方法的构造可知, 它完全符合重载的要求

    所以, 构造方法可以进行重载

    class Person{

    private String name;

    private int age;

    // 构造方法

    public Person() { // 不带参数的构造方法

    System.out.println("person");

    }

    public Person(String name, int age) { // 带有参数的构造方法

    System.out.println("person || String || age");

    }

    }

    public class Test {

    public static void main(String[] args) {

    c

    Person person = new Person("zhangsan",18);

    }

    }

    this关键字的简单介绍

    这里我们从一个问题入手: this代表一个对象, 这句话对不对?

    这句话是错误的

    这里展示一段代码:

    class Person{

    private String name;

    private String age;

    // 构造方法

    public Person() {

    this.name = "zhangsan";

    this.age = 18;

    System.out.println(name + " " + age);

    }

    }

    public class TestDemo03 {

    public static void main(String[] args) {

    Person person = new Person();

    }

    }

    我们知道, 一个对象要产生, 首先就要先给对象分配内存, 然后再调用合适的构造方法. 但是从这段代码中我们可以看出, 在构造方法中就已经使用了this关键字, 而这个时候, 对象还没有完全创建好. 所以, this代表一个对象是错误的

    那么,this到底代表什么呢? this代表的是当前对象的引用(this写在哪个类, 就代表哪个类的对象的引用)

    构造方法还可以调用构造方法

    public Book() {

    this("木偶奇遇记", "10697061418"); // 调用了有参的构造方法

    this.name = "鲁宾逊漂流记";

    this.id = "10697061419";

    System.out.println("name = " + name + ", " + "id = " + id);

    }

    // 有参的构造方法

    public Book(String name, String id) {

    this.name = name;

    this.id = id;

    System.out.println("name = " + name + ", " + "id = " + id);

    }

    调用构造方法, 需要使用 this( ) 来调用自己的构造方法

    注意: 1. this( ) 只能在构造方法里面写

    ​ 2. this( ) 只能调用一次

    ​ 3. 调用的时候只能写在第一行

    2. 代码块

    代码块分为3种: 1. 静态代码块

    ​ 2. 实例代码块(构造代码块)

    ​ 3.本地代码块

    我们着重介绍前两个代码块

    class Person {

    private String name;

    private int age;

    // 构造方法

    public Person() {

    System.out.println("person");

    }

    // 实例代码块

    {

    System.out.println("实例代码块");

    }

    // 静态代码块(使用static定义的代码块)

    static {

    System.out.println("静态代码块 ");

    }

    }

    public class TestDemo04 {

    public static void main(String[] args) {

    Person person = new Person();

    }

    }

    运行结果为:

    静态代码块

    实例代码块

    teacher

    由运行结果可知: 不论静态代码块, 实例代码块, 构造方法如何分布, 在访问的时候都是优先访问静态代码块, 再下来是实例代码块, 之后才是构造方法

    注意: 无论创建多少个对象, 静态代码块都只执行一次, 并且是最先执行的

    如果一个类中存在两个或者多个静态类的数据成员, 那么他们被访问的顺序按照他们定义的先后顺序

    展开全文
  • 14英寸MateBook D AMD不能增加内存条

    千次阅读 2019-11-03 22:50:20
    14英寸MateBook D AMD不能增加内存条 与14英寸 MagicBook锐龙版 (AMD R5) 8GB+256GB (KPL-W00B) 一样,内存是焊在主板上 https://club.huawei.com/thread-18931535-1-12.html 拆机图解: 1、卸掉螺丝后,撬开后盖...
  • 计算机主板的构造

    2020-03-31 17:12:49
    不管是台式机还是笔记本,它们内部都有一块电路板,上面密密麻麻地布满了大小不一的电子器件,包括CPU、内存条、网卡、各种插槽和接口等,这就是“主板”,如下图所示。 这张图片主要让读者了解主板的构造,你不必...
  • Symbian内存管理的二十二军规 收藏 1、C类必须有析构函数,这是CBase的一个虚函数。2、C类的构造函数和ConstructL()必须为protect或private类型的成员函数(这个有待讨论)3、...
  • 第三 用私有的构造器或者枚举类型强化singleton属性 首先说下singleton,设计模式叫单例模式,就是只被实例化一次的实例,是唯一的类。例如做单元测试时,你要测试数据库的增删改查,你不会new四个Connection吧?...
  • 条款11: 为需要动态分配内存的类声明一个拷贝构造函数和一个赋值操作符 这是非常重要,经常会导致一些内存的泄露,如以下这段代码所示: // 一个很简单string类 class string { public: string...
  • Symbian内存管理的二十二军规1、C类必须有析构函数,这是CBase的一个虚函数。2、C类的构造函数和ConstructL()必须为protect或private类型的成员函数3、在C class中必须有一个NewLC()函数,除非它是嵌套类。NewL()...
  • 接上一博客, 今天, 我们来谈谈java中的构造方法以及代码块 1. 构造方法 有一个问题: 一个对象的产生分为几步? 他是怎样产生的? 答案为: 两步 1. 给对象分配内存; 2. 调用合适的构造方法 那么什么是构造方法? 构造...
  • 在effective c++中第十一写到这样话,可是我今天又忘了。 在写一个类时候,里面用到了指针和动态分配内存的东西。我定义了一个全局变量来存放这些类对象,在程序里用了临时一个对象来循环取出这些对象...
  • 图灵机的构造

    2020-10-24 10:18:53
    图灵机拥有一无限长纸带,纸带上是一个格子挨着一个格子,格子中可以写字符,你可以把纸带看作内存,而这些字符可以看作是内存数据或者程序。 图灵机有一个读写头,读写头可以读取任意格子上字符,也可以...
  • Symbian内存管理的二十二军规1、C类必须有析构函数,这是CBase的一个虚函数。2、C类的构造函数和ConstructL()必须为protect或private类型的成员函数3、在C class中必须有一个NewLC()函数,除非它是嵌套类。NewL()...
  • CPU内部构造

    2020-03-10 16:30:45
    4,依据相应条件进行跳转,执行其他指令(一指令跳转到另外一指令) 专业描述: 第一:取指令 字面意思很好理解啊,不就是拿到需要指令嘛,那么指令在哪嘞,必须是在内存啊,也就是需要从内存中取出我们...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 528
精华内容 211
关键字:

内存条的构造