面向对象知识点归纳与深入

# 面向对象

## 概念 

> 现实生活：
>
> ​    类：抽象的概念，把具有相同特征和操作的事物归为一类
>
> ​    先有实体，再有类的概念
>
> 代码世界：
>
> ​    类：抽象的概念，把具有相同属性和方法的对象归为一类
>
> ​    编写顺序：先有类，再创建对象
>
> ​    类的作用：类相当于一个模板，刻画出具有相同属性和方法的对象

## 类

> 1. 类中只有属性和方法
> 2. 属性也叫做全局变量，属性分为成员变量和静态变量
> 3. 方法分为成员方法和静态方法

```java
public class 类名{
    //属性也叫做全局变量，分为成员变量和静态变量
    
    //成员变量
    数据类型 变量名;
    
    //静态变量
    static 数据类型 变量名;
    
    //方法分为成员方法和静态方法
    
    //成员方法
    访问修饰符 返回值类型 方法名([参数]){}
    
    //静态方法
    访问修饰符 static 返回值类型 方法名([参数]){}
}
```

## 对象

> 创建对象的语法：类名 对象名 = new 类名();
>
> ​    new 构造方法; 属于对象，就在堆内存中开辟空间
>
> ​    类名 对象名 ：对象名属于引用，存的是对象在堆内存中的地址
>
> 操作对象：
>
> 1. 设置成员属性
>
>      2. 获取成员属性
>      3. 调用成员方法

## 成员属性/成员变量

> 语法结构：数据类型 变量名;
>
> 编写的位置：类里，方法的外面

> 成员变量 vs 局部变量
>
> 成员变量：类里，方法的外面的变量，并且系统会赋默认值，作用在整个类中
>
> 局部变量：方法内的变量，系统不会赋默认值，作用在方法中

## 成员方法

> 语法结构：访问修饰符 返回值类型 方法名([参数]){}
>
> 编写的位置：类里

> 成员方法 vs 静态方法
>
> 成员方法：属于对象的方法，必须使用对象调用
>
> 静态方法：属于类的方法，使用类名调用

## 构造方法

> 含义：和new一起是创建对象的功能
>
> 特点：
>
> 1. 与类名相同的方法
>
>      2. 没有返回项
>
> 注意：
>
>     1. 当类中没有写构造方法时，系统会默认添加无参构造（无参数的构造方法）
>      2. 构造方法可以重载的
>
> 有参构造好处：创建对象时，把数据赋值给该对象

```java
public class Person{
    //注意：这种不是构造方法，是成员方法
    public void Person(){}
}
```

## private - 私有化

> 含义：私有化
>
> 作用：
>
> ​    1. 修饰属性：私有化属性，不能让外界使用
>
>      2. 修饰方法：私有化方法，不能让外界使用
>
> 应用场景：不让让外界访问的属性和方法就用private修饰

## 封装

> 步骤：
>
> 1.  私有化属性
>
>      2. 添加get（获取）/set（设置）方法
>
> 好处：外界不可以直接操作属性，必须通过get、set方法操作，可以在get、set方法中做额外的功能

## this - 本对象

> 含义：代表本对象，this出现方法里，表示调用该方法的对象
>
> 作用：
>
> 1. this.属性：调用本对象的成员变量
>
>      2. this.方法：调用本对象的成员方法
>      3. this()：调用本对象的构造方法（在一个构造方法中的第一句调用另外一个构造方法）

## 分包

> 基本作用：防止了类的重名问题
>
> 项目作用：项目中有众多的类，把相同功能的类放在同一个包中，方便管理
>
> 工具类：com.dream.util/tool
>
> 实体类：com.dream.vo/bean/entity/bto/pojo
>
> 数据库类：com.dream.dao/mapper

## static - 静态的

> 作用：
>
>  1. 修饰属性
>
>  ​    类加载到方法区时，JVM会扫描该类的所有属性
>  ​    并把静态属性加载到静态区中，静态属性属于类属性，
>  ​    该类所有的对象都共享该属性
>  ​    静态属性直到项目结束时才会被回收
>
>  ​    注意：静态属性使用类名调用
>
>  2. 修饰方法
>
>     属于类方法，直接用类名调用
>
>     应用场景：工具类
>
>  3. 静态代码块
>
>     静态代码块是类加载到方法区时才会被调用，该代码块只能初始化静态变量
>
>     代码块是创建对象时优先于构造方法调用，该代码块可以初始化成员变量和静态变量
>
>     构造方法是创建对象时调用，该方法可以初始化成员变量和静态变量

> 成员变量 vs 静态变量
>
> 成员变量：属于对象的变量，每个对象独享一份
>
> 静态变量：属于类的变量，每个对象都共享一份

## 继承

> 使用场景：多个类似的类，有相同的属性和方法，就可以把相同属性和方法抽取到父类
>
> 好处：减少了代码的冗余

