Java面向对象

一：封装

         1.类：封装的是对象的行为与属性

         2.方法：封装特定的业务逻辑功能

         3访问控制修饰符：封装的具体的访问权限.

二：继承

          1.作用：代码复用     extends来继承  implement来实现接口

          2.超类：所有派生类共有的行为属性

              接口：部分派生类所共有的行为

              派生类：派生类所特有的属性和行为（构造派生类之前必须构造超类，派生类中若没有调用超类的构造方法则默认super（）调用超类的无参构造，若调用了超类的构造方法则不再默认）

           3.传递性、单一继承、多接口实现

三：多态

          1.意义：行为的多态（所有抽象方法都是多态）

                          对象的多态（所有对象都是多态的，因为java本身有一个Object最基本的类，没有继承的类都继承他）

          2.向上造型、强制转换类型、instanceof判断

          3.多态的表现形式：

             3.1）重写：根据对象的不同来表现多态

             3.2）重载：根据参数的不同来表现多态

           1)意义:
                      1.1)同一类型的引用指向不同的对象时，有不同的实现
                             -----行为的多态:cut(),run(),step()...
                      1.2)同一对象被造型为不同的类型时，有不同的功能
                             -----对象的多态:我、你、水...
            2)向上造型/自动类型转换:
                         2.1)超类型的引用指向派生类的对象
                         2.2)能造型成为的数据类型有: 超类+所实现的接口
                         2.3)能点出来什么，看引用的类型
            3)强制类型转换，成功的条件只有如下两种:
                        3.1)引用所指向的对象，就是该类型
                        3.2)引用所指向的对象，实现了该接口或继承的该类
            4)强转若不符合如上条件，则发生ClassCastException类型转换异常
              建议:在强转之前先通过instanceof来判断引用的对象是否是该类型

