一般产生单例是不是就是将构造函数私有化？然后用属性为对象，在方法中返回对象，接着其他类调用它的方法产生对象，我的理解没错吧？但是我写的怎么这样了。。。

1. package com.itcast.first;
   
2. 
   
3. class Person{
   
4.                 private String name;
   
5.                 private int age;
   
6.                 private static Person p = new Person("lisi", 20);
   
7.                 private Person(){}
   
8.                 private Person(String name,int age){
   
9.                         this.name = name;
   
10.                         this.age = age;
    
11.                 }
    
12.                 public static Person getPerson()
    
13.                 {
    
14.                         return p;
    
15.                 }
    
16.                 private void eat(){
    
17.                         System.out.println("eat");
    
18.                 }
    
19. }
    
20. 
    
21. public class Demo9 {
    
22.         
    
23.         public static void main(String[] args) {
    
24.                 //Person p = new Person("lisi", 20);
    
25.                 Person pp = Person.getPerson();
    
26.                 System.out.println(pp);//lisi 20
    
27.         }
    
28. 
    
29. }
    

复制代码

1. com.itcast.first.Person@1c78e57

复制代码

怎么回事，不应该是lisi 20吗？？？

晕，发现了，那2个属性都得有get方法，然后调用get获取

{:soso_e100:}{:soso_e100:}我试了下代码，结果是这样的，不能打印正确的类属性值，是因为，打印对象信息，是调用继承的toString() ;
可以用重写方法来获得自己想要的结果，至于GET,SET， 好像是什么标准 JAVABEAN 什么的，刚初学，不太懂，

  看来楼主对于单例不是太清楚吧

• package com.itcast.first;
• class Person{
•                 private String name;
•                 private int age;
•          //定义一个构造方法
•                 private static Person p = new Person("lisi", 20);
•                 private Person(){}
•                 private Person(String name,int age){
•                         this.name = name;
•                         this.age = age;
•                 }
•                 public static Person getPerson()
•                 {
•                         return p;
•                 }
•                 private void eat(){
•                         System.out.println("eat");
•                 }
•      public String toString() {
                  // TODO Auto-generated method stub
                  return "name："+this.name+"age"+this.age;  
                /*   覆写父类的toString()方法，默认的toString（）返回的是
                      getClass().getName() + '@' + Integer.toHexString(hashCode())
              */
                  }
• }
• public class Demo9 {
•         public static void main(String[] args) {
•                 //Person p = new Person("lisi", 20);
•                 Person pp = Person.getPerson(); //这里得到的是Person默认的实例对象
•                 System.out.println(pp.toString());//覆写后调用自己写的toString()方法，这里不添加toString()方法也可以
•         }
• }
  

  关于单例模式重点在于：一旦把该类的构造器隐藏起来，则需要提供一个public方法作为该类的访问点，用于创建该类的对戏那个，且该方法必须使用static修饰(因为调用该方法之前还不存在对象，因此调用该方法的不可能是对象，只能是类)
   单例模式代码：
   class Singleton{
      //使用一个变量来缓存曾经创建的实例
      private static Singleton instance;
     //将构造器使用private修饰，隐藏该构造器
     private Singleton(){}
     //提供一个静态方法，用于返回Singleton实例
    //该方法可以加入自定义的控制，保证只产生一个Sinleton对象
     public static Singleton getSingleton(){
         //如果instance为null,表明还不曾创建Singleton对象
         //如果instace不为null，则表明已经创建了Singleton对象
         if(instance==null){
             //创建一个Singleton对象，并将其缓存起来
             instance=new Singleton();
         }
         return instance;
     }
    }
     public class TestSingleton {
          public static void main(String[] rgs){
        Singleton s=Singleton.getSingleton();
    }
}

武庆东 发表于 2012-9-17 16:18
看来楼主对于单例不是太清楚吧

toString方法什么时候使用，是不是如果打印出结果为哈希值，就复写他转为String??