黑马程序员------static，内部类的应用

android培训、 java培训、

 

static关键字：是一个修饰符，用于修饰成员（成员变量，成员函数），不能修饰局部变量。
       
 1、特点：1，随着类的加载而加载，随着类的消失而消失，生命周期最长。
                    2，优先于对象存在。
                    3，被所有对象共享。
                    4，除了可以被对象调用还可被类名直接调用。
 2,、 实例变量和类变量（静态变量）的区别：
                    1，类变量随着类的加载而加载，存在于方法区中，随着类的消失而消失。
                    2，实例变量随着对象的建立而存在于堆内存中，随着对象的消失而消失。
3、 注意事项：
                    1，静态方法只能调用静态成员（变量和方法），非静态方法可以访问静态成员也可以访问非静态。
                    2，静态方法中不可以定义this，super关键字，因为静态优先于this，super而存在。
                    3，主函数是静态的。
4、静态的利弊：
                     利处：对对象的共享数据进行单独空间的存储，节省内存。可以被类名直接调用。
                     弊端：生命周期过长，访问出现局限性，只能访问静态成员。
5、什么时候使用静态：
                    1，当对象中出现了共享数据时，该数据可以被定义成静态。对象中的特有数据要定义成非静态的。
                    2，定义静态函数，需要功能内部没有访问到非静态数据（对象的特有数据）时，该功能可以定义为静态的。
6、静态代码块：
                   格式：
                   static{
                       静态代码块中要执行的语句。
                   }
                  特点：随着类的加载而执行，只执行一次，并优先于主函数执行。用于给类进行初始化。
7、建立一个对象，代码的执行顺序：
                  例如：
                  Person p = new Person();
                 1，因为new了一个Person对象，所以用到了Person.class文件，所以首先将Person.class文件加载进内存。
                 2，如果该类中有静态代码块，则执行该类的静态代码块。
                 3，在堆内存中开辟空间，分配内存地址。
                 4，在堆内存中建立对象的特有属性，并进行默认初始化。
                 5，对属性进行显示初始化。
                 6，对对象进行构造代码块初始化。
                 7，对对象进行与之对应的构造函数初始化。
                 8，将内存地址赋给栈内存中的p变量。
8、单例设计模式：一个类在内存中只存在一个对象。
                 步骤如下：1，为了避免建立重复对象，需要先将构造函数私有化。
                                     2，在本类中自定义一个对象，并将其私有。
                                     3，对外提供获得此对象的访问方法，并将其设置为静态。
                                     代码如下：
                                    

                               方法一：饿汉式：
                                     class Single{
                                          private Single(){}
                                          private static Single s = new Single();
                                          public static Single getInstance(){
                                          return s;
                                           } 
                                      }
                                     方法二：懒汉式：
                                     class Single{
                                        private Single(){}
                                        private static Single s = null;
                                        public static Single getInstance(){
                                        if(s==null){
                                            synchronized(Single.class){
                                               if(s==null)
                                                   s = new Single();
                                            }
                                        }
                                       return s;
                                     }
                                   }
                                  用枚举定义一个单例设计模式：
                                        enum Single{
                                      S;
                                  }

9、帮助文档的制作方法：
              如果一个类要生产帮助文档，那么这个类需要用public修饰，需要有足够大的权限。
              如果想让构造函数对外提供，需要将构造函数用public修饰。
               /**
              注释栏，对此类的描述。
              @author 作者
              @version 版本
               */
               /**
               对方法进行描述。
              @param 参数名 接受一个什么类型的参数。
              @return 返回值是什么。
                */
              javadoc -d 保存路径 -author -version 源文件名
              javadoc -d c:\myjava -author -version ArrayTools.java
   
10、内部类：一个类定义在另一个类的内部，这个类称为内部类。
         内部类的访问规则：
                1，内部类可以直接访问外部类中的成员，包括私有的，是因为内部类中持有了一个外部类的引用，写法是外部类名.this。
                 2，外部类要访问内部类，必须建立内部类对象。
                 3，如何访问一个类的内部类：外部类名.内部类名 变量名 = new 外部类名（）.new 内部类名（）；
                 4，当内部类在外部类的成员位置时，可以被private，static修饰。
                       在外部其他类中，如何访问静态内部类的非静态成员：
                               new Outer.Inner().function();
                       在外部其他类中，如何访问静态内部类的静态成员：
                               new Outer.Inner.function();
                 5，当内部类中定义了静态成员，该内部类必须定义为静态的。
                 6，当外部类中的静态方法访问内部类的成员时，该内部类也必须为静态的。
                 7，内部类定义在局部时，不可以被成员修饰符修饰，仍可以访问外部类的成员，因为还持有外部类的引用，
                       但是不可以访问它所在的局部中没有被final修饰的局部变量。
        匿名内部类：其实就是内部类的简写格式。
        定义匿名内部类的前提就是，内部类必须继承一个类或是实现一个接口。
        匿名内部类的格式：new 父类接口（）{定义子类的内容}