四：小知识点

        1.什么是类？什么是对象？
            1)现实世界是由很多对象组成的
                基于对象抽出类
            2)对象:真实存在的单个的个体
                类:类型/类别，代表一类个体
            3)类中可以包含:
                 3.1)所有对象所共有的属性/特征--------成员变量
                 3.2)所有对象所共有的行为-------------方法
            4)一个类可以创建多个对象
                 同一类型的多个对象，结构相同，数据不同
             5)类是对象的模板，对象是类的具体的实例

         2.重载

             1）方法的签名：方法名+参数列表

             2）方法的重载：发生在一个类中，方法名称相同，参数列表不同，方法体实现不同，遵循"编译期"绑定，编译器在编译时根据方法的签名（参数/引用的类型）自动绑定调用的方法

             3）构造方法：给成员变量赋初值，与类同名，没有返回值类型，在创建对象时被自动调用，若自己不写构造方法，则编译器默认一个无参构造，若自己写了构造方法则不再默认，构造方法可以重载

             4）this：指代当前对象，那个对象调用方法就指的那个对象，只能用在方法中，方法中访问成员变量之前默认有个this，用法：this.成员变量名，this.方法名，this()------调用构造方法

             5）null：空，没有指向任何对象，若引用的值为null，则该引用不能再进行任何操作，NullPointerException为空指针异常

             6）“=”：引用类型划等号表示指向同一个对象，通过一个引用对数据的修改会影响另一个引用对数据的访问，基本类型划等号为赋值

         3.super：指代当前对象的超类对象，用法：super（）------调用超类的构造方法，super.成员变量名----调用超类的成员变量，super.方法名（）------调用超类的方法

         4.向上造型：超类型的引用指向派生类的对象，接口的引用指向实现的对象，   引用出来的能点出什么看引用的类型

         5.方法的重写：发生在父子类中，方法签名相同，方法体不同，遵循"运行期"绑定，重写方法被调用时看对象的类型

             5.1）重写遵循的原则：派生类方法的返回值类型小于或等于超类方法的，void时，必须相等，基本类型时，必须相等，引用类型时，小于或等于，派生类方法抛出的异常小于或等于超类方法的，派生类方法的访问权限大于或等于超类方法的

         6.package作用避免类的命名冲突，包名可以有层次结构，同包中的类不能同名，类的全称：包名.类名，建议包名所有字母都小写，import ： 同包中的类可以直接访问，不同包中的类不能直接访问可以先import声明类在使用

         7.访问控制修饰符：public:公开的，任何类，private:私有的，本类，protected:受保护的，本类、派生类、同包类，默认的:什么也不写，本类、同包类说明: 1)类的访问修饰只能是public或默认的     2)类中成员的访问修饰如上4种都可以    建议：变量private，超类的变量protected    方法public   数据私有化，行为公开化

         8.final:最终的、不可改变的-----单独应用率低   修饰变量:变量不能被改变   修饰方法:方法不能被重写   修饰类:类不能被继承

         9.static：静态的

                1)静态变量:
                      1.1)由static修饰
                      1.2)属于类，存储在方法区中，只有一份
                      1.3)常常通过类名点来访问
                      1.4)何时用:所有对象所共享的数据(图片、音频、视频等)
                2)静态方法:
                       2.1)由static修饰
                       2.2)属于类，存储在方法区中，只有一份
                       2.3)常常通过类名点来访问
                       2.4)静态方法没有隐式的this传递，
                              静态方法中不能直接访问实例成员
                       2.5)何时用:方法的操作仅与参数相关而与对象无关
                3)静态块:
                        3.1)属于类，在类被加载期间自动执行，
                               因类只被加载一次，所以静态块只执行一次
                        3.2)何时用:加载/初始化静态资源(图片、音频、视频)

           10.static fianl:常量：必须声明同时初始化，通过类名点来访问，建议常量所有字母都大写多个单词用_分隔，编译器在编译时将常量直接替换为具体的值，效率高，何时用：数据永远不变并经常使用

            11.抽象方法：由abstract修饰，只有方法的定义没有具体的实现（连{}都没有）

            12.抽象类：由abstract修饰，包含抽象方法的类必须是抽象类，抽象类不能被实例化，抽象类需要被继承，派生类重写所有抽象方法，抽象的意义：封装共有的属性行为，为所有的派生类提供统一的类型-----向上造型，可以包含抽象方法为所有的派生类提供统一的入口

            13.成员内部类：应用率低，了解     1)类中套类，外面的称为Outer外部类，里面的称为Inner内部类  2)内部类通常只服务于外部类，对外不具备可见性   3)内部类对象通常只在外部类中创建   4)内部类中可以直接访问外部类的成员(包括私有的)内部类中有隐式的引用指向了创建它的外部类对象  eg: 外部类名.this.（内部类有独立的.class）

             14.匿名内部类：若想创建一个类（派生类）的对象，并且对象只被创建一次，此时该类不必命名，称为匿名内部类

             15.功能实现的步骤:
                   1)先写行为:
                        1.1)为对象所特有的行为，将其设计在特定的类中
                        1.2)为所有对象所共有的行为，将其设计在超类中
                   2)页面调用:
                         2.1)定时触发的，在定时器中调用
                         2.2)事件触发的，在侦听器中调用

              16.paint()方法的调用方式:  1)frame.setVisible(true);   2)repaint();

               17.接口：是一种数据类型（引用类型），由interface定义，只能包含常量和抽象方法，接口不能被实例化，是需要被实现的/继承的，由implement来实现，必须重写接口中所有抽象方法（重写注意访问权限），一个类可以实现多个接口，用逗号分开，若又继承又实现时，应先继承后实现，接口可以继承接口（接口可以理解成完全抽象的抽象类）

               18.         1.内存管理:由JVM管理的------------了解
                                 1)堆:
                                           1.1)存储new出来的对象(包括实例变量)
                                           1.2)垃圾:没有任何引用所指向的对象
                                                      垃圾回收器(GC)不定时到内存中清扫垃圾
                                                      回收过程是透明的(看不到的)，不一定一发现垃圾就立刻回收，
                                                      调用System.gc()可以建议JVM尽快调度GC来回收
                                                      回收对象时，实例变量一并被回收
                                             1.3)实例变量的生命周期:
                                                        创建对象时存储在堆中，对象被回收时一并被回收
                                              1.4)内存泄漏:不再使用的对象还没有被及时的回收
                                                        建议:对象不再使用时，及时将引用设置为null
                                   2)栈:
                                               2.1)存储正在调用方法中的局部变量(包括方法的参数)
                                               2.2)调用方法时会在栈中为该方法分配一块对应的栈帧（栈帧存储着方法在方法区的地址），
                                                         栈帧中存储方法中的局部变量(包括参数)，
                                                         方法调用结束时，栈帧被清除，局部变量一并被清除
                                               2.3)局部变量的生命周期:
                                                         调用方法时存储在栈中，方法结束与栈帧一并被清除
                                    3)方法区:
                                               3.1)存储.class字节码文件(包括方法、静态变量)
                                               3.2)方法只有一份，通过this来区分具体的调用对象

ps：类的命名单词首字母大写，方法命名驼峰命名法

变量分为成员变量和局部变量，

成员变量:
1)实例变量:没有static修饰的，属于对象，堆中，
           有几个对象就有几份
       通过对象名点来访问
2)静态变量:由static修饰的，属于类，方法区中，
           只有一份，
       通过类名点来访问

设计规则:
1)将所有派生类所共有的属性和行为，抽到超类中-----抽共性
2)所有派生类的行为都一样，设计普通方法
  所有派生类的行为都不一样，设计为抽象方法
3)将部分派生类所共有的行为，抽到接口中
  符合既是也是原则时，使用接口
  接口是对继承的单根性的扩展---------实现多继承

基本类型:自动类型转换，
         强制类型转换(有可能溢出或丢精度)
          byte,short,int,long,float,double
                 char

         引用类型:自动类型转换(向上造型)，
                          强制类型转换(有可能异常)（）
                           派生类小，超类大

当程序运行结果与你所预期的结果不同时:
1.打桩: System.out.println(数据);
2.Debug调试工具: 添加断点
  1)掌握四个键:
    1.1)F5:单步调试(会进入到方法中)
    1.2)F6:逐过程调试(不会进入到方法中)
    1.3)F7:结束方法的调试
    1.4)F8:直接跳到下一个断点(若后面无断点，则结束调试)
  2)会看两个东西:
    2.1)会看变量
    2.2)添加监视(看表达式的值--选中表达式右键Watch)

实例变量:
1)类中，方法外
2)创建对象时存储在堆中，对象被回收时一并被回收
3)有默认值

局部变量:
1)方法中
2)调用方法时存储在栈中，方法结束时一并被清除
3)没有默认值