面向对象编程

一、面向对象和面向过程

1、面向对象：是以具体的事物为单位，考虑的是它的特征（属性）和行为（方法）。

2、面向过程：是以具体的流程为单位，考虑功能的实现。

二、类和对象

1、对象：看得见摸得着的具体事物。

     类：抽象化的概念

2、类和对象的关系：

     类是对象的模板/抽象化的概念，对象是类的实例。

3、创建类和对象

     类：

    特征：全局变量/属性/成员变量

    动作：方法

    对象：

    类名 对象名=new 类名（）

    注意：一个类可以创建多个对象，，每个对象之间没有关系。

三、内存图

1、栈：先进后出，存放基本数据类型变量名和变量值，引用数据类型的变量名，
方法执行的时候进入栈中。

2、堆：先进先出，new出来的对象的实例，包括类的属性个方法。

四、构造方法

1、构造方法是new关键字调用的，用来帮助构建对象

2、显示构造对象

3、隐示构造对象（没有显示的情况下存在）

4、构造对象可以重载，参数类型不一致。

五、关键字

1、static调用格式：

    1、同一个类中：

        静态的：

            方法名     属性名

            类名.方法名  类名.属性名

            对象名.方法名 对象名.属性名

        非静态的：

            对象名.属性名 对象名.方法名

    2、不同类中:

        静态的：

            对象名.方法名 对象名.属性名

            类名.方法名  类名.属性名

        非静态的：

            对象名.属性名 类名.方法名

    注意：1、static可以修饰属性、方法、代码块，不可以修饰类和构造方法。

          2、静态方法随着类的加载而加载。

          3、在静态方法区内的东西只有一份，所有的对象共享这一份空间，
                只要有一个对象对属性进行修改，所有的对象调用都是修改后的数据。

          4、代码块的执行顺序：静态代码块（只被调用一次）>
                构造代码块{}>构造方法>普通方法（需调用）

2、this关键字

    1、可以调用属性和方法。

        this.属性名（全局变量）

        this.方法名（）;

    2、在构造方法中：

        1、this();括号内的参数个数、顺序、类型根据调用的方法来决定。

        2、必须放在第一行，只能调用一次。

        3、调用构造方法时只能在构造方法中调用，调用属性和方法时可以在构造方法中可以在普通方法中。

        4、当全局变量和局部变量有重名字的时候，用this来区分。

3、super关键字

    1、super指代父类对象。

    2、super可以调用属性、方法、构造方法。

    3、super调用父类的构造方法。

    4、super调用构造方法时候必须放在第一行。

4、final最终的

    1、可以修饰全局变量，声明的时候必须赋值，只能赋值一次。

    2、可以修饰局部变量，声明时候可以不赋值，但也只能赋值一次。

    3、可以修饰方法，可以正常使用，不能被重写。

    4、可以修饰类，可以正常使用，不能被继承。

    5、用final修饰的属性通常叫常量。

    6、static final 全局变量。每个字母都要大写。

5、this和super的区别

    1、this指的是本类创建的对象。                           
          super指代的是父类的对象

    2、this可以调用属性、方法、构造方法。                   
          super也可以调用属性、方法、构造方法。

    3、this调用属性和方法的时候，调用自己本类的属性和方法。 
          如果本类没有，那就用super去父类中找

    4、this调用构造方法调用，调用本类的其他构造方法。       super调用父类的构造方法。

    5、this和super在调用构造方法的时候必须放在第一行。

    6、this和super不能同时存在

6、最小作用域最强原则：

    局域变量在此方法中，比全局变量在此方法中的作用强。

六、面向对象的三大特征

1、封装

        作用：提高代码的安全性

        1、将属性私有化，并提供对外界的接口（get/set方法）。

        2、用private修饰的属性和方法，只能在本类中使用。

2、继承

  　作用：提高代码的复用性，减少重复代码

    1、子类可以继承父类非私有的属性和方法，
          不能继承构造方法和私有的属性和方法。

    2、可以综合子类的共同特征来去提炼父亲的类。

    3、子类在继承父类的各种属性和方法时，也可以有自己的属性和方法。

    4、一个子类只能有一个父类，java只能单继承，不能多继承，
          因为多个类中的方法名相同，方法体不同，不知使用哪个。

    5、一个类继承最顶端叫做基类或者超类，所有的超类叫做object 。

    6、在继承关系中，如果父类没有无参数的构造方法，如何解决？

           1>子类中添加一个和父类构造方法参数列表相同的构造方法，
            通过super参数传递给父类的构造方法

           2>如果父类允许修改的时候，可以在父类中创建一个无参的构造方法

    7、在继承关系中，代码块的执行顺序：父静>子静>
          父构造代码块>父构造方法>子构造代码块>子构造方法

