Java基础——面向对象（OO）

一、    方法(函数) :  在java中，方法就是用来完成解决某件事情或实现某个功能的办法。

    方法的定义语法: 

                权限修饰符 返回值类型 方法名 (参数类型 参数名1 ... 参数类型 参数名n) {

                        方法体;

                        return 返回值;

                }

 二、 方法的递归调用指的是一个方法自己调用自己的形式。一般如果要进行方法的递归操作往往都具备有以下的特点：

        方法必须有一个递归的结束条件；

               方法在每次递归处理的时候一定要做出一些变更；

三、Java 中参数传递 :

        传值 :  方法调用时，实参把它的值传递给对应的形参，方法执行中形参值的改变不影响实参的值。

        传引用 : (传址) 非八大基本类型，方法调用时，实参的引用(地址，而不是参数的值)被传递给方法中相对应的形参，在方法执行中，对形参的操作实际上就是对实参的操作，方法执行中形参值得改变将会影响实参的值。 

四、面向对象（OO）和面向过程的区别 : 

        同样一个问题的解决过程，面向对象，是把这个过程看作是对象之间的相互作用关系；而面向过程，是把问题分成n个过程，然后按一定顺序执行。

        面向对象开发经过 OOA(面向对象分析)、OOD(面向对象设计)和 OOP(面向对象编程) 三个阶段

        面向对象(OO): 将功能封装进对象，强调具备了功能的对象

            类与对象的关系: 类是对象的抽象，对象是类的实例

            类的成员包括: 属性(变量)和行为(方法)

            用来描述对象的动态特征(行为)的一个动作序列是对象的方法而非属性，类的方法描述了该类的对象的行为

            使用对象的属性形式是: 对象.属性名

            使用对象的方法形式是: 对象.方法名()

        面向对象的三大(四大)特征: 封装、继承、多态(抽象)

    面向对象的思维 : 

            作为面向对象的思维来说，当考虑问题的时候，不应该再去考虑第一步干嘛，第二步干嘛，而应该首先考虑，作为这个问题来说，在这个问题里应该有

            哪些类哪些对象，然后再考虑这些类和对象，每一种类和每一种对象，应该具有哪些属性和方法，再考虑类与类之间具备了什么样的关系。

1.  面向对象封装应遵循的原则 :

    高内聚 : 

        内聚是指事务内部的联系紧密程度。在面向对象编程中，就是对象内各元素之间关系紧密程度。高内聚追求的是事物尽量只完成单一功能，以降低事物本身的复杂程度。

         事物复杂度降低后，和其他事物的关系就会变得简单。最终目的是避免牵一发而动全身的情况。

    低耦合 : 

        耦合是指事物之间的联系紧密程度。在面向对象编程中，就是对象与对象之间的关系紧密程度。低耦合追求的是事物尽量保持自身独立，以达到牵一发而动全身的情况。

2. 类与对象的关系 : 

        类是对象的抽象，而对象是类的具体事例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。

    如何区分类和对象 : 

         对象可以看成是静态属性（成员变量） 和 动态属性（方法函数）的封装体。对象是new出来的，位于堆内存。

         类是用来创建同一类型的对象的“模板”，在一个类中定义了该类对象所具有的成员变量及方法。类是静态的慨念，放在代码区。

3. static 静态修饰符 

      ① static 修饰的方法是静态方法，静态方法不能直接访问非静态方法，静态方法可以直接访问静态方法和静态属性。静态如果要调用非静态，必须new 对象，才能调用。

      ② 非静态方法任务时候都可以直接访问静态方法和静态属性。 

      ③ 静态的方法和属性可以直接用类名.访问。

      ④ static 方法和属性内存只分配一次，在类装载器中开辟内存。

      ⑤ static 修饰的变量是属于类而不属于对象。 静态优于对象而存在

      ⑥ static 不能以任何形式去访问this 和 super。

      ⑦ static 不能修饰类 , 不能修饰构造方法。

      ⑧ 如果想在第一时间加载某段代码，可以使用静态代码块。

4.  成员变量、局部变量、类变量 : 

    成员变量 : (全局变量、实例变量) 定义在类中，在整个类中都可以访问。 存在于堆内存中。

                    成员变量随着对象的建立而建立，存在于对象所在的堆内存中，成员变量有默认初始化值。

    局部变量 : 局部变量只定义在局部范围内。

                    局部变量存在于栈内存中，作用范围结束，变量空间会自动释放，局部变量没有默认初始化值。

    类变量 : 使用static 修饰，只开辟一次内存。伴随类的存在而存在，生命周期最长。存在于方法区中。

5. 重载（overload） ： 在同一个类中方法名相同，参数列表不同，与返回值及权限修饰符无关。

                参数列表不同的情况 : ① 参数个数不同

                                                 ② 参数个数相同，但类型不同

                                                 ③ 参数个数和参数类型都相同，参数类型顺序不同

6. 重写（overide/overwrite） ： 建立在继承的基础之上，子类与父类拥有相同的方法名、相同的参数列表、相同的返回值类型，并且子类权限大于父类权限。

                为何需要重写？ 当父类方法不能满足子类的需求的时候，我们就需要重写父类的方法。

                两同两小一大原则 : 

                        两同 : ① 方法名相同

                                  ② 形参列表相同

                        两小 :  ① 子类方法返回值类型比父类方法返回值类型更小或相等

                                   ② 子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等

                        一大 :  子类方法的访问权限应比父类方法的访问权限更大或相等     

