java基本知识--关键字:static、final、abstract、interface、this和super；常量、接口、抽象类；方法重载和重写、内部类、类对象之间关系等

一、关键字

static  （静态的）

1、所有static修饰的都是类相关的，类级别的，都是采用【类名.】方式访问

      所有实例相关的都是对象相关的，对象级别的，都是要先用类创建对象，采用【对象.】方式访问（没有static修饰的方法）

2、static修饰的特点：

    static修饰的变量---静态变量----通过【类名.变量名】调用

    static修饰的方法---静态方法----通过【类名.方法名（）】调用

                                                             【方法名（）】---同一个类中类名可省略

    static修饰的代码块--静态代码块---类加载时执行，且只执行一次

3、注意

（1）static修饰的静态变量、方法、代码块均在类加载时运行，先于main方法

（2）static修饰的方法只能访问类的成员变量

（3）static修饰的变量存在JVM的方法区中

final （修饰的东西不可变）

1、final修饰的特点：

   final 类----无法继承

   final 方法----无法覆盖

   final 变量----只能手动赋值，且赋一次值，成为定值，不可再改

   final 引用----只能指向一个对象

2、常量---static final

（1）两个关键字 功能：

       final---设为固定值（声明的变量随new放在堆中）

       static---放到方法区（将固定值放到方法区）

（2）常量一般定义为全部大写

（3）常量一般都是公开的---公开也修改不了（不用封装）

3、常量与静态变量都存储在方法区，但是常量的值不变，静态变量的值还可修改。

4、联想概念：常量池（JVM方法区）

       （1）用于存储字面量和对应用类型、域和方法符号信息

       （2）字面量---变量的值---字符串或final修饰的常量值

                符号引用---变量名（而不是实际的内存地址引用）、

                         类和接口的全限定名（路径）、

                        方法的名称和描述符（修饰符、参数）

       [注] 类名：xxx.xx.xx

              全限定名：xxx/xx/xx

       （3）常量池=常量池计数器+常量池表

•               常量池计数器---常量池容量
•                常量池表----存字面量+符号引用---表-----范围[1-常量计数器值-1]

                     常量池表---用符号的形式表示当前类、方法、变量的相关信息

                      根据这些符号可以得到相应的具体的数据类型或参数返回值类型

   【注】常量池不简单等于存放static final常量的池

5、final finally finalize的区别

  （1）final----关键字，定义不变的量

  （2）finally---处理异常--和try连用

•              保证try中出现异常之后需要执行的语句必须执行；
•              finally语句块一定会执行，除非手动退出JVM；
•              当finally语句块中使用了return或throw语句，将会导致try块、catch块中的return，                     thow语句失效
•              异常处理中，try必有，catch和finally可有可无，finally一般用于资源释放

    (3)finalize--标识符--object类中的一个方法，方法名---GC垃圾回收，手动调用，消除垃圾对象

                     垃圾回收时，通过该方法不保证立即执行。

abstract(抽象)

1、抽象类---不可同final一起使用 

（1）目的

    类和类之间有共同特征，将这些共同特征提取出来形成抽象类

（2）抽象类的语法

         [修饰符列表] abstract class 类名{}

（3）特点

•  抽象类是对类的抽象，不能创建对象，只能实现类---属于引用数据类型

             类是对对象的抽象，可以创建对象

• 抽象类是无法实例化的，无法创建对象的，所以抽象类是被子类继承
• 抽象类的子类可以是抽象类（类可以层层抽象）
• 抽象类无法实例化，但抽象类有构造方法，这个构造方法是提供给子类用的

       因为子类继承执行构造方法时必须先执行父类的构造方法

      系统默认在子类构造方法第一行加super（），给父类加无参构造方法

（4）final和abstract不可同时存在，因为，final修饰的类无法被继承

2、抽象方法

（1）特点：

•   没有实现，没有方法体的方法，以分号结尾（无大括号）

             public abstract void sum（）；

•    有abstract关键字修饰的方法才是抽象方法

（2）抽象类中可以没有抽象方法，但抽象方法必须在抽象类中

（3）非抽象类继承抽象类，必须将抽象类中的抽象方法实现了，并把抽象方法的abstract去掉

         抽象类继承抽象类，可以不将抽象方法实现了（与接口不同的地方）

         即，抽象方法必须出现在抽象类中。

（4）java语言中饭时没有方法体的方法都是抽象方法（错）

         object类中有很多方法没有方法体都是以”；“结尾的，但他们不是抽象方法

          没有abstract修饰，有native修饰---表示调用JVM本地程序

  如：public native int hashCode（）；-----调用C++写的动态连接库程序

【注】一般实例方法（有实现部分）既可以放在抽象类中，也可以放在抽象类中；

           但抽象方法一定放在抽象类中。

           即，抽象类中既可以有实例方法，又可以有抽象方法；

                   是否为抽象类取决于是否是abstract修饰，不取决于存的是否是抽象的方法

interface（接口）

 1、接口定义

         接口是完全抽象的类，抽象类是半抽象的，接口是特殊的抽象类。

         接口=常量（static final 大写）+抽象方法（public abstract）

         通常提取的是行为动作

