如题。。   


class Person{
        private static Person p = new  Person();
        private Person(){}
        public static Person getp(){                     
                return p;
        }
        public void print(){
                System.out.println("hello world");
        }
        
}
public class Demo01 {
        public static void main(String[] args) {
               
            Person.getp().print();


        }

}
这个是从getp()  获得的引用吧？  是不是调用了非static方法   

static修饰的属性，他不属于任何一个对象，它随着类的加载已经加载进来了，它是公共的，而this关键字是当前对象，

Fc10232 发表于 2012-5-17 19:37
class Person{
        private static Person p = new  Person();
        private Person(){}

这跟单例有什么关系么？而且这也不是通过getp()获得的方法啊

袁冬梅 发表于 2012-5-17 19:54
Person.getp().print();
总算懂了，你说的是这句话是吧。

可以这样还原么·······

Fc10232 发表于 2012-5-17 19:49
static里的一个引用调用了非static的方法···是不？

Person.getp().print();
总算懂了，你说的是这句话是吧。

我帮你还原一下这句话吧，我觉得还原出来之后，你基本能懂整一个表达式的意思了
Person p = Person.getp();
P.print();

这样的话，看得懂了吧， Person.getp()的返回值是一个Person对象，所以，后面调用的print（）其实是对象调用的，而不是静态方法调用。。咳咳，而且方法也不能调用方法吧。O(∩_∩)O~

Fc10232 发表于 2012-5-17 19:41
那是不是调用了非staitc方法？

我刚刚解释得很明白了，实际上没有调非static方法，只是返回了一个引用p。new person（）是在main程序运行前就创建了对象。

袁冬梅 发表于 2012-5-17 19:43
囧，public static Person getp(){                     
这句话就是static修饰的呀，怎么还说是非static ...

static里的一个引用调用了非static的方法···是不？

袁冬梅 发表于 2012-5-17 19:43
囧，public static Person getp(){                     
这句话就是static修饰的呀，怎么还说是非static ...

static里的一个引用调用了非static的方法···是不？

Fc10232 发表于 2012-5-17 19:31
class Person{
        private static Person p = new  Person();
        private Person(){}

囧，public static Person getp(){                     
这句话就是static修饰的呀，怎么还说是非static方法？你说的非静态方法是指哪里？

梁小波 发表于 2012-5-17 19:39
是从gep（）获得的引用。获得的是p的引用。怎么没有对象？在加载时new person（）就运行了！也就是说在没 ...

那是不是调用了非staitc方法？

Fc10232 发表于 2012-5-17 19:31
class Person{
        private static Person p = new  Person();
        private Person(){}

是从gep（）获得的引用。获得的是p的引用。怎么没有对象？在加载时new person（）就运行了！也就是说在没有调  Person.getp().print();的时候，这个对象就有了在内存里！调用这些代码是建立个指向这个对象的引用！

于潇 发表于 2012-5-17 19:15
这是毕老师的单例代码，你所说的通过静态得到私有对象是指？

class Person{
        private static Person p = new  Person();
        private Person(){}
        public static Person getp(){                     
                return p;
        }
        public void print(){
                System.out.println("hello world");
        }
        
}
public class Demo01 {
        public static void main(String[] args) {
               
            Person.getp().print();


        }

}
你看  是从gep()  获得的引用吧？  是不是调用了非static方法   

袁冬梅 发表于 2012-5-17 18:52
首先，单例模式为什么叫做单例模式，就是因为这个类只能存在一个对象，所以，不用static来获取这个对象， ...

class Person{
        private static Person p = new  Person();
        private Person(){}
        public static Person getp(){                     
                return p;
        }
        public void print(){
                System.out.println("hello world");
        }
        
}
public class Demo01 {
        public static void main(String[] args) {
               
            Person.getp().print();


        }

}
你看  是从gep()  获得的引用吧？  是不是调用了非static方法   

梁小波 发表于 2012-5-17 19:02
哦，你说的还是不太明白，
是在单例设计模式中，是通过静态方法得到的私有对象！
然而你说可以通过着这对 ...

class Person{
        private static Person p = new  Person();
        private Person(){}
        public static Person getp(){                     
                return p;
        }
        public void print(){
                System.out.println("hello world");
        }
        
}
public class Demo01 {
        public static void main(String[] args) {
               
            Person.getp().print();


        }

}
你看  是从gep()  获得的引用吧？  是不是调用了非static方法   

Fc10232 发表于 2012-5-17 18:34
那假如里面有个对象的引用类？？
比如单例设计里  不是通过静态方法得到私有对象？？
  然后不就可以 ...

1. class Single
   
2. {
   
3. 
   
4. 
   
5.         private  Single(){}
   
6. 
   
7.         private static Single s = new Single();
   
8. 
   
9.         public static  Single getInstance()
   
10.         {
    
11.                 return s;
    
12.         }
    
13. }
    
14. 
    
15. 
    
16. class SingleDemo
    
17. {
    
18.         public static void main(String[] args)
    
19.         {
    
20.                 Single s1 = Single.getInstance();
    
21.                 Single s2 = Single.getInstance();
    
22. 
    
23.                 s1.setNum(23);
    
24. 
    
25.                 System.out.println(s2.getNum());
    
26. 
    
27. 
    
28.                
    
29. //                Single s1 = new Single();
    
30. //                Single s2= new Single();
    
31. //                s1.setNum(30);
    
32. //                System.out.println(s2.getNum());
    
33. 
    
34. //                Student s1 = new Student();
    
35. //                s1.setAge(30);
    
36. //
    
37. //                Student s2 = new Student();
    
38. //                s2.setAge(12);
    
39. 
    
40.                 Student s1 = Student.getStudent();
    
41.                 Student s2 = Student.getStudent();
    
42. 
    
43.                
    
44. 
    
45. 
    
46.         }
    
47. }
    
48. 
    
49. 
    
50. 
    
51. class Student
    
52. {
    
53.         private int age;
    
54. 
    
55. 
    
56.         private static Student s = new Student();
    
57.         private Student(){}
    
58.         public static Student getStudent()
    
59.         {
    
60.                 return s;
    
61.         }
    
62. 
    
63. 
    
64. 
    
65.         public void setAge(int age)
    
66.         {
    
67.                 this.age = age;
    
68.         }
    
69.         public int getAge()
    
70.         {
    
71.                 return age;
    
72.         }
    
73. }
    

复制代码

这是毕老师的单例代码，你所说的通过静态得到私有对象是指？

Fc10232 发表于 2012-5-17 18:35
那假如里面有个对象的引用
比如单例设计里  不是通过静态方法得到私有对象？？
  然后不就可以通过这个 ...

哦，你说的还是不太明白，
是在单例设计模式中，是通过静态方法得到的私有对象！
然而你说可以通过着这对象调用其他？要注意这里的单例设计模式是为了让类只有一个实例！所以得到的私有对象都是同一块内存的!所以这个对象的引用也是静态的。关于你说的什么意思，真不大明白。举个例子如何？

Fc10232 发表于 2012-5-17 18:34
汗················  这个我也明白  
那假如里面有个对象的引用呢？？
比如单例设计里   ...

首先，单例模式为什么叫做单例模式，就是因为这个类只能存在一个对象，所以，不用static来获取这个对象，那么岂不是一个类可以获取到N多对象了？
然后，后面两句我实在没搞懂什么意思，你可以弄一个小代码把你想表达 的思想表达一下么，我看看你的代码，才能知道你说的是什么情况，再具体分析

怎么没人说话了？？？

梁小波 发表于 2012-5-17 18:22
我想你的意思是static方法中为什么不能用this关键字吧？
我是这么理解的：你想一下this是什么作用？是在一 ...

那假如里面有个对象的引用
比如单例设计里  不是通过静态方法得到私有对象？？
  然后不就可以通过这个对象调用其他的 ？？

梁小波 发表于 2012-5-17 18:22
我想你的意思是static方法中为什么不能用this关键字吧？
我是这么理解的：你想一下this是什么作用？是在一 ...

那假如里面有个对象的引用
比如单例设计里  不是通过静态方法得到私有对象？？
  然后不就可以通过这个对象调用其他的 ？？