面向对象

概念

现实生活：

​ 类：抽象的概念，把具有相同特征和操作的事物归为一类

​ 先有实体，再有类的概念

代码世界：

​ 类：抽象的概念，把具有相同属性和方法的对象归为一类

​ 编写顺序：先有类，再创建对象

​ 类的作用：类相当于一个模板，刻画出具有相同属性和方法的对象

类

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

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

对象

创建对象的语法：类名 对象名 = new 类名();

​ new 构造方法; 属于对象，就在堆内存中开辟空间

​ 类名 对象名 ：对象名属于引用，存的是对象在堆内存中的地址

操作对象：

1. 设置成员属性

2. 获取成员属性

3. 调用成员方法

成员属性/成员变量

语法结构：数据类型 变量名;

编写的位置：类里，方法的外面

成员变量 vs 局部变量

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

局部变量：方法内的变量，系统不会赋默认值，作用在方法中

成员方法

语法结构：访问修饰符 返回值类型 方法名([参数]){}

编写的位置：类里

成员方法 vs 静态方法

成员方法：属于对象的方法，必须使用对象调用

静态方法：属于类的方法，使用类名调用

构造方法

含义：和new一起是创建对象的功能

特点：

1. 与类名相同的方法

2. 没有返回项

注意：

1. 当类中没有写构造方法时，系统会默认添加无参构造（无参数的构造方法）
2. 构造方法可以重载的

有参构造好处：创建对象时，把数据赋值给该对象

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

含义：最终

作用：

1. 修饰类：该类不能被继承

2. 修饰方法：该方法不能被重写

3. 修饰变量：变成常量，不能重新赋值

   ​ 常量的命名规则：全大写，单词之间用下划线隔开

   ​ 常量的生命周期：存在常量池中，直到项目结束才会被销毁

抽象类及抽象方法

//抽象类
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出来的匿名类内部类的对象

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

多态

知识点：类的多态

子类对象赋值给父类引用

父类引用中存储的是子类对象在堆中开辟的空间地址

好处：遵守了OCP原则，降低了出bug的几率

知识点：接口的多态

实现类对象指向的接口的引用

接口的引用中存储的是实现类对象在堆中开辟的空间

对象转型

向上转型/自动转型：子类类型 转 父类类型
经验：向上转型就是多态
注意：

1. 可以调用父类非私有化的成员变量
2. 可以调用父类非私有化的成员方法
3. 可以调用子类重写父类的成员方法
4. 不可以调用子类独有的属性和方法

多态的优、缺点？

​ 优点：不违反OCP原则，降低出bug的几率

​ 缺点：不可以调用子类独有的属性和方法

向下转型/强制转型：父类类型 转 子类类型

前提：向上转型后，再向下转型

注意：向下转型是不安全的

知识点：instanceof的使用

经验：向下转型必须使用instanceof判断

内部类

含义：一个类的内部声明另外一个类

应用场景：B类的对象如果只在A类中使用，就可以考虑将B类写在A类中，成为A类内部类

分类：

成员内部类：外部类的成员内部类
静态内部类：静态修饰的内部类
局部内部类：方法中写内部类
接口内部类：接口里面声明类
匿名内部类：没有名字的类

知识点：成员内部类

总结：成员内部类可以调用外部类所有的属性

知识点：静态内部类

注意：创建静态内部类不用创建外部类对象

总结：静态内部类只调用外部类静态属性

静态内部类为什么不可以调用外部类的成员属性？

因为静态内部类不用创建外部类对象，所以外部类的成员属性就会在堆内存中加载，自然就无法调用

静态内部类为什么可以调用外部类的静态属性？

因为创建静态内部类对象时，先要把外部类的class文件加载到方法区中，所以外部类的静态属性会在静态区中得到体现

知识点：接口内部类

默认添加public static

注意：接口内部类就是在接口中的静态内部类

总结：接口内部类只调用外部接口静态常量

知识点：局部内部类

注意：

1. 不能用访问修饰符修饰
2. 局部内部类使用到外部类的局部变量时，该变量如果在局部内部类中使用，在JDK1.8开始改变了自动变成常量

知识点：研究局部内部类使用到外部类的局部变量的情况

为什么局部内部类使用到外部类的局部变量时，该变量自动使用final修饰？

加长局部变量的生命周期，使得该变量（常量）在方法以外也能正常使用

知识点：匿名内部类

创建匿名内部类的对象（创建匿名子类的对象）

1. 创建一个没有名字的类，继承A类（匿名子类）
2. 创建匿名子类的对象，并赋值给父类的引用

匿名类使用场景：

B类的对象如果只在A类中使用，并且B类使用到A类所有的属性，就可以考虑将B类写在A类中，成为A类的成员内部类（应用场景较多）

B类的对象如果只在A类中使用，并且B类只使用到A类的静态属性，就可以考虑将B类写在A类中，成为A类的静态内部类（应用场景较多）

B类的对象如果只在A接口中使用，就可以考虑将B类写在A接口中，成为A接口的接口内部类（应用场景较少）

B类的对象如果只在A类某个方法中使用，就可以考虑将B类写在A类某个方法中，成为A类的局部内部类（应用场景较少）

抽象类A的子类对象只使用一次，就可以不写A的子类，new抽象类，直接使用匿名内部类（应用场景较多）

接口A的实现类对象只使用一次，就可以不写A的实现类，new接口，直接使用匿名内部类（应用场景较多）