精华内容
下载资源
问答
  • JS数据类型之引用数据类型

    千次阅读 2019-06-28 16:46:51
    1、引用数据类型也就是对象数据类型object,比如:object、array、function、data等; 2、引用类型的值可以改变: let person = {name: 'lisa'} person.name = 'Jane' // 通过修改对象属性值更改对象 console....

    1、引用数据类型也就是对象数据类型object,比如:object、array、function、data等;

    2、引用类型的值可以改变:

      let person = {name: 'lisa'}
      person.name = 'Jane' // 通过修改对象属性值更改对象
      console.log(person) // 输出:{name: "Jane"}
      person.age = 18 // 给对象增加一个属性
      console.log(person) // 输出:{name: "Jane", age: 18}
      let arr = [1, 2, 3, 4, 5]
      arr[0] = 0 // 更改数组的某一个元素
      console.log(arr) // 输出:[0, 2, 3, 4, 5]
      arr[5] = 6 // 给数组增加一个元素
      console.log(arr) // 输出:[0, 2, 3, 4, 5, 6]

    3、引用类型可以添加属性和方法:

      let person = {}
      person.name = 'lisa'
      person.say = function () {
        alert('hello world')
      }
      console.log(person.name)   // 输出:lisa
      console.log(person.say)   // 输出:function () { alert('hello world') }

    4、引用类型的赋值是对象引用

      let a = {}
      let b = a
      a.name = 'lisa'
      console.log(a.name)  // 输出:lisa
      console.log(b.name)  // 输出:lisa
      b.age = 18
      console.log(a.age)  // 输出:18
      console.log(b.age)  // 输出:18

    看上面的代码,我们发现当从一个变量向另一个变量赋值引用类型的值时候,同样会将存储在变量中的对象的值复制一份放到位新变量分配的空间中,引用类型保存在变量中的是对象在堆内存中的地址。所以,与基本数据类型的简单赋值不同,这个值的副本实际上是一个指针,而这个指针指向存储在堆内存的一个对象。那么赋值操作后,两个变量都保存了同一个对象的地址,而这两个地址都指向了同一个对象,因此,改变其中任何一个变量,都会互相影响。

    关系图如下所示:

    所以,引用类型的赋值其实是对象保存在栈区地址指针的赋值,所以两个变量指向同一个对象,任何的操作都会互相影响。

    5、引用类型的比较是引用的比较

      let man = {}
      let woman = {}
      console.log(man === woman) // 输出:false

    看上面的例子发现,两个对象一模一样,但是却不相等。因为引用类型的比较是引用的比较,换句话说,就是比较两个对象保存在栈区的指向堆内存的地址是否相等,此时,虽然man和woman看起来都是一个“{}”,但是他们保存在栈区中的指向堆内存的地址却是不同的,所以两个对象不相等。

    6、引用类型是同时保存在栈区中和堆区中的,引用类型的存储需要在内存的栈区和堆区中共同完成,栈区保存变量标识符和指向堆内存的地址:

      let a = {name: 'aaa'}
      let b = {name: 'bbb'}
      let c = {name: 'ccc'}

    上面三个对象的内存中保存情况如下图:

     

    展开全文
  • 理解Java自定义类作为数据类型——引用数据类型

    千次阅读 多人点赞 2020-01-11 20:01:48
    前言:Java的数据类型按照类型可分为基本数据类型(byte、short、int、long、double、float、char、boolean)和引用数据类型(类(class)、接口(interface)、数组(array)),8种基本数据类型相信只要接触过Java就...

    目录

    说在前面的话

    复现问题

    引用数据类型的理解

    总结


     

    • 说在前面的话

    前言:Java的数据类型按照类型可分为基本数据类型(byte、short、int、long、double、float、char、boolean)和引用数据类型(类(class)、接口(interface)、数组(array)),8种基本数据类型相信只要接触过Java就比较熟悉。而对于引用数据类型相对来说比较陌生,下边会对引用数据类型中的类(class)做一个比较浅显的介绍,这也是由于我自己在学习的过程中碰见了问题,难以理解之后查阅了相关资料稍微理解了一点儿,希望能学习过程中不理解这块的同道中人提供一些可借鉴的地方!!!

    • 复现问题

    下面是我写的两个类,描述问题:可以看到类B的第二个属性被定义为private A a;显然是用了第一个自定义的类 作为数据类型,当我看到这一步我有点儿懵了,经过网上阅读博客借鉴加上自身理解,故有此篇博文!

    public class A {
    	private int age;
    	private String name;
    	……
    }
    
    public class B {
    	private int score;
    	private A a;
    	……
    }
    • 引用数据类型的理解

    引用类型指向一个对象,不是原始值,指向对象的变量是引用变量,那么引用数据类型相较于基本数据类型,与基本数据类型有哪些区别或是特性?我们不妨可以通过一个客户存钱与取钱的例子进行解释:

    Accout类:定义了账号、余额私有属性,定义构造方法对属性进行赋值的同时提供了对应的get/set方法。此外提供取款withdraw()方法以及存款deposit()方法进行相关操作。

    public class Account {
    	
    	private int id;//账号
    	private double balance;//余额
    	public Account(int id, double balance) {//构造方法
    		this.id = id;
    		this.balance = balance;
    	}
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public double getBalance() {
    		return balance;
    	}
    	public void setBalance(double balance) {
    		this.balance = balance;
    	}
    	public void withdraw(double amount) {//取款
    		if (balance >= amount) {
    			balance -= amount;
    			System.out.println("取款成功:" + amount + "元," + "账户余额为:" + this.getBalance() + "元");
    		} else {
    			System.out.println("取款失败");
    		}
    	}
    	public void deposit(double amount) {//存款
    		if(amount > 0) {
    			balance += amount;
    			System.out.println("存款成功:" + amount + "元," + "账户余额为:" + this.getBalance() + "元");
    		} else {
    			System.out.println("存款失败");
    		}
    	} 
    	
    }

     

    Customer类:定义了name私有属性,使用Java自定义类Account作为属性数据类型(重复上文提到的:引用类型指向一个对象,不是原始值,指向对象的变量是引用变量),是否可以理解为Customer类中属性是包含Account类的,private Account account是否可以说是定义了Account类的一个对象,正如灯管和灯泡,灯管中必定是包含着灯泡的。

    public class Customer {
    	
    	private String name;//姓名
    	private Account account;//账单,引用数据类型,与String类型进行比较,String[] string = new String[10];
    	public Customer(String name) {//构造方法
    		this.name = name;
    	}
    	public String getName() {
    		return name;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public Account getAccount() {
    		return account;
    	}
    	public void setAccount(Account account) {
    		this.account = account;
    	}
    }
    

     

    CustomerTest类:测试类,我们先定义了Customer类的一个对象并通过构造方法赋值,接着定义了Account类的一个对象并赋值,比较重要的一步是如何将账户信息与客户之间建立联系,我们在Customer类中提供了account属性的set方法,可以将我们定义的Account类的对象作为参数调用Customer类对象的setAccoount()方法,这样我们就使得客户有了自己的账户信息,这也就是类作为引用数据类型的一个作用。

    public class CustomerTest {
    	public static void main(String[] args) {
    		Customer customer = new Customer("haitao");//创建用户对象customer
    		
    		Account account = new Account(1000, 2020);//创建账单对象
    
    		customer.setAccount(account);//实现客户与账单的联系
    		System.out.println("当前客户ID:" + account.getId() + ",账户余额为:"+ account.getBalance() + "元");
    		System.out.println("**********************************");
    		customer.getAccount().deposit(100);//存款
    		customer.getAccount().withdraw(960);//取款
    	}
    }
    

     在eclipse中运行程序,我们将会看到以下的结果:

    • 总结

    我们可以看到Java自定义类作为数据类型的一个作用,可以使得两个类之间能够建立起联系,博文只是简单的从表面上进行了类作为引用数据类型的一些介绍,并没有进行更加深入细致的详解,毕竟我本人也就是一个初学者,自己的理解也没有大牛那么深刻,可能在一些细节的表述有出入不恰当,欢迎大家指正共同进步,希望对大家有所帮助!

    展开全文
  • JS中的数据类型 (一)、基本数据类型(值类型) 1.number:数字 -12、12.5、-12.5 0这些数字都是number; js中增加了一个number类型的数据:‘NaN’ typeof NaN ->“number” ①"NaN&...

    JS中的数据类型

    (一)、基本数据类型(值类型)

    1.number:数字

    -12、12.5、-12.5 0这些数字都是number;
    js中增加了一个number类型的数据:‘NaN’
    typeof NaN ->“number”

    ①"NaN"

    not a number:不是一个数,但是属于number类型
    NaN == NaN :false NaN和任何其它值都不相等

    ②"isNaN() "

    用来检测当前这个值是否是有效数字,如果不是有效数字,检测的结果是true;反之为false
    isNaN(0)->false
    isNaN(NaN)->true
    isNaN(‘12’)–>false 当我们使用isNaN检测值的时候,检测的值不是number类型的,浏览器会默认的把值转化为number类型,然后再去检测
    在这里插入图片描述

    ③"Number()"

    把其它数据类型值转化为number类型的值;
    Number(‘12’) ->12
    Number(‘12px’) ->NaN 在使用Number转换的时候只要字符串中出现一个非有效数字字符,最后结果都是NaN;
    在这里插入图片描述

    ④Number([])

    把引用数据类型转换为number,首先把引用数据类型转换为字符串(toString),在把字符串转换为number即可 例如:[]->’’ ‘’->0
    在这里插入图片描述

    ⑤ ‘parseInt()’

    把其它数据类型转换为number,和Number方法在处理字符串的时候有区别
    在这里插入图片描述
    parseInt(‘12px13’) -->12 提取规则:从左到右依次查找有效数字字符,直到遇见非有效数字字符为止(不管后面是否还,有都不找了),把找到的转换为数字
    parseInt(‘px12’) ->NaN

    ⑥parseFloat()

    在parseInt的基础上可以识别小数点
    在这里插入图片描述

    2. string:字符串

    -'zhufeng' '珠穆朗玛峰' ->单双引号包裹起来的都是字符串(单双引号没有区别)
    字符串常用方法
    charAt charCodeAt
    substr substring slice
    toUpperCase toLowerCase
    indexOF lastindexOf
    split
    replace
    replace
    match

    3. boolean:布尔类型( 只有true 和false俩个值`)

    Boolean()

    把其它数据类型的值转换为布尔类型
    只有“0,NaN,空字符串、null,undefined”这五个数据值转换成布尔类型的false,其余的都为true
    在这里插入图片描述

    '!'

    !=;不等于
    叹号在JS中还有一个作用:取反,先把值转换成布尔类型,再去取反
    在这里插入图片描述

    ③ ‘!!’

    在一个叹号取反的基础上在取反,取俩次反相当于没有任何操作,但是已经把其他类型值转换为布尔类型了,和Boolean是相同的效果
    在这里插入图片描述

    4. (null):空对象指针(null是空对象,不是(null),因为不加(),null就是个空对象,不显示了)

    现在没有, 以后会有的, 空指针对象

    5. undefined:未定义

    压根就没有过,现在没有以后也没有0

    (二)、引用数据类型

    引用数据类型(应运而生){} [] Date RegExp fn .

    1.object对象数据类型

    对象 是复合数据的载体, 用{}包起来, 内容是一对一对的键值对(属性名: 属性值)
    这里的冒号相当于 等号 是赋值的意思,不同的键值对之间用逗号隔开
    ③ 属性名 对应 咱们变量名 (但是属性名可以是数字,也不能是数字开头的字符)
    ④: 对应咱们的 等号
    ⑤ /属性值 对应咱们的 变量的值(可以是任意的数据类型)

       var per = { c
            "name":'zfpx',
            1:'wwww',
            age:9,
            bol: true,
            hobby:{
                hobby1:'play',
                hobby2: 'read'
            },
            fn: function () {
    
            }
        };
        var per2 = {
            name:'小明',
            'name':'小红',
            age:12,
            age: 15,
            2:13,
            '2':18
        };
        console.log(per2["name"],per2.name);
    
    对象的 增 删 改 查

    (1)查
    如果属性名是数字的话 我们再获取该属性对应的属性值的时候只能用 [] 的这种方式(属性名可以带引号 也可以不带引号(不区分单双); 带不带引号,表示的都是一个属性)

     // 1、 打点的方式 (从属关系)
        per.name;
        console.log(per2[2]);//当属性名是数字的时候 我们只能用 [] 的方式获取
        //2、中括号的方式
        console.log(per['name']);
    
           var name1 = 'age';
        console.log(per[name1],per.name1,per["name1"],per[1],per["1"]);
        var name2 = 'hobby';
        console.log(per[name2].hobby1,per.name,per["bol"]);
        console.log(per[name2][12222222]);
        console.log(per[name2]['hobby1']);
        per[name] //--> per['age'] -- > 9  per.age
    
    
    
        //定义属性时,属性名的引号可带可不带
        //调用时,若是通过打点的方式获取某个属性对应的值,我们不能给这个属性加引号
        //若是通过 [] 的方式获取某个属性对应的值,我们必须用引号把这个属性名包起来
        //如果不用引号包起来,则 [] 内代表的是变量对应的值;
        //若属性名是数字的时候, 我们必须用 [] 的方式获取该属性对应的值,这时的数字属性名的引号可加可不加
    
    

    (2)给对象添加 一项()

     var user = {
            name:'xiaoming',
            password:'1234'
        };
    

    (3)修改对象(直接给属性名重新赋值)

        user.name = 'xm1';
    

    当这个对象里边有这个属性的时候,我们再重新赋值时,是相当于修改这个属性对应的属性值
    当这个对象里边没有这个属性时,我们给这个属性赋值时,就相当于给这个对象添加了这个属性
    (4)对象的属性的删除
    1、真删除 2、假删除
    在这里插入图片描述

    2. [] 数组

    数组的每一项都有一个属性名(数组本身就是一个对象,他只是对象的一个细分)跟他对应。这里的属性名(依次递增的数字) 我们叫做索引
    数组对象的作用是:使用单独的变量名来存储一系列的值。

    [12,23,34]
      var ary = [1,true,'qqq',null,undefined,{q:1},function(){console.log(2)},sum,sum()];
    
    var ary2 = [sum,sum()];// [sum,NaN]
        var  t = sum();//NaN
        var ary3 = [sum,t,'t'];//[sum,NaN,'t']
        // 数组里的变量,我们是要把对应的变量值放到相应的位置
    
        // obj[name]
    
        //对象中的查看 打点  ['']
        // 数组本身也因该有打点和 [''] 两种方式 ,但是 对象中 数字的属性名,我们只能用 [''][]的方式,所以数组中的查看我们只能用 [''][]
        // console.log(ary['8'],ary[8]);
    
    

    3. 正则

    正则:就是用来处理字符串的一种规则
    处理字符串的两种方式
    一种是匹配 test; 编写了一个正则;用这个正则去查看这个字符串是否满足你的规则;
    另一种是捕获 exec;编写一个正则;然后去字符串中获取满足你规则的字符串
    -/^-?(\d|([1-9]\d+))(\.\d+)?$/ /*匹配有效数的正则*/

    var reg = /-/;//字面量的声明定义方式
        var reg2 = new RegExp('-');// 构造函数式的定义方式
        console.log(reg, reg2);
        console.log(reg == reg2);//false
    
        //用上边字面量方式 生成的正则 ;两个斜杠中的内容叫做 元字符
        var reg = / /;
    
    
        // 元字符  修饰符
        // 修饰符
        // i ignoreCase : 忽略大小写
        // m multiline : 多行匹配
        // g global : 全局匹配
    
        //特殊意义的元字符
        // \ :转义的意思; 把在正则里有特殊意义的字符 转成 字符本身
        // . :除了换行以外的所有字符;
        // \d: 代表 0~9 之间的数字
        // \D: 代表除了0~9以外的字符
        // \w: 数字 字母 下划线
        // |W: 除了 数字 字母 下划线 以外的字符
        //[a-z]:a到z之间的任意字母
        //[A-Z]:
        //[A-z]
        //[abc]: a,b,c中的任意一个
        // a|b : a或者b
        //[^abc]: 除了 abc 以外的任意字符
        //[^a-z]: 除了 小写字母 以外的任意字符
    
        // 量词元字符
        var reg = /\d+/;
        // + : 代表前边的字符出现一次或者多次
        // * :代表前边的字符出现零次或者多次
        // ? : 代表前边的字符出现零次或者一次
        //{n}: 代表前边的字符出现n次
        //{n,}:代表前边的字符最少出现n次
        //{n,m}:代表前边的字符出现 n到m次
    
        //^  $
        var reg = /^\d+$/; //23424253
        //^ 代表字符串以什么开头
        //$ 代表字符串以什么结尾
    
        // () 在正则里边代表分组
        // ?: -–> 代表只匹配 不捕获
        // ?= -–> 正向预查
        // ?! -–> 负向预查
        // \s : 空白符
        // \n : 换行符
    

    4. function函数数据类型

    
        //我们要用函数的原因
        // 1、 节省代码
        // 2、 高内聚(把东西缩到一块,这一块就是为了实现某个功能,跟其他代码没有任何联系) 低耦合(跟其他代码没关联)
    
        // 函数的 语法
    
        /*
        * 1、function 函数名(){
        *      函数体
        * }
        *
        * 2、var 函数名 = function [函数名-可写可不写](){
        *       函数体
        * }
        *
        * 第一种声明方式, 我们在声明的代码的之前调用这个函数
        * 第二种声明方式,  我们只能在声明的代码之后调用
        *
        * 函数声明之后 可以无限次调用
        *
        * return //返回的意思
        *
        * */
        clearRoom();//函数的调用  -->  函数名()
    
        function clearRoom() {
            console.log('收拾桌子');
            console.log('收拾卧室');
            console.log('出门');
        }
    
        // clearRoom();
    
        // clearPer();
    
        var clearPer  = function (){
            console.log('洗脸');
            console.log('刷牙');
            console.log('穿鞋');
            return '出门';// return 什么 那函数执行完 返给外界的就是啥
        };
        var a = clearPer();//把函数执行的结果赋值给 a
        console.log(a);
        // clearPer();
    

    检测数据类型方法

    1. typeof: 检测数据类型的运算符

    使用typeof检测,返回的结果是一个字符串,字符串中包含的内容证明了值是属于什么类型的;
    【局限性】
    ①.typeof null 不是‘null’而是’object’,因为null虽然是单独的一个数据类型,但是它原本意思就是空对象指针,浏览器使用typeof检测的时候会把它按照对象来检测;
    ②.使用typeof无法具体细分出到底是数组还是正则,因为返回的结果都是’object’

    typeof  12 => 'number'
    
    var num =12;
    typeof num => 'number'
    
    课外扩展(腾讯面试题)

    console.log(typeof typeof [])
    typeof [] ->‘object’
    typeof “object” -> “string”

    2. instanceof:检测某个实例是否属于这个类

    3. constructor 获取当前实例的构造器

    4. Object.prototype.toString.call:获取当前实例的所属类信息

    展开全文
  • Java中的数据类型分为两大类,基本数据类型和引用数据类型 一、数据类型二、基本数据类型和引用数据类型的区别

    Java中的数据类型分为两大类,基本数据类型和引用数据类型

    一、数据类型

    1. 基本数据类型
      基本数据类型只有8种,可按照如下分类
      ①整数类型:long、int、short、byte
      ②浮点类型:float、double
      ③字符类型:char
      ④布尔类型:boolean
      在这里插入图片描述

    对于 boolean 类型,只有真和假两个可能的值,java规范中它的大小并没有明确的定义
    (1)1 byte:boolean类型的值只有true和false两种逻辑值,在编译后会使用1和0来表示,这两个数在内存中按位算,仅需1位(bit)即可存储,位是计算机最小的存储单位。
    (2)4 byte:《Java虚拟机规范》虽然定义了boolean这种数据类型,但是只对它提供了非常有限的支持。Java语言表达式所操作的boolean值,在编译之后都使用Java虚拟机中的int数据类型来代替
    使用int的原因是,对于当下32位的处理器(CPU)来说,一次处理数据是32位(这里不是指的是32/64位系统,而是指CPU硬件层面),32 位 CPU 使用 4 个字节是最为节省的,哪怕你是 1 个 bit 他也是占用 4 个字节。因为 CPU 寻址系统只能 32 位 32 位地寻址,具有高效存取的特点。

    1. 引用类型
      引用数据类型非常多,大致包括:类、 接口类型、 数组类型、 枚举类型、 注解类型、 字符串型
      例如,String类型就是引用类型,还有Double,Byte,Long,Float,Char,Boolean,Short(注意这里和基本类型相比首字母是大写)
      简单来说,所有的非基本数据类型都是引用数据类型

    二、基本数据类型和引用数据类型的区别

    1. 存储位置

    java中的基本数据类型一定存储在栈中的,这句话是错的!

    (1)在方法中声明的变量

    该变量是局部变量,每当程序调用方法时,系统都会为该方法建立一个方法栈,其所在方法中声明的变量就放在方法栈中,当方法结束系统会释放方法栈,其对应在该方法中声明的变量随着栈的销毁而结束,这就局部变量只能在方法中有效的原因

    在方法中声明的变量可以是基本类型的变量,也可以是引用类型的变量。

    • 当声明是基本类型的变量的时,其变量名及值(变量名及值是两个概念)是放在JAVA虚拟机栈中
    • 当声明的是引用变量时,所声明的变量(该变量实际上是在方法中存储的是内存地址值)是放在JAVA虚拟机的栈中,该变量所指向的对象是放在堆类存中的。
      在这里插入图片描述

    (2)在类中声明的变量

    在类中声明的变量是成员变量,也叫全局变量,放在堆中的(因为全局变量不会随着某个方法执行结束而销毁)。

    同样在类中声明的变量即可是基本类型的变量 也可是引用类型的变量

    • 当声明的是基本类型的变量其变量名及其值放在堆内存中的
    • 引用类型时,其声明的变量仍然会存储一个内存地址值,该内存地址值指向所引用的对象。引用变量名和对应的对象仍然存储在相应的堆中

    2. 传递方式

    基本变量类型:在方法中定义的非全局基本数据类型变量,调用方法时作为参数是按数值传递的

    //基本数据类型作为方法参数被调用
    public class Main{
       public static void main(String[] args){
           int msg = 100;
           System.out.println("调用方法前msg的值:\n"+ msg);    //100
           fun(msg);
           System.out.println("调用方法后msg的值:\n"+ msg);    //100
       }
       public static void fun(int temp){
           temp = 0;
       }
    }
    

    在这里插入图片描述
    引用变量类型:引用数据类型变量,调用方法时作为参数是按引用传递的

    //引用数据类型作为方法参数被调用
    class Book{
        String name;
        double price;
    
        public Book(String name,double price){
            this.name = name;
            this.price = price;
        }
        public void getInfo(){
            System.out.println("图书名称:"+ name + ",价格:" + price);
        }
    
        public void setPrice(double price){
            this.price = price;
        }
    }
    
    public class Main{
       public static void main(String[] args){
           Book book = new Book("Java开发指南",66.6);
           book.getInfo();  //图书名称:Java开发指南,价格:66.6
           fun(book);
           book.getInfo();  //图书名称:Java开发指南,价格:99.9
       }
    
       public static void fun(Book temp){
           temp.setPrice(99.9);
       }
    }
    

    在这里插入图片描述
    引用数据类型是基本数据类型的包装类

    三、补充知识点

    1. 一切的引用数据类型都可以使用Objec进行接收具体可参考

    在这里插入图片描述

    public class Test {
        public static void main(String[] args) {
            int[] list1 = {1, 2, 3};
            //因为数组也是引用,此处可以接收这里的数组应用list1
            Object list2 = list1;
            //但是这里输出时,就需要判断下是否是整型数组,然后再进行输出操作
            if (list2 instanceof int[]){
                //执行向下转型操作
                int[] list3 = (int[]) list2;
                for (int i : list3) {
                    System.out.println(i);
                }
            }
        }
    }
    

    四、装箱和拆箱

    我们将基本数据类型转化为引用数据类型的过程叫做装箱,相应的,我们把从引用数据类型转化为基本数据类型的过程叫做拆箱

    如下列代码:我们首先创建了两个Integer类型的对象。然后使用intValue可以将Integer对象拆箱为int类型变量

    package com.Integer;
     
    public class IntegerDemo3 {
    	public static void main(String[] args) {
    		//创建两个Integer对象
    		Integer x=new Integer("10");
    		Integer y=new Integer("10");
    		//创建两个int类型变量
    		int m=10;
    		int n=10;
    		//valueOf的作用是将int变量转化成Integer对象
    		//将int类型变量“手动”装箱
    		Integer m1=Integer.valueOf(m);
    		Integer n1=Integer.valueOf(n);
    		
    		//intValue的作用是将Integer对象转化成int类型
    		//将Integer对象“手动”拆箱
    		int v1=x.intValue();
    		int v2=y.intValue();
    }
    

    自动装箱自动拆箱
    java自己的一种机制,叫做自动装箱和自动拆箱

    借用反编译器可以看一下class文件中经过处理后的文件,可以看得出,class中自动添加了intValue和valueOf方法,用来适应对方。这就是自动装箱和自动拆箱。

    在这里插入图片描述
    参考:https://blog.csdn.net/qq_41469636/article/details/107369554

    展开全文
  • 一、基本数据类型: byte:Java中最小的数据类型,在内存中占8位(bit),即1个字节,取值范围-128~127,默认值0 short:短整型,在内存中占16位,即2个字节,取值范围-32768~32717,默认值0 int:整型,用于存储...
  • 基本数据类型和引用数据类型的区别

    千次阅读 多人点赞 2018-03-18 21:35:18
    javascript中基本数据类型和引用数据类型的区别1、基本数据类型和引用数据类型 ECMAScript包括两个不同类型的值:基本数据类型和引用数据类型。 基本数据类型指的是简单的数据段,引用数据类型指的是有多个值构成...
  • Java 数据类型(基本数据类型、引用数据类型)

    千次阅读 多人点赞 2013-12-11 23:40:11
    Java 数据类型(基本数据类型、引用数据类型) 简单的介绍
  • 一个变量可以存放两种类型的值,基本类型的值...它是 JavaScript 语言的第七种数据类型,前六种是:Undefined、Null、布尔值(Boolean)、字符串(String)、数值(Number)、对象(Object)。 基本类型 ...
  • 关于String为值类型还是引用类型的讨论一直没有平息,最近一直在研究性能方面的问题,今天再次将此问题进行一次明确。希望能给大家带来点帮助。 如果有错误请指出。 来看下面例子: 复制代码 复制代码 //值类型 int ...
  • JS有六大数据类型: Number、String、Boolean、Null、Undefined、Object ​ 这些数据类型可以通过 typeof关键字 进行检测 typeof 123 //number typeof 'abc' //string typeof true //boolean typeof ...
  • Java引用数据类型(类)+案例

    千次阅读 多人点赞 2019-03-08 19:54:09
    引用数据类型(类) 自定义类也是一种数据类型。只是自定义类型并非Java为我们预先提供好的类型,而是我们自己定义的一种引用数据类型用来描述一个事物。 类的定义格式 创建java文件,与类名相同 public class 类名{...
  • java中的五种引用数据类型(对象类型)

    万次阅读 多人点赞 2019-01-20 14:38:23
    Java有 5种引用类型(对象类型):类 接口 数组 枚举 标注 引用类型:底层结构和基本类型差别较大 JVM的内存空间: (1). Heap 堆空间:分配对象 new Student() (2). Stack 栈空间:临时变量 Student stu (3)...
  • 基本数据类和引用数据类型

    万次阅读 多人点赞 2018-06-07 22:19:07
    Java提供了两类数据类型:一种是基本数据(原始类型),一种是引用类型。 数据类型图: 基本数据类型: 注意: 1.在基本数据类型中,除了boolean类型所占长度与平台有关外,其他数据类型长度都是与平台无关的...
  • Java数据类型分为基本数据类型与引用数据类型。 1、 基本数据类型 byte:Java中最小的数据类型,在内存中占1个字节(8 bit),取值范围-128~127,默认值0 short:短整型,2个字节(16 bit),取值范围-...
  • 前言:内存分为栈内存和堆内存如如下图: 一,基本数据类型 例如 var a=123; b=a; a=456; 那么a,b的值分别为456...二,引用数据类型 是在堆内存中进行存储的 例如: var obj = new Object(); obj.name = ‘张三
  • 编辑器所开发的代码都是推送到浏览器。...将基本数据类型存在当前栈里边,解析到引用数据类型的时候,他会接着做另一个辅助工作,在浏览后台开辟一个堆内存(私有作用域),来储存我们的代码字符;
  • 两者之间的关系特点:一、从概念方面来说基本数据类型:变量名指向具体的数值引用数据类型:变量名指向存数据对象的内存地址,即变量名指向hash值二、从内存构建方面来说基本数据类型:变量在声明之后java就会立刻分配给...
  • 五、引用数据类型——数组的使用

    千次阅读 2018-04-17 21:24:51
     在之前的学习我们知道八大基本数据类,而我们现在学习的引用数据类型,这里大家先记住引用数据类型,稍后补充。举个例子,我们现在有个需求,想统计每个班级同学的成绩,一个年级有5个班级,每个班级40人,这时候...
  • 引用数据类型:比较的是引用数据类型的地址是否相同 基本数据类型:比较的是基本数据类型的值是否相同 举个例子来说: public class Main{ public static void main(String[] args) { //引用数据类型 String s1...
  • 引用数据类型{类【class】;接口【interface】;数组【[ ]】} 两种不同数据类型的区别: 基本数据类型:变量存储在栈中;栈的特点是存储空间小,但是存取速度快 引用数据类型:变量存储在堆中...
  • String str="test" 调用run方法传入str SOP( str); run(string str){ Str ="test2" } 问题 String作为引用数据类型传递为什么值不改变。
  • Java引用数据类型String详解

    万次阅读 2020-07-02 23:54:44
    Java引用数据类型(String)引用数据类型概述引用数据类型与基本数据类型的差别(举例说明) 引用数据类型概述 说到引用数据类型,那么何为引用数据类型? 引用类型,都可以用null值作为值,也就是说可以在初始化的...
  • Java的引用数据类型--枚举

    千次阅读 2020-03-30 17:17:58
    标题:Java的引用数据类型--枚举 作者:Nstar 时间:2020年3月30日 * */ public enum Name_test { //枚举数据类型,Java中的引用数据类型 ZHANGSAN,LISI,WANGWU,ZHAOLIU } class Test_name{ public static void ...
  • 2.引用数据类型包括:对象. 数组. 函数 3.存储位置不同:原始数据类型存储在栈中,占据空间小,大小固定,属于频繁使用数据。引用数据类型存储在堆中,占据空间大,大小不固定。 4.传值方式不同:基本数据类型按值...
  • JavaScript中基本数据类型和引用数据类型的区别

    千次阅读 多人点赞 2018-01-06 11:09:53
    1、基本数据类型和引用数据类型  ECMAScript包括两个不同类型的值:基本数据类型和引用数据类型。  基本数据类型指的是简单的数据段,引用数据类型指的是有多个值构成的对象。  当我们把变量赋值给一个变量时...
  • java中引用数据类型有哪些?

    万次阅读 多人点赞 2016-07-18 09:45:37
    Java中有俩种数据类型,其中主要有8中基本数据类型和引用数据类型,除了8中基本数据类型以外都是引用数据类型,8中基本数据类型分别是byte,short,int,long,char,boolean,float,double,具体如下:1、boolean:数据值...
  • js数据类型:基本数据类型和引用数据类型(文章最下面会介绍各类型的基础以及注意事项) 基本数据类型指的是简单的数据段,引用数据类型指的是有多个值构成的对象 当我们把变量赋值给一个变量时,解析器首先要确认...
  • Java基础_引用数据类型的强制类型转换

    千次阅读 多人点赞 2019-05-23 20:01:07
    在Java中由于继承和向上转型,子类可以非常自然地转换成父类...当我们用一个类型的构造器构造出一个对象时,这个对象的类型就已经确定的,也就说它的本质是不会再发生变化了。在Java中我们可以通过继承、向上转型的...
  • 1、基本数据类型存放在哪? 基本类型的变量存在栈里或者堆里不是由"大小可知,生存期可知"就能确定了。关键是上下文。 比如: void method(){ int a = 3; } 这自然是存在栈里的。局部方法嘛。 而: class ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,412,561
精华内容 565,024
关键字:

引用数据类型