2、接口的语法

    [修饰符列表]  interface 接口名{}

 3、接口的特点

        （1）引用数据类型

        （2）接口可以支持多继承，一个接口可以支持多个接口

        （3）接口中所有修饰符都是public

        （4）接口中抽象方法的public abstract可以省略，方法中不能有方法体

        （5）接口中常量的static final 可以省略---常量值不能改变

                即接口中不加修饰的变量和方法都会默认为常量和抽象方法

          (6) 虽然不是class定义，但编译之后也是一个class字节码

【注】抽象类和接口区别

1、抽象类是半抽象的----里面的方法可以是抽象方法，也可以是实例方法，

                                但抽象方法不可以放在一般类中，抽象方法一定放在抽象类或接口中

     接口是完全抽象的----里面的方法只有抽象方法

2、抽象类有构造方法----抽象类是被继承的，构造方法供子类执行构造方法时调用，子类执行构造方法前必须执行父类构造方法

    接口没有构造方法----接口时被实现的，里面只有常量和抽象方法

3、类与类之间只支持单继承（extends）---public abstract class类名{}  抽象类，还是类，

    接口与接口，类与接口之间支持多继承（implements）--- interface 接口名{} 接口不是类，单可以看作类

4、一个抽象类本质是类，可以被非抽象类继承，也可以被抽象类继承

       被非抽象类继承----必须将抽象类中的方法都实现了

       被抽象类继承------可以实现其中部分方法，可以根据需要具体实现一些方法

  一个接口不可以实现其他的接口，被实现时只能实现它的全部方法

  当

this

1、this的含义

   （1）this是一个变量，一个引用，保存当前对象的地址并指向自身

   （2）this代表的就是“当前对象”

   （3）一个对象一个this

2、this的应用

（1）this只能使用在实例方法中，谁在调用这个实例方法，this现在就是谁。this代表的是当前对象

（2）this只能用于实例方法中作为引用调用当前类中的属性

       因为属性引用格式为【对象（引用）.属性】，调用属性必须先new一个对象，而在同一个类中的方法中用this代表当前对象，无需new一个对象，在其他类中需要new一个对象。

（3）this不可用于静态方法中

        因为this代表“当前对象”，而静态方法不需要对象调用，是类级别的，不是对象级别的

【总结】   

同一个类，实例方法可直接访问实例变量和静态变量，

                   但静态方法只能直接访问静态变量，访问实例变量要先new对象，用对象调用

3、this是否省略

（1） 同一类中调用当前对象属性，this.可以省略

（2）set封装时或有参构造方法中，当形参名和实例变量名一样时，

         为区分实例变量和局部变量（形参），this表示当前对象调用实例变量，不可省略

4、this（）-----用来调用同类中的构造方法

    作用：用来通过当前构造方法调用同类中的另一个构造方法

     格式：this（参数列表）

     目的：代码复用

    注：this（）的调用只能出现在构造方法的第一行，且只能调用一次

super----调用父类构造函数

1、super代表 当前对象（this）的父类型特征

2、当父类的属性为私有属性时，在子类中不可直接调用其属性（私有属性只能在本类中访问）

     则通过super（参数）调用父类的有参构造函数，采用将子类中形参传给super（参数）的形式，实现子类有参构造方法中的有参赋值

3、super（参数）的作用--初始化当前对象的父类型特征，

                    并不是创建了新对象，实际只创建了1个子类对象，这个子类对象复制了父类的特征

                     super关键字代表的就是“当前对象”的那部分父类型特征

4、super不能省略的情况：

    如果父类和子类中有同名属性或方法，需要在子类中访问父类中的同名属性或方法---          【super.】----不可省略

5、super（）

•  当子类继承父类后，子类每个构造函数的第一行，系统都默认给一个super（）调用父类的无参构造函数
•    当自己编写super（）后，系统默认给的就会消失。
• 子类构造方法执行时，必须先执行父类的构造方法

6、super（）和this（）都用于构造函数中调用另一个构造函数，

       但一个是调用父类的，一个是调用本类的

       两者都必须只有一个且处于构造方法的第一行，两者不能共存

【总结this和super】

1、this （）：在一个构造函数中调用同类另一个构造函数---this（）调同类无参构造   this（参数）调同类有参构造

    super（）：在一个子类构造函数中调用父类的构造函数---同上

2、this（）和super（）都只能在构造函数的第一行，且两者不能同时存在

3、this.----针对本类中对象属性特征    “当前对象“

     super.----针对父类中对象属性特征  ”当前对象父类特征“

二、方法及变量

1、方法定义

  [修饰符列表] 返回值类型 方法名（参数）{}

（1）[修饰符列表]---一般为方便调用，统一写成 public static

（2）返回值类型：任意类型

                 返回值一般指的是程序的执行结果，一般时数字

                 只要有返回值，就要有【return 值】

                 只要关键字【return 值】语句执行，当前所在方法结束

                 没有返回值用void，可有【return；】---表示方法的终止，但不可【return 值；】

