精华内容
下载资源
问答
  • 1.我们知道js ES5中数据类型分为基本数据类型和复杂数据类型。 基本类型有5类,分别是null,undefined,number,string,boolen。 复杂数据类型是object; 2.基本数据类型又被成为值类型 ; 复杂数据类型又被...

    学习js经常看到这句话——Javascript里面所有的数据类型都是对象 。

    1.我们知道js ES5中数据类型分为基本数据类型和复杂数据类型。

    基本类型有5类,分别是null,undefined,number,string,boolen。

    复杂数据类型是object;

    2.基本数据类型又被成为值类型 ; 复杂数据类型又被成为引用类型;

    3.是不是所有的数据类型都是对象?明显不是。只有复杂数据类型是对象。

    4.举个栗子;

    String.prototype.str=function()
    {
    return 'hello';
    }
    var str1=5;
    str1 instanceof String //结果:false
    typeof str1  	       //'string'
    str1.str() 	       //hello 可以调用到String.prototype挂载的方法
    var str2=new String('a_string');
    typeof str2            //object
    str2.str()             //hello
    
    也可以调用到Number.prototype挂载的方法
    
    
    所以,在不需要明确判断类型字符串的时候,其实用法上基本没区别。

    区别在于,通过对象类型初始化的(typeof显示object) 可以挂载任意方法。而原始类型却不能。
    str2.bb=function()
    {
    return 'bb'
    }
    str2.bb()   //bb
    str1.bb=function(){
    return 'bb'
    }
    str1.bb()  //Uncaught TypeError: str1.bb is not a function(…)
    除了undefined 和 null 不能直接调用属性,其它的基本数据类型都可以直接调用属性,不存在则返回undefined

    所以说js是基于对象的脚本语言。

    5.另一个栗子;
    var num = new Number(7);

    console.log(num instanceof Number);  //true
    console.log(typeof a);                            // "object"


    var num = 7;

    console.log(num instanceof Number ); //false
    console.log(typeof num);                       //"number"

    展开全文
  • Java 基本数据类型对象类型

    千次阅读 2011-09-07 22:48:28
    基本数据类型在栈中进行分配,而对象类型在堆中进行分配。  所有方法的参数都是在传递引用而非本身的值(基本类型例外)。  对象之间的赋值只是传递引用,基本类型之间的赋值是创建新的拷贝。  例如: ...

      基本数据类型在栈中进行分配,而对象类型在堆中进行分配。

      所有方法的参数都是在传递引用而非本身的值(基本类型例外)。

      对象之间的赋值只是传递引用,基本类型之间的赋值是创建新的拷贝。

      例如:  String a = "china";

                 String b =a;  则a、b都指向常量池的"china"。

                 String a =  new String("china");

                 String b =a; 则a、b都指向堆中的"china"。

                 String a =  new String("china");

                 String b =a;

                 a = a.substring(0,1);

                 则b指向栈中的"china",a指向新的对象"c"。


      对于基本类型,“==”和“!=”是在比较值。而对于对象来说,“==”和“!=”是在比较两个引用是否相同。

      使用equals()方法有一点需要注意:equals()方法的默认行为是比较引用。如果是你自己写的类,你应该为它重写equals()来比较对象的内容。大多数Java类库都实现了比较对象内容的equals()方法。

      字符串操作符的特性:如果表达式以一个字符串起头,那么后面的操作数都会被自动转换为字符串型。所以有时候看到一个空的String后面+一个基本类型变量,这是一种简单执行字符串转换的方式。


    展开全文
  • java中基本数据类型对象引用类型的默认初始化值学习 8种基本数据类型的所占存储空间大小,最大值,最小值,及两个高精度类型。
    import org.junit.Test;
    
    public class TestInit {
        boolean boo;
        char cha;
        byte by;
        short shor;
        int in;
        float flo;
        long lon;
        double dou;
        String str;
    
        @Test
        public void aa() {
            System.err.println("boolean:" + boo);
            if (cha == '\u0000') {
                System.err.println("char:" + (int) cha);
                System.err.println(cha);
            }
            System.err.println("byte:" + by);
            System.err.println("short:" + shor);
            System.err.println("int:" + in);
            System.err.println("long:" + lon);
            System.err.println("float:" + flo);
            System.err.println("double:" + dou);
            System.err.println("String:" + str);
        }
    }
    

    以上为测试程序,输出结果为:

    boolean:false
    char:0
    byte:0
    short:0
    int:0
    long:0
    float:0.0
    double:0.0
    String:null
    


    结论:

           布尔值: boolean默认false

           字符: char,

           整数:byte,short,int,long为0

           实数: float,double为double类型的0.0

           对象引用为null


    补充:

    (1)、new方式创建对象保存到堆中,保存其地址的引用,对于基本数据类型来说,java采取和c、c++相同方式,创建的变量直接存储值,置于栈顶,更加高效。

    (2)、Java中每种基本数据类型所占存储空间大小,不依赖于机器硬件架构变化而变化,即基本数据类型所占存储空间具有不变性。

    (3)、所有数值类型都有正负号,没有无符号的数值类型

    各个基本数据类型的大小及精度如下表:

    基本类型 大小 最小值 最大值 包装类型
    boolean -- -- -- Boolean
    char 16bit,2个字节(byte) Unicode 0 Unicode 2^16-1即,65535 Character
    byte 8bit,1个字节 -128 127 Byte
    short 16bit,2个字节 -2^15即32768 +2^15-1,即32767 Short
    int 32bit,4个字节 -2^31即2147483648,约-21亿 +2^31-1,即2147483647,约约+21亿 Integer
    long 64bit,8个字节 -2^63即9223372036854775808,约-922亿亿 +2^63即9223372036854775807,约+922亿亿 Long
    float 32bit,4个字节 1.4E-45,即1.4*(1/10^45) 3.4028235E38,即3.4028235*10^38 Float
    double 64bit,8个字节 4.9E-324,即4.9*(1/10*324) 1.7976931348623157E308即1.7976931348623157*10^308 Double

    表说明:1)、boolean类型所占存储空间大小没有明确指定,仅仅定义能够取字面值true,false

                 2)、各个数值类型的最大值,最小值,均可通过包装类型的MIN_VALUE与MAX_VALUE获取,如Double.MIN_VALUE。

                 3)、jdk1.5后提供自动装拆箱机制,基本数据类型和包装类型自动转换。

                 4)、表格中按照从上到下精度由低到高(boolean除外),从高精度到低精度需显示强制转换(boolean除外)。

    附加:高精度数字

    BigInteger:支持任意精度的额整数,可以表示任何大小整数值,而不会丢失信息。

    BigDecimal:支持任何精度的定点数,如可以进行精确的货币运算。

    高精度数字缺点:运算速度比较慢,以速度换取精度。



    展开全文
  • java基本数据类型对象包装类

    千次阅读 2017-10-30 22:37:35
    java基本数据类型对象包装类   一、包装类说明 为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。 基本数据类型与...

    java基本数据类型对象包装类

     

    一、包装类说明

    为了方便操作基本数据类型值,将其封装成了对象,在对象中定义了属性和行为丰富了该数据的操作。用于描述该对象的类就称为基本数据类型对象包装类。

    基本数据类型相应的包装类

    byte             Byte

    short    Short

    int         Integer

    long             Long

    float     Float

    double Double

    char             Character

    boolean      Boolean

    二、包装类主要功能

    该包装对象主要用基本类型和字符串之间的转换。

    (1)基本类型--->字符串

    1、基本类型数值+""

    2、用String类中的静态方法valueOf(基本类型数值);

    3、用包装类的静态方法valueOf(基本类型数值);

    (2)字符串--->基本类型

    1、使用包装类中的静态方法:xxx parseXxx("xxx类型的字符串");

    eg:

    int parseInt("intstring");

    long parseLong("longstring");

    boolean parseBoolean("booleanstring");

    备注:只有Character没有parse方法,本身就是封装了字符,无须转换

    2、如果字符串被xxx包装类进行对象的封装。

    可使用另一个非静态的方法,xxxValue();

    将一个xxx包装类对象转成基本数据类型值。

    三、JDK1.5自动装箱拆箱

    (1)拆箱装箱概念

    装箱:自动将基本数据类型转换为包装器类型;

    拆箱:自动将包装器类型转换为基本数据类型。

    (2)jdk1.5后包装类新特性


    Integeri=4;//自动装箱,简化书写:Integer i=new Integer(4);
    i=i+6;//i=new Integer(i.intValue+6);//自动拆箱
    System.out.println(i.intValue());//10

    (3)拆箱装箱实现

    装箱:自动将基本数据类型转换为包装器类型;装箱过程是通过调用包装器的valueOf方法实现的

    拆箱:自动将包装器类型转换为基本数据类型。拆箱过程是通过调用包装器的 xxxValue方法实现的。(xxx代表对应的基本数据类型)。

    【1】实现代码案例

    package wrapper;
    
    
    public class Autoboxing_Unboxing {
    
    
    	public static void main(String[] args) {
    	Integer i = 10;//装箱
            int n = i;//拆箱
    	}
    	
    }

    【2】反编译代码发现

    反编译class文件之后得到如下内容:


     从反编译得到的字节码内容可以看出,在装箱的时候自动调用的是Integer的valueOf(int)方法。而在拆箱的时候自动调用的是Integer的intValue方法。

    其他的也类似,比如Double、Character,不相信的朋友可以自己手动尝试一下。

     

    【3】结论

      因此可以用一句话总结装箱和拆箱的实现过程:

    装箱过程是通过调用包装器的valueOf方法实现的,

    拆箱过程是通过调用包装器的 xxxValue方法实现的。(xxx代表对应的基本数据类型)。

    四、包装类装箱之valueOf方法之思

    1、创建对象与valueOf方法【装箱】

    思考:由于装箱过程是调用包装器的valueOf方法实现的,

    即:当Integer i=3过程,创建Integer对象的时候,这样一个装箱过程,就会调用包装器的valueOf方法。所以,我们在此重点讨论这个valueOf方法。

    2、valueOf方法结论

    主要得出几个结论:

    2.1不同包装类之间,有共性的地方。分为三大派别:

    【1】Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。比较特殊,根据数值的大小范围而获得对象的方式不同

    【2】Double、Float的valueOf方法的实现是类似的,每次都返回不同的对象。

    【3】Boolean的valueOf方法实现,每次返回的都是同一个对象

    2.2对于类别【1】

    (1)有两种创建对象的情况:

    《1》在一些特定取值范围内,创建的对象是共享的,即:该数值范围的对象,在内存中只创建一个(一次),以后想创建该数值的对象,直接获取即可,不需要去new新的。

    这个范围的取值情况是:

    相同对象范围:在该范围内,同数值情况下,对象是相同的,是同一个。

    Integer    相同对象范围  [-128,127]

    Short      相同对象范围  [-128,127] 

    Byte      相同对象范围  [-128,127]  

    Character  相同对象范围  [0,127]    

    Long      相同对象范围 [-128,127]  

    《2》除了上述的取值范围内,对象只创建一个,这里所说的范围内,对象不会共享,相同数值情况下,会创建不同的对象

    这个范围的取值情况是:

    不同对象范围:在该范围内,同数值情况下,对象是不同的,是多个不同的。

    Integer    不同对象范围 i<128||i>=128

    Short     不同对象范围 s<128||s>=128

    Byte      不同对象范围  无

    Character  不同对象范围  c>=128

    Long      不同对象范围 L<128||L>=128

    综合《1》《2》得

    Integer    相同对象范围 [-128,127] 不同对象范围i<128||i>=128

    Short     相同对象范围 [-128,127] 不同对象范围s<128||s>=128

    Byte      相同对象范围 [-128,127] 不同对象范围

    Character  相同对象范围 [0,127]   不同对象范围c>=128

    Long     相同对象范围 [-128,127] 不同对象范围 L<128||L>=128

    (2)Integer的valueOf源码

    来源:CSDN博客

    博文:Java 自动装箱和拆箱

    博主:jackiehff

    网址:http://blog.csdn.net/jackiehff/article/details/8509056

    【1】valueOf工厂方法

       

     public static Integer valueOf(int i) {   
            if(i >= -128 &&i<=IntegerCache.high)   
              //如果i在-128~high之间,就直接在缓存中取出i的Integer类型对象 
              return IntegerCache.cache[i + 128];   
            else 
              return new Integer(i); //否则就在堆内存中创建  
        }   

    【2】IntegerCache内部类

     private static class IntegerCache {//内部类,注意它的属性都是定义为static final 
            static final inthigh; //缓存上界 
            static final Integer cache[];//cache缓存是一个存放Integer类型的数组 
         
            static {//静态语句块 
               final int low = -128;//缓存下界,值不可变 
         
               // high valuemay beconfigured by property 
               int h = 127;// h值,可以通过设置jdk的AutoBoxCacheMax参数调整(参见(3)) 
               if (integerCacheHighPropValue!=null) { 
                   // UseLong.decode here to avoid invoking methods that 
                   // requireInteger's autoboxing cache to be initialized 
                   // 通过解码integerCacheHighPropValue,而得到一个候选的上界值 
                   int i = Long.decode(integerCacheHighPropValue).intValue(); 
                   // 取较大的作为上界,但又不能大于Integer的边界MAX_VALUE 
                   i = Math.max(i, 127);//上界最小为127 
                   // Maximumarray size is Integer.MAX_VALUE 
                   h = Math.min(i, Integer.MAX_VALUE - -low); 
               } 
               high = h; //上界确定,此时high默认一般是127 
               // 创建缓存块,注意缓存数组大小 
               cache =new Integer[(high - low) +1]; 
               int j = low; 
               for(int k = 0; k <cache.length; k++) 
                   cache[k] =new Integer(j++);// -128到high值逐一分配到缓存数组 
           } 
         
            private IntegerCache() {}//构造方法,不需要构造什么 
        } 

    分析:取值范围[-128,127]共享对象,之外创建独立对象

    (3)Short的valueOf源码

      

    public static Short valueOf(short s) {
            final int offset = 128;
            int sAsInt = s;
            if (sAsInt >= -128 &&sAsInt <= 127) { // must cache
                return ShortCache.cache[sAsInt +offset];
            }
            return new Short(s);
    }

    分析:取值范围[-128,127]共享对象,之外创建独立对象

     

    (4)Long的valueOf源码

    public static Long valueOf(long l) {
            final int offset = 128;
            if (l >= -128 &&l <= 127) { // will cache
                return LongCache.cache[(int)l + offset];
            }
            return new Long(l);
    }

    分析:取值范围[-128,127]共享对象,之外创建独立对象

    (5)Byte的ValueOf源码

    public static Byte valueOf(byte b) {
            final int offset = 128;
            return ByteCache.cache[(int)b +offset];
    }
     
    private static class ByteCache {
            private ByteCache(){}
            static final Byte cache[] =new Byte[-(-128) + 127 + 1];
            static {
                for(int i = 0; i < cache.length;i++)
                    cache[i] =new Byte((byte)(i - 128));
            }
        }


    分析:取值范围[-128,127]共享对象

    备注:基本数据类型byte的取值范围[-128,127]

    (6)Character的valueOf源码

      

     public static Character valueOf(char c) {
            if (c <= 127) {//must cache
                return CharacterCache.cache[(int)c];
            }
            return new Character(c);
    }

    分析:取值范围[0,127]共享对象,之外创建独立对象

    (7)一些测试案例

    《1》案例一

    package wrapper;
     
    public class CharacterTest {
     
        //测试结论: 0-127范围,对象共享;128开始,创建不同的新对象
        public static void main(String[] args) {
     
           Character c1=(char) 128;
           Character c2=(char)128;
           System.out.println(c1==c2);//false
           System.out.println(c1.equals(c2));//true
          
           Character c11=(char) 127;
           Character c12=(char)127;
           System.out.println(c11==c12);//true
           System.out.println(c11.equals(c12));//true
          
           Character c21=(char) 0;
           Character c22=(char)0;
           System.out.println(c21==c22);//true
           System.out.println(c21.equals(c22));//true
          
     
        }
     
    }


    《2》案例二

    package wrapper;
     
    public class ByteTest {
     
        //测试结论:byte取值的范围:-128-127
        //而在byte的范围内的对象都是可以共享的
       
        public static void main(String[] args) {
           //byte最大
           Byte b1=127;
           Byte b2=127;
           System.out.println(b1==b2);//true
           System.out.println(b1.equals(b2));//true
          
           //byte最小
           Byte b11=-128;
           Byte b12=-128;
           System.out.println(b11==b12);
           System.out.println(b11.equals(b12));
          
           //对于超出byte取值范围[-128,127]的,最终都会转为byte范围内的数字,所以一样得到了true的结果
          
    //     Byte b12=128;//报错
           Byte b13=(byte) 128;
           //int(32位)的128强制类型转为byte(8位)型,其中会把多余的24位剔除,从而转换成byte范围的数
           Byte b23=(byte) 128;
           System.out.println(b13==b23);//true
           System.out.println(b13.equals(b23));//true
          
           Byte b21=(byte) -129;
           Byte b22=(byte) -129;
           System.out.println(b21==b22);//true
           System.out.println(b21.equals(b22));//true
          
        }
     
    }


    2.3对于类别【2】Double、Float的valueOf方法的实现是类似的,每次都返回不同的对象】

    (1)Double 的ValueOf源码

       

     public static Double valueOf(double d) {
            returnnew Double(d);
    }

    分析:每次都创建不同的对象

    (2)Float 的ValueOf源码

       

    public static Float valueOf(floatf) {
            return new Float(f);
        }

    分析:每次都创建不同的对象

     

    2.4对于类别【3】Boolean的valueOf方法实现,每次返回的都是同一个对象

    Boolean 的ValueOf源码

      

      public static final Boolean TRUE =new Boolean(true);
        public static final Boolean FALSE =new Boolean(false);
        public static Boolean valueOf(booleanb) {
            return (b ?TRUE : FALSE);
    }

    分析:每次的对象都是同一个,因为那个对象是创建好的常量。

    五、包装类的equals方法

    1、方法结论

    1.1结论

    equals方法为true时,需要满足两个条件:

    1、类型相同  2、内容相同

    1.2源码分析

    (1)Integer的equals源码

      public boolean equals(Object obj) {
            if (obj instanceof Integer) {
                return value == ((Integer)obj).intValue();
            }
            return false;
        }


    (2)Short的equals源码

     

     public boolean equals(Object obj) {
            if (obj instanceof Short) {
                return value == ((Short)obj).shortValue();
            }
            return false;
        }

    (3)Long的equals源码

      

    public boolean equals(Object obj) {
            if (obj instanceof Long) {
                return value == ((Long)obj).longValue();
            }
            return false;
        }

    (4)Character的equals源码

      public boolean equals(Object obj) {
            if (obj instanceof Character) {
                return value == ((Character)obj).charValue();
            }
            return false;
        }


    (5)Byte的equals源码

     

     public boolean equals(Object obj) {
            if (obj instanceof Byte) {
                return value == ((Byte)obj).byteValue();
            }
            return false;
        }

    (6)Float的equals源码

      

      public boolean equals(Objectobj) {
            return (obj instanceof Float)
                   && (floatToIntBits(((Float)obj).value) ==floatToIntBits(value));
        }

    (7)Double的equals源码

     

       public boolean equals(Objectobj) {
            return (obj instanceof Double)
                   && (doubleToLongBits(((Double)obj).value) ==
                          doubleToLongBits(value));
        }

    (8)Boolean的equals源码

      

      public boolean equals(Objectobj) {
            if (obj instanceof Boolean) {
                returnvalue == ((Boolean)obj).booleanValue();
            }
            return false;
        }

    六、包装类一些结论总结

    1、当一个基础数据类型封装类进行==运算时,会将封装类进行拆箱

    2、+运算时,会将封装类进行拆箱

    3、当封装类与基础类型进行==运行时,封装类会进行拆箱,拆箱结果与基础类型对比值;

    两个封装类进行==运行时,与其它的对象进行==运行一样,对比两个对象的地址,也即判断是否两个引用是否指向同一个对象。

    4、陷阱一:有拆箱操作时一定要特别注意封装类对象是否为null,如果为空,则不能调用对象的任何方法,否则会报错

    5、陷阱二:不同范围数值的对象产生情况不同(详情看:四、包装类装箱之valueOf方法之思)

    该结论来自以下参考文章,如果想了解详细,请看该文

    博文:详解Java的自动装箱与拆箱(Autoboxingand unboxing)

    博主:Mirhunana

    网址:http://blog.csdn.net/hp910315/article/details/48654777

    七、包装类综合实例应用

    package wrapper;
     
    public class Test {
     
        public static void main(String[] args) {
           /*
            * 当 "=="运算符的两个操作数都是包装器类型的引用,则是比较指向的是否是同一个对象,
            * 而如果其中有一个操作数是表达式(即包含算术运算)则比较的是数值(即会触发自动拆箱的过程)。
            * 另外,对于包装器类型,equals方法并不会进行类型转换
            */
            Integer a = 1;
            Integer b = 2;
            Integer c = 3;
            Integer d = 3;
            Integer e = 321;//大于一个字节表示范围(byte:-128-127)
            Integer f = 321;
            Long g = 3L;
            Long h = 2L;
     
     
            //如果装箱的是一个字节,该数据会被共享不会重新开辟空间
            System.out.println(c==d);//true
            System.out.println(e==f);//false 
           
            /*
             * a+b包含了算术运算,因此会触发自动拆箱过程(会调用intValue方法),
             * 因此它们比较的是数值是否相等。
             * 
             * 而对于c.equals(a+b)会先触发自动拆箱过程,再触发自动装箱过程,
             * 也就是说a+b,会先各自调用intValue方法,得到了加法运算后的数值之后,
             * 便调用Integer.valueOf方法,再进行equals比较。同理对于后面的也是这样,
             * 不过要注意倒数第二个和最后一个输出的结果(如果数值是int类型的,
             * 装箱过程调用的是Integer.valueOf;如果是long类型的,装箱调用的Long.valueOf方法)
             */
           
            /*
             * 3=(1+2)
             * a+b包含了算术运算,因此会触发自动拆箱过程(会调用intValue方法),
             * 因此它们比较的是数值是否相等。
             */
            System.out.println(c==(a+b));//true
           
            /*
             * 3.equals(1+2)
             * 先自动拆箱,左边数值为3,右边数值为3;
             * 然后出发自动装箱,装箱过程中调用Integer.valueOf方法,
             * 即:如果装箱的是一个字节,该数据会被共享不会重新开辟空间
             * 过左边和右边是同一个空间的地址,所以相等
             */
            System.out.println(c.equals(a+b));//true
           
    //       System.out.println("3L==(1+2)--"+(3L==(1+2)));
           
            /*
             * 3L==(1+2)
             * a+b包含了算术运算,因此会触发自动拆箱过程(会调用intValue方法),
             * 因此它们比较的是数值是否相等。
             * 左边为3L 右边为3 ,两者的值相等吗?
             * 相等:int与 long进行运算、比较时 int 会自动进行类型提升为 long类型
             *      类型自动提升
             */
            System.out.println(g==(a+b));//true
            /*
             * 3L.equals(1+2)
             * 先自动拆箱,左边数值为3L,右边数值为3;
             * 然后出发自动装箱,装箱过程中左边调用Double.valueOf方法,右边调用Integer.valueOf方法
             * 左边为Long型,右边为Integer型(原因:类型不同,内容相同)
             */
            System.out.println(g.equals(a+b));//false
     
            /*
             * 3L.equals(1+2L)
             * 先自动拆箱,左边数值为3L,右边数值为3L(运算的时候,由于自动类型转换,所以为3L);
             * 然后出发自动装箱,装箱过程中两边都调用Double.valueOf方法
             * 两边数值相等,故相等(类型和内容相同)
             */
            System.out.println(g.equals(a+h));//true
        }
     
    }

    八、参考文章

    1、参考文章一

    来源:CSDN博客

    博文:Java 自动装箱和拆箱

    博主:jackiehff

    网址:http://blog.csdn.net/jackiehff/article/details/8509056

    2、参考文章二

    来源:博客园

    博文:深入剖析Java中的装箱和拆箱

    博主:海 子

    网址:http://www.cnblogs.com/dolphin0520/p/3780005.html

    3、参考文章三

    来源:CSDN博客

    博文:Java自动装箱与拆箱及其陷阱

    博主:JairusChan

    网址:http://blog.csdn.net/jairuschan/article/details/7513045

    4、参考文章四

    来源:CSDN博客

    博文:详解Java的自动装箱与拆箱(Autoboxing and unboxing)

    博主:Mirhunana

    网址:http://blog.csdn.net/hp910315/article/details/48654777

    展开全文
  • 1.Foundation框架中提供了很多的集合类  如:NSArray,NSMutableArray,NSSet,NSMutableSet,NSDictionary,NSMutableDictionary但  是这些类只能存放OC对象类型数据
  • JS基本数据类型对象的valueOf方法

    千次阅读 2017-03-03 10:00:01
    js基本数类型javascript高级程序设计第三版中讲到,js基本数据类型有五个,分别是undefinded、null、boolean、string以及number,但是我们有时候会在很多相关博客以及书籍中看到他们所讲的基本数据类型和此处不一致...
  • JAVA 基本数据类型对象包装类

    千次阅读 2013-03-12 21:34:35
    基本数据类型对象包装类 基本数据类型 引用数据类型 byte Byte short Short int Integer long Long float Float double Double char Characher boolean Boolean 基本数据类型对象...
  • JS数据类型之基本数据类型

    万次阅读 多人点赞 2019-06-28 16:46:43
    1.JavaScript(以下简称js)的数据类型分为两种:原始类型(即基本数据类型)和对象类型(即引用数据类型); 2.js常用的基本数据类型包括undefined、null、number、boolean、string; 3.js的引用数据类型也就是...
  • JAVA比较(基本数据类型对象类型)

    千次阅读 2018-01-29 13:14:00
    两个人的年纪谁大,谁小,年纪一般是基本数据类型,整型,如小明今年30岁,小张今年25我们说小张比较年轻,我们是怎么判断的呢,我们是用年纪的差,即小明年龄减去小张年龄,如果大于0,说明小张
  • Java方法中一个返回值类型为基本数据类型long,return语句可以是一个对象吗
  • 在JAVA 程序中我们往往需要给对象进行赋值操作,但是对于不同数据类型的赋值是有区别的,比如:对基本数据类型的赋值并非指向一个对象的引用,所以在为其赋值的时候是直接将一个地方的值复制到另一个地方,所以对于...
  • 为何数据类型中还分为:基本类型和对象?按理不应该只有一个类型—对象吗? 1.首先,Java中一切皆是对象!这句话没错,因为八种基本类型都有对应的包装类(int的包装类是Integer),包装类自然就是对象了。基本类型...
  • java中的对象类型与基本数据类型的区别
  • JAVA之旅(十八)——基本数据类型对象包装类,集合框架,数据结构,Collection,ArrayList,迭代器Iterator,List的使用 JAVA把完事万物都定义为对象,而我们想使用数据类型也是可以引用的 一.基本数据类型对象...
  •  Java中有8种基本数据类型boolean、byte、short、char、int、flaot、long、double,基本数据类型作为Java语言的一部分,但基本数据类型不是对象基本数据类型放在堆栈中,对象放在堆中。堆的读写速度远不及栈,...
  • C51基本数据类型

    千次阅读 2019-12-19 13:42:36
    C51基本数据类型 C51中基本数据类型主要是指变量类型。变量是指其值可以改变的量。一个变量实质上是代表了内存中的某个存储单元。程序中的变量a,就是指用a命名的某个存储单元,用户对变量a进行的操作就是对该存储...
  • 根据这篇文章可以理解一下java中的基本... 基本数据类型指的是简单的数据段,引用数据类型指的是有多个值构成的对象。 当我们把变量赋值给一个变量时,解析器首先要确认的就是这个值是基本类型值还是引用类型值...
  • Java不是纯的面向对象的语言,不纯的地方就是这些基本数据类型不是对象。当然初期Java的运行速度很慢,基本数据类型能在一定程度上改善性能。如果你想编写纯的面向对象的程序,用包装器类是取代基本数据类型就可以了...
  • 1.泛型的定义:在程序中我们将一个...2.泛型要求包容的是对象类型,而基本数据类型在Java中不属于对象。但是基本数据类型有其封装类,且为对象类型。 3.想放int类型,要放Integer类型不能直接放int(基本数据类型...
  • public class WrapperDemo { /** * @param args ... * 基本数据类型对象包装类 * 为了方便操作基本数据类型值,将其封装成对象,在对象中定义属性和行为,丰富了该数据类型的操作。 * 概述:用于
  • JavaScript基本数据类型

    万次阅读 2018-07-13 19:49:32
    JavaScript是弱类型脚本语言...JavaScript基本数据类型有如下五个(1)数值类型(2)布尔类型(3)字符串类型(4)Undefined类型(5)Null类型1. 数值类型与强类型语言如C、Java不同,JavaScript的数值类型不仅包括...
  • JAVA基本数据类型与引用数据类型

    万次阅读 多人点赞 2016-11-09 09:30:34
    基本数据类型 对象类型 在栈中进行分配 在堆中进行分配 基本类型之间的赋值是创建新的拷贝 对象之间的赋值只是传递引用 “==”和“!=”是在比较值 “==”和“!=”是在比较两个引用是否...
  • typescript基本数据类型

    千次阅读 2019-08-02 17:06:37
    ts共有7种基本数据类型 分别为: Boolean Number String Array Enum Any Void 对各种数据类型的声明以及注意事项都浓缩在如下代码块,为了方便您可以可自行粘贴运行:如果您还不会编译ts文件请点击这里看我的另一篇...
  • //数据结构基本概念 #include&lt;iostream&gt; using namespace std; /* 数据 – 程序的操作对象,用于描述客观事物 数据的特点: ...数据是一个抽象的概念,将其...数据元素:组成数据对象基本单位 数据对...
  • 在java开发中,如何高效的判断json对象的键值对中的值是对象、数组还是基本数据类型
  • Java集合不能存放基本数据类型,只存放对象的引用

    万次阅读 多人点赞 2017-05-06 13:52:15
    1. 集合存储对象Java集合中实际存放的只是对象的引用,每个集合元素都是一个引用变量,实际内容都放在堆内存或者方法区里面,但是基本数据类型是在栈内存上分配空间的,栈上的数据随时就会被收回的。2.
  • 一个变量可以存放两种类型的值,基本类型的值...它是 JavaScript 语言的第七种数据类型,前六种是:Undefined、Null、布尔值(Boolean)、字符串(String)、数值(Number)、对象(Object)。 基本类型 ...
  • Python基本数据类型

    千次阅读 2015-09-12 08:12:40
    基本数据类型 数值型 整型Integral 浮点型Float 复数 布尔型Bool 变量的命名规则 组合数据类型 序列 字符串String 元组Tuple 列表List 最后前言Python作为一种弱类型编程语言,其数据类型较之于C/C++无论是在数据的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,361,155
精华内容 544,462
关键字:

基本数据类型是对象吗