单例设计模式是保证对象的唯一性，最后的执行代码中如果有N个设置值那么输出的结果怎么选择？
s1.setAge(20) ;
s2.setAge(22);
s3.setAge(24);
代码如下
public class Student {

        private int age;
        
        private static Student s = new Student();
        private Student(){}
        public static Student getInfo(){
                return s;
        }
        public void setAge(int age){
                this.age = age;
        }
        public int getAge(){
                return age;
        }
}

public class StudentDemo{

        public static void main(String[] args) {
               
                Student s1 = Student.getInfo();
                Student s2 = Student.getInfo();
                Student s3 = Student.getInfo();
                s1.setAge(25);
                s2.setAge(23);
                s3.setAge(22);
                System.out.println(s1.getAge());
                System.out.println(s2.getAge());
                System.out.println(s3.getAge());
               
        }
}

Student类使用单例模式设计，因此仅仅存在一个对象。
在主函数中，虽然通过Student.getInfo();语句建立了三个Student类型的引用变量s1，s2，s3。但是这三个引用变量都指向的是同一个对象。因此，操作的也都是同一个对象。(可以理解为唯一确定的一个笔记本电脑，可以叫它笔记本，也可以叫它本子，也可以叫它电脑，称呼不同，但都是同一个东西)

所以三行setAge(int数值)语句执行后，this.age就等于最后执行的那个22。

三行打印语句调用的是同一个对象中的方法，所以是打印三行的效果。

1. class Student
   
2. {
   
3.         private int age;
   
4.         private Student(){}//①
   
5.         private static Student s = new Student();//②
   
6.         public static Student getInfo()//③
   
7.         {
   
8.                 return s;
   
9.         }
   
10.         public void setAge(int age)
    
11.         {
    
12.                 this.age = age;
    
13.         }
    
14.         public int getAge()
    
15.         {
    
16.                 return this.age;
    
17.         }
    
18. }
    
19. 
    
20. class StudentDemo
    
21. {
    
22.         public static void main(String[] args)
    
23.         {
    
24.                 Student s1 = Student.getInfo();
    
25.                 Student s2 = Student.getInfo();
    
26.                 Student s3 = Student.getInfo();//指向同一个对象，仅仅是"名字"不同
    
27.                 s1.setAge(25);
    
28.                 s2.setAge(70);
    
29.                 s3.setAge(55);//操作的是同一个对象，后面的"覆盖"前面的。可看作最后一个有效
    
30.                 System.out.println(s1.getAge());
    
31.                 System.out.println(s2.getAge());
    
32.                 System.out.println(s3.getAge());//打印的是同一个对象的内容，所以是打印三次
    
33.         }
    
34. }

复制代码

山鹰 发表于 2013-5-24 15:19
20期的还有名额吗  还有机会吗？

包括我在内都是进21期的  20期快要结束了  6月10号开班了  建立楼主多学学技术吧。

袁梦希 发表于 2013-5-24 15:15
加油山鹰

20期的还有名额吗  还有机会吗？

加油山鹰

陈潜 发表于 2013-5-24 10:29
楼主，单例设计模式 顾名思义就是只有一个对象。。这点你自己也说了的。。。
所以你这三句话
Student s1 =  ...

嗯  最后一次覆盖前面的  知道了  谢谢

直接覆盖了

因为它只有一个对象，所以如果
s1.setAge(25);
                s2.setAge(23);
                s3.setAge(22);
                System.out.println(s1.getAge());
                System.out.println(s2.getAge());
                System.out.println(s3.getAge());
这样的话，后面输出的全部是最后一次改变的结果，因为只有一个对象，不管操作多少次，都以最后一次改变位准。当然如果
s1.setAge(25);
                System.out.println(s1.getAge());
                s2.setAge(23);
                System.out.println(s2.getAge());
                s3.setAge(22);               
                System.out.println(s3.getAge());
这样输出他肯定是不同的，因为每当你改变一次就输出结果

楼主，单例设计模式 顾名思义就是只有一个对象。。这点你自己也说了的。。。
所以你这三句话
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
Student s3 = Student.getStudent();
其实s1,s2,s3得到的是同一个对象，都是相同的，也因此
s1.setAge(25);
s2.setAge(23);
s3.setAge(22);
就是对同一个对象先后进行三次操作，因此最后一次操作的值就是最终值。
System.out.println(s1.getAge());
System.out.println(s2.getAge());
System.out.println(s3.getAge());
因此其实就是拿3次相同的age。