代码
 
注意：当方法区内的常量池有该字符串，以后再使用也就是调用该方法区内的该字符串（实际上），构造方法创建的字符串对象和直接赋值方式创建的字符串对象本质上是调用方式的不同（所以地址值有区别）
 
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结合起来得到的。我们看一下代码：
 
还和前面一样，一个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 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创建类对象，使用完后需使用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 
   
 
   
 
   
  
 
 
 
 
 class CTest {  public:   int a;  };      
 class CBest {  public:   int b;  };      
 CTest* fun(CBest* pBest) {    
                            CTest* pTest = new CTest();     
                            pTest->a = pBest->b;   return pTest;    
 }      
 int main() {    
              CBest* pBest = new CBest();     
              CTest* pRes= fun(pBest);        
              if(pBest!=NULL)      
              delete pBest;     
              if(pRes!=NULL)      
              delete pRes ;     
              return 0;    
 }  
 
 
 
 
 
 
 C++对象实例化
 
 
 
 
  
 
   [cpp] 
   view plain
    copy 
   
 
   
 
   
  
 
 
 
 
 JAVA：  
 A a = new A();  
 为A对象创建了一个实例，但在内存中开辟了两块空间：一块空间在堆区，存放new A（）这个对象；  
 另一块空间在堆栈，也就是栈，存放a，a的值为new A（）这个对象的内存地址。因为java在JVM中运行，  
 所以a 描述的内存地址不一定是这个对象真实内存的地址。  
   
 Object o; // 这是声明一个引用，它的类型是Object，他的值为null，还没有指向任何对象，该引用放在内存的栈区域中。  
   
 o = new Object(); // new Object()句，实例化了一个对象，就是在堆中申请了一块连续空间用来存放该对象。  
 = // 运算符，将引向o指向了对象。也就是说将栈中表示引用o的内存地址的内容改写成了Object对象在堆中的地址。  
   
 C++：  
 C++ 如果直接定义类，如classA a; a 存在栈上（也意味着复制了对象a在栈中），如果classA a = new classA就存在堆中。  
 
 
 
 
 初学Java时，在很长一段时间里，总觉得基本概念很模糊。后来才知道，在许多Java书中，把对象和对象的引用（实例）混为一谈。
 
 如果分不清对象与对象引用，那实在没法很好地理解下面的面向对象技术，把自己的一点认识写下来，或许能让初学Java的朋友们少走一点弯路。        
 
为便于说明，我们先定义一个简单的类：  
  
 
 
 
  
 
   [cpp] 
   view plain
    copy 
   
 
   
 
   
  
 
 
 
 
 class student  
 {  
       int name;  
       int age;  
       int sex;  
 }  
 
 
 有了这个类(模板)，就可以用它来创建对象：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对象