抽象类与接口

抽象类

为什么要有抽象类？

假设我有一个父类：Animal类

//创建一个动物类
public class Animal {
    //动物有名字
    public String name;
    //动物有年龄
    public String age;

    //动物有吃的功能
    public void eat(){
        System.out.println("动物在吃东西");
    }
}

子类：Cat类和Dog类

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("小狗吃骨头");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("小猫吃鱼");
    }
}

发现每个子类都需要重写父类eat()方法，而且Animal类中eat()方法无法具体的写出动物吃什么，是无法确定的，因为动物是一个抽象的概念，无法具体为某种动物，所以这里需要用到抽象类。

抽象类和抽象方法的定义

抽象类的定义：需要用到abstract关键字来修饰。

抽象方法的定义：当不确定方法体的内容时，就需要用到抽象方法，需要用到abstract关键字修饰，而抽象方法不能有方法体,连{}都不能有。

语法：

abstract  class  类名{
   
       代码块;
}

举个例子：（而上面的例子就可以使用抽象类和抽象方法实现）

父类：Animal类

//创建一个动物类，父类可以写成一个抽象类
public abstract class  Animal {
    //动物有名字
    public String name;
    //动物有年龄
    public String age;

    //动物有吃的功能,但无法确定方法的具体实现，所以使用抽象方法
    public abstract void eat();
}

子类：Dog类和Cat类

public class Dog extends Animal{
    //子类继承抽象类后，必须重写抽象类中的抽象方法
    //如果不实现抽象方法，则也需要定义成抽象类
    @Override
    public void eat() {
        System.out.println("小狗吃骨头");
    }
}
class Cat extends Animal{
    //子类继承抽象类后，必须重写抽象类中的抽象方法
    //如果不实现抽象方法，则也需要定义成抽象类
    @Override
    public void eat() {
        System.out.println("小猫吃鱼");
    }
}

注意：

①如果一个类继承抽象类时，必须实现抽象类中的所有抽象方法，否则该类也要是一个抽象类

②抽象类中可以抽象方法，也可以有普通的方法

③抽象类不能被实例化，但是有构造方法（是类就一定有构造方法）

④抽象方法必须使用abstract修饰，并且不能有方法体

⑤含有抽象方法的类一定是抽象类

接口

接口的理解

接口的本质是标准，规范，大家都要遵守的规则，比如现实中type-c接口，你想要充电就必须是圆口才可以插进去充电。

接口在jdk1.8以前接口中的所有方法都是抽象方法，所有的属性都是静态常量，而接口也能解决类中的局限性(单继承)

接口中的方法都是用 public  abstract 修饰

接口中的属性都是用 public  static  final修饰

如何定义接口

语法：

public interface 接口名{
     //成员-1.8以后
     //1.静态常量成员
     //2.抽象方法成员
}

举个例子：

//定义接口
public interface Animal {
    //定义常量，只能赋值一次
    //而接口中的属性都是静态常量，所以默认属性添加public  final  static修饰
    public final static  String name = "旺财";
    
    //定义抽象方法
    //而接口中的方法都是抽象方法，所以默认方法添加public  abstract
    public abstract  void eat();
}

 接口与接口之间继承关系

一个接口可以继承多个接口

语法：

interface   接口名   extends  接口名1，接口名2，.....，接口名n{

          //代码内容

}

举个例子：

interface   A{
    //代码内容
}

interface   B{
   //代码内容
}

interface  C  extends  A,B{

    //代码内容
}

接口与类之间实现关系

使用implements关键字

语法：

public class 类名   implements   接口1，接口2，接口3，...... ，接口n{

     //代码内容

}

举个例子：

//定义接口
public interface Animal {
    //定义常量，只能赋值一次
    //而接口中的属性都是静态常量，所以默认属性添加public  final  static修饰
    public final static  String name = "旺财";

    //定义抽象方法
    //而接口中的方法都是抽象方法，所以默认方法添加public  abstract
    public abstract  void eat();
}
//类实现接口
class Cat implements Animal{
    //需要重写接口中所有抽象方法
    @Override
    public void eat() {
        System.out.println("小猫吃鱼");
    }
}

接口的知识点：

（1）接口中声明的静态方法只能被接口调用，不能被其他实现类进行调用

（2）接口中声明的默认方法可以被实现类继承，实现类在没有重写方法的情况下，默认调用接口中声明的方法，如果实现类重写方法，则调用的是自己重写的方法。

（3）类实现两个接口，而两个接口中定义了同名同参的默认方法。则实现类在没有重写此两个接口默认方法下会报错---------->接口冲突

那如何继承父类，并实现接口呢？子类的格式要如何写呢？

很简单，先继承后实现接口。

举个例子：

 class A extends SuperA implement B,C {
     //代码内容

} 
A相较于SuperA来讲是子类，A相较于B,C来讲叫做实现类。

总结一下：

①同类型之间使用继承，类与接口使用实现

②类与类之间，只允许单继承，使用extends关键字

③接口与接口之间：允许多继承，使用extends关键字

④类与接口之间：允许多实现。使用implements关键字