3、多态

    1、分类

        编译时多态：在编译过程中察觉的多态，重载，向上转型。

        运行时多态：在运行过程中察觉的多态，向下转型。

    2、向上转型、向下转型是在继承关系中，向下转型必须在向上转型的基之上。

    3、在继承关系中，父类的对象可以指向子类的实例，父类引用实体方法的时候，
          是调用子类重写以后的方法。

    4、向上转型

        父类的引用指向子类的实体

        父类类名 对象名=new 子类类();

        优点：减少重复代码，提高代码的复用性

        缺点:父类的引用无法调用子类特有的属性和方法

        解决方案：向下转型

    5、向下转型：

        子类对象的父类引用赋给子类

        子类类名 对象名=（子类类名）父类对象;

    6、 instanceof 判断左边的对象是否属于右边的类  对象名 instanceof 类名（子类类名）

    7、匿名对象

        new 类名（）  只有堆空间，没有栈空间，只能属于一次，为了节省代码。

七、抽象abstract

作用：节省代码，提高代码的复用性

1、抽象类格式：访问权限修饰符   abstract class 类名{}

2、抽象方法格式：访问权限修饰符  abstract 返回值类型  方法名(形式参数列表);

注意：

    1、如果一个类里有抽象方法，那么这个类必须声明成抽象类。

    2、一个类里面可以没有抽象方法，可以有非抽象方法，

    3、类继承抽象类：

        把子类也用abstract修饰，变成抽象类。

        子类重写父类的抽象的方法

    4、抽象类不能创建对象。

    5、抽象类可以有构造方法，在创建子类的时候，super隐式调用父类的构造方法，
          将父类的属性和方法放到子类的对象空间里。

    6、在继承你关系中，子类能够继承抽象类的各种属性和方法，除了私有的和构造方法。

    7、只有公开的才可以和abstract连用，static final private 都不可以。

        static属于类方法，不允许覆盖，abstract必须被覆盖。final不能被重写。

八、接口interface

作用：规范了代码，提高代码的拓展性

1、格式：访问权限修饰符  interface 接口名称{}

2、实现类的格式：访问权限修饰符  class 实现类名 
      implements 接口名{必须重写接口中的所有的抽象方法}

3、接口中只有全局常量和抽象方法。

4、书写的时候可以省略部分修饰符，系统会默认给添上。

5、接口在实现的同时去继承，extends在implement前面。

6、接口可以多实现，实现的也必须是接口，方法名可以重复，
      实现类实现一个就行了，因为没有方法体，不会发生冲突。

九、抽象和接口的区别

1、关键字：抽象类 abstract      接口interface

2、抽象类继承 extends         接口实现 implements

3、子类继承抽象类和          实现类实现接口的格式不同

4、接口中只有全局变量和抽象方法        抽象类中有各种属性和方法

5、抽象类只能单继承              接口可以多实现

6、抽象类的子类只能继承一个父类    实现类可以实现多个接口，并且还可以继承父类

7、抽象类的作用：提高代码的复用性   接口的作用：1、规范代码2、提高代码的拓展新

十、方法重写override 覆盖（多态）

1.在子类中。

2、返回值相同、方法名相同、参数列表相同。

3、访问权限修饰符不能比父类更严格。

4、父类的方法不能够满足子类需求的时候，子类需要重写父类的方法。

十一、重写和重载的区别：

1、重写是在继承关系中             重载是在同一个类中

2、重写是方法名、参数列表和父类相同      重载，方法名相同，
      参数列表不相同（个数、类型、顺序）

3、重写返回值类型和父类相同          重载和返回值无关

4、重写访问权限修饰符不能比父类更加严格 重载没有要求

十二、访问权限修饰符

	本类中	本包中	其他包子类	其他包非子类
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

十三、equals

object中的equals比较的是地址，底层封装的是==

==比较的是基本数据类型，比较的是内容

    引用数据类型比较的是地址

String中也有equals，String中的equals被重写过了，比较的是内容。

十四、空指针异常

1、声明了对象名，但没有给对象初始化，然后使用这个对象

2、遇到了类类型作为属性的时候，就必须初始化，否则就会报错

十五、内部类

   分类：成员内部类、静态内部类、局部内部类、匿名内部类

1、成员内部类：

    1、可以用四种访问权限修饰符修饰

    2、可以有自己的属性和方法，除了静态的。

    3、可以使用外部类的所有属性和方法，包括私有的。

    4、创建对象

        1、通过创建外部类对象的方式创建对象

        外部类 外部类对象=new 外部类();

        内部类 对象名=外部类对象.new 内部类();

        2、内部类 对象名=new 外部类.new 内部类();

2、静态内部类

    1、格式：static class 类名{}

    2、可以声明静态的属性和方法

    3、可以使用外部的静态的属性和方法

    4、创建对象

        内类名 对象名=new 内类名();(可以直接创建)

        外部类名.内部类 对象名=new  外部类.内部类();

        包名.外部类名.内部类 对象名=new  包名.外部类.内部类();

    5、外部类与内部类同名时，默认是使用内部类对象调用外部类属性

        this代表内部类对象

    6、要想使用外部类属性，需要使用外部类对象调用

3、局部内部类

    1、在方法中声明

    2、只能用default修饰

    3、可以声明属性和方法，但不能是静态的

    4、创建对象，必须在声明内部类的方法内创建

    5、调用方法的时候，局部内部类才会被执行

4、匿名内部类

    1、匿名内部类只是用一次

    2、格式：

    父类或接口名 对象名=new  父类或接口名（参数列表）{

       重写抽象方法

      }

    调用抽象方法：对象名.方法名