Day16 面向对象进阶——接Day15

Day16 面向对象进阶——接Day15

一、抽象类及抽象方法

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

1、抽象方法交给非抽象的子类去实现(重写)

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

3、面试题：
1.抽象类不能有构造方法？

​ 抽象类可以有构造方法

2.抽象类中只能有抽象方法？

​ 抽象类中有非抽象方法（成员方法和静态方法）

3.抽象类中不可以没有抽象方法？

​ 抽象类中可以没有抽象方法，但是毫无意义

4.如果父类是抽象类，则子类必须实现父类的抽象方法？

​ 不一定，子类如果是抽象类，可以不实现父类的抽象方法

5.可以使用new关键字来创建抽象类对象？

​ 不可以，创建的是匿名内部类的对象

二、接口

1、含义：特殊的抽象类

注意：

1. JDK1.7时，接口中只能有静态常量和抽象方法
2. JDK1.8开始，接口中添加了静态方法和默认方法

2、应用场景：接口更像一个规范

3、 理解：
3.1.接口是一个特殊的抽象类

  	 3. 2.JDK1.8之前，接口中只能有抽象方法及静态常量
  	3.3.JDK1.8开始，接口中允许使用抽象方法、静态常量、静态方法、默认方法

4、抽象类 vs 接口

​ 4.1. 抽象类：成员变量、静态变量、静态常量、成员方法、静态方法

​ 4.2 接口：静态常量、静态方法(JDK1.8)、默认方法(JDK1.8)

5、面试题：

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

6、类 - 接口的关系：
6.1 类 - 类：单继承
6.2 类 - 接口：多实现
6.3 接口 - 接口：多继承

三、多态

1、理解：多种形态

2、分类：

​ 类的多态：子类对象指向父类引用（父类引用中存储的是子类对象在堆中开辟的地址）

​ 接口的多态：实现类对象指向接口的引用（接口的引用中存储的是实现类对象在堆中开辟的地址）

3、设计原则：前人总结的经验，告诉我们什么不该做

4、设计模式：前人总结的经验，告诉我们一步一步的怎么做

5、OCP原则：

​ O - Open - 在需求升级时，对于创建类是欢迎的

​ (因为创建类对于原来代码的影响几乎为0)

​ C - Close - 在需求升级时，对于改动原有类是拒绝的

​ (因为原有类之间的关系是趋于稳定状态，如果改动原有类，

​ 很有可能打破这种平衡，导致bug的出现)

​ P - Principle - 原则

6、优缺点：

​ 优点：提高程序的维护性，在需求升级/迭代时，不违反OCP原则

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

四、对象转型

1、自动转型 - 向上转型：子类类型 转 父类类型

注意：

1. 向上转型就是多态！！！

   2. 向上转型后，可以调用父类属性
   3. 向上转型后，可以调用父类方法
   4. 向上转型后，不可以调用子类独有的属性
   5. 向上转型后，不可以调用子类独有的方法
   6. 向上转型后，可以调用子类重写父类的方法

2、强制转型 - 向下转型：父类类型 转 子类类型

五、内部类

1、概念： 内部类（Inner Class）是定义在另一个类内部的类。内部类可以访问包含它的外部类的成员，包括私有成员，并且可以实现更加灵活和封装的设计。内部类分为四种类型：成员内部类、静态内部类、局部内部类和匿名内部类。

2、理解：一个类中再声明另外一个类

3、分类：

1. 成员内部类

   2. 静态内部类
   3. 接口内部类
   4. 局部内部类
   5. 匿名内部类

4、应用场景：

1. B类的对象只在A类中使用，并且B类对象使用到了A类所有的属性，就可以将B类作为A类的成员内部类
2. B类的对象只在A类中使用，并且B类对象使用到了A类静态的属性，就可以将B类作为A类的静态内部类
3. 抽象类的子类只创建一次对象，就没必要创建子类，直接使用匿名内部类（new 抽象类）
4. 接口的实现类只创建一次对象，就没必要创建实现类，直接使用匿名内部类（new 接口）

5、举例：

public class OuterClass {
   private int outerField = 10;

   public void outerMethod() {
       System.out.println("Outer method");
   }

   public class InnerClass {
       public void innerMethod() {
           System.out.println("Inner method");
           System.out.println("Accessing outerField from inner class: " + outerField);
           outerMethod();
       }
   }

   public static void main(String[] args) {
       OuterClass outerObject = new OuterClass();
       OuterClass.InnerClass innerObject = outerObject.new InnerClass();
       
       innerObject.innerMethod();
   }
}

分析： 在这个例子中，OuterClass包含一个内部类InnerClass。内部类可以访问外部类的成员变量outerField和方法outerMethod。在main方法中，我们首先实例化外部类对象outerObject，然后使用它来实例化内部类对象innerObject，最后调用内部类的方法innerMethod来展示内部类访问外部类成员的例子。

局部内部类内存图：
匿名内部类内存图1：

匿名内部类内存图2：