精华内容
下载资源
问答
  • 这篇文档就是解密百度百科之“APP”创建的那些不为人知的问题,并且我将抛开各种繁琐的“大道理”“无用的知识点”,通过简单直接的“核心秘密”让大家看完后很快就能轻松的创建各种类型的百度百科词条,从此以后...
  • 构造方法创造的字符串对象直接赋值方式创建的字符串对象有什么区别? 猜想:存放字符串的地址值不同,方便程度不同 结果:构造方法创建的字符串对象是在堆内存 直接赋值方式创建的对象是在方法区的常量

    代码

    注意:当方法区内的常量池有该字符串,以后再使用也就是调用该方法区内的该字符串(实际上),构造方法创建的字符串对象和直接赋值方式创建的字符串对象本质上是调用方式的不同(所以地址值有区别)

    package MyString;
    /*
           构造方法创造的字符串对象和直接赋值方式创建的字符串对象有什么区别?
                猜想:存放字符串的地址值不同,方便程度不同
    
             结果:构造方法创建的字符串对象是在堆内存
                  直接赋值方式创建的对象是在方法区的常量池。
    
                 字符串的内容是存储在方法区的常量池内的,为了方便字符串的重复利用
    
           扩充:  == 比较符号两边的数值
                     基本数据类型:比较的是基本数据类型的值是否相同(true/false)
                     引用数据类型:比较的是引用数据类型的地址值是否相同(true/false)
     */
    public class StringDemo2 {
        public static void main(String[] args) {
            String s5="hello";
            //构造方法创造的字符串对象
            String s1=new String("hello");
            //直接赋值方式创建的字符串对象
            String s2="hello";
            //先看输出值
            System.out.println("s1:"+s1);
            System.out.println("s2:"+s2);
    
            String s3="hello";
            String s4=new String("hello");
            System.out.println("s1==s2? "+(s1==s2));//false
            System.out.println("s1==s3? "+(s1==s4));//false
            System.out.println("s2==s4? "+(s2==s3));//true
            System.out.println("s5==s1? "+(s5==s1));//false
            System.out.println("s5==s2? "+(s5==s2));//true
            System.out.println("s5==s3? "+(s5==s3));//true
            //其中如果构造方法创建的字符串对象在直接赋值后,则直接赋值会在常量池开辟一个新内存存放该字符串
            //往后再有直接赋值与该字符串相同的数据,则栈内存方法直接指向该方法区的常量池内的该字符串地址
            //而构造方法由于在堆内存开辟了新的空间,所以需要二次(多次)寻址才能调用该常量池内的字符串
            //由此来看,除去第一次开辟后,常量池内有该字符串,字符串的利用还是直接赋值创建对象更加方便省事
        }
    }
    

    图示

    在这里插入图片描述

    展开全文
  • 工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象,所谓复合对象就是指某个类具有不同的属性,其实建造者模式就是前面抽象工厂模式最后的Test结合起来得到的。...

    一、创造者模式

    工厂类模式提供的是创建单个类的模式,而建造者模式则是将各种产品集中起来进行管理,用来创建复合对象,所谓复合对象就是指某个类具有不同的属性,其实建造者模式就是前面抽象工厂模式和最后的Test结合起来得到的。我们看一下代码:

    还和前面一样,一个Sender接口,两个实现类MailSender和SmsSender。最后,建造者类如下:

    public class Builder {
    	
    	private List<Sender> list = new ArrayList<Sender>();
    	
    	public void produceMailSender(int count){
    		for(int i=0; i<count; i++){
    			list.add(new MailSender());
    		}
    	}
    	
    	public void produceSmsSender(int count){
    		for(int i=0; i<count; i++){
    			list.add(new SmsSender());
    		}
    	}
    }
    

    测试类:

    public class Test {
     
    	public static void main(String[] args) {
    		Builder builder = new Builder();
    		builder.produceMailSender(10);
    	}
    }
    

    二、总结

    从这点看出,建造者模式将很多功能集成到一个类里,这个类可以创造出比较复杂的东西。所以与工程模式的区别就是:工厂模式关注的是创建单个产品,而建造者模式则关注创建符合对象,多个部分。因此,是选择工厂模式还是建造者模式,依实际情况而定。

    创造者—MM最爱听的就是“我爱你”这句话了,见到不同地方的MM,要能够用她们的方言跟她说这句话哦,我有一个多种语言翻译机,上面每种语言都有一个按键,见到MM我只要按对应的键,它就能够用相应的语言说出“我爱你”这句话了,国外的MM也可以轻松搞掂,这就是我的“我爱你”builder。又或者如同做汉堡,你只要说你要的是鸡肉、牛排、鲜虾等。快餐店就不根据你的需要为你做好你要的汉堡。而你不需要知道其内部制作的过程。 

    建造模式:将产品的内部表象和产品的生成过程分割开来,从而使一个建造过程生成具有不同的内部表象的产品对象。建造模式使得产品内部表象可以独立的变化,客户不必知道产品内部组成的细节。建造模式可以强制实行一种分步骤进行的建造过程。

     



     

     

     

     

     

    展开全文
  • Executors提供了一些方便创建ThreadPoolExecutor的常用方法,主要有以下几个: 1、 Executors.newFixedThreadPool(int nThreads);创建固定大小(nThreads,大小不能超过int的最大值)的线程池 //线程数量 int ...

    Executors提供了一些方便创建ThreadPoolExecutor的常用方法,主要有以下几个:

    1、 Executors.newFixedThreadPool(int nThreads);创建固定大小(nThreads,大小不能超过int的最大值)的线程池

    //线程数量

    int nThreads = 20;

    //创建executor 服务

    ExecutorService executor = Executors.newFixedThreadPool(nThreads) ;

    重载后的版本,需要多传入实现了ThreadFactory接口的对象。

    ExecutorService executor = Executors. newFixedThreadPool(nThreads,threadFactory);

    说明:创建固定大小(nThreads,大小不能超过int的最大值)的线程池,缓冲任务的队列为LinkedBlockingQueue,大小为整型的最大数,当使用此线程池时,在同执行的任务数量超过传入的线程池大小值后,将会放入LinkedBlockingQueue,在LinkedBlockingQueue中的任务需要等待线程空闲后再执行,如果放入LinkedBlockingQueue中的任务超过整型的最大数时,抛出RejectedExecutionException。

    2、Executors.newSingleThreadExecutor():创建大小为1的固定线程池。

    ExecutorService executor = Executors.newSingleThreadExecutor();

    重载后的版本,需要多传入实现了ThreadFactory接口的对象。

    ExecutorService executor = Executors. newSingleThreadScheduledExecutor(ThreadFactory threadFactory)

    说明:创建大小为1的固定线程池,同时执行任务(task)的只有一个,其它的(任务)task都放在LinkedBlockingQueue中排队等待执行。

    3、Executors.newCachedThreadPool();创建corePoolSize为0,最大线程数为整型的最大数,线程keepAliveTime为1分钟,缓存任务的队列为SynchronousQueue的线程池。

    ExecutorService executor = Executors.newCachedThreadPool();

    当然也可以以下面的方式创建,重载后的版本,需要多传入实现了ThreadFactory接口的对象。

    ExecutorService executor = Executors.newCachedThreadPool(ThreadFactory threadFactory) ;

    说明:使用时,放入线程池的task任务会复用线程或启动新线程来执行,注意事项:启动的线程数如果超过整型最大值后会抛出RejectedExecutionException异常,启动后的线程存活时间为一分钟。

    4、Executors.newScheduledThreadPool(int corePoolSize):创建corePoolSize大小的线程池。

    //线程数量

    int corePoolSize= 20;

    //创建executor 服务

    ExecutorService executor = Executors.newScheduledThreadPool(corePoolSize) ;

    重载后的版本,需要多传入实现了ThreadFactory接口的对象。

    ExecutorService executor = Executors.newScheduledThreadPool(corePoolSize, threadFactory) 

    说明:线程keepAliveTime为0,缓存任务的队列为DelayedWorkQueue,注意不要超过整型的最大值。

     

     

     

    区别: 

    一:

    newCachedThreadPool

     (1)缓存型池子,先查看池中有没有以前建立的线程,如果有,就reuse,如果没有,就建立一个新的线程加入池中;  

     (2)缓存型池子,通常用于执行一些生存周期很短的异步型任务;因此一些面向连接的daemon型server中用得不多;  

     (3)能reuse的线程,必须是timeout IDLE内的池中线程,缺省timeout是60s,超过这个IDLE时长,线程实例将被终止及移出池。  

     (4)注意,放入CachedThreadPool的线程不必担心其结束,超过TIMEOUT不活动,其会自动被终止

     

     

    二:

    newFixedThreadPool

     (1)newFixedThreadPool与cacheThreadPool差不多,也是能reuse就用,但不能随时建新的线程  

     (2)其独特之处:任意时间点,最多只能有固定数目的活动线程存在,此时如果有新的线程要建立,只能放在另外的队列中等待,直到当前的线程中某个线程终止直接被移出池子

     (3)和cacheThreadPool不同,FixedThreadPool没有IDLE机制(可能也有,但既然文档没提,肯定非常长,类似依赖上层的TCP或UDP IDLE机制之类的),所以FixedThreadPool多数针对一些很稳定很固定的正规并发线程,多用于服务器 

     (4)从方法的源代码看,cache池和fixed 池调用的是同一个底层池,只不过参数不同: fixed池线程数固定,并且是0秒IDLE(无IDLE)cache池线程数支持

    0-Integer.MAX_VALUE(显然完全没考虑主机的资源承受能力),60秒IDLE 

     

    三:

    ScheduledThreadPool

    (1)调度型线程池 

    (2)这个池子里的线程可以按schedule依次delay执行,或周期执行 


    四:

    SingleThreadExecutor

    (1)单例线程,任意时间池中只能有一个线程 

    (2)用的是和cache池和fixed池相同的底层池,但线程数目是1-1,0秒IDLE(无IDLE)

     

    展开全文
  • 起初刚学C++时,很不习惯用new,后来看老外的程序,发现几乎都是使用new,想一想区别也不是太大,但是在大一点的项目设计中,有时候不使用new的确会带来很多问题。当然这都是跟new的用法有关的。new创建类对象,使用...

    起初刚学C++时,很不习惯用new,后来看老外的程序,发现几乎都是使用new,想一想区别也不是太大,但是在大一点的项目设计中,有时候不使用new的确会带来很多问题。当然这都是跟new的用法有关的。new创建类对象,使用完后需使用delete删除,跟申请内存类似。所以,new有时候又不太适合,比如在频繁调用场合,使用局部new类对象就不是个好选择,使用全局类对象或一个经过初始化的全局类指针似乎更加高效。

    C++ 对象实例化的一些概念
    C++ 如果直接定义类,如classA  a; a存在栈上(也意味着复制了对象a在栈中);
    如果classA  a = new classA就存在堆中。

    一、new创建类对象与不new区别

    下面是自己总结的一些关于new创建类对象特点:

    • new创建类对象需要指针接收,一处初始化,多处使用
    • new创建类对象使用完需delete销毁
    • new创建对象直接使用堆空间,而局部不用new定义类对象则使用栈空间
    • new对象指针用途广泛,比如作为函数返回值、函数参数等
    • 频繁调用场合并不适合new,就像new申请和释放内存一样

    二、new创建类对象实例

    1、new创建类对象例子:

    CTest* pTest = new CTest();

    delete pTest;

    pTest用来接收类对象指针。

    不用new,直接使用类定义申明:

    CTest mTest;

    此种创建方式,使用完后不需要手动释放,该类析构函数会自动执行。而new申请的对象,则只有调用到delete时再会执行析构函数,如果程序退出而没有执行delete则会造成内存泄漏。

    2、只定义类指针

    这跟不用new申明对象有很大区别,类指针可以先行定义,但类指针只是个通用指针,在new之前并为该类对象分配任何内存空间。比如:

    CTest* pTest = NULL;

    但使用普通方式创建的类对象,在创建之初就已经分配了内存空间。而类指针,如果未经过对象初始化,则不需要delete释放

    3、new对象指针作为函数参数和返回值

    下面是天缘随手写一个例子,不太严谨。主要示意一下类指针对象作为返回值和参数使用。

    [cpp]  view plain  copy
    1. class CTest {  public:   int a;  };      
    2. class CBest {  public:   int b;  };      
    3. CTest* fun(CBest* pBest) {    
    4.                            CTest* pTest = new CTest();     
    5.                            pTest->a = pBest->b;   return pTest;    
    6. }      
    7. int main() {    
    8.              CBest* pBest = new CBest();     
    9.              CTest* pRes= fun(pBest);        
    10.              if(pBest!=NULL)      
    11.              delete pBest;     
    12.              if(pRes!=NULL)      
    13.              delete pRes ;     
    14.              return 0;    
    15. }  

    C++对象实例化

    [cpp]  view plain  copy
    1. JAVA:  
    2. A a = new A();  
    3. 为A对象创建了一个实例,但在内存中开辟了两块空间:一块空间在堆区,存放new A()这个对象;  
    4. 另一块空间在堆栈,也就是栈,存放a,a的值为new A()这个对象的内存地址。因为java在JVM中运行,  
    5. 所以a 描述的内存地址不一定是这个对象真实内存的地址。  
    6.   
    7. Object o; // 这是声明一个引用,它的类型是Object,他的值为null,还没有指向任何对象,该引用放在内存的栈区域中。  
    8.   
    9. o = new Object(); // new Object()句,实例化了一个对象,就是在堆中申请了一块连续空间用来存放该对象。  
    10. // 运算符,将引向o指向了对象。也就是说将栈中表示引用o的内存地址的内容改写成了Object对象在堆中的地址。  
    11.   
    12. C++:  
    13. C++ 如果直接定义类,如classA a; a 存在栈上(也意味着复制了对象a在栈中),如果classA a = new classA就存在堆中。  

    初学Java时,在很长一段时间里,总觉得基本概念很模糊。后来才知道,在许多Java书中,把对象和对象的引用(实例)混为一谈

    如果分不清对象与对象引用,那实在没法很好地理解下面的面向对象技术,把自己的一点认识写下来,或许能让初学Java的朋友们少走一点弯路。        

    为便于说明,我们先定义一个简单的类:  
    [cpp]  view plain  copy
    1. class student  
    2. {  
    3.       int name;  
    4.       int age;  
    5.       int sex;  
    6. }  

    有了这个类(模板),就可以用它来创建对象:student stu1 = new  student();

    通常把这条语句的动作称之为创建一个对象,其实,它包含了四个动作

    1)右边的"new  student",是以student类为模板,在堆空间里创建一个student类的对象(也简称为student对象)

    2)末尾的()意味着,在对象创建后,立即调用student类的构造函数,对刚生成的对象进行初始化

        构造函数是肯定有的。如果你没写,Java会给你补上一个默认的构造函数。

    3)左边的"student stu1"创建了一个student类引用变量。所谓student类引用,就是以后可以用来指向某个 

        student对象的对象引用,它指向的是某个student对象的内存地址(有点C语言中指针的味道)

    4)"="操作符使对象引用指向刚创建的那个student对象

        我们可以把这条语句拆成两部分student  stu1;                 (1)

                                                                 stu1 = new student();     (2)

        效果是一样的

        这样写,就比较清楚了,有两个实体:一是对象引用变量(stu1),在Sun公司的实现中,对象的引用是一个句柄,其中包含一对指针:一个指针指向该对象的方法表,一个指向该对象的数据另一个是对象本身(就是new出来的那个对象)

        在堆空间里创建的实体,与在数据段以及栈空间里创建的实体不同。尽管它们也是确确实实存在的实体,但是,我们看不见,也摸不着。不仅如此,我们仔细研究一下第二句,想想刚刚创建的student对象叫什么名字?

        有人说,它叫"student"。不对,"student"是类(对象的创建模板)的名字。一个student类可以据此创建出无数个对象,这些对象不可能全叫"student"对象连名都没有,没法直接访问它。我们只能通过对象引用(实例)来间接访问对象

        为了形象地说明对象、对象引用及它们之间的关系,可以做一个或许不很妥当的比喻:

        对象好比是一只没有线的风筝,引用变量是一根线,可以用来系风筝。如果只执行了第一条语句还没执行第二条,此时创建的引用变量stu1还没指向任何一个对象,它的值是null,引用变量可以指向某个对象,或者为null。这时stu1是一根线,一根还没有系上任何一个风筝的线。

       执行了第二句后,一只新风筝做出来了,并被系在stu1这根线上。我们抓住这根线,就等于抓住了那只风筝。

       再来一句:student  stu2;就又做了一根线,还没系上风筝。如果再加一句:stu2=stu1;系上风筝了

       这里,发生了复制行为。但是,要说明的是,对象本身并没有被复制,被复制的只是对象引用

       结果是,stu2也指向了stu1所指向的对象,也就是两根线系的是同一只风筝。

       如果用下句再创建一个对象:stu2=newstudent();则引用变量stu2改指向第二个对象。

       从以上叙述再推演下去,我们可以获得以下结论:

       (1)一个对象引用可以指向0个或1个对象(一根线可以不系风筝,也可以系一个风筝),而且可以改指;

       (2)一个对象可以有N个引用指向它(可以有N条线系同一个风筝)

        如果有下面语句:stu1=stu2;

        按上面的推断,stu1也指向了第二个对象。这个没问题。问题是第一个对象呢?没有一条线系住它,它飞了。

        很多书里说,它被Java的垃圾回收机制回收了,这不确切,准确地说,它已成为Java垃圾回收机制的处理对象。至于什么时候真正被回收,那要看垃圾回收机制的心情了。由此看来,new  student();该语句应该不合法吧,至少是没用的吧?不对,它是合法的,而且可用的。譬如,如果我们仅仅为了打印而生成一个对象,就不需要用引用变量来系住它。最常见的就是打印字符串:System.out.println("Iam Java!");

        字符串对象"I amJava!"在打印后即被丢弃,有人把这种对象称之为临时对象。

    最后再说明一下:

    C++中:

    Student  student(20) ;  //这里student是引用 对象分配在 栈空间中,这里只是我的理解

    Student *student = new  Student(20);  //这里student是指针,new Student(20)是分配在堆内存空间的

    但是在Java中

    Student  student(20) ;  //注意:java中没有这样实例化对象的, 要想得到一个对象 必须要new出来.

    Student student ; //这个只是定义了一个引用 ,没有指向任何对象

    Student student = new Student(20);   //定义了一个引用,指向堆内存中的student对象

    展开全文
  • 为什么我感觉可以用反射的都可以用new,刚开始学有点不理解编译时new对象无法确定时用反射这句话
  • 这是父接口,写了两个test方法。 ... /** * Created by wang.jiancheng on 2017/8/4. */ interface InterParent { ...但是直接通过本身创建自己的对象,就会有所有的方法。(好像是废话。。。)
  • 使用File创建文件绝对路径相对路径的区别 1.绝对路径 File file = new File("/this.txt"); file.createNewFile(); 那么该文件会被创建到磁盘的根目录下,如果你的项目在D盘,那么它会被创建到D盘下。 2....
  • 线程创建的两种方式和区别

    千次阅读 2017-06-21 16:13:29
    那么这两种实现多线程的方式在应用上有什么区别呢?   为了回答这个问题,我们可以通过编写一段代码来进行分析。我们用代码来模拟铁路售票系统,实现通过四个售票点发售某日某次列车的100张车票,一个售票点用一...
  • 系统允许一个进程创建新进程,新进程即为子进程,子进程还可以创建新的子进程,形成进程树结构模型。整个linux系统的所有进程也是一个树形结构。树根是系统自动构造的,即在内核态下执行的0号进程,它是所有进程的...
  • 1:作用域不同 ...用new:创建的是指向类对象的指针,作用域变成了全局,当程序结束时,必须用delete删除,系统不会自动释放,(不注意可能造成内存泄漏)。 2:一个类对象,一个是指向类对象的指针。
  • 方法一:构造函数创建组件 实例:创建一个简单组件 实例:向组件传递数据 实例:复合组件 方法二:class关键字创建组件 实例:向组件传递数据 方法一:构造函数创建组件 使用构造函数来创建组件时,如果要...
  • fork,vfork,clone都是linux的系统调用,用来创建子进程的,但是大家在使用时经常混淆,这里给出具体例子讲解三者的联系与区别。  在此之前,推荐大家先看我的文章:linux进程创建过程与原理   我们知道,...
  • new一个类对象使用类名创建一个对象有什么区别? 用new来给一个类的对象分配空间,使用类名称来定义一个类的对象,有什么区别?难道区别只是new的返回值是个指针,而对象定义得到的是变量名么?或者是在存储...
  • Linux上创建和更改硬链接符号链接

    万次阅读 2016-07-06 02:05:24
    在本篇中,学习创建和管理硬链接符号链接。学习: 创建硬或软链接识别链接并知道它们的类型理解复制与链接文件之间的区别使用链接执行系统管理任务 链接简介 在存储设备上,文件或目录包含在一些数据块中。...
  • MySQL创建约束条件(四)

    千次阅读 2019-11-15 14:09:16
    古语有云: 万恶淫为首,百善孝为先。 我们后辈当自勉。 上一章简单介绍了 MySQL的数据类型(三),如果没有看过,请观看上一章 ...在创建表时,一定要在 database 里面进行创建, 既先使用 use 数据库名来选择...
  • 达梦数据库如何创建表空间

    万次阅读 热门讨论 2016-08-24 16:05:35
    第一步: 创建一个表空间 第二步: 创建一个用户,这一步,需要选择一个表空间,就选择你所创建的哪一个表空间 ...创建模型,在创建模式中需要选择一个用户,选择所创建的用户就好 第四步: 创建表 成功!
  • 创建动态元素

    2020-03-16 15:04:50
    三种动态创建元素的区别: document.write():直接把内容写入页面的内容流 但是文档加载完成后,会导致页面全部重绘只显示他自己创造的元素或者文本 innerHTML跟createlements的区别: innerHTML跟...
  • 进程的创建

    2016-10-07 10:08:11
    在系统启动时,操作系统会创建一些进程,他们承担着管理分配系统资源的任务,这些进程通常被称为系统进程。 系统允许一个进程创建新进程,新进程即为子进程,子进程还可以创建新的子进程,形成进程树结构。整个...
  • 其中aString是通过直接赋值的方式创建,bString是通过String类型的构造方法创造对象。相同的地方在于他们两都是两个值都为“a”字符串对象。但他们在创建对象的方式是不同的。现在通过常见的判断两个字符串对象的值...
  • 创建型模式

    热门讨论 2014-12-14 20:22:51
    创建型模式隐藏了类的实例是如何被创建和放在一起,整个系统关于这些对象所知道的是由抽象类所定义的接口。这样,创建型模式在创建了什么,谁创建的,...允许客户用结构功能差别很大的产品对象配置一个系统。    
  • My SQL 创建数据库表(1)

    千次阅读 2019-05-17 17:11:35
    2、用于访问操作数据库的标准计算机语言 二、用途 1、操作数据库对象 2、表记录的增删改查 创建数据库 一、常见类型 每种字段都有自己的类型、如整数型、字符串、时间类型、日期类型、浮点型 1、整型(可以保存:...
  • 本文详细介绍下jsjquery对dom节点的操作包括创建、追加等等,感兴趣的朋友可以参考下哈,希望对你有所帮助
  • append:这个操作与对指定的元素执行原生的appendChild方法,将它们添加到文档中的情况类似。appendTo:实际上,使用这个方法是颠倒了常规的$(A).append(B)的操作,即不是把B追加到A中,而是把A追加到B中。...
  • javascript创建对象

    千次阅读 2016-08-27 15:35:48
    js面向对象的关系 JS是基于对象的语言,可以使用面向对象思想模拟JAVA|C++之类的面向对象语言。 面向过程 关注解决问题的步骤 面向对象 ...自定义对象必须自己创造,无法利用系统函数来创造。 ja
  • class Single{ //将构造函数私有化,就无法在外部创造其对象,就能保证只有一个对象 private Single(){} //在本类中,创建本类的对象,以便外部获取 private static Single s = new Single(); //定义个方法,方便...
  • 系统允许一个进程创建新...由0号进程创建1号进程(内核态),1号负责执行内核的部分初始化工作及进行系统配置,并创建若干个用于高速缓存虚拟主存管理的内核线程。随后,1号进程调用execve()运行可执行程序init,
  • 创建窗体及一系列操作

    热门讨论 2020-12-06 09:57:23
    以前我用VB创建窗体,现在用C#创建窗体,我感觉两者并没有什么本质区别,就是要不断地去运用去发现,去创造,运用要有具体的逻辑思路。 代码: 结果:
  • 1.lambda表达式创建线程 2.匿名内部类创建线程 注意为调用start的方法,下图只是参考不准 3.使用线程池创建一个线程在这里插入代码片

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 68,035
精华内容 27,214
关键字:

创建和创造的区别