精华内容
下载资源
问答
  • 最近我弄清楚了如何递归地实现嵌套插槽,包括如何使用作用域插槽来实现。起因是我想看看是否可以构建一个复制v-for指令但仅使用template组件。 它还支持插槽和作用域插槽,也可以支持命名插槽,我们可以这样使用它...

    最近我弄清楚了如何递归地实现嵌套插槽,包括如何使用作用域插槽来实现。起因是我想看看是否可以构建一个复制v-for指令但仅使用template组件。

    它还支持插槽和作用域插槽,也可以支持命名插槽,我们可以这样使用它:

    <template>
      <div>
        <!-- Regular list -->
        <v-for :list="list" />
        
        <!-- List with bolded items -->
        <v-for :list="list">
          <template v-slot="{ item }">
            <strong>{{ item }}</strong>
          </template>
        </v-for>
      </div>
    </template>
    

    第一个将正常打印列表,而第二个将每个项包装在<strong>标记中。

    这不是一个非常有用的组件,但可以从中学到的最多,我们来看看。

     

    无循环实现循环

    通常,当我们要渲染元素或组件的列表时,可以使用v-for指令,但这次我们希望完全摆脱它。

    那么,我们如何在不使用循环的情况下渲染项目列表呢?就是使用 递归

    我们可以使用递归来渲染项目列表。过程并不会复杂,我们来看看怎么做。

    递归表示一个列表

    我在大学里最喜欢的课程之一是“编程语言概念”

    对我来说,最有趣的部分是探索函数式编程和逻辑编程,并了解与命令式编程的区别(Javascript 和最流行的语言是命令式编程)。

    这门课让我真正了解如何使用递归,因为在纯函数语言中,一切都是递归。不管怎样,从那门课我学到了可以使用递归地表示一个列表。

    与使用数组不同,每个列表是一个值(头)和另一个列表(尾)。

    [head, tail]
    

    例如要表示列表[1、2、3],则可以递归方式表示为:

    [1, [2, [3, null]]]
    

    我们必须以某种方式结束列表,因此我们使用null而不是另一个数组(也可以使用空数组)。

    看到这里,你或许就可以明白了,我们可以使用此概念并将其应用于我们的组件。 相反,我们将递归嵌套组件以表示列表。

    我们最终将渲染出这样的内容。 注意我们“list”的嵌套结构:

    <div>
      1
      <div>
        2
        <div>
          3
        </div>
      </div>
    </div>
    

    诚然,这与v-for渲染的效果并不完全相同,但这也不是本练习的重点。

     

    构建组件

    首先,我们将解决递归渲染项目列表的问题。

    使用递归来渲染列表

    这次我们使用一个普通数组,而不是使用前面介绍的递归列表:

    [1, 2, 3]
    

    这里要讨论两种情况:

    • 基本情形-渲染列表中的第一项
    • 递归情形-渲染项目,然后沉浸下一个列表

    我们把[1,2,3]传给v-for

    <template>
      <v-for :list="[1, 2, 3]" />
    </template>
    

    我们希望获取列表中的第一项,即1,并显示它

    <template>
      <div>
        {{ list[0] }}
      </div>
    </template>
    

    现在,该组件将渲染1,就像我们期望的那样。

    但是我们不能只渲染第一个值并停止。 我们需要渲染值,然后还渲染列表的其余部分:

    <template>
      <div>
        {{ list[0] }}
        <v-for :list="list.slice(1)" />
      </div>
    </template>
    

    我们不传递整个list数组,而是删除第一项并传递新数组。第一个项目我们已经打印出来了,所以没有必要保留它。

    顺序是这样的:

    1. 我们将[1,2,3]传递到v-for中进行渲染
    2. 我们的v-for组件渲染1,然后将[2,3]传递到下一个v-for进行渲染
    3. 取[2,3]并渲染2,然后将[3]传递到下一个v-for
    4. 最后一个v-for组件渲染出3,我们已经打印出列表!

    现在,我们的Vue应用程序的结构如下所示:

    <App>
      <v-for>
        <v-for>
          <v-for />
        </v-for>
      </v-for>
    </App>
    

    可以看到,我们有几个v-for组件,它们彼此嵌套在一起。最后一件事,我们需要停止递归

    <template>
      <div>
        {{ list[0] }}
        <v-for
          v-if="list.length > 1"
          :list="list.slice(1)"
        />
      </div>
    </template>
    

    最终,渲染完所有项后,我们需要停止递归操作。

     

    递归嵌套的插槽

    现在,组件可以正常工作,但是我们也希望它与作用域内插槽一起使用,因为这样可以自定义渲染每个项的方式:

    <template>
      <v-for :list="list">
        <template v-slot="{ item }">
          <strong>{{ item }}</strong>
        </template>
      </v-for>
    </template>
    

    嵌套插槽

    一旦弄清楚了如何递归地嵌套插槽,就会对它痴迷一样的感叹:

    • 嵌套n级的插槽
    • 递归插槽
    • 包装组件将一个插槽转换为多个插槽

    首先,我们将简要介绍嵌套插槽的工作方式,然后介绍如何将它们合并到v-for组件中。

    假设我们有三个组件:Parent、Child和Grandchild。我们希望传递来自Parent组件的一些内容,并在Grandchild组件中渲染它。

    从Parent开始,我们传递一些内容:

    // Parent.vue
    <template>
      <Child>
        <span>Never gonna give you up</span>
      </Child>
    </template>
    

    我们在Child组件中做一些事情,将在稍后介绍。 然后我们的Grandchild组件获取插槽并渲染内容:

    // Grandchild.vue
    <template>
      <div>
        <slot />
      </div>
    </template>
    

    那么,这个Child组件是什么样的?

    我们需要它从Parent组件获取内容并将其提供给Grandchild组件,因此我们将两个不同的插槽连接在一起。

    // Child.vue
    <template>
      <Grandchild>
        <slot />
      </Grandchild>
    </template>
    

    请记住,<slot />元素渲染出作为插槽传递到组件的内容。 因此,我们将从“Parent”中获取该内容,然后将其渲染到“Grandchild”插槽中。

     

    添加作用域插槽

    与嵌套作用域插槽唯一不同的是,我们还必须传递作用域数据。将其添加到v-for中,我们现在得到以下信息:

    <template>
      <div>
        <slot v-bind:item="list[0]">
          <!-- Default -->
          {{ list[0] }}
        </slot>
        <v-for
          v-if="list.length > 1"
          :list="list.slice(1)"
        >
          <!-- Recursively pass down scoped slot -->
          <template v-slot="{ item }">
            <slot v-bind:item="item" />
          </template>
        </v-for>
      </div>
    </template>
    

    首先让我们看一下基本情况。

    如果没有提供插槽,则默认<slot>元素内部的内容,并像以前一样渲染list[0]。 但是如果我们提供了一个slot,它会将其渲染出来,并通过slot作用域将列表项传递给父组件。

    这里的递归情况类似。 如果我们将插槽传递给v-for,它将在下一个v-for的插槽中进行渲染,因此我们得到了嵌套。 它还从作用域槽中获取item并将其传递回链。

    现在,我们这个组件仅使用template就能实现 v-for效果。

     

    总结

    我们做了很多事情,终于了解了如何创建一个仅使用 template 就能实现v-for的效果。

    展开全文
  • 点击进入_更多_Java千...了解8种基本数据类型看这里:java有哪8种基本数据类型2、包装器有什么作用包装器描述了基本数据类型的若干属性,包括基本类型的取值范围以及长度等。 例子:public class PrimitiveTypeTest {

    点击进入_更多_Java千百问

    1、什么是包装器

    包装器也叫包装类,继承于Object,可以当作8种基本数据类型的类映射,包装器可以直接转换为基本数据类型(成为拆箱)。如下:
    这里写图片描述

    了解8种基本数据类型看这里:java有哪8种基本数据类型

    2、包装器有什么作用

    包装器描述了基本数据类型的若干属性,包括基本类型的取值范围以及长度等。
    例子:

    public class PrimitiveTypeTest { 
        public static void main(String[] args) { 
            // byte 
            System.out.println("基本类型:byte 二进制位数:" + Byte.SIZE); 
            System.out.println("包装类:java.lang.Byte"); 
            System.out.println("最小值:Byte.MIN_VALUE=" + Byte.MIN_VALUE); 
            System.out.println("最大值:Byte.MAX_VALUE=" + Byte.MAX_VALUE); 
            System.out.println(); 
    
            // short 
            System.out.println("基本类型:short 二进制位数:" + Short.SIZE); 
            System.out.println("包装类:java.lang.Short"); 
            System.out.println("最小值:Short.MIN_VALUE=" + Short.MIN_VALUE); 
            System.out.println("最大值:Short.MAX_VALUE=" + Short.MAX_VALUE); 
            System.out.println(); 
    
            // int 
            System.out.println("基本类型:int 二进制位数:" + Integer.SIZE); 
            System.out.println("包装类:java.lang.Integer"); 
            System.out.println("最小值:Integer.MIN_VALUE=" + Integer.MIN_VALUE); 
            System.out.println("最大值:Integer.MAX_VALUE=" + Integer.MAX_VALUE); 
            System.out.println(); 
    
            // long 
            System.out.println("基本类型:long 二进制位数:" + Long.SIZE); 
            System.out.println("包装类:java.lang.Long"); 
            System.out.println("最小值:Long.MIN_VALUE=" + Long.MIN_VALUE); 
            System.out.println("最大值:Long.MAX_VALUE=" + Long.MAX_VALUE); 
            System.out.println(); 
    
            // float 
            System.out.println("基本类型:float 二进制位数:" + Float.SIZE); 
            System.out.println("包装类:java.lang.Float"); 
            System.out.println("最小值:Float.MIN_VALUE=" + Float.MIN_VALUE); 
            System.out.println("最大值:Float.MAX_VALUE=" + Float.MAX_VALUE); 
            System.out.println(); 
    
            // double 
            System.out.println("基本类型:double 二进制位数:" + Double.SIZE); 
            System.out.println("包装类:java.lang.Double"); 
            System.out.println("最小值:Double.MIN_VALUE=" + Double.MIN_VALUE); 
            System.out.println("最大值:Double.MAX_VALUE=" + Double.MAX_VALUE); 
            System.out.println(); 
    
            // char 
            System.out.println("基本类型:char 二进制位数:" + Character.SIZE); 
            System.out.println("包装类:java.lang.Character"); 
            // 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台 
            System.out.println("最小值:Character.MIN_VALUE=" 
                    + (int) Character.MIN_VALUE); 
            // 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台 
            System.out.println("最大值:Character.MAX_VALUE=" 
                    + (int) Character.MAX_VALUE); 
        } 
    } 

    输出结果如下:

    基本类型:byte 二进制位数:8
    包装类:java.lang.Byte
    最小值:Byte.MIN_VALUE=-128
    最大值:Byte.MAX_VALUE=127

    基本类型:short 二进制位数:16
    包装类:java.lang.Short
    最小值:Short.MIN_VALUE=-32768
    最大值:Short.MAX_VALUE=32767

    基本类型:int 二进制位数:32
    包装类:java.lang.Integer
    最小值:Integer.MIN_VALUE=-2147483648
    最大值:Integer.MAX_VALUE=2147483647

    基本类型:long 二进制位数:64
    包装类:java.lang.Long
    最小值:Long.MIN_VALUE=-9223372036854775808
    最大值:Long.MAX_VALUE=9223372036854775807

    基本类型:float 二进制位数:32
    包装类:java.lang.Float
    最小值:Float.MIN_VALUE=1.4E-45
    最大值:Float.MAX_VALUE=3.4028235E38

    基本类型:double 二进制位数:64
    包装类:java.lang.Double
    最小值:Double.MIN_VALUE=4.9E-324
    最大值:Double.MAX_VALUE=1.7976931348623157E308

    基本类型:char 二进制位数:16
    包装类:java.lang.Character
    最小值:Character.MIN_VALUE=0
    最大值:Character.MAX_VALUE=65535

    展开全文
  • 包装流和缓冲流

    千次阅读 2016-10-05 14:56:02
    处理流/包装流(相对于节点流更高级)装饰设计模式/包装模式: 1:隐藏了底层的节点流的差异,并对外提供了更方便的输入/输出功能,让我们只关心高级流的操作. 2:使用处理流包装了节点流,程序直接操作处理流,让节点流与...

    处理流/包装流(相对于节点流更高级)装饰设计模式/包装模式:

    1:隐藏了底层的节点流的差异,并对外提供了更方便的输入/输出功能,让我们只关心高级流的操作.

    2:使用处理流包装了节点流,程序直接操作处理流,让节点流与底层的设备做IO操作.

     

    实际识别处理流/包装流非常简单,只要流的构造器参数不是一个物理节点,而是已经存在的流,那么这种流就一定是处理流,而所有节点流都是直接以物理IO节点作为构造器参数的。

     

    使用处理流的优势:

    1.使用处理流进行输入输出操作更简单

    2.使用处理流的执行效率更高


    ----------------------------------------------------------

    什么是缓冲流:

    是一个包装流,目的起缓冲作用.包括:

    BufferedInputStream:

    BufferedOutputStream:

    BufferedReader:

    BufferedWriter:

     

    int read():每次都从磁盘文件中读取一个字节.  直接操作磁盘文件性能极低.

    解决方案:定义一个数组作为缓冲区.

    byte[] buffer = new byte[1024]; 该数组其实就是一个缓冲区.

    一次性从磁盘文件中读取1024个字节.  如此以来,操作磁盘文件的次数少了,性能得以提升.

    提供的默认缓存区大小是8192(1024*8),我们一般不用修改大小.为了提供IO性能/效率,操作字节和字符流都习惯使用缓冲流给包装起来.


    字节缓冲流:

    //字节缓冲流
    public class BufferStreamDemo {
    	public static void main(String[] args) throws Exception {
    		//字节缓冲输入流
    		BufferedInputStream bin = new BufferedInputStream(new FileInputStream("text/hello.txt"));
    		//IO操作
    		byte[] buffer = new byte[1024];
    		int len = -1;
    		while((len = bin.read(buffer)) != -1){
    			System.out.println(new String(buffer,0,len));
    		}
    		
    		bin.close();
    		
    		//字节缓冲输出流
    		BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream("text/hello.txt",true));
    		//IO操作
    		bout.write("Hhhh2333333".getBytes());
    		bout.write("Hhhh2333333".getBytes());
    		bout.close();
    	}
    
    }

    字符缓冲流:

    //字符缓冲流
    public class BufferWriterReaderDemo {
    	public static void main(String[] args) throws Exception {
    		//字符缓冲输出流
    		BufferedWriter out = new BufferedWriter(new FileWriter("text/hello",true));
    		//IO操作
    		out.write("白日依山尽");
    		out.newLine();
    		out.write("黄河入海流");
    		out.close();
    		
    		//字符缓冲输入流
    		BufferedReader in = new BufferedReader(new FileReader("text/hello.txt"));
    		//IO操作
    //		char[] buffer = new char[1024];
    //		int len = -1;
    //		while((len = in.read(buffer)) != -1){
    //			System.out.println(new String(buffer,0,len));
    //		}
    		//String readLine() 
    		String line = null;
    		while((line = in.readLine()) != null){
    			System.out.println(line);
    		}
    		in.close();
    	
    	}
    
    }


    展开全文
  • 浅谈JS的包装对象

    千次阅读 2016-04-19 22:21:09
    其中包括了三种基本包装类型,也就是Number、String和Boolean,它们是特殊的引用类型,既与其他的引用类型相似,同时又具有与各自的原始类型相应的特殊行为。 一、什么是包装类型? 因为这字符串、数值、布尔三种...

    JS提供了11种引用类型:Object、Array、Date、Function、Error、RegExp、Math、Number、String、Boolean、Globle。其中包括了三种基本包装类型,也就是Number、String和Boolean,它们是特殊的引用类型,既与其他的引用类型相似,同时又具有与各自的原始类型相应的特殊行为。

    一、什么是包装类型?

    因为这字符串、数值、布尔三种原始类型的值,在一定条件下会自动转化为对象,因此被称为原始类型的“包装类型”。

    例如:var a1="some text";

       var a2=a1.substring(0,2);

      console.log(a2);//"so"

    上面这个例子中,变量a1是一个字符串,字符创必然是基本类型的值,但是它却在第二行调用了substring()方法,并将结果返回保存在a2中,我们都知道,既然a1是基本类型的值而不是对象,因而从逻辑上讲,它是没有方法的。其实在在实现这个操作的时候,JS内部已经隐式地帮我们帮创建了一个包装对象了,以上的实际的情形应该是这样的

    var a1=new String("some text");

    var a2=a1.substring(0,2);

    a1=null;   

    console.log(a2);//"so"

    但是这两种方式还是有区别的:

    区别一:浏览器自己隐式创建的包装对象和你显式创建的包装对象不严格相等。

    var a1="test";

    var a2=new String("test");

    console.log(a1==a2);//true

    console.log(a1===a2);//false

    区别2: 隐式创建的包装对象,在使用完后之后就会被销毁了。例如:

    var s1="some text";

    var s1.color="red";

    console.log(s1.color);//undefined

    上面的代码,在第二行代码试图为一个字符s1添加一个color属性,但是当第三行再次访问的时候,color属性已经不见了。原因就是第二行代码创建的String对象在执行第三行代码时已经被销毁了,第三行代码又创建来了自己的String对象,可是没有了color属性,所以最终返回的值是undefined。

    在实际运用中,我们可以显式的调用String、Number和Boolean来创建基本包装类型的对象,不过,应该在绝对必要的时候再这么做,因为这种做法很容易让人分不清自己是在处理基本类型还是引用类型。对基本包装类型的实例调用 typeof 会返回object。

    二、包装类型和引用类型的区别

    引用类型和包装类型的主要区别是对象的生存期。使用new操作符创建的引用类型的实例,在执行流离开当前作用域之前都一直保存在内存中。而自动穿件的基本包转类型的对象,则只存在于一行代码的执行期间,然后立即被销毁,这也意味着我们不能在运行时为基本类型添加属性和方法。


    展开全文
  • Spring的作用 Struts的作用 Hiberante的作用
  • switch可作用于char byte short int ...switch不可作用于long double float boolean,包括他们的包装类 public class Test { public static void main(String[] args) { // switch可作用于char byte...
  • python包装和授权

    千次阅读 2015-09-04 11:04:16
    首先了解什么是包装和授权。 我们知道,面向对象程序设计中有一个理念就是封装,而实际上面向对象也让程序员在使用一些类(自己定义或则别人定义)对象的时候非常方便。包装就是一个希望将某个对象(或类),进行...
  • 包装国际惯例

    万次阅读 2011-09-16 11:46:11
    按英国和美国茶叶联合会提出的国际通用的散装茶(进口后 由包装商拼配分装成小包装茶的原料茶)定量包装标准,散装茶应采用多层 复合牛皮纸夹衬铝箔袋,袋上口设灌装阀;每纸袋装茶 50 公斤,20 个纸袋 组装成一个...
  • /**  * 问题:switch语句能否作用在byte上,能否作用在long上,能否作用在String上  * 基本类型的包装类(如:Character、Byte、... * switch可作用于char byte short int对应的包装类  * switch不可作用于long do
  • 1.(Object 类)在 Object 类中,定义的 finalize 方法在______时调用,toString()方法返回值表示________,equals 方法的作用为_________,getClass 方法作用为__________ 2.(toString 方法,equals 方法)写出 O
  • 药品的泡罩包装技术介绍

    千次阅读 2008-08-02 16:50:00
    药品的泡罩包装又称为水泡眼包装,简称为PTP(Press through Packaging),是药品包装的主要形式之一,适用于片剂、胶囊、栓剂、丸剂等固体制剂药品的机械化包装。 泡罩包装在我国的兴起 早在二十世纪三十年代
  • Java:自动拆箱和装箱及包装

    千次阅读 2018-10-26 11:50:48
    自动拆箱和装箱是从JDK5.0才开始有的,它方便了基本数据类型和其对应的包装类型之间的转换。   将一个基本数据类型的值赋给其所对应的包装类型称之为自动装箱;将一个基本数据类型包装类类型的值赋给其所对应的...
  • 函数作用域和块作用

    千次阅读 2018-10-29 21:31:32
    1.函数中的作用域  1. 无论标识符声明在作用域的何处,这个标识符所代表的变量或函数都将附属于所处作用域的气泡。  2.函数作用域的含义:属于这个函数的全部变量可以在整个函数的范围内使用及复用。 ...
  • 包装行业ERP解决方案

    千次阅读 2011-11-05 11:29:17
    全球经济一体化使包装企业的竞争日益剧烈,建立一个有效的ERP管理系统,可以使企业拥有比竞争对手更严谨的业务管理和控制,可以比竞争对手更快速地获得业务信息,掌握了这些信息企业就可以更准确、更及时的进行判断...
  • volatile关键字的作用

    万次阅读 多人点赞 2019-06-09 23:46:30
    volatile关键字的作用
  • 在实际开发项目中,我们查询条件不可能很单一,查询字段可能包括很多字段,比如:查询条件可以有用户信息,商品信息,订单信息等。 这里我们的基础实体类是用户类,我在这个基础上扩展他,之后包装他作为我们的查询...
  • Java之路:变量作用

    千次阅读 多人点赞 2018-12-15 09:50:01
    变量作用域 变量是有作用范围(Scope)的,也即作用域。一旦超出变量的作用域,就无法再使用这个变量。 按作用域范围划分,变量分为成员变量和局部变量。 (1)成员变量 在类体内定义的变量称为成员变量,它的...
  • switch可作用于char byte short int ... switch不可作用于long double float boolean,包括他们的包装类 switch中可以是字符串类型,String(JDK1.7之后才可以作用在string上) switch中可以是枚举类型(JDK1....
  • 基本类型和包装类之间的转换基本类型和包装类之间经常需要互相转换,以 Integer 为例(其他几个包装类的操作雷同哦):在 JDK1.5 引入自动装箱和拆箱的机制后,包装类和基本类型之间的转换就更加轻松便利了。...
  • 7. 不要过分包装简历

    千次阅读 2016-06-22 10:11:02
    因为企业聘来人才是为了在工作中发挥作用,创造效益,为企业带来价值的,而不是像花瓶一样作摆设的。因此,企业特别关心应聘者具备的能力到底能不能满足自己的要求,而不是看简历作的是不是花哨、高档次。  如果...
  • DispatcherServlet作用

    万次阅读 2018-09-14 10:06:19
    2、通过HandlerMapping,将请求映射到处理器(返回一个HandlerExecutionChain,它包括一个处理器、多个HandlerInterceptor拦截器); 3、通过HandlerAdapter支持多种类型的处理器(HandlerExecutionChain中的...
  • 随着《中国制造2025》规划路线的出台,制造业改革之船已经起航了,其主攻方向是智能制造,智能包装迎来发展的春天。我国包装工业总产值已达1.9万亿元,位居世界第二,而智能包装将成为下一个风口!智能包装的发展离不...
  • 包装类: 在JS中为我们提供了三个包装类,这三个包装类将我们的基本数据类型转换成对象。 String()----可以将基本数据类型的字符串转换为String对象 Number()----可以将基本数据类型的数字转换为Number对象 ...
  • 下面说说关于mapper.xml文件中的输入映射 我们看一下之前为User配置的mapper文件UserMapper.xml: <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" ...-- namespace命名空间,作用
  • 【Java】原始数据类型与其包装

    千次阅读 热门讨论 2018-04-01 21:23:40
      使用包装类有以下作用: 提供了一些实用方法,比如:基本类型之间相互转换 要求Object类型时无法使用基本数据类型,比如集合内不允许存放基本数据类型 Autoboxing&Unboxing   自动装箱是指...
  • 一、Java基本类型 Java语言提供... 1、整数:包括int,short,byte,long ,初始值为0 2、浮点型:float,double ,初始值为0.0 3、字符:char ,初始值为空格,即'' ",如果输出,在Console上是看不到效果的。 ...
  • Handler有何作用?如何使用?

    千次阅读 2014-04-27 12:03:39
    android Handler有何作用?如何使用?
  • 包装类:  自jdk5之后,java就提供了自动装箱与自动拆箱功能,大大简化了基本类型与其包装类对象之间的转换过程,当然装换过程中要注意类型的匹配。 public class IntAndInteger { public static void main...
  • java 反射中的包装类与基本数据类型

    千次阅读 2018-11-28 13:45:46
    下面的transferToPrime函数就起这个作用,(说明,如果是单独的一条语句Method method=c.getDeclaredMethod(String name, Class<?>... parameterTypes),你就可以手动地写成int.class,double.class,但是抽取成方法时,...
  • 你不知道的JavaScript–Item4 基本类型和基本包装类型(引用类型) 标签: <a h

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 119,815
精华内容 47,926
关键字:

包装的作用包括