（3）方法名：首字母小写，后面每个单词首字母大写（类名每个单词首字母大写，驼峰式命名）

（4）参数列表----形参，局部变量，方法结束后内存释放

                     （数据类型 变量名）起决定作用的是数据类型，变量名随意

                       变量名在方法中直接使用，无需重新声明

            【注】  实参---调用时传入形参的参数值

2、方法分类

（1）静态方法-----static修饰的方法，类加载时候运行，同类中调用直接用方法名即可

（2）实例方法----一般的方法，通过对象调用

（3）构造方法-----有参构造、无参构造，创建对象时自动调用（无返回值，但也不是void）

4、方法的重载和重写

（1）重载----同一个类中

•          方法名同，参数列表不同

                   与修饰符和返回值无关

•    用相同的方法名定义相似的功能函数

（2）重写（覆盖）---继承关系中，子类重写父类方法

•         方法名同，参数列表同，返回值同            

               访问权限不能更低、抛出异常不能更多

•     子类修改父类的功能（一般建议使用重载的方式修改父类功能，不建议使用重写方式）      

5、一个类中方法变量执行顺序

（1）一般情况

         静态-----非静态-----构造

 （2）有继承关系

• 父类静态对象，静态代码块

              子类静态对象，静态代码块

• 父类非静态对象，非静态代码块

              父类构造方法      

•  子类非静态对象，非静态代码块

             子类构造方法

   6、修饰符的介绍----类，方法，属性

      访问权限修饰符可修饰：

     属性----4个都可用

     方法---4个都可用

     类----public和默认

     接口---public和默认

      ....

三、类和对象

（一）相关概念

1、类：抽象的概念，对象共同特征的总结，如明星

    对象：实际存在的个体，如沈腾

2、JAVA中要想得到对象，必须先定义类

    类是一个模板：描述所有对象的共同特征，本质是

    对象是通过类创建出的个体

3、类和对象的关系 

4、几个术语总结

  类：人类大脑思考总结的模板，里面描述对象的共同特征（不存在的）

  对象：实际存在的个体

  实例化：通过类这个模板创建对象的过程【类---》对象】

  抽象：提取多个对象共同特征的过程【对象---》类】

5、类：属性+方法

状态特征：名词---属性

动作特征：动词---方法

（二）类的定义

1、类的定义

[修饰符] class 类名{

        类体=属性+方法 }

2、属性以变量形式存在：因为属性对应的是数据，数据在程序中只能放在变量中，

     变量：

     方法内的变量是局部变量----JVM栈中

     方法体外的变量是成员变量（全局变量）----JVM方法区中

    一般new出来的对象，无论是局部变量还是成员变量，均在堆中分配空间，具体引用是全局变量在方法区中，是局部变量在栈中

3、变量特点：

         必须先声明，再赋值，然后调用 

 4、类中的成员变量：利用构造函数 set get 赋值和调用

 5、成员变量声明时可以不赋值，在不赋值情况下，系统赋默认类型值

       一般数据类型：0，引用数据类型：null

      局部变量声明时一定要赋值

（三）类与类之间关系【关键！！】

1、is a-------》继承关系（extends）

    cat is a animal    cat是子类，animal是父类

2、has a------》关联关系（包含的属性）【建议使用的】

     I have a friend   我有一个朋友，朋友是我的属性之一。

                             I是一个类，Friend是另一个类， 将Fridend fridend作为我的一个属性，

                            我通过这个属性指向我的朋友

3、like a------》实现关系（接口implements）

    cooker like a FoodMenu-----厨师做菜，实现菜单中的功能，类实现接口

（四）内部类

1、内部类

   （1） 类里面套一个类

   （2）一般类是各自独立的，可以在同一个文件，也可以在不同文件，但类与类之间是分开的

        同一个文件：Student.class----public class Student{属性（特征）和方法（行为）}

                              Student.class----public class TestStudent{main函数}

        不同文件：Student.class----public class Student{}

                          TestStudent.class--public class TestStudent{main函数}

    （3）内部类分类

           静态内部类----类似于静态变量（static修饰）

           实例内部类----类似于实例变量

           局部内部类-----类似于局部变量----包含匿名内部类

2、匿名内部类【开发要用】

（1）匿名内部类是局部内部类的一种，因为没有类名，所以称为匿名内部类

（2）作用----在调用接口对象时，匿名实现接口

                   因为接口不能new对象，必须要实现，用接口实现类new对象传参，

                   这样就不用单独写一个接口实现类了

（3）缺点： 没有类名，没法重复使用，可读性查，在一次性测试时候可以使用。

                  不建议使用，只为了读懂别人的代码--逼格高。

3、静态内部类----   static修饰的内部类

             1、创建静态内部类对象----InnnerClass

                  类名.InnnerClass 对象名=new 类名.InnnerClass；

              2、静态内部类中方法的调用

                  （1）类名.InnnerClass.方法名()

                    (2)对象.方法名()

【注】

内部类可以是静态static的，也可用public，default，protected和private修饰，

外部类的修饰符只能是public，abstract，final，不可为static