精华内容
下载资源
问答
  • 今天讲一下 Java 包装类的的由来,及自动装箱、拆箱的概念和原理。什么是包装类型Java 设计当初就提供了 8 种 基本数据类型及对应的 8 种包装数据类型。我们知道 Java 是一种面向对象编程的高级语言,所以包装类型...

    本篇文章给大家带来的内容是关于Java中的包装类是什么?Java包装类的应用场景介绍 ,有一定的参考价值,有需要的朋友可以参考一下,希望对你有所帮助。

    今天讲一下 Java 包装类的的由来,及自动装箱、拆箱的概念和原理。

    什么是包装类型

    Java 设计当初就提供了 8 种 基本数据类型及对应的 8 种包装数据类型。我们知道 Java 是一种面向对象编程的高级语言,所以包装类型正是为了解决基本数据类型无法面向对象编程所提供的。

    下面是基本数据类型与对应的包装类型。基本数据类型包装类型byteByte

    booleanBoolean

    shortShort

    charCharacter

    intInteger

    longLong

    floatFloat

    doubleDouble

    下面是包装类型的继承结构图。

    ad5d11b54536db0290dd224e4780a44a.png

    从以上图表可以对基本类型和包装类型有一个全面的了解。

    包装类应用场景

    1、集合类泛型只能是包装类;// 编译报错

    List list1 = new ArrayList<>();

    // 正常

    List list2 = new ArrayList<>();

    2、成员变量不能有默认值;private int status;

    基本数据类型的成员变量都有默认值,如以上代码 status 默认值为 0,如果定义中 0 代表失败,那样就会有问题,这样只能使用包装类 Integer,它的默认值为 null,所以就不会有默认值影响。

    3、方法参数允许定义空值;private static void test1(int status){

    System.out.println(status);

    }

    看以上代码,方法参数定义的是基本数据类型 int,所以必须得传一个数字过来,不能传 null,很多场合我们希望是能传递 null 的,所以这种场合用包装类比较合适。

    还有更多应用场景就不一一例举了,欢迎留言共同探讨包装类的更多的应用场景。

    自动装箱、拆箱

    Java 5 增加了自动装箱、拆箱机制,提供基本数据类型和包装类型的相互转换操作。

    自动装箱

    自动装箱即自动将基本数据类型转换成包装类型,在 Java 5 之前,要将基本数据类型转换成包装类型只能这样做,看下面的代码。Integer i1 = new Integer(8);

    Integer i2 = Integer.valueOf(8);

    // 自动装箱

    Integer i3 = 8;

    以上 3 种都可以进行转换,但在 Java 5 之前第 3 种方法是编译失败的,第 3 种方法也正是现在的自动装箱功能。另外,第一种构造器方法也不推荐使用了,已经标为废弃了。

    其实自动装箱的原理就是调用包装类的 valueOf 方法,如第 2 个方法中的 Integer.valueOf 方法。

    自动拆箱

    自动拆箱即自动将包装类型转换成基本数据类型,与自动装箱相反,有装就有拆,很好理解。// 自动拆箱

    int i4 = i3;

    int i5 = i3.intValue();

    继续上面的例子,把 i3 赋值给 i4 就是实现的自动拆箱功能,自动装箱的原理就是调用包装类的 xxValue 方法,如 i5 中的 Integer 的 intValue 方法。

    自动装箱、拆箱不只是体现在以上的例子,在方法接收参数、对象设置参数时都能自动装箱拆箱。

    展开全文
  • (1)@public (公开)在有对象前提下,任何地方都可以直接访问。...(4)@package (框架级别)作用域介于私有公开之间,只要处于同一个框架中就可以直接通过变量名访问 我个人理解框架就是包装程序

    1@public (公开的)在有对象的前提下,任何地方都可以直接访问。

    2@protected (受保护的)只能在当前类和子类的对象方法中访问

    3@private (私有的)只能在当前类的对象方法中才能直接访问

    4@package (框架级别的)作用域介于私有和公开之间,只要处于同一个框架中就可以直接通过变量名访问


    我个人理解框架就是包装好的程序,里面有定义好的数据类型,各种类和方法,#import<>之后就可以用里面的数据类型和方法,想想是不是跟我们自己写的程序或自己写的一个类一样。
    我个人的理解是框架就是一个已经封装好的无数个方法,类的集合,oc是面向对象的,所以我们只需要知道这个方法的作用是什么,不需要知道他怎么做的。

    框架式一种把头文件、库、图片、声音等内容聚集在一个独立单元中的集合体。Cocoa就是一个框架集,其中包括Foundation和AppKit框架

    框架就是常用函数,类,方法的声明组合包装到一起。我们通常包含自己写的。h文件,Foundtion更广更大而已。
    1、Foundation框架

        Foundation框架是其他所有ios框架的基础
       Foundation框架包含了很多开发中常用的数据类型:结构体 、枚举、类 
       
    比如,你使用一个NSString类的实例存储用户输入的userName。你还使用了Foundation框架的initWithFormat方法创建了一个字符串。

        使用Foundation框架你可以实现:创建和管理集合,比如数组和字典;访问存储在应用程序里的图片和其它资源;创建和管理字符串;提交和接收通知;创建日期和时间对象;自动发现IP网络上的设备;操作URL流;执行异步代码。
       要想使用Foundation中的数据类型,包含它的主文件即可#import<Foundation/Foundation.h>

    2、但是其实还有UIKit、和Core Graphics框架,你可以去网上搜一下,它们的具体用法http://www.open-open.com/lib/view/open1343210425380.html


    什么是框架?

    ??框架,即framework。其实就是某种应用的半成品,就是一组组件,供你选用完成你自己的系统。简单说就是使用别人搭好的舞台,你来做表演。而且,框架一般是成熟的,不断升级的软件。

    ??为什么要用框架?

    ??因为软件系统发展到今天已经很复杂了,特别是服务器端软件,设计到的知识,内容,问题太多。在某些方面使用别人成熟的框架,就相当于让别人帮你完成一些基础工作,你只需要集中精力完成系统的业务逻辑设计。而且框架一般是成熟,稳健的,他可以处理系统很多细节问题,比如,事物处理,安全性,数据流控制等问题。还有框架一般都经过很多人使用,所以结构很好,所以扩展性也很好,而且它是不断升级的,你可以直接享受别人升级代码带来的好处。

    ??框架一般处在低层应用平台(如J2EE)和高层业务逻辑之间的中间层。

    展开全文
  • 首先介绍定义:闭包可以让一个函数访问并操作其声明时的作用域中变量函数,并且,即使声明时的作用域消失了,也可以调用 应用: 私有变量 回调与计时器 绑定函数上下文 偏应用函数 函数重载:缓存记忆、函数包装...

    首先介绍定义:闭包可以让一个函数访问并操作其声明时的作用域中的变量和函数,并且,即使声明时的作用域消失了,也可以调用
    应用:

    私有变量
    回调与计时器
    绑定函数上下文
    偏应用函数
    函数重载:缓存记忆、函数包装
    即时函数:独立作用域、简洁代码、循环、类库包装、通过参数限制作用域内的名称

    正文
    看了很多文章,都在说闭包的定义和闭包的优缺点。我呢,再加上闭包的应用吧。
    闭包的定义很多文章里都有,我记得有一种角度说只要能访问外部变量的就是闭包,还有一种角度所有函数都是闭包。
    我觉得这些回答是正确的,但是不太方便面试官继续问下去,或者说是不好引导面试官。所以,如果是我在面试,我会用忍者秘籍里的定义:闭包是一个函数在创建时允许该自身函数访问并操作该自身函数之外的变量时所创建的作用域。这个还有点绕口,更清晰的版本是:闭包可以让一个函数访问并操作其声明时的作用域中的变量和函数,并且,即使声明时的作用域消失了,也可以调用。要注意的是:闭包不是在创建的那一时刻点的状态的快照,而是一个真实的封装,只要闭包存在,就可以对其进行修改。
    最简单的闭包:
    // 全局作用于就是一个闭包
    var outerVal = ‘lionel’;
    function outerFn(){
    console.log(outerVal)
    }
    outerFn() // lionel
    复制代码复杂点的,也是我们印象中的:
    var outerVal = ‘lionel’;
    var later;
    function outerFn(){
    var innerVal = ‘karma’;
    function innerFn(){
    console.log(outerVal, innerVal);
    }
    later = innerFn;
    }
    outerFn(); // 此时outerFn的作用域已经消失了
    later(); // lionel karma
    复制代码难以理解的,这个例子我们可以理解到,闭包不是快照:
    var later;
    function outerFn(){
    function innerFn(){
    console.log(lateVal)
    }
    later = innerFn;
    }
    console.log(lateVal); // undefined
    var lateVal = ‘lionel’; // 变量提升,闭包声明的那一刻存在这个变量
    outerFn();
    innerFn(); // lionel
    复制代码缺点大家很熟悉了,闭包里的信息会一直保存在内存里。解决方法是,在你觉得可以的地方,清除引用,像上面的例子中,使用 later = null 即可,这样就可以在下次垃圾回收中,清除闭包。
    下面我们重点来看一下闭包的实际应用。
    一、私有变量
    闭包常见的用法,封装私有变量。用户无法直接获取和修改变量的值,必须通过调用方法;并且这个用法可以创建只读的私有变量哦。我们从下面的例子来理解:
    function People(num) { // 构造器
    var age = num;
    this.getAge = function() {
    return age;
    };
    this.addAge = function() {
    age++;
    };
    }
    var lionel = new People(23); // new方法会固化this为lionel哦
    lionel.addAge();
    console.log(lionel.age); // undefined
    console.log(lionel.getAge()); // 24
    var karma = new People(20);
    console.log(karma.getAge()); // 20
    复制代码如下图,lionel中并不存在age属性,age只存在new的那个过程的作用域中,并且,getAge和addAge中,我们可以看到他们的作用域中都包含一个People的闭包。

    二、回调和计时器
    这部分我没有多聊的,
    三、绑定函数上下文
    刚看到这个应用可能有点懵,仔细想想其实我们看到很多次了,那就是bind()函数的实现方式,这里再贴一次简单实现的代码:
    Function.prototype.myBind = function() {
    var fn = this,
    args = […arguments],
    object = args.shift();
    return function() {
    return fn.apply(object, args.concat(…arguments))
    }
    }
    复制代码这里要注意的是:bind()并不是apply和call的替代方法。该方法的潜在目的是通过匿名函数和闭包控制后续执行上下文。
    四、偏应用函数
    偏应用函数返回了一个含有预处理参数的函数,以便后期可以调用。具体还是看代码吧
    Function.prototype.partial = function() {
    var fn = this,
    args = […arguments];
    return function() {
    var arg = 0;
    var argsTmp = […args]
    for (var i=0; i<argsTmp.length && arg < arguments.length; i++) {
    if (argsTmp[i] === undefined) {
    argsTmp[i] = arguments[arg++]
    }
    }
    return fn.apply(this, argsTmp)
    }
    }
    function addAB(a ,b) {
    console.log( a + b);
    }
    var hello = addAB.partial(‘hello ‘, undefined);
    hello(‘lionel’); // hello lionel
    hello(‘karma’); // hello karma
    var bye = addAB.partial(undefined, ’ bye’)
    bye(‘lionel’); // lionel bye
    bye(‘karma’); // karma bye
    复制代码上面的例子可能有点难以理解,下面是一个简化版的例子:
    function add(a) {
    return function(b) {
    console.log( a + b);
    };
    }
    var hello = add(‘hello ‘)
    hello(‘lionel’); // hello lionel
    hello(‘karma’); // hello karma
    复制代码emmm… 写到这里去研究了半天柯里化和偏函数的区别,最终找到一篇文章符合我的想法:偏函数与函数柯里化,不对的地方请指正。
    五、函数重载
    1 缓存记忆
    我们可以通过闭包来包装一个函数,,从而让调用我们函数的人,不知道我们采用了缓存的方法,或者说,不需要调用者额外做什么,就可以缓存计算结果,如下代码
    Function.prototype.memoized = function(key) {
    this._values = this._values || {};
    return this._values[key] !== undefined ?
    this._values[key] + ’ memoized’ :
    this._values[key] = this.apply(this, arguments);
    }
    Function.prototype.memoize = function() {
    var fn = this;
    return function() {
    // return fn.memoized.apply(fn, arguments);
    console.log(fn.memoized.apply(fn, arguments))
    }
    }
    var computed = (function(num){
    // 这里有超级超级复杂的计算,耗时特别久
    console.log(’----计算了很久-----’)
    return 2
    }).memoize();
    computed(1); // ----计算了很久----- 2
    computed(1); // 2 memoized
    复制代码2 函数包装
    下面的这个例子写的没有书里的好。
    function wrap(object, method, wrapper){
    var fn = object[method];
    return object[method] = function() {
    return wrapper.apply(this, [fn.bind(this)].concat(…arguments))
    }
    }
    let config = {
    baseUrl: ‘真实url’,
    getBaseUrl: function(){
    console.log(this.baseUrl)
    }
    }
    if(process.env.NODE_ENV === ‘development’){
    wrap(config, getBaseUrl, function(){
    console.log(‘测试url’)
    })
    config.getBaseUrl(); // 测试url
    }else{
    config.getBaseUrl() // 真实url
    }
    复制代码六、即时函数
    针对为什么即时函数会放在闭包里介绍,下图是一个很好的说明:

    1 独立作用域
    (function(){
    var numClicks = 0;
    button.click = function(){
    alert(++numClicks)
    }
    })
    复制代码2 简洁代码
    // 例如有如下data
    data = {
    a: {
    b: {
    c: {
    get: function(){},
    set: function(){},
    add: function(){}
    }
    }
    }
    }
    // 第一种调用这三个方法的代码如下, 繁琐
    data.a.b.c.get();
    data.a.b.c.set();
    data.a.b.c.add();
    // 第二种方法如下, 引入多余变量
    var short = data.a.b.c;
    short.get();
    short.set();
    short.add();
    // 第三种使用即时函数 优雅
    (function(short){
    short.get();
    short.set();
    short.add();
    })(data.a.b.c)
    复制代码3 循环
    这部分是经典的for循环中调用setTimeout打印i,之所以打印i为固定值,是因为闭包并不是快照,而是变量的引用,在执行到异步队列时,i已经改变。
    解决方法就是再用一个闭包和即时函数。
    4 类库包装
    // 下方的代码展示了,为什么jquery库中,它可以放心的用jquery而不担心这个变量被替换
    (function(){
    var jQuery = window.jQuery = function() {
    // Initialize
    };
    // …
    })()
    复制代码5 通过参数限制作用域内的名称
    // 当我们担心jquery中的,,,//,(:jQuery...)(function(符号,被其他库占用,导致我们代码出问题的时候, // 用下面的方法,就可以放心大胆的用啦(不过要注意:如果jQuery也被占用的话就...) (function(){
    $.post(…)
    })(jQuery)

    展开全文
  • 基本数据类型对象包装最常见作用 就是用于基本数据类型字符串类型之间做转换 基本数据类型转成字符串 1. 基本数据类型+"" 2. 基本数据类型.toString(基本数据类型值); 如: Integer.toString(34);//将34整数...

    基本数据类型对象包装类

    byte	Byte
    short	short
    int		Integer
    long	Long
    boolean Boolean
    float	Float
    double	Double
    char	Character
    

    基本数据类型对象包装类的最常见作用

    就是用于基本数据类型和字符串类型之间做转换

    基本数据类型转成字符串

    1. 基本数据类型+""
    
    2. 基本数据类型.toString(基本数据类型值);
    
    如: Integer.toString(34);//将34整数变成"34";
    

    字符串转成基本数据类型

    xxx a = Xxx.parseXxx(String);
    
    int a = Integer.parseInt("123");
    
    double b = Double.parseDouble("12.23");
    
    boolean b = Boolean.parseBoolean("true");
    
    Integer i = new Integer("123");
    
    int num = i.intValue();
    

    十进制转成其他进制。

    toBinaryString();
    toHexString();
    toOctalString();
    
    Integer.toHexString(60)
    

    其他进制转成十进制。

    parseInt(string,radix);
    
    int x = Integer.parseInt("3c",16);
    

    jdk1.5后的新特性

    自动装箱

    Integer i=14;//相当于 Integer i =new Integer(14);
    x+=2;//注意i 不可为null 否则会报错
    

    包装类特点

    Integer i=128;
    Integer j=128;
    System.out.println(i==j);//false 地址不一样
    Integer a=127;
    Integer b=127;
    System.out.println(a==b);//true 当Integer 范围在byte字面值范围(-128~127) 堆区不会再去额外开辟一个数值的空间 因为-128~127这个范围的数值早已经存在,不再需要创建空间,从而提高效率
    
    
    展开全文
  •  Java是一种动态连接语言,常量池的作用非常重要,常量池中除了包含代码中所定义各种基本类型(如int、long等等)对象型(如String及数组)常量值还,还包含一些以文本形式出现符号引用,比如: ...
  •  Java是一种动态连接语言,常量池的作用非常重要,常量池中除了包含代码中所定义各种基本类型(如int、long等等)对象型(如String及数组)常量值还,还包含一些以文本形式出现符号引用,比如: ...
  • 泛型和包装

    2019-11-02 16:43:30
    (1)泛型是作用在编译期间的一种机制,即运行期间没有泛型的概念。 (2)泛型代码在运行期间利用 Object 达到的效果。 2.泛型总结: (1)泛型是为了解决某些容器、算法等代码的通用性而引入,并且能在编译期间做...
  • 包装泛型

    2019-09-08 19:37:14
    1. 静态内部类 定义在类成员级别,同时被static修饰一种类 class LinkedList{ ...作用就是一个类从概念上应该属于另一个范围 使用上: 在LinkedList内部使用,一般类没有什么区别 Node n=new N...
  • ObjectWrapper ...具备了MetaObject,对象包装的公共父类,主要处理集合类型 BeanWrapper 具备了储存对象的ObjectMetaClass @Override public Object get(PropertyTokenizer prop) { ...
  • 毫秒值的概念和作用 毫秒:千分之一秒 1000毫秒=1秒 特定瞬间:一个时间点 毫秒值的作用:可以对时间和日期进行计算 使用场景 例如:计算2099-01-03到2088-01-01中间一共有多少天 解决方案: 可以将日期转换为毫秒值进行...
  • Java泛型和包装

    2020-01-16 18:05:04
    泛型是作用在编译期间的一种机制,即运行期间没有泛型的概念。 泛型代码在运行期间,利用 Object 达到效果。实际上 E 的类型还是 Object。 泛型的分类 泛型类 //1. 尖括号 <> 是泛型的标志 //2. E 是类型...
  • 基本类型的包装

    2021-01-06 13:07:06
    1、包装概念: 将基本数据类型数据组装成引用数据类型数据。 2、包装作用: String使用数据类型与基本数据类型(byte,short,int,long,float…)区别,基本数据类型只是一个取值范围,没有具体方法或者属性。...
  • 在1.5版本之前,java并没有直接支持泛型实现,泛型编程实现时通过使用继承一些基本概念来完成。这种方式局限性有:1. 使用此种方式会不可避免地用到强制类型转换。2.不能使用基本类型,只有引用类型能...
  • 下面是我们需要了解的知识l 包装的概念作用l BufferedInputStream与BufferedOutputStream类l DataInputStream与DataOutputStream类首先我们先看一下过滤流(包装类)的概念作用这里需要澄清一点,这里所说...
  • 局部变量成员变量区别 1 类中位置不同(成员变量在类中方法外,局部变量在类中方法中) 2 作用域不同(成员变量作用于整个类中,而局部变量只能作用于方法中) 3 生命周期不同(.从变量在内存中生存时间上看,...
  • 对象多态性,从概念上非常好理解,在类中有子类父类之分,子类就是父类一种形态,对象多态性就从此而来。 多态使用 向上转型:将子类实例变为父类实例 格式:父类 父类对象 = 子类实例; 向下转型...
  • 定义:闭包可以让一个函数访问并操作其声明时的作用域中变量函数,并且,即使声明时的作用域消失了,也可以调用 应用: 私有变量 回调与计时器 绑定函数上下文 偏应用函数 函数重载:缓存记忆、函数包装 即时...
  • 类型主要有以下作用: 命名组织概念 确保内存中比特序列被正确理解 向编译器提供程序中操作数据信息 1. 程序组织文档 类型实际上起到了描述程序设计意图文档的作用。相对注释,类型会被编译器检查,而...
  • 1.增加编译期间的类型检查:泛型是作用再编译期的一种机制,即运行期间没有泛型的概念 2.取消类型转换的使用 泛型分类: (1)泛型类: public class MyArrayList<E> { private E<> array; private ...
  • java 包装

    2020-12-22 19:22:10
    包装的概念 在进行类型转换的范畴内,有一种特殊的转换,需要将基本数据类型转换为对象;所有的基本类型都有一个与之对应的类,即包装类,所谓包装类就是把基本类型转为对象,是引用类型 例如: int —> Integer...
  • Java是一个面向对象编程语言,但是Java中八种基本数据类型却是不面向对象,为了使用方便解决这个不足,在设计类时为每个基本数据类型设计了一个对应类进行代表,这样八种基本数据类型对应类统称为包装类...
  • 文章目录面向对象一、工具类...包装的作用2.自动装箱拆箱四、内部类1.内部类概念2.使用内部类理由3.内部类分类4.普通成员内部类5.私有成员内部类6.静态内部类7.局部内部类8.匿名内部类[常用] 面向对象 一、工具
  • 课前熟悉包装与运输的概念 2. 熟悉包装与运输的作用 3. 熟悉包装与运输的特点 4. 根据包装设计制作或制定包装 5. 注意包装材料结构对行李的保护及影响 三.针对此次任务我们设计的主要工作内容如下: 1. 顾客需求...
  • 课前熟悉包装与运输的概念 2. 熟悉包装与运输的作用 3. 熟悉包装与运输的特点 4. 根据包装设计制作或制定包装 5. 注意包装材料结构对行李的保护及影响 六.针对此次任务我们设计的主要工作内容如下: 1. 顾客需求...
  • 仅仅表达一个封装的概念;但是Java的内部类不同,它可以访问包装类的成员(这表示它拥有指向包装类的句柄)。 匿名内部类是内部类的一种简化写法:return new Wrapper { ... }; 等价于:Wrapped extends Wrapper {...
  • Java学习笔记-包装

    2019-04-02 13:03:00
    基本数据类型对象包装类的最常见作用,就是用于基本数据类型字符串类型之间做转换 包装类的由来 为了解决8种基本数据类型的变量不能当成Object类型变量使用的问题,Java提供了包装类(Wrapper Class)的概念,为8...

空空如也

空空如也

1 2 3 4 5 ... 10
收藏数 190
精华内容 76
关键字:

包装的概念和作用