精华内容
下载资源
问答
  • Java命名规范+常量定义方法

    千次阅读 2018-12-12 22:05:33
    但是由于Java面向对象编程的特性,每一名Java程序员都 可以编写属于自己的Java包,为了保障每个Java包命名的唯一性,在最新的Java编程规范中,要求程序员在自己定义的名称之前加上唯一的前缀。 由于互联网上的域...

    Java命名规范

    定义规范的目的是为了使项目的代码样式统一,使程序有良好的可读性。

    包的命名  (全部小写,由域名定义)

    Java包的名字都是由小写单词组成。但是由于Java面向对象编程的特性,每一名Java程序员都 可以编写属于自己的Java包,为了保障每个Java包命名的唯一性,在最新的Java编程规范中,要求程序员在自己定义的包的名称之前加上唯一的前缀。 由于互联网上的域名称是不会重复的,所以程序员一般采用自己在互联网上的域名称作为自己程序包的唯一前缀。 
    例如:net.frontfree.javagroup


    类的命名 (单词首字母大写)

    根据约定,Java类名通常以大写字母开头,如果类名称由多个单词组成,则每个单词的首字母均应为大 写例如TestPage;如果类名称中包含单词缩写,则这个所写词的每个字母均应大写,如:XMLExample,还有一点命名技巧就是由于类是设计用来 代表对象的,所以在命名类时应尽量选择名词。    
    例如: Graphics


    方法的命名 (首字母小写,字母开头大写)

    方法的名字的第一个单词应以小写字母作为开头,后面的单词则用大写字母开头。 
    例如:drawImage


    常量的命名 (全部大写 ,常加下划线)
    常量的名字应该都使用大写字母,并且指出该常量完整含义。如果一个常量名称由多个单词组成,则应该用下划线来分割这些单词。 
    例如:MAX_VALUE


    参数的命名

    参数的命名规范和方法的命名规范相同,而且为了避免阅读程序时造成迷惑,请在尽量保证参数名称为一个单词的情况下使参数的命名尽可能明确。

    Javadoc注释

    Java除了可以采用我们常见的注释方式之外,Java语言规范还定义了一种特殊的注释,也就是我们 所说的Javadoc注释,它是用来记录我们代码中的API的。Javadoc注释是一种多行注释,以/**开头,而以*/结束,注释可以包含一些 HTML标记符和专门的关键词。使用Javadoc 注释的好处是编写的注释可以被自动转为在线文档,省去了单独编写程序文档的麻烦。 
    例如:

    /** 
    * This is an example of 
    * Javadoc 
    * @author darchon 
    * @version 0.1, 10/11/2002 
    */

    在每个程序的最开始部分,一般都用Javadoc注释对程序的总体描述以及版权信息,之后在主程序中 可以为每个类、接口、方法、字段添加 Javadoc注释,每个注释的开头部分先用一句话概括该类、接口、方法、字段所完成的功能,这句话应单独占据一行以突出其概括作用,在这句话后面可以跟 随更加详细的描述段落。在描述性段落之后还可以跟随一些以Javadoc注释标签开头的特殊段落,例如上面例子中的@auther和@version,这 些段落将在生成文档中以特定方式显示。


    变量和常量命名


    变量的命名

    主要的的命名规范有以下三种:
    Camel 标记法:首字母是小写的,接下来的单词都以大写字母开头
    Pascal 标记法:首字母是大写的,接下来的单词都以大写字母开头
    匈牙利标记法:在以Pascal标记法的变量前附加小写序列说明该变量的类型

    在Java我们一般使用匈牙利标记法,基本结构为scope_typeVariableName,它 使用1-3字符前缀来表示数据类型,3个字符的前缀必须小写,前缀后面是由表意性强的一个单词或多个单词组成的名字,而且每个单词的首写字母大写,其它字 母小写,这样保证了对变量名能够进行正确的断句。例如,定义一个整形变量,用来记录文档数量:intDocCount,其中int表明数据类型,后面为表 意的英文名,每个单词首字母大写。这样,在一个变量名就可以反映出变量类型和变量所存储的值的意义两方面内容,这使得代码语句可读性强、更加容易理解。 byte、int、char、long、float、 double、boolean和short。

    数据类型/前缀(附)
    byte b
    char c
    short sh
    int i
    long l
    char c
    string s
    float f
    double d
    hashtable h
    [] arr
    List lst
    Vector v
    StringBuffer sb
    Boolean b
    Byte bt
    Map map
    Object ob

    对于在多个函数内都要使用的全局变量,在前面再增加“g_”。例如一个全局的字符串变量:g_strUserInfo。

    在变量命名时要注意以下几点:

    · 选择有意义的名字,注意每个单词首字母要大写。

    · 在一段函数中不使用同一个变量表示前后意义不同的两个数值。

    · i、j、k等只作为小型循环的循环索引变量。

    · 避免用Flag来命名状态变量。

    · 用Is来命名逻辑变量,如:blnFileIsFound。通过这种给布尔变量肯定形式的命名方式,使得其它开发人员能够更为清楚的理解布尔变量所代表的意义。

    · 如果需要的话,在变量最后附加计算限定词,如:curSalesSum。

    · 命名不相包含,curSales和curSalesSum。

    · static final 变量(常量)的名字应该都大写,并且指出完整含义。

    · 如果需要对变量名进行缩写时,一定要注意整个代码中缩写规则的一致性。例如,如果在代码的某些区域中使用intCnt,而在另一些区域中又使用intCount,就会给代码增加不必要的复杂性。建议变量名中尽量不要出现缩写。

    · 通过在结尾处放置一个量词,就可创建更加统一的变量,它们更容易理解,也更容易搜索。例如,请使用 strCustomerFirst和strCustomerLast,而不要使用strFirstCustomer和strLastCustomer。常 用的量词后缀有:First(一组变量中的第一个)、Last(一组变量中的最后一个)、Next(一组变量中的下一个变量)、Prev(一组变量中的上 一个)、Cur(一组变量中的当前变量)。

    · 为每个变量选择最佳的数据类型,这样即能减少对内存的需求量,加快代码的执行速度,又会降低出错的可能性。用于变量的数据类型可能会影响该变量进行计算所产生的结果。在这种情况下,编译器不会产生运行期错误,它只是迫使该值符合数据类型的要求。这类问题极难查找。

    · 尽量缩小变量的作用域。如果变量的作用域大于它应有的范围,变量可继续存在,并且在不再需要该变量后的很长时间内仍然占用资源。它们的主要问题是,任何类 中的任何方法都能对它们进行修改,并且很难跟踪究竟是何处进行修改的。占用资源是作用域涉及的一个重要问题。对变量来说,尽量缩小作用域将会对应用程序的 可靠性产生巨大的影响。

    关于常量的命名方法,在JAVA代码中,无论什么时候,均提倡应用常量取代数字、固定字符串。也就是 说,程序中除0,1以外,尽量不应该出现其他数字。常量可以集中在程序开始部分定义或者更宽的作用域内,名字应该都使用大写字母,并且指出该常量完整含 义。如果一个常量名称由多个单词组成,则应该用下划线“_”来分割这些单词如:NUM_DAYS_IN_WEEK、MAX_VALUE。

     

    JAVA中定义常量方法

     

     

    一、常量定义的基本注意事项。
      在Java语言中,主要是利用final关键字(在Java类中灵活使用Static关键字)来定义常量。当常量被设定后,一般情况下就不允许再进行更改。如可以利用如下的形式来定义一个常量:final double PI=3.1315。在定义这个常量时,需要注意如下内容:


      一是常量在定义的时候,就需要对常量进行初始化。也就是说,必须要在常量声明时对其进行初始化。都跟局部变量或者成员变量不同。当在常量定义的 时候初始化过后,在应用程序中就无法再次对这个常量进行赋值。如果强行赋值的话,数据库会跳出错误信息,并拒绝接受这一个新的值。(接口中定义的常量的访问方法)


      二是final关键字使用的范围。这个final关键字不仅可以用来修饰基本数据类型的常量,还可以用来修饰对象的引用或者方法。如数组就是一 个对象引用。为此可以使用final关键字来定义一个常量的数组。这就是Java语言中一个很大的特色。一旦一个数组对象被final关键字设置为常量数 组之后,它只能够恒定的指向一个数组对象,无法将其改变指向另外一个对象,也无法更改数组(有序数组的插入方法可使用的二分查找算法)中的值。


      三是需要注意常量的命名规则。不同的语言,在定义变量或者常量的时候,都有自己一套编码规则。这主要是为了提高代码的共享程度与提高代码的易读 性。在Java语言中,定义常量的时候,也有自己的一套规则。如在给常量取名的时候,一般都用大写字符。在Java语言中,大小写字符是敏感的。之所以采 用大写字符,主要是跟变量进行区分。虽然说给常量取名时采用小写字符,也不会有语法上的错误。但是,为了在编写代码时能够一目了然的判断变量与常量,最好 还是能够将常量设置为大写字符。另外,在常量中,往往通过下划线来分隔不同的字符。而不想对象名或者类名那样,通过首字符大写的方式来进行分隔。这些规则 虽然不是强制性的规则,但是为了提高代码友好性,方便开发团队中的其他成员阅读,这些规则还是需要遵守的。没有规矩,不成方圆。


      总之,Java开发人员需要注意,被定义为final的常量需要采用大写字母命名,并且中间最好使用下划线作为分隔符来进行连接多个单词。在定义final的数据不论是常量、对象引用还是数组,在主函数中都不可以改变。否则的话,会被编辑器拒绝并提示错误信息。


      二、Final关键字与static关键字同时使用。


      由于Javal是面向对象的语言,所以在定义常量的时候还有与其它编程语言不同的地方。如一段程序代码从编辑到最后执行,即使需要经过两个过程,分别为代码的装载与对象的建立。不同的过程对于常量的影响是不同的。现在假设有如下的代码:


      Private static Random rd1=new Random(); //实例化一个随机数生成对象。


      Private final int int1=rd1.nestInt(10); //生成随机数并赋值给常量int1


      Private static final int int2=rd1.nestInt(10); //生成随机数并赋值给常量int2


      这上面的语句的大致含义是,通过Java语言提供的随机数类对象,生成随机数。并把生成的随机数赋值给常量int1与int2。细心的读者会发 现,虽然同样是赋值语句,但是以上两个语句中有一个细小的差别,即在第二条语句中多了一个关键字static。关于关键字的用途,笔者在以前的文章中也有 谈到过。这个是一个静态的概念。即当利用这个关键字来修饰一个变量的时候,在创建对象之前就会为这个变量在内存中创建一个存储空间。以后创建对对象如果需 要用到这个静态变量,那么就会共享这一个变量的存储空间。也就是说,在创建对象的时候,如果用到这个变量,那么系统不会为其再分配一个存储空间,而只是将 这个内存存储空间的地址赋值给他。如此做的好处就是可以让多个对象采用相同的初始变量。当需要改变多个对象中变量值的时候,只需要改变一次即可。从这个特 性上来说,其跟常量的作用比较类似。不过其并不能够取代常量的作用。

    展开全文
  • 标识符:组成:26个英文字母大小写,数字,0-...包名:xxyyzz……2.类名/接口名:XxxYyyZzz……3.变量名/函数名:xxYyyZzz……4.常量名:XXX_YYY_ZZZ……常量:整数常量几种特殊表现形式:八进制:0123(十进制的83)十六进制:0x1...

    标识符:

    组成:26个英文字母大小写,数字,0-9,符号:$,_

    规则:

    1.数字不可以开头(1ab)

    2.不能使用关键字(class)

    java严格区分大小写

    Java中的一些命名规范:

    1.包名:xxyyzz……

    2.类名/接口名:XxxYyyZzz……

    3.变量名/函数名:xxYyyZzz……

    4.常量名:XXX_YYY_ZZZ……

    常量:

    20181014061841208472.jpg

    整数常量几种特殊表现形式:

    八进制:0123(十进制的83)

    十六进制:0x13(0X13)

    二进制

    注意:

    长整形必须以l(L小写/小写)结尾:9l,1238238238L

    单精度浮点型(float)以f结尾:3.6f, .4f, 5.022e+23f

    变量:

    基本类型:

    20181014061843848928.jpg

    注意:整数默认:int,小数默认:double

    基本类型转换:

    例子:

    class TypeConversion1

    {

    public static void main(String[] args)

    {

    byte b=1;//判断1这个整形常量在不在-128~127范围内,在则正确,否则报错

    //b=b+2;//ERROR!,此时b的数据类型提升为int,与2(默认int),和为int

    //因此不能放在byte变量中

    b=(byte)(b+2);//把b+2的值强制转换为byte赋值给b,可能丢失精度(看下面的情况)

    int i=393;//此时已经超出byte范围

    System.out.println((byte)i);//-119,发生截断 详解转 截断图

    //long i2=1238989001234;//虽然定义的long,

    //但是此时已经超出默认int范围(-2^31~2^31-1),会报错

    long i2=1238989001234L;

    System.out.println(‘a‘+1);//98,字符类型会被提升为int(对应ASCII码为97)

    int n=123456789;

    float f=n;//1.234567892E8,虽然n的值没有超出f的数值范围,

    //但是float的有效数字为7位,也就是说 92这两位数字

    //已经不准了

    System.out.println(f);

    //float f=1.2;//由于浮点数默认为double,1.2赋值给f在编译时会报”可能损失精度”,这时可以使用单精度浮点数1.2f

    }

    }

    20181014061844365497.jpg

    需要知道:计算机中的数据以二进制补码的形式存储,其中正数的原码,反码,补码相同.

    而负数的反码为:符号位不变,其余位取反.补码:反码+1.

    20181014061844739496.jpg

    基本类型间的转换图:

    20181014061845088107.jpg

    注意:

    实心箭头表示无精度丢失的转换,虚箭头表示可能有精度损失的转换

    转换规则:

    一 数值类型转换规则

    数值型数据进行运算时,如果操作数的类型不同或操作数的类型均低于int型,则

    会进行自动类型转换处理,具体规则如下:

    1)如果两个操作数中有一个是double型,则系统先将另一个操作数的值转换为double

    型,然后再进行运算,否则

    2)如果两个操作数中有一个是float型,则系统先将另一个操作数的值转换为float

    型,然后再进行运算,否则

    3)如果两个操作数中有一个是long型,则系统先将另一个操作数的值转换为long

    型,然后再进行运算,否则

    4)两个操作数的值都将被转换为int型

    5)如果只有一个操作数(例如进行"~"位运算时)且其类型低于int型时,则将该操作数的值转换为int型

    简单归结为:

    1) byte,short,char->int->long->float->double

    2) byte,short,char之间不会互相转换,他们三者在计算时首先会转换为int类型

    注意:Java中可以将int型数值常量直接赋值给相应低级的byte,short,char型变量,

    而不需要进行强制类型转换,只要不超出变量的数值范围.

    展开全文
  • Java 常量

    2016-12-02 15:54:27
     Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如: ...

    在class文件中,“常量池”是最复杂也最值得关注的内容。

      Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如:

      类和接口的全限定名;

      字段的名称和描述符;

      方法和名称和描述符。

      在C语言中,如果一个程序要调用其它库中的函数,在连接时,该函数在库中的位置(即相对于库文件开头的偏移量)会被写在程序中,在运行时,直接去这个地址调用函数;

      而在Java语言中不是这样,一切都是动态的。编译时,如果发现对其它类方法的调用或者对其它类字段的引用的话,记录进class文件中的,只能是一个文本形式的符号引用,在连接过程中,虚拟机根据这个文本信息去查找对应的方法或字段。

      所以,与Java语言中的所谓“常量”不同,class文件中的“常量”内容很非富,这些常量集中在class中的一个区域存放,一个紧接着一个,这里就称为“常量池”。

    java中的常量池技术,是为了方便快捷地创建某些对象而出现的,当需要一个对象时,就可以从池中取一个出来(如果池中没有则创建一个),则在需要重复重复创建相等变量时节省了很多时间。常量池其实也就是一个内存空间,不同于使用new关键字创建的对象所在的堆空间。本文只从java使用者的角度来探讨java常量池技术,并不涉及常量池的原理及实现方法。个人认为,如果是真的专注java,就必须对这些细节方面有一定的了解。但知道它的原理和具体的实现方法则不是必须的。

    常量池中对象和堆中的对象

    [java] view plain copy
    1. public class Test{  
    2.   
    3. Integer i1=new Integer(1);  
    4.    Integer i2=new Integer(1);  
    5. //i1,i2分别位于堆中不同的内存空间  
    6.   
    7.    System.out.println(i1==i2);//输出false  
    8.   
    9.   
    10.    Integer i3=1;  
    11.    Integer i4=1;  
    12. //i3,i4指向常量池中同一个内存空间  
    13.   
    14.    System.out.println(i3==i4);//输出true  
    15.   
    16. //很显然,i1,i3位于不同的内存空间  
    17.   
    18. System.out.println(i1==i3);//输出false  
    19.   
    20. }  

    8种基本类型的包装类和对象池

    java中基本类型的包装类的大部分都实现了常量池技术,这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池,也即对象不负责创建和管理大于127的这些类的对象。以下是一些对应的测试代码:

    [java] view plain copy
    1. public class Test{  
    2.   
    3. public static void main(String[] args){  
    4.   
    5.    //5种整形的包装类Byte,Short,Integer,Long,Character的对象,  
    6.   
    7.    //在值小于127时可以使用常量池  
    8.   
    9.    Integer i1=127;  
    10.   
    11.    Integer i2=127;  
    12.   
    13.    System.out.println(i1==i2)//输出true  
    14.   
    15.    //值大于127时,不会从常量池中取对象  
    16.   
    17.    Integer i3=128;  
    18.   
    19.    Integer i4=128;  
    20.   
    21.    System.out.println(i3==i4)//输出false  
    22.   
    23.    //Boolean类也实现了常量池技术  
    24.   
    25.    Boolean bool1=true;  
    26.   
    27.    Boolean bool2=true;  
    28.   
    29.    System.out.println(bool1==bool2);//输出true  
    30.   
    31.    //浮点类型的包装类没有实现常量池技术  
    32.   
    33.    Double d1=1.0;  
    34.   
    35.    Double d2=1.0;  
    36.   
    37.    System.out.println(d1==d2)//输出false  
    38.   
    39.    
    40.   
    41. }  
    42.   
    43. }  

    String也实现了常量池技术

    String类也是java中用得多的类,同样为了创建String对象的方便,也实现了常量池的技术,测试代码如下:

    [java] view plain copy
    1. public class Test{  
    2.   
    3. public static void main(String[] args){  
    4.   
    5. //s1,s2分别位于堆中不同空间  
    6.   
    7. String s1=new String("hello");  
    8.   
    9. String s2=new String("hello");  
    10.   
    11. System.out.println(s1==s2)//输出false  
    12.   
    13. //s3,s4位于池中同一空间  
    14.   
    15. String s3="hello";  
    16.   
    17. String s4="hello";  
    18.   
    19. System.out.println(s3==s4);//输出true  
    20.   
    21. }  
    22.   
    23. }  

    最后

    细节决定成败,写代码更是如此。

    在JDK5.0之前是不允许直接将基本数据类型的数据直接赋值给其对应地包装类的,如:Integer i = 5; 

    但是在JDK5.0中支持这种写法,因为编译器会自动将上面的代码转换成如下代码:Integer i=Integer.valueOf(5);  

    这就是Java的装箱.JDK5.0也提供了自动拆箱. Integer i =5;  int j = i;  

    Integer的封装:

    [java] view plain copy
    1. public static Integer valueOf(int i) {    
    2.     final int offset = 128;    
    3.     if (i >= -128 && i <= 127) { // must cache     
    4.         return IntegerCache.cache[i + offset];    
    5.     }    
    6.       return new Integer(i);    
    7.  }    
    8.     
    9.     
    10. private static class IntegerCache {    
    11.     
    12.         
    13.     
    14. private IntegerCache(){}    
    15. static final Integer cache[] = new Integer[-(-128) + 127 + 1];    
    16.     static {    
    17.         for(int i = 0; i < cache.length; i++)    
    18.         cache[i] = new Integer(i - 128);    
    19.     }    
    20. }    

    由于cache[]在IntegerCache类中是静态数组,也就是只需要初始化一次,即static{......}部分,所以,如果Integer对象初始化时是-128~127的范围,就不需要再重新定义申请空间,都是同一个对象---在IntegerCache.cache中,这样可以在一定程度上提高效率。

    展开全文
  • java常量

    2016-05-03 15:49:54
     Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如: ...

    在class文件中,“常量池”是最复杂也最值得关注的内容。

      Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如:

      类和接口的全限定名;

      字段的名称和描述符;

      方法和名称和描述符。

      在C语言中,如果一个程序要调用其它库中的函数,在连接时,该函数在库中的位置(即相对于库文件开头的偏移量)会被写在程序中,在运行时,直接去这个地址调用函数;

      而在Java语言中不是这样,一切都是动态的。编译时,如果发现对其它类方法的调用或者对其它类字段的引用的话,记录进class文件中的,只能是一个文本形式的符号引用,在连接过程中,虚拟机根据这个文本信息去查找对应的方法或字段。

      所以,与Java语言中的所谓“常量”不同,class文件中的“常量”内容很非富,这些常量集中在class中的一个区域存放,一个紧接着一个,这里就称为“常量池”。

    java中的常量池技术,是为了方便快捷地创建某些对象而出现的,当需要一个对象时,就可以从池中取一个出来(如果池中没有则创建一个),则在需要重复重复创建相等变量时节省了很多时间。常量池其实也就是一个内存空间,不同于使用new关键字创建的对象所在的堆空间。本文只从java使用者的角度来探讨java常量池技术,并不涉及常量池的原理及实现方法。个人认为,如果是真的专注java,就必须对这些细节方面有一定的了解。但知道它的原理和具体的实现方法则不是必须的。

    常量池中对象和堆中的对象

    [java] view plain copy
    1. public class Test{  
    2.   
    3. Integer i1=new Integer(1);  
    4.    Integer i2=new Integer(1);  
    5. //i1,i2分别位于堆中不同的内存空间  
    6.   
    7.    System.out.println(i1==i2);//输出false  
    8.   
    9.   
    10.    Integer i3=1;  
    11.    Integer i4=1;  
    12. //i3,i4指向常量池中同一个内存空间  
    13.   
    14.    System.out.println(i3==i4);//输出true  
    15.   
    16. //很显然,i1,i3位于不同的内存空间  
    17.   
    18. System.out.println(i1==i3);//输出false  
    19.   
    20. }  

    8种基本类型的包装类和对象池

    java中基本类型的包装类的大部分都实现了常量池技术,这些类是Byte,Short,Integer,Long,Character,Boolean,另外两种浮点数类型的包装类则没有实现。另外Byte,Short,Integer,Long,Character这5种整型的包装类也只是在对应值小于等于127时才可使用对象池,也即对象不负责创建和管理大于127的这些类的对象。以下是一些对应的测试代码:

    [java] view plain copy
    1. public class Test{  
    2.   
    3. public static void main(String[] args){  
    4.   
    5.    //5种整形的包装类Byte,Short,Integer,Long,Character的对象,  
    6.   
    7.    //在值小于127时可以使用常量池  
    8.   
    9.    Integer i1=127;  
    10.   
    11.    Integer i2=127;  
    12.   
    13.    System.out.println(i1==i2)//输出true  
    14.   
    15.    //值大于127时,不会从常量池中取对象  
    16.   
    17.    Integer i3=128;  
    18.   
    19.    Integer i4=128;  
    20.   
    21.    System.out.println(i3==i4)//输出false  
    22.   
    23.    //Boolean类也实现了常量池技术  
    24.   
    25.    Boolean bool1=true;  
    26.   
    27.    Boolean bool2=true;  
    28.   
    29.    System.out.println(bool1==bool2);//输出true  
    30.   
    31.    //浮点类型的包装类没有实现常量池技术  
    32.   
    33.    Double d1=1.0;  
    34.   
    35.    Double d2=1.0;  
    36.   
    37.    System.out.println(d1==d2)//输出false  
    38.   
    39.    
    40.   
    41. }  
    42.   
    43. }  

    String也实现了常量池技术

    String类也是java中用得多的类,同样为了创建String对象的方便,也实现了常量池的技术,测试代码如下:

    [java] view plain copy
    1. public class Test{  
    2.   
    3. public static void main(String[] args){  
    4.   
    5. //s1,s2分别位于堆中不同空间  
    6.   
    7. String s1=new String("hello");  
    8.   
    9. String s2=new String("hello");  
    10.   
    11. System.out.println(s1==s2)//输出false  
    12.   
    13. //s3,s4位于池中同一空间  
    14.   
    15. String s3="hello";  
    16.   
    17. String s4="hello";  
    18.   
    19. System.out.println(s3==s4);//输出true  
    20.   
    21. }  
    22.   
    23. }  

    最后

    细节决定成败,写代码更是如此。

    在JDK5.0之前是不允许直接将基本数据类型的数据直接赋值给其对应地包装类的,如:Integer i = 5; 

    但是在JDK5.0中支持这种写法,因为编译器会自动将上面的代码转换成如下代码:Integer i=Integer.valueOf(5);  

    这就是Java的装箱.JDK5.0也提供了自动拆箱. Integer i =5;  int j = i;  

    Integer的封装:

    [java] view plain copy
    1. public static Integer valueOf(int i) {    
    2.     final int offset = 128;    
    3.     if (i >= -128 && i <= 127) { // must cache     
    4.         return IntegerCache.cache[i + offset];    
    5.     }    
    6.       return new Integer(i);    
    7.  }    
    8.     
    9.     
    10. private static class IntegerCache {    
    11.     
    12.         
    13.     
    14. private IntegerCache(){}    
    15. static final Integer cache[] = new Integer[-(-128) + 127 + 1];    
    16.     static {    
    17.         for(int i = 0; i < cache.length; i++)    
    18.         cache[i] = new Integer(i - 128);    
    19.     }    
    20. }    

    由于cache[]在IntegerCache类中是静态数组,也就是只需要初始化一次,即static{......}部分,所以,如果Integer对象初始化时是-128~127的范围,就不需要再重新定义申请空间,都是同一个对象---在IntegerCache.cache中,这样可以在一定程度上提高效率。

    展开全文
  • java常量池概念

    2017-06-28 22:56:00
    java常量池概念 在class文件中,“常量池”是最复杂也最值得关注的内容。  Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和...
  • Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如:类和接口的全...
  • Java常量池概念

    2018-01-16 13:46:13
     Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如: ...
  • Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如:类和接口的全...
  • Java常量池相关问题

    2016-09-12 14:06:19
    因此在这里把JAVA常量池相关的知识记录一下。  Java是一种动态链接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值外,还包含...
  • Java 常量池了解

    2016-01-08 10:05:49
    Java是一种动态链接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值外,还包含一些以文本形式出现的符号引用,比如: ...
  • java 常量池详解

    2014-07-13 23:23:49
     Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如: ...
  • 一、关键字关键字的定义和特点定义:被Java语言赋予特殊含义,用做专门用途的字符串(单词)。特点:关键字中所有字母均为小写下面列举一些常用的关键字。用于定义数据类型的关键字:byte、short、int、long、float、...
  • Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如: 类和接口...
  •  Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如: ...
  • java常量池概念(转)

    2017-08-03 10:23:48
    Java是一种动态连接的语言,常量池的作用非常重要,常量池中除了包含代码中所定义的各种基本类型(如int、long等等)和对象型(如String及数组)的常量值还,还包含一些以文本形式出现的符号引用,比如: 类和接口...
  • 但是由于Java面向对象编程的特性,每一名Java程序员都可以编写属于自己的Java包,为了保障每个Java包命名的唯一性,在最新的Java编程规范中,要求程序员在自己定义的名称之前加上唯一的前缀。由于互联网上的域...

空空如也

空空如也

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

java常量定义包名

java 订阅