static关键字特点懒汉式继承-子父类中的构造函数-子类的实例化过程final关键字抽象类接口

一，static的特点：

1，static是一个修饰符，用于修饰成员

2，static修饰的成员被所有的对象所共享

3，static优先于对象存在，因为static的成员随着类的加载就已经存在了

4，static修饰的成员多了一种调用方式，就可以直接被类名所调用，类名，静态成员

5，static修饰的数据是共享数据，对象中的存储的是特有数据

二，static关键字——成员变量和静态变量的区别

      a，两个变量的生命周期不同。成员变量随着对象的创建而存在，随着对象的被回收而释放

                                                             静态变量随着类的加载而存在，随着类的消失而消失

      b，调用方式不同：成员变量只能被对象调用

                                        静态变量可以被对象调用，还可以被类名调用

      c，别名不同：成员变量也称为实例变量

                                静态变量称为类变量

      d，数据存储位置不同：成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据

                                                静态变量数据存储在方法区，所以也叫对象的共享数据

三，static关键字的注意事项：

      1，静态方法只能访问静态成员（非静态即可以访问静态，又可以访问非静态）

      2，静态方法中不可以使用this或者super关键字

      3，主函数是静态的

四，static关键字——main函数解析

      public  static void  main （string[ ] args）

   主函数特殊之处：

  1，格式是固定的2，被jvm所识别和调用

   public：因为权限必须是最大的

   static：不需要对象的，直接用主函数所属类名调用即可

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

  main：函数名，不是关键字，只是一个jvm识别的固定的名字

  string[ ]args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型

五，static关键字什么时候用？

       1，静态变量。当分析对象中所具备的成员变量的值都是相同的，这是这个成员就可以被静态修饰，只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。如果只是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的

       2，静态函数。函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。简单点说，从源代码看，该功能是否需要访问非静态的成员变量。如果需要，该功能就是非静态的。如果不需要，就可以将该功能定义成静态的。没有访问特有的数据的方法，该对象的创建是没有意义的

六，static关键字——静态代码块

       静态代码块随着类的加载而执行

      作用：用于给类进行初始化

七，面向对象（单例设计模式——概述及体现）

     1，单例设计模式

            解决的问题；就是可以保证一个类在内存中的对象唯一性，必须对于多个程序使用同一个配置信息对象时，就需要保证该对象的唯一性如何保证唯一性呢？

            a，不允许其他程序用new创建该类对象

             b，在该类创建一个本类实例

             c，对外提供一个方法，让其他程序可以获取该类对象

 步骤：1，私有化该类构造函数

             2，通过new在本类中创建一个本类对象

             3，定义一个公有的方法将创建的对象返回

八，面向对象，单例设计模式——懒汉式

      //饿汉式

     class，single//类——加载，对象就已经存在了

    {

             private  static  single  s =new single ( );

             private  single  ( ) { }

             public static single getInstance( )

             {

                        return s;

              }

    }

//懒汉式

   class single 2//类加载进来，没有对象，只有调用了getInstance 方法时，才会创建对象

                             //延迟加载形式

  {

            private  static single 2  s=null;

            private  static 2 () { }

             public static single 2 get Instance （ ）

            {

                     if（s==null）

                             s=new single 2（ ）；

                    return;

             }

   }

九，面向对象（继承-子父类中的构造函数-子类的实例化过程）

      子父类中的构造函数的特点。

       1，   在子类构造对象时，发现访问子类构造函数时，父类也运行了

为什么呢？

         原因是：在子类的构造函数中第一行有一个默认的隐式语句，super（ ）；

子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数

        2，为什么子类实例化的时候要访问父类中的构造函数呢？

          那是因为子类继承了父类，获取到了父类中内容（属性）所以在使用父类内容之前，首先看父类是如何对自己的内容进行初始化的

所以子类在构造函数时，必须访问父类中的构造函数

       3，为什么完成这个必须得动作，就在子类的构造函数中加入了super（ ），语句

          如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确

        4，要调用父类中的那个构造函数，同时子类构造函数中如果使用this调用了本类构造函数时，那么super就没有了，因为super和this都只能定义第一行，所以只能有一个

注意：super语句必须要定义在子类构造函数的第一行，因为父类的初始化动作要先完成。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数