> 深入继承：
>
> 创建子类对象，会不会调用父类构造方法？
>         会
>  创建子类对象，会不会创建父类对象？
>         不会
> 创建子类对象，为什么会调用父类构造方法？
>         目的是将父类的属性存放在子类对象中
>
> 创建子类对象，先调用父类构造方法还是子类构造方法？
>         先调用子类构造方法
>
> 创建子类对象，先完成父类构造方法还是子类构造方法？
>         先完成父类构造方法
>
> 子类可以继承父类私有化的属性和方法吗？
>
> ​        可以，但是只能间接调用

## super - 父类

> 含义：代表父类
>
> 作用 在子类中：
>
> 1. super.属性：调用父类非私有化的成员变量
>
>        2. super.方法：调用父类非私有化的成员方法
>           3. super()：调用父类非私有化的构造方法

## 重写

> 含义：重写也叫做复写，将父类中方法在子类中重新编写一遍
>
> 应用场景：父类方法不满足子类需求时，子类就可以重复父类的方法
>
> 条件：
>
> 1. 在子类中重写父类的方法
> 2. 返回值、方法名和参数列表必须和父类重写的方法一致
> 3. 访问修饰符不能比父类重写的方法更严格

## 访问修饰符

> 含义：修饰类、方法、属性，定义使用的范围
>
> 学习：做实验
>
> | 访问修饰符 | 本类 | 本包 | 其他包子类 | 其他包 |
> | ---------- | ---- | ---- | ---------- | ------ |
> | private    | OK   |      |            |        |
> | 默认的     | OK   | OK   |            |        |
> | protected  | OK   | OK   | OK         |        |
> | public     | Ok   | OK   | OK         | Ok     |

## Object

> 含义：基类也叫做超类，Object是所有类的祖先类
>
> 注意：如果一个类没有明确继承的父类，默认继承Object
>
> equals：比较两个对象内存地址是否相同
>
> hashCode：获取对象的hash值
>
> getClass：获取类的字节码文件对象
>
> toString：获取对象的字符串表示

> 标杆作用：Object作为所有类的父类，定义了几个方法，方便子类去重写
>
> equals的标杆作用：比较两个对象是否相同，不同的对象比较规则不一样，所以子类重写即可
>
> toString的标杆作用：每个子类都有不同的属性，重写toString直接打印该对象中所有的属性，方便观察数据

## final

> 含义：最终2
>
> 作用：
>
>  1. 修饰类：该类不能被继承
>
>  2. 修饰方法：该方法不能被重写
>
>  3. 修饰变量：变成常量，不能重新赋值
>
>     ​        常量的命名规则：全大写，单词之间用下划线隔开
>
>     ​        常量的生命周期：存在常量池中，直到项目结束才会被销毁

## 抽象类及抽象方法

```java
//抽象类
public abstract class 类名{
    //抽象方法
    public abstract void method();
}
```

> 抽象方法交给非抽象的子类去实现(重写)
>
> 应用场景：当一个方法必须在父类中出现，但是这个方法又不好实现，就把该方法变成抽象方法，交给非抽象的子类去实现

> 面试题：
> 1.抽象类不能有构造方法？
>
> 抽象类可以有构造方法
>
> 2.抽象类中只能有抽象方法？
>
> 抽象类中有非抽象方法（成员方法和静态方法）
>
> 3.抽象类中不可以没有抽象方法？
>
> 抽象类中可以没有抽象方法，但是毫无意义
>
> 4.如果父类是抽象类，则子类必须实现父类的抽象方法？
>
> 不一定，子类如果是抽象类，可以不实现父类的抽象方法
>
> 5.可以使用new关键字来创建抽象类对象？
>
> 不可以，创建的是匿名内部类的对象

## 接口

> 含义：特殊的抽象类
>
> 注意：
>
> 1. JDK1.7时，接口中只能有静态常量和抽象方法
> 2. JDK1.8开始，接口中添加了静态方法和默认方法
>
> 应用场景：接口更像一个规范

> 抽象类 vs 接口
>
> 抽象类：成员变量、静态变量、静态常量、成员方法、静态方法
>
> 接口：静态常量、静态方法(JDK1.8)、默认方法(JDK1.8)

> 面试题：
>
> 1.一个类可以实现多个接口？可以
>             
> 2.一个接口可以实现多个接口？不可以，接口与接口的关系是多继承
>             
> 3.接口里面的方法不一定都是抽象的？JDK1.7时接口里只能有抽象方法，JDK1.8时接口可以有抽象方法和默认方法
>             
> 4.接口解决了类的单继承问题？是的，因为类与类是单继承，类与接口是多实现
>             
> 5.一个类是否可以继承一个类并同时实现多个接口？可以
>             
> 6.接口可以new对象？接口是特殊的抽象类，但是本质还是抽象类，抽象类是不可以new对象的，接口也是不能new对象，new出来的匿名类内部类的对象

> 类 - 接口的关系：
>         类 - 类：单继承
>         类 - 接口：多实现
>         接口 - 接口：多继承