1. public class Student {
   
2. 
   
3.         private String name;
   
4.         private int age;
   
5. 
   
6.         private Student() {
   
7. 
   
8.         }
   
9. 
   
10.         private static Student s = new Student();
    
11. 
    
12.         public static Student getInstance() {
    
13.                 return s;
    
14.         }
    
15. 
    
16.         public void setName(String name) {
    
17.                 this.name = name;
    
18.         }
    
19. 
    
20.         public String getName() {
    
21.                 return name;
    
22.         }
    
23. 
    
24.         public void setAge(int age) {
    
25.                 this.age = age;
    
26.         }
    
27. 
    
28.         public int getAge() {
    
29.                 return age;
    
30.         }
    
31. 
    
32.         public static void main(String[] args) {
    
33.                 // TODO Auto-generated method stub
    
34.                 Student s1 = Student.getInstance();
    
35.                 s1.setName("zhangsan");
    
36.                 System.out.println(s1.getName());
    
37.                 s1.setAge(20);
    
38.                 System.out.println(s1.getAge());
    
39.                 Student s2 = new Student();
    
40.                 s2.setName("lisi");
    
41.                 System.out.println(s2.getName());
    
42.                 s2.setAge(21);
    
43.                 System.out.println(s2.getAge());
    
44.         }
    
45. 
    
46. }

复制代码

帮忙分析一下我哪里写错了，运行竟然可以分别输出两个人的姓名和年龄

{:soso_e143:}丢人丢到家了  没看清题就瞎写 哈哈

{:soso_e105:}你坑我呢哥哥  你这就在本类里边得瑟呢  把主函数写到其他类里边得瑟去

的确是输出两个呀。你有4个输出语句吗，对象是只有一个。但你的语句是分别赋值的吗，后来的lisi会覆盖掉zhangsan。没有问题！

踩单车的幸福 发表于 2012-5-19 21:38
单例模式是要解决使用的是同一个对象，而你所说的分别输出了两个人的姓名和年龄，那是因为是对这个对象的属 ...

我的问题是为什么使用了单例设计模式之后我建立新对象时代码还可以正常运行而不报错。 重点是我试着建立新对象而没有报错。 你说我的概念混淆了，那你帮忙给我分析一下吧。

01.public class Student {

第一行改成 public static class Student 静态 让他不能new

39行代码Student s2 = new Student(); 上面变成了静态这里是不能new的. 但是可以像34行一样 调用getInstance()方法


另外你的main方法要另放一个类里 不然在用一个类里你的私有化就无效了


这就像什么呢 我给你做一个比喻 你用播放器播放视频 先播放一个 再点击下一个的时候 播放路径就由第一个改变成了第二个了.
但是你是调用然后马上打印 所以还是可以看到2个人的信息的.
你说的只能看见一个人的信息 是在最后打印 只打印一次
望采纳

这么说吧，你这个单例模式没有任何意义，你的main方法在这个单例的类里面，那么你把构造方法私有化就没用了，你同样可以在这个main方法里面new这个对象，
单例模式是为了限制别的类不能new他这个对象，所以你main方法不能放在这个类里，要不然没有意义了！！

因为你的main方法跟你的单例模式在同一个类里边，然后对于构造方法的私有就无效了
private static Student s = new Student();
在同一个类里边的方法可以访问私有方法，也就是说你的 Student s2 = new Student();

这句还是建立的新的对象，没有达到单例模式的效果。
你把main方法放在其他类里边

代码

1. package com.a;
   
2. 
   
3. class Student {
   
4. 
   
5. 
   
6. 
   
7.     private String name;
   
8. 
   
9.     private int age;
   
10. 
    
11. 
    
12. 
    
13.     private Student() {}
    
14. 
    
15. 
    
16. 
    
17.     private static Student s = new Student();
    
18. 
    
19. 
    
20. 
    
21.     public static Student getInstance() {
    
22. 
    
23.             return s;
    
24. 
    
25.     }
    
26. 
    
27. 
    
28. 
    
29.     public void setName(String name) {
    
30. 
    
31.             this.name = name;
    
32. 
    
33.     }
    
34. 
    
35. 
    
36. 
    
37.     public String getName() {
    
38. 
    
39.             return name;
    
40. 
    
41.     }
    
42. 
    
43. 
    
44. 
    
45.     public void setAge(int age) {
    
46. 
    
47.             this.age = age;
    
48. 
    
49.     }
    
50. 
    
51. 
    
52. 
    
53.     public int getAge() {
    
54. 
    
55.             return age;
    
56. 
    
57.     }
    
58. 
    
59. 
    
60. 
    
61.   
    
62. 
    
63. 
    
64. 
    
65. }
    
66. public class Test6{
    
67.           public static void main(String[] args) {
    
68. 
    
69.           // TODO Auto-generated method stub
    
70. 
    
71.           Student s1 = Student.getInstance();
    
72. 
    
73.           s1.setName("zhangsan");
    
74. 
    
75.           System.out.println(s1.getName());
    
76. 
    
77.           s1.setAge(20);
    
78. 
    
79.           System.out.println(s1.getAge());
    
80. 
    
81.           Student s2 = new Student();
    
82. 
    
83.           s2.setName("lisi");
    
84. 
    
85.           System.out.println(s2.getName());
    
86. 
    
87.           s2.setAge(21);
    
88. 
    
89.           System.out.println(s2.getAge());
    
90. 
    
91.   }
    
92. }
    
93. 
    

复制代码

这样才是单例模式  但是你的代码Student s2 = new Student();这里就会报错了，也就是说达到了单例模式的目的

孙宇晨 发表于 2012-5-19 21:44
01.public class Student {

第一行改成 public static class Student 静态 让他不能new

谢谢大家，不过我还是没有理解，我记得单例设计模式在建立对象的限制是将构造函数私有化，这一点我做到了，为什么我在后面再次建立对象的时候没有失败呢？

踩单车的幸福 发表于 2012-5-19 21:40
通过set方式它最终修改的是对象成员中的值，而不是这对象的地址值。
举个简单例子来说就是，屋子是同一个， ...

可能是我理解能力不够强，还是没明白，不过谢谢你。

袁錦泰 发表于 2012-5-19 21:52
可能是我理解能力不够强，还是没明白，不过谢谢你。

晕死了   没注意代码  你把主函数别跟这个单例写在一个类里。否则它创建多少个对应的都是你在本类中创建，你这样做没有意义。

踩单车的幸福 发表于 2012-5-19 21:40
你坑我呢哥哥  你这就在本类里边得瑟呢  把主函数写到其他类里边得瑟去  ...

你这么说我就懂了，我刚写时大意了，在本类中可以访问被private修饰的成员，所以即使被private修饰，其构造函数依然可以建立对象。

蒋映辉 发表于 2012-5-19 21:50
因为你的main方法跟你的单例模式在同一个类里边，然后对于构造方法的私有就无效了
private static Student  ...

一步到位，解释得清楚！！！！ 给力。。。。