赵海洋 发表于 2013-7-15 20:40
7，示例代码：单例设计模式，两种方法一种即可，并说说这两种方法的区别？ ...

饿汉式
使用显示初始化方式
在方法中直接返回static实例。
懒汉式
不在使用显示初始化方式了。
而是在方式中使用初始化！
我用的饿汉
public class Single {
        private static Single instance = new Single();
       
        private Single() {}
       
        public static Single getInstance() {
                return instance;
        }
}

赵海洋 发表于 2013-7-15 20:00
答题开始，第一题，送分题：面向对象的三个特征？（在线答题，四分钟后更新下一题，请大家抓紧！）答案直接 ...

封装 继承 多态

1. package Thread;
   
2. /*
   
3. * 单例设计模式  
   
4. */
   
5. //饿汉式
   
6. /*
   
7. * Class Single
   
8. * {   
   
9. *       private static final Single s = new Single();
   
10. *       private Single(){}
    
11. *       public static Single getInstanse(){
    
12. *                         return s;
    
13. *       }
    
14. *
    
15. * }
    
16. * */
    
17. public class DanLi {    //懒汉式
    
18.          private static DanLi dl =null;
    
19.          private DanLi(){};
    
20.          public static DanLi getInstanse(){
    
21.                    if(dl==null){
    
22.                            dl = new DanLi();
    
23.                    }
    
24.                    return dl;
    
25.          }
    
26. 
    
27. }
    

复制代码

恶汉式直接获取对象
懒汉式延迟加载，但是如果有多线程的程序访问程序时会出现安全问题，可以通过添加同步代码块或者同步函数都可以解决。但是效率有点低，可以再加一层判断增加代码效率

第七题：单例设计模式
/**
需求:实现饿汉式单例设计模式

思路:用 static 把对象创建封装在类内部

步骤:
1.将构造函数私有化
2.在类中创建一个本类对象
3.提供一个可以方法可以获取到该对象

*/
class Single
{
        private static Single single = new Single();

        private Single()
        {
        }

        public static Single getInstance()
        {
            return single;
        }
}

class SingleDemo
{
        public static void main(String[] args)
        {
                Single single = Single.getInstance();
        }
}

饿汉式 单例设计模式，主要是在第一次调用 getInstance 的时候才会创建对象，懒汉式单例设计模式在类加载的时候就会创建对象

1. class Single{
   
2.   private Single s = new Single();

复制代码

上门是饿汉式。

懒汉式是延长加载

class EHan//   饿汉式
{
        private EHan s=new EHan();
        private EHan(){}
        public EHan show()
        {
               
                return s;
        }
}

单例设计模式有饿汉式和懒汉式。饿汉式是先创建对象，懒汉式是后加载对象。懒汉式在多线程时会出现安全问题

/*饿汉式*/
class SingleInstance{
   private SingleInstance(){}
   private static final ref=new SingleInstance();
   public static SingleInstance getInstance(){
     return ref;
    }
}
/*
饿汉式:不存在多线程并发问题,代码简单
懒汉式:对象延迟加载,产生多线程并发问题.
*/

1. class Singleton{//<span style="color: rgb(63, 127, 95); font-family: 宋体; font-size: 10.5pt; mso-bidi-font-family: Consolas; mso-ansi-language: EN-US; mso-fareast-language: ZH-CN; mso-bidi-language: AR-SA;">饿汉式：</span>
   
2.         private int num;
   
3.         public int getNum() {
   
4.                 return num;
   
5.         }
   
6.         public void setNum(int num) {
   
7.                 this.num = num;
   
8.         }
   
9.         private Singleton(){}
   
10.         private static Singleton s = new Singleton();
    
11.         public static Singleton getInstance(){
    
12.                 return s;
    
13.         }
    
14. }
    

复制代码

区别：饿汉式先定义对象
懒汉式:对象的延时加载，而是还有线程安全问题

赵海洋 发表于 2013-7-15 20:35
6，重载和重写的区别？

重载:同一类中 不同方法的 方法名相同
重写:覆盖父类或接口中的方法

8、下面代码片段创建（）个对象。
       int a = 10;
       String b = "abc";
       String c = new String("abc");
       MyTest test = new MyTest();

赵海洋 发表于 2013-7-15 20:40
7，示例代码：单例设计模式，两种方法一种即可，并说说这两种方法的区别？ ...

7，示例代码：单例设计模式，两种方法一种即可，并说说这两种方法的区别？
饿汉式class Singleton
{  
private static Singleton instance=new Singleton();
private Singleton(){}
static Singleton getInstance()
{   
  return instance;
  }
}
饿汉式是直接加载，
懒汉式是延时加载。

7、恶汉式，与懒汉式的不同是Single类一进内存，就已经创建好了对象，懒汉式会出现延时加载进而导致出错

1. private  Single(){}
   
2. 
   
3.         private static Single s = new Single();
   
4. 
   
5.         public static  Single getInstance()
   
6.         {
   
7.                 return s;
   
8.         }

复制代码

赵海洋 发表于 2013-7-15 20:05
第二题：列举五个RuntimeException？

ArithmeticException,NullPointerException,StringIndexOutOfBoundsException,NegativeArraySizeException,ClassCastException

class SingleDemo
{
    private static SingleDemo sd  = new SingleDemo();
    private SingleDemo()
    {}
    public SingleDemo getInstance()
    {
         return sd;
    }
}
区别：上面是饿汉式，这种方式是一来就创建好对象，这种方式如果一直没有人调用那一开始就创建的对象就会浪费内存。懒汉式是等到第一次调用getInstance()方法才会创建，不过这种方法当多个用户一起调用时是线程不安全的。

      五个

赵海洋 发表于 2013-7-15 20:40
7，示例代码：单例设计模式，两种方法一种即可，并说说这两种方法的区别？ ...

1. class Single
   
2. {
   
3.         private Single(){}
   
4.         private static Single s=new Single();
   
5.         public static Single getInstance()
   
6.         {
   
7.                 return s;
   
8.         }
   
9. }
   
10. class SingleDemo
    
11. {
    
12.         public static void main(String args[])
    
13.         {
    
14.                 Single ss=Single.getInstance();
    
15.         }
    
16. }饿汉式

复制代码

饿汉式和懒汉式的区别：懒汉式对象是方法被调用时才初始化，也叫做对象的延时加载，类进入内存，对象还没有初始化，只有调用了getInstance方法时，才创建对象。饿汉式这个是先初始化对象,类一进入内存，就已经创建好了对象。突然断网了⊙﹏⊙b汗！

3个对象

赵海洋 发表于 2013-7-15 20:45
8、下面代码片段创建（）个对象。
       int a = 10;
       String b = "abc";

个人认为是6个

赵海洋 发表于 2013-7-15 20:45
8、下面代码片段创建（）个对象。
       int a = 10;
       String b = "abc";

3个对象我觉得

第八题          2个