百日Java知识积累《第一篇》

这个专栏只记录Java语言的部分，不包含其他知识。数据库、框架、算法等知识，其他面试前的覆盖积累可以参考我的其他专栏。

前言

准备开始每天按照规划进度学习复习了，对于Java后端，Java的基础知识，会在一个专栏里面记录每次的学习笔记，方便复习。以及形成自己的知识体系，才方便知道知识的覆盖面和存在的漏洞。

---

大家可以持续关注专栏。

---

以下是本篇文章正文内容

---

一、面试官：讲一下抽象类和接口有哪些区别？

抽象类和接口的主要区别：

从设计层面来说，抽象类是对类的抽象，是一种模板设计；接口是行为的抽象，是一种行为的规范。

1. 一个类可以有多个接口 只能有继承一个父类

2. 抽象类可以有构造方法，接口中不能有构造方法。

3. 抽象类中可以有普通成员变量，接口中没有普通成员变量

4. 接口里边全部方法都必须是abstract的；抽象类的可以有实现了的方法

5. 抽象类中的抽象方法的访问类型可以是public，protected；但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型

6. 抽象类中可以包含静态方法，接口中不能包含静态方法

7. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意；但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

   接口和抽象类各有优缺点，在接口和抽象类的选择上，必须遵守这样一个原则：
   1.行为模型应该总是通过接口而不是抽象类定义，所以通常是优先选用接口，尽量少用抽象类。
   2.选择抽象类的时候通常是如下情况：需要定义子类的行为，又要为子类提供通用的功能。

二、关于接口

概述：接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含常量和抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。

接口的定义：它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

接口的使用：1. 接口不能直接使用，必须有一个“实现类”来“实现”该接口。2. 接口的实现类必须覆盖重写（实现）接口中所有的抽象方法。实现：去掉abstract关键字，加上方法体大括号。3. 创建实现类的对象，进行使用。

注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类。
接口定义格式：

实现的概述：类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用implements 关键字。

非抽象子类实现接口：1. 必须重写接口中所有抽象方法。2. 继承了接口的默认方法，即可以直接调用，也可以重写。
实现格式：

class 类名 implements 接口名 {
    // 重写接口中抽象方法【必须】
   // 重写接口中默认方法【可选】  
}

含有抽象方法的使用：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。代码如下：
定义接口：

定义实现类：

定义测试类：

注意事项：

1. 接口当中的抽象方法，修饰符必须是两个固定的关键字：public abstract
2. 这两个关键字修饰符，可以选择性地省略。（刚学时，还是要写上）
3. 方法的三要素，可以随意定义。

包含默认方法的使用：可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。
定义格式：public default 返回值类型 方法名称(参数列表) {方法体}

备注：接口当中的默认方法，可以解决接口升级的问题。

1.继承默认方法：
定义接口：

public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}

定义实现类：

public class Animal implements LiveAble {
// 继承，什么都不用写，直接调用    
}

定义测试类

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象 
        Animal a = new Animal();
        // 调用默认方法
        a.fly();
    }
}
输出结果：
天上飞

2.重写默认方法：
定义接口

public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}

定义实现类：

public class Animal implements LiveAble {
    @Override
    public void fly() {
        System.out.println("自由自在的飞");
    }
}

定义测试类：

public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象 
        Animal a = new Animal();
        // 调用重写方法
        a.fly();
    }
}
输出结果：
自由自在的飞

包含静态方法的使用：静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，代码如下：

定义接口：

public interface LiveAble {
    public static void run(){
        System.out.println("跑起来~~~");
    }
}
定义实现类：
public class Animal implements LiveAble {
// 无法重写静态方法    
}
定义测试类：
public class InterfaceDemo {
    public static void main(String[] args) {
        // Animal.run(); // 【错误】无法继承方法,也无法调用
        LiveAble.run(); //
    }
}
输出结果：
跑起来~~~

注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。（静态方法不需要对象）

正确用法：通过接口名称，直接调用其中的静态方法。
格式： 接口名称.静态方法名(参数);

包含私有方法的使用：
问题描述：我们需要抽取一个共有方法，用来解决两个默认方法之间重复代码的问题。但是这个共有方法不应该让实现类使用，应该是私有化的。将抽取出来的重复部分，封装到私有方法中，供默认方法进行调用。
解决方案：1. 普通私有方法，解决多个默认方法之间重复代码问题
格式：private 返回值类型 方法名称(参数列表) {方法体}

2.静态私有方法，解决多个静态方法之间重复代码问题
格式：private static 返回值类型 方法名称(参数列表) {方法体}
例子：

public default void methodDefault1() {
    System.out.println("默认方法1");
    methodCommon();
}

public default void methodDefault2() {
    System.out.println("默认方法2");
    methodCommon();
}

private void methodCommon() {
    System.out.println("AAA");
    System.out.println("BBB");
    System.out.println("CCC");
}

包含常量的使用：接口当中也可以定义“成员变量”，但是必须使用public static final三个关键字进行修饰。从效果上看，这其实就是接口的【常量】。
格式：
public static final 数据类型 常量名称 = 数据值;

备注：
一旦使用final关键字进行修饰，说明不可改变。
注意事项：

1. 接口当中的常量，可以省略public static final，注意：不写也照样是这样。
2. 接口当中的常量，必须进行赋值；不能不赋值。
3. 接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）

三、关于抽象类

由来：父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法的类就是抽象类。

定义：抽象方法 ： 没有方法体的方法。抽象类 ：包含抽象方法的类。

抽象方法：定义格式----修饰符 abstract 返回值类型 方法名 (参数列表)；如public abstract void run()；

抽象类：如果一个类包含抽象方法，那么该类必须是抽象类。定义格式-----public abstract class Animal { public abstract void run()；}

抽象的使用：继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。代码举例：

public abstract class Animal {
    public abstract void run()；
}
public class Cat extends Animal {
    public void run (){
       System.out.println("小猫静悄悄地走~~~")；         
    }
}
public class CatTest {
   public static void main(String[] args) {   
        // 创建子类对象
        Cat c = new Cat();
        // 调用run方法
        c.run();
   }  
}
输出结果：
小猫静悄悄地走~~

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。
抽象的注意事项：

1 . 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。

2 . 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

3.抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

4 . 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

---