黑马程序员_JAVA之路6——面向对象2(static、main函数、对象)

------- android培训、java培训、期待与您交流！ ----------

1  static关键字，是一个修饰符，用于修饰成员变量和成员函数。当成员被静态修饰后，就多了一个调用方式，除了可以被对象调用外，还可以直接被类名调用，格式：类名.静态成员。

        修饰成员变量：在生成对象时，不被修饰的成员变量，存放在堆内存中。对于多个对象中存在的共同数据，可以用static修饰，用static修饰后的成员变量单独存在方法区（或称为共享区、数据区，函数也放在这里），而不存放在堆内存中，可以节省内存空间。此时，多个对象共用一个静态成员变量，多个对象均可调用这个静态成员变量。

        特点：

                随着类的加载而加载，类一旦被使用，则静态成员就立即存在（成员变量在对象生成时才产生）；静态会随着类的消失而消失，静态成员的生命周期最长。静态成员变量也称为类变量。

                优先于对象存在

                被所有对象所共享

                可以直接被类名所调用

        实例变量与类变量区别：

                存放位置：类变量随着类的加载而存在于方法区中；实例变量随着对象            的建立而存在于堆内存中。

                生命周期：类变量生命周期最长，与类同生共死；实例变量与对象同生共死。

        静态使用注意事项：

                类可直接调用静态方法

                静态方法只能访问静态成员变量或静态方法，静态方法中不能调用实例变量

                非静态方法可以访问静态成员

                静态方法中不可以定义this super关键字，因为静态先于对象而存在（this  super  代表的是对象）

                主函数是静态的，但是主函数中可以通过创建对象调用非静态方法，但是不能用this调用非静态方法。

        静态优点：对对象的共享数据进行单独空间的存储，节省空间，没有必要每个对象都存储一份。可以直接被类名调用。

        静态弊端：生命周期过长；访问出现局限性（静态虽好，但只能访问静态）

2  主函数main，public static void main(String[] args){}

        主函数是一个特殊的函数，作为程序的入口，可以被jvm调用。

        主函数定义：

                public：代表着该函数访问权限是最大的。

                static  ：代表主函数随着类的加载就已经存在了。 类名.main。

                void    ：主函数没有具体返回值。

                main   ：不是关键字，但是一个特殊的单词，可以被jvm识别。

                String[] args:主函数参数，String类型的数组。args是arguments的简写，表示参数名，可以用其他正确名称代替，但一般都写作args。

                主函数是固定格式的，jvm识别。main可以被重载，但jvm只识别固定格式的主函数。jvm在调用主函数时，传入的是new String[]    （打印args   和args.length来验证）。

        可以给主函数main传值：

                格式1：命令行中，java 类名 参数1 参数2 参数3 。。。

                格式2：在两个类中定义两个main，一个main调用另一个main时传入字符串数组。（不过一般不这么干）

        

3  什么时候定义静态变量：当对象共享数据（是数据值，不是属性）时，该数据被static所修饰，对象中的特有数据要定义成非static存在于堆内存中。

    什么时候定义静态函数：当功能内部没有访问到非静态数据（对象的特有数据），那么该功能可以定义成静态的。（通俗说，一个方法用不到非静态的成员变量时就可以定义为静态的；反过来说，一个方法只要调用非静态成员变量，就不能定义成静态的）

4  静态的应用，每个应用程序中都有共性的功能，可以将这些功能进行抽取，独立封装，以便复用。即定义工具类

        工具类：类中封存一系列功能性方法，以便于其他类使用，而不涉及工具类中成员变量，因此没有必要创建工具类对象再调用函数，可以直接将这一系列方法定义为static的，所以可以将工具类的构造函数定义为private以阻止建立工具类对象。在其他类使用时直接   类名.方法名    即可。

5  制作程序说明书，java的说明书通过文档注释来完成。注意：该类必须是public的

        /**

        这是一个可以对数据进行操作的工具类，该类中提供了一系列方法。

        @author  张三

        @version v1.1

        */

        对类中静态方法都进行上述文档注释

        生成文档：命令提示行中，javadoc -d 存放地址 -author -version

        注意：一个类中默认会有一个空参数的构造函数，这个默认的构造函数的权限和所属类一致的，如果类被public修饰，那么默认的构造函数也带public修饰符，如果类没有被public修饰，那么默认的构造函数，也没有public修饰。

6  静态代码块

        格式：

                static

                {

                    静态代码块中的执行语句。

                }

        特点：随着类的加载而执行，只执行一次。用于给类进行初始化。

        class StaticCode

        {

                static

                {

                       System.out.println("a");

                }

               

        }

        class StaticCodeDemo

        {

                static

                {

                       System.out.println("b");

                }

                public static void main(String[] args)

                {

                        new StaticCode();

                        new StaticCode();

                        System.out.println("d");

                }

              static

                {

                       System.out.println("c");

                }

        }

结果：b  c a  d

注意：Person p = new Person("zhangsan",20);

        内存执行过程：

                因为new用到了Person.class,所以会先找到Person.class文件并加载到内存中。

                执行该类中的static代码块，如果有的话，给Person.class类进行初始化

                在堆内存中开辟空间，分配内存地址

                在对内存中建立对象的特有属性，并进行默认初始化

                对属性进行显示初始化（属性有初始值时，将初始值赋给属性）

                对对象进行构造代码块初始化

                对对象进行对应懂得构造函数的初始化

                将内存地址赋给栈内存中的变量

7  设计模式，解决某一类问题最行之有效的方法，java中有23种设计模式：

    单例设计模式：解决一个类在内存只存在一个对象。

    想要保证对象唯一：

        1 为了避免其他程序过多建立该类对象，先控制禁止其他程序建立该类对象。

        2 还为了让其他程序可以访问到该类对象，只好在本类中自定义一个对象。

        3 为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

    代码体现：

        1 将构造函数私有

        2 在类中创建一个本类对象

        3 提供一个方法可以获取到该对象

    应用：

        对于事物该怎么描述还怎么描述，当需要将该事物的对象保证在内存中唯一时，就这么使用。

    //先初始化对象，称为：饿汉式；一进内存就创建好对象————开发时建议此种方式

    class Single

    {

        private Single(){}//阻止其他类产生对象

       private static Single s = new Single();//private表示私有，只能本类使用，static，因为被静态方法调用，所以定义为static的。

        public static Single getInstance()//静态方法返回对象s

        {

            return s;

        }

    }

    class SingleDemo

    {

        public static void main(String[] args)

        {

           Single ss = Single.getInstance();

           Single s1 = Single.getInstance();//ss  s1同指向一个对象

        }

    }

    另一种书写方式：

//对象是方法被调用时，才初始化，也叫做对象的延时加载，称为  ：懒汉式

//类进内存时，对象还没有存在，只有调用了getInstance方法时，才建立对象 

  class Single

    {

        private static Single s = null;

        private Single(){}

        public static Single getInstance()

        {

            if (s==null)

                    s=new Single();

            return s;

        }

    }