7. 封装 （private）:  隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。

               将对象的属性私有化，提供set、get方法供他人访问使用。

               好处 :  ① 类内部的结构可以自由修改

                              ② 可以对成员进行更精确的控制

                              ③ 隐藏信息，实现细节

8. 继承（extends） : 子类继承父类除私有化修饰的属性和方法。    继承可以减少代码的冗余。

                在Java中，只支持单一继承，不支持多继承。一个子类只能有一个直接父类，一个父类可以有一个或多个子类。

9. 构造方法（constructor） : 

                ① 方法名与类名一样。

                ② 构造方法无返回类型，并且在new 一个对象的时候，由JVM自动调用。

                ③ 构造方法同样遵从方法重载的原则。

                ④ 在构造方法中调用另一个构造方法 ，this 语句必须放在第一行。

                ⑤ 如果程序在类中有非空构造方法，那么JVM不会自动生成空的构造方法，否则会自动生成一个空构造方法。

                ⑥ 提前初始化类中的属性和方法。

                ⑦ new 一个对象的时候，从这个对象开始到 Object ，默认是最子类查找空构造直到Object，途中如果有一个类缺少空构造，则编译不通过。

                    查找是从最子类查找到最父类，执行是从最父类执行到最子类。

 10. 多态（动态绑定 Polymorphism）: 

                动态绑定 是指：在执行期间（而非编译期间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。

                                new的哪个对象就调用那个对象重写的父类的方法。

                多态 是建立在继承的基础之上，因继承机制允许，可以将某个对象看成其所属类，也可以看成其超类，这样就可以将多个对象看成同一个类，

                        当子类重写父类的方法，由同一个对象调用，产生不同的行为，这种现象就叫做多态！

                多态存在的三个必要条件：① 要有继承   ② 要有重写  ③ 父类引用指向子类对象，三个条件满足，当调用父类里被重写的方法时，实际中new的是哪个子类对象

                        就调用那个子类对象的方法。

                        非静态： 父有 子有 调子类，父有 子无 调父类，父无 子有 编译出错

                        静态（属性）： 父有 子有 调父类 ，父有 子无 调父类，父无 子有 编译出错

11. 抽象类（abstract）：逆着关系由下向上（从子类到父类），类逐渐变得通用，变得抽象，越往上越通用越抽象，越往下越具体越实用。

                ① 用 abstract 修饰的类 叫做抽象类，用 abstract 修饰的方法 叫做抽象方法。

                ② 含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写。

                ③ 抽象类不能被实例化。抽象类中的抽象方法要被使用，必须由子类重写其所有的抽象方法，建立子类对象调用。

                ④ 抽象类中可以有抽象方法，也可以有变量、常量、普通方法、构造方法。

                ⑤ 抽象类可以被继承，但子类要有两种情况：① 重写父类的抽象方法   ② 子类也使用 abstract 修饰

                ⑥ 抽象方法不能私有化（不能被 private 修饰），抽象方法不能被static 修饰，不能用final 修饰，抽象类也不能用final 修饰，不能与native、synchronized 同时使用。

             注： 抽象类中可以有构造方法！！！！

                       在抽象类中可以有构造方法，只是不能直接创建抽象类的实例对象，但实例化子类的时候，就会初始化父类，不管父类是不是抽象类都会调用父类的构造方法，初始化一个类，先初始化父类。

            使用抽象类是为代码的复用，而使用接口是为了实现多态性。

12. 接口（interface）：和类是同一种结构，接口中的方法都是抽象方法。

                ① 接口中不能有构造方法，不能有普通方法，可以有抽象方法。

                ② 接口中的方法可以加 abstract 修饰，也可以不加，默认是 public abstract 修饰的。

                ③ 接口中的抽象方法不能用 protected 和 private 修饰，可以用public修饰。。

                ④ 接口中可以有变量、常量、静态常量，编译后所有属性都是静态常量。 public static final 修饰

                ⑤ 接口可以用来弥补Java中类单一继承的缺陷。

                ⑥ 类可以实现（implements）多个接口，实现接口后必须重写所有的抽象方法。

                ⑦ 接口不能实例化，实现接口 使用 implements 关键字，语法： class 类名 implements 接口名

                ⑧ 类可以在继承一个类同时实现多个接口，顺序为 先继承再实现

                       类与类的关系是继承关系： extends                   

                       类与接口的关系是实现关系：implements

                       接口与接口的关系是继承关系：extends 接口之间存在多继承。

                为什么Java中不支持多继承却支持多实现？

                       答：因为多继承的方法，都存在方法体，当子类重写父类的方法时，会使JVM绑定规则变得更复杂，

                              而多实现的方法，不存在方法体，可以由子类任意定义，只需重写一次，故而不会增加JVM的绑定机制和复杂度。

                 接口与抽象类的区别：

                        答： 相同点：① 都是上层的抽象层

                                              ② 都不能实例化 

                                              ③ 都可以包含抽象方法 ，这些抽象方法用于描叙具备的功能，但不必提供具体的实现

                                异同点：① Java抽象类可以提供某些方法的部分实现，而Java接口不可以

                                                  interface中只能定义方法，而不能有方法的实现，而在abstract class中则可以既有方法的具体实现，又有没有具体实现的抽象方法

                                              ② 一个类只能继承一个直接父类，这个父类可以是具体的类也可以是抽象类，但是一个类可以实现多个接口

13. final ： 最终的

               ① 可以修饰类，但是不能被继承

               ② 可以修饰方法，但是不能被重写，只能被继承

               ③ 可以修饰属性，但属性的值不能被改变，是一个常量，可以修饰参数，参数值也不能改变

               ④ 不能修饰构造方法