十，一个对象实例化过程

     person p=new person( );

 1,jvm会读取指定的路径下的person，class文件，并加载进内存，并会先加载person的父类（如果有直接的父类的情况下）

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

 3，并在对象空间中，对对象中的属性进行默认初始化

 4，调用对应的构造函数进行初始化

 5，在构造函数中，第一行会先到调用父类中构造函数进行初始化

 6，父类初始化完毕后，在对子类的属性进行显示初始化

  7，在进行子类构造函数的特定的初始化

  8，初始化完毕后，将地址值赋值给引用变量

十一，final关键字

1，final 可以修饰类，方法，变量,

2，final 修饰的类不可以被继承,

3，final修饰的方法不可以被覆盖,

4，final修饰的变量是一个常量，只能被赋值一次,

5，内部类只能访问被final修饰的局部变量

//继承弊端，打破了封建性

1,2,3,4，

为什么要用final修饰变量，其实在程序如果一个数据是固定的，那么直接使用这个数据就可以了，但是这样阅读性差，所以他该数据起个名称，而且这个变量名称的值不能变化所以加上final固定。

用法规范：常量所有字母都大写，多个单词，中间用-连接

十二，抽象类

抽象类的特点：1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰，抽象方法必须定义在抽象类中，该类必须也被abstract修饰

                            2，抽象类不可以被实例化，为什么？因为调用抽象方法没意义

                             3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化，否则，这个子类还是抽象类

抽象类——细节

                  a，抽象类中有构造函数吗？ 有，用于给子类对象进行初始化

                  b，抽象类可以不定义抽象方法吗？可以的，但是很少见。目的就是不让该类创建对象，AWT的适配器对象就是这种类，通常这个类中的方法有方法体，但是却没有内容

                  c，抽象关键字不可以和那些关键字共存？private不行    static不行   final不行

                  d，抽象类和一般类的区别：

                   相同点：抽象类和一般类都是用来描述事物的，都在内部定了成员

                    不同点：1，一般类有足够的信息描述事物  抽象类描述事物的信息有可能不足

                                      2，一般类中不能定义抽象方法，只能定义非抽象方法  抽象类中可定义抽象方法，同时也可以定义非抽象方法

                                     3，一般类可以被实例化  抽象类不可以被实例化

                    e，抽象类一定是个文类吗？是的，因为需要子类覆盖其方法后才可以对子类实例化

abstract修饰类：

会使这个类成为一个抽象类，这个类将不能生成对象实例，但可以做为对象变量声明的类型，也就是编译时类型

抽象类就相当于一个类的半成品，需要子类继承并覆盖其中的抽象方法，这时子类才又创建实例的能力，如果子类没有实现父类的抽象方法，那么子类也要为抽象类。

十三、接口

接口(interface)：

接口的定义：接口从本质上说是一种特殊的抽象类。

关键字interface。

在接口中，所有的方法为公开、抽象的方法：public abstract

在接口中，所有的属性都是公开、静态的常量：public static final

接口与接口之间可以多继承，用extends，多个之间用逗号隔开。

接口中没有构造方法，不能用“new 接口名”来实例化一个接口，但可以声明一个接口。

接口的实现：

关键字implements

一个类实现一个接口必须实现接口中所有的方法，否则其为抽象类，并且在实现类中的方法要加上public(不能省略)。

类中的默认修饰符：default。

接口中的默认修饰符：public。

一个类除了继承另一个类外（只能继承一个类），还可以实现多个接口(接口之间用逗号分隔)。

 接口的特点：1：接口是对外暴露的规则

                         2：接口是程序的功能扩展

                         3：接口的出现降低耦合性

                         4：接口可以用来多实现

                         5：类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口

                         6：接口与接口之间可以有继承关系

抽象类和接口的异同点

          相同点：都是不断向上抽取而来的

         不同点：1，抽象类需要被继承，而且只能单继承，接口需要被实现，而且可以多实现

                          2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。接口中只能定义抽象方法，必须由子类去实现

                          3,抽象类的继承是is a关系，在定义该体系的基本共性内容 接口的实现是like a关系，在定义体系额外功能

接口的应用：笔记本电脑使用：为了扩展笔记本的功能，但日后出现什么功能设备不知道，定义一个规则，只要日后出现的设备都符合这个规则就可以了，规则在java中就是借口