抽象类和接口

抽象类和接口

提示：本文主要讲述了Java中抽象类和接口的相关知识。

---

---

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、抽象类

什么是抽象类？

抽象类是指没有包含具体信息去描述一个类，这样的类叫做抽象类。
abstract + class + 类名

abstract class Shape{//此时Shape被abstract修饰，因此此时Shape是一个抽象类
     abstract void picture();
     public void func(){
         System.out.println("抽象类中也可以有非抽象类方法");//抽象类中既可以有抽象方法也可以有非抽像方法，但是抽象方法需要被abstract修饰
     }
}
class Cycle extends Shape{
//如果一个类继承了抽象类，那么该类一定要重写抽象类的方法
    @Override
    public void picture() {
        System.out.println("画圆形！！");
    }
}
class Rect extends Shape{
    @Override
    void picture() {
        System.out.println("画一个矩形！！");
    }
}
class Flower extends Shape{
    @Override
    void picture() {
        System.out.println("画一个花朵！！！");
    }
}
public class Test {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        Rect rect = new Rect();
        Flower flower = new Flower();
        Shape[] shapes = new Shape[]{cycle,rect,flower};//定义了一个Shape[]类型的数组，里面分别存放了他的三个子类对象，此时可以理解为向上转型。
        for (Shape x: shapes) {
            x.picture();
        }//for each循环遍历数组
        System.out.println("==========");
        for (int i = 0; i < shapes.length; i++) {
            shapes[i].picture();
        }for i循环遍历该数组
    }
}

输出结果：

多态：不同对象调用了同一个方法，产生了不同的行为叫做多态。

多态发生的三个要素

1.继承（三个子类继承了抽象类)
2.子类重写了父类的方法
3.通过父类的引用调用了子类和父类重写方法中子类的方法。

抽象类、普通类在多态中的意义

如果一个类继承普通类，编译器并不会要求重写类中方法，但是如果继承自抽象类，就必须重写抽象类中的抽象方法，否则编译器会报错。这样的行为也有便于我们的开发进行。

总结

1.抽象类用abstract关键字修饰
2.抽象类不能实例化对象
3.抽象类中可以有抽象方法或者非抽象方法
4.抽象方法被abstract修饰 权限可以写作public和protected，默认为public，抽象不需要具体的实现
例如: abstract + (public) + void + 方法名（）;
如果一个方法是抽象类方法，那么方法所在的类一定是抽象类。
5.由于抽象类存在的最大意义就是为了被继承,且抽象方法并没有具体的实现，所以子类一定会重写该方法，因此抽象方法不可以被static、final、private修饰。
6.如果一个子类A继承了抽象类，但是并没有重写抽象类方法，那么该子类A需要被abstract修饰

二、接口

什么是接口

接口是某种抽象功能行为的实现，用 interface 定义接口通常在接口名开头大写字母I 例如：interface IUsb
接口当中的方法也不需要具体的实现

public abstract void + 方法 （）；其中方法默认为public abstract

---

接口实现多态

利用接口同样可以实现多态，以刚才画图形的代码举例

interface IShape{
    void draw();
}
class Cycle implements IShape{
//一个类实现接口需要用到关键字implements
//一个类只能继承extends一个父类，但是可以实现多个接口
    @Override
    public void draw() {
        System.out.println("画一个圆形");
    }
}
class Flower implements IShape{
    @Override
    public void draw() {
        System.out.println("画一个花朵");
    }
}
class Rect implements IShape{
    @Override
    public void draw() {
        System.out.println("画一个矩形！");
    }
}
public class Test {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        Rect rect = new Rect();
        IShape[] iShapes = new IShape[]{cycle,flower,rect};
        for (IShape x: iShapes) {
            x.draw();
        }
    }
}

接口出现的好处就是可以让程序员忘记类本身的类型，只要这个类具有该接口的特性，就可以实现该接口在类上的具体行为

二级

interface IRun{
    void run();
}
interface ISwim{
    void swim();
}
interface IFly{
    void fly();
}
//定义了三个接口，分别代表跑、游泳、飞。
class Animal{
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
//狗本身既可以跑也可以游泳
class Dog extends Animal implements IRun,ISwim{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void run() {
        System.out.println("姓名为:" + name + "年龄为：" + age + "正在用两条狗腿跑！");
    }

    @Override
    public void swim() {
        System.out.println("姓名为:" + name + "年龄为：" + age + "正在用狗刨式游泳！");
    }
}
//鸭子可以跑、游泳、也可以飞。
class Duck extends Animal implements IRun,ISwim,IFly{
    public Duck(String name, int age) {
        super(name, age);//先帮助父类构造
    }

    @Override
    public void run() {
        System.out.println("姓名为:" + name + "年龄为：" + age + "正在用两个鸭腿跑步！");
    }

    @Override
    public void swim() {
        System.out.println("姓名为:" + name + "年龄为：" + age + "正在用两个翅膀游泳！");
    }

    @Override
    public void fly() {
        System.out.println("姓名为:" + name + "年龄为：" + age + "正在用两个翅膀飞！");
    }
}
//以上两种都属于动物类，因此都继承了Animal
//但是Root不属于动物，但是它具有跑步的能力
//因此就看出接口的作用了，不在意类型，只有该类具有接口的抽象行为，该类就可以实现该接口
class Root  implements IRun{
    public String name;
    public int age;

    public Root(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void run() {
        System.out.println("姓名为:" + name + "年龄为：" + age + "正在用两个机器腿跑！");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog("小灰灰",18);
        Duck duck = new Duck("元宝",5);
        Root root = new Root("阿尔法狗",2);
        dog.run();
        dog.swim();
        System.out.println("========");
        duck.run();
        duck.fly();
        duck.swim();
        System.out.println("=========");
        root.run();
    }
}

输出结果

姓名为:小灰灰年龄为：18正在用两条狗腿跑！
姓名为:小灰灰年龄为：18正在用狗刨式游泳！
========
姓名为:元宝年龄为：5正在用两个鸭腿跑步！
姓名为:元宝年龄为：5正在用两个翅膀飞！
姓名为:元宝年龄为：5正在用两个翅膀游泳！
=========
姓名为:阿尔法狗年龄为：2正在用两个机器腿跑！

三、抽象类和接口的区别

相同点

1.接口和抽象类都不可以实例化对象
2.接口中的方法和抽象类中的方法都没有具体的实现，只有子类实现了接口或者继承了抽象类并且重写了方法才可以具体实现该方法

不同点

1.抽象类用关键字abstract定义 语法规则为：abstract + class + 类名；接口用关键字interface定义 语法规则为：interface + 接口名。通常情况下默认接口名开头第一个字母为大写的I
2.抽象类中可以有成员变量，非抽象方法和抽象方法，接口中可以有成员变量和没有具体实现的方法
3.抽象类中成员变量默认为default，抽象方法默认为 abstract void +方法名；接口中成员变量默认为public static final； 接口中方法默认为（abstract public） + void +方法名（);
4.一个类用extends继承抽象类，且只能继承一个类，implements实现接口，一个类可以实现多个接口
5.接口强调特定功能的实现，抽象类强调所属关系。