昨天面试，被一位hr问到这个问题：java中多态的单例模式怎么实现？各位大神怎么想。。。
PS：
我的想法是：在getInstance得到单例的时候，把不同的参数传递进来；

宋朋山 发表于 2013-3-4 11:46:04
本帖最后由 宋朋山 于 2013-3-4 13:59 编辑


不好意思，看错了。楼主说的是多态中单例的实现哈

之前没碰见过这样的问题，多态的话就是重写重载和继承了。
1、重载应该是通过

那就是说继承这个单例类，看样子我理解偏了，多谢！来自: Android客户端

我觉得这个小例子应该能满足这个题目的条件了吧

1. 
   
2. public class Multimode {
   
3.         public static void main(String[] args){
   
4.                 Father adult = Son.getSon();
   
5.                 //利用方法得到实例并赋值给父类引用
   
6.         }
   
7. }
   
8. 
   
9. class Father{
   
10.         //父类
    
11. }
    
12. 
    
13. class Son extends Father{
    
14.         //子类，并用饱汉式来设计单例类
    
15.         private final static Son son = new Son();
    
16.         //创建私有实例对象
    
17.         private Son(){
    
18.                 //私有构造方法
    
19.         }
    
20.         public static Son getSon(){
    
21.                 //利用方法得到实例
    
22.                 return son;
    
23.         }
    
24. }

复制代码

{:soso_e103:}个人理解不需要这么麻烦吧，所谓多态不就是父类引用能接受子类对象，你用单例产生子类对象赋值给父类的引用就是多态的单例了吧。。。。也不知道是不是这个意思。。。

        单例设计模式：解决一个类在内存中只存在一个对象。
                想要保证对象唯一。
1，        为了避免其他程序过多建立该类对象。先禁止其他程序建立该类对象
2，        还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。
3，        为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。
这三步怎么用代码体现呢？
1，        将构造函数私有化。
2，        在类中创建一个本类对象。
3，        提供一个方法可以获取到该对象。
先初始化对象。称为俄汉式。类一进内存对象就存在，单例编程用饿汉式
class Single
{
        private Single(){}
private static Single s = new Single();
        public static Single getInstance()
{
return s;
}
}
        调用方式：Single ss = Single.getInstance();
                        对象是方法被调用时，才初始化，也叫做对象的延时加载。称为:懒汉式。类进内存后调用getInstance（）才建立对象。为了防止出现问题，可以上一锁：synchronized
                                class Single
                                {
                                        private static Single s = null;
                                        private Single(){}
                                        public static Single getInstance()
                                        {
                                                if(s == null)
                                                {
                                                        synchronized(Single.class)
                                                                {
                                                                        if( s== null)
                                                                                s = new Single();
                                                                }
                                                }
                                                return s;
}
}

不好意思，看错了。楼主说的是多态中单例的实现哈

之前没碰见过这样的问题，多态的话就是重写重载和继承了。
1、重载应该是通过重载getInStance方法来实现
2、需要注意的就是子类继承单例后，需要重写getInStance方法，否则返回的仍会是父类。且由于是创建了新的对象，并不能节省内存, 但是可以有效合理化的扩展