黑马程序员---2015.6.14java基础笔记--静态方法--单例

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1.什么时候可以将方法定义为静态方法（将整个类定义为工具类）？
    a.类中的每个方法都没有用到类的对象的特有数据
    b.这时就可以考虑将方法定义成static，直接通过类名调用即可
    c.但是该类还是可以被其他程序建立对象，
        为了更严谨，强制让该类不能建立对象
        可以通过构造函数私有化完成
        
2.如何制作java程序说明书？
        a.通过文档注释来完成。
        b.此类必须定义成public类型
        c.而且生成的文档中，只能显示public的函数。因为private是不需要对外公开的
    

<pre name="code" class="java">   /**
            简单测试：生产java帮助文档
                @author 乔栋
                @version 1
        */
        public class TestPerson
        {
            private String name;
            private int age;
            /**
                设置年龄
                @param age 接受一个int型数字
            */
            public void setAge(int age) {
                this.age = age;
            }
            
            /**
                获取年龄
                @return 返回年龄
            */
            public int getAge() {
                return age;
            }
        }</span>

        cmd中的写法：javadoc -d myhelp -author -version TestPerson.java3.默认构造函数：        一个类中会有一个默认的空参数的构造函数        类为public时，此构造也为public；即默认构造函数和类的权限一致。4.静态代码块        static {            静态代码。。        }            特点：随着类的加载而加载，且只执行一次，并且优于主函数                用于给类初始化的                    具体的一个使用实例！！！！  

   <pre name="code" class="java">   class StaticCode
        {
            static
            {
                System.out.print("a")    ;
            }
            
        }
        
        class StaticCodeDemo
        {
            static
            {
                System.out.print("b");
            }    
            
            public static void main(String[] args)
            {
                new StaticCode();    
                new StaticCode();    //当类加载时，静态代码块只执行一次，所以此句不再执行
                System.out.print("e");
            }
            
                static
            {
                System.out.print("c");
            }    
        }</span>

        //输出结果是bcae        5.构造代码块的优先级高于构造函数6. Person p = new Person("qiaodong",24);这句话都做了什么事情？        1.因为用到了Person.class,所以先寻找此class并加载        2.执行该类的静态代码块，如果有的话，给此类进行初始化        3.在堆内存中开辟空间，分配内存地址        4.在堆内存中建立对象的特有属性，并初始化        5.属性显示初始化        6.对对象的构造代码块进行初始化        7.对对象进行对应的构造函数的初始化        8.将内存地址赋给栈内存中p变量 7.设计模式：解决某一类问题最行之有效的方法                        java中有23中设计模式                      单例设计模式：解决一个类在内存中只有一个对象    想要保证对象唯一。        1.先禁止其他程序建立该类对象        2.还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象        3.为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式    这三部用代码怎么体现呢？        1.将构造方法私有化        2.在类中创建一个本类对象        3.提供一个方法可以访问到该对象    

    对类该怎么描述就怎么描述，只是再加上以上3部条件

/* 单例模式
             这个是先初始化对象
             称为：饿汉式-------开发一般常用！！！！！
             Single一进内存，就已经创建好了对象
        */
        class Single
        {
            private int number = 0;
            //禁止外部程序创建该类的对象
            private Single(){}
            //自己本类中创建一个对象
            private static Single s = new Single();
            //提供一个外部类能获得本类对象的方法
            public static Single getInstance()
            {
                return s;    
            }
            
            public void setNumber(int n)
            {
                    this.number = n;
            }
            
            public int getNumber()
            {
                return number;    
            }
        }
        
        class TestSingle
        {
            public static void main(String[] args)
            {
                Single s1 = Single.getInstance();
                s1.setNumber(23);
                Single s2 = Single.getInstance();    
                System.out.println(s2.getNumber());
            }    
            
        }    </span>

        
        /* 懒汉式
             对象是方法被调用时，才初始化。也叫做对象的延迟加载
             Single进内存，对象还没创建，只有调用了getInstance方法，才建立对象
             private Single() {}
           private static Single s = null;
           public static Single getInstance() {
                       if(s == null) {
                           s = new Single();
                       return s;
           }
        */