面向对象总结

一. 什么是面对对象:

        面向对象编程(OOP)就是一种设计思想，相对的存在面向过程编程：

                1. 面向对象：在程序设计中把每一部分尽量都当成一个对象来考虑，以实现代码的可拓展性、可维护性、可重用性。

                2. 面向过程：更多的是对过程的实现，需要一步步实现。

二. 类与对象：

        类：对同一类具有相同特征的事物的抽象概念。

               创建类：权限修饰符  class  类名 {};

        对象：类的具体化实例，万物皆对象。

               创建对象：类名  引用  = new 类名( );

三.类的成员：

        1.成员变量：属性

        2.方法：行为

                语法：权限修饰符  返回值  方法名(形参列表){}

                返回值：有返回值的方法中要有 return 返回值;

                形参列表：数据类型  变量名

        3.构造器：

                语法：权限修饰符 类名(形参列表){}

                ①. 有参构造：有形参。

                ②. 无参构造：当没有任何构造器存在时，默认为无参构造；当存在构造器时，默认存在的无参构造会消失。

                作用：①.创建对象

                           ②.初始化对象的属性

        4.代码块

        5.内部类

四. 面向对象的三大特征：

        封装、继承、多态

                1. 封装：该隐藏的隐藏，该暴露的暴露，就是封装的思想。

                        什么是封装 —— 隐藏属性，隐藏一个类或方法的实现细节(私有化)，仅对外提供简单的接口get和set方法。

                        特点 —— 高内聚，低耦合。内部细节自己完成，不允许外部干涉(高内聚)；仅对外暴露少量的方法用于使用(低耦合)。

                2. 继承：子类继承父类的所有属性和方法(私有化除外)。

                        特点 —— 继承只能是单继承，父类只能有一个。

                                        所有类都直接或者简介继承自 Objec。

                                        子类会拓展，比父类更加强大。

                        语法 —— 通过 extends 继承

public class A extends B{
//  A  子类
//  B  父类
}

                3. 多态：同一事物或者对象，不同的形态，就是多态。

                        语法 —— 父类的引用指向子类的对象. (前提是有继承关系)

//父类 A ；子类 B、C
    A a1 = new B();
    A A2 = new C();
//B、C 可以修改，使当前对象换一个类。

                        虚拟方法的调用 —— 编译期看等号左边，运行期看右边。

                                在编译期只能调用父类的方法；在运行期执行的是子类重写之后的方法。

                        向上与向下转型 —— 

                                ①.向上：父类引用指向子类的对象，只有这样引用才既能调用父类的方法，又能调用子类的方法。

                                ②.向下：子类的对象指向父类的引用，缺点是编译期不能检测出来错误，不能保证完全正确。

                        优点 —— 可复用性、可扩充性、可维护性。

                        使用前提 —— ①.有继承关系。

                                                ②.有方法的重写。

                                                ③.向上转型。

五. 关键词：

    static、final、abstract

                1、static —— 静态的，使用static修饰的属性和方法，会提升一个层级，随着类的加载而加载。(类的加载只有一次)

                       修饰变量（静态变量）：【类名.变量名】

                               · 所有对象，共享同一个静态属性。

                               · 可以直接使用【类名.属性】的方式调用。

                       非静态变量：

                               · 当创建一个个实例后，每个实例都有一套独立的非静态属性。

                       修饰方法（静态方法）：【类名.方法名】

                               · 所有对象，共享同一个静态方法。

                               · 可以直接使用【类名.方法名】的方式调用。

                               · 静态方法中不能使用this、super。

                               · 静态方法只能调用 静态的方法和属性。

                       非静态方法：

                               · 当创建一个个实例后，每个实例都有一套独立的非静态方法。

               2、final —— 最终的，可以用来修饰变量、类、方法。

                        · 修饰变量，这个变量不可以被修改，会变成常量，必须赋值。

                                赋值位置：①.显式初始化

                                                  ②.代码块

                                                  ③.构造方法中赋值(如果构造方法有多个，每一个构造方法中都要对常量进行赋值)

                        · 修饰类，这个类不能被继承。

                        · 修饰方法，方法不能被重写。

                3、abstract —— 抽象的，可以用来修饰类和方法。

                        · 修饰类(抽象类)，不能被实例化，只能被继承，抽象类不一定有抽象方法。

                        · 修饰方法(抽象方法)，在子类中必须被重写，否则要让子类变成抽象类，有抽象方法必须是抽象类，抽象方法没有方法体。

六. 接口：

        接口的本质是契约、标准、规范。

        类是单继承，接口是多实现。

        继承是一个“是不是”的关系，而接口是一个“能不能”的关系。

                 语法 —— 全局常量：public static final 修饰的变量

                                 抽象方法：public abstract 修饰的方法

                 1、接口中不能定义构造器，也就是接口不能被实例化。

                 2、java中，接口是用来被类实现(implements)的。

                 3、如果一个类想要实现一个接口，那么此类必须重写接口中的所有抽象方法，否则此类要变成抽象类。

                 4、一个类可以实现(implements)多个接口。(弥补了单继承的局限性)。

                 5、接口的使用，就是多态的一种体现。