java中抽象类和接口-CSDN博客

本文链接：https://blog.csdn.net/weixin_63141843/article/details/137669949

一.什么是抽象类

一.什么是抽象类

在面向对象的概念中，所有的类都是通过类描绘的，但并不是所有的类都用来描绘对象，如果一个类中没有包含足够的信息来描绘一个具体的对象，这个类就叫抽象类。

abstract class 类名{
     方法
    ......
}

简单来说就是被abstract修饰的类，就是抽象类。

当然有抽象类也有抽象方法，被abstract修饰的方法就是抽象方法。

举个例子：

abstract class Shape{
    abstract void drow1();//抽象类中的抽象方法
    public void drow2(){ //抽象类中的普通成员方法
        
    }
}

抽象方法中也可以包含普通方法，但是普通类中不可以包含抽象方法，否则编译器就会报错

总结成一句话就是：抽象类中的方法不一定是抽象方法，但含有抽象方法的类一定是抽象类，

同时抽象类是不能被实例化的

抽象类在多态中的意义及应用

抽象类存在的一个最大意义就是被继承，当被继承后就可以利用抽象类实现多态

具体怎么做，来看例子：

abstract class Shape{
    abstract void drow();//抽象类中的抽象方法
}

class Cycle extends Shape{
    //继承之后必须重写父类中的抽象方法
    @Override
    void drow(){
        System.out.println("画一个圆圈！");
    }

}
class Dog extends Shape{
    @Override
    void drow() {
        System.out.println("画一只狗！");
    }
}
class Cat extends Shape{
    @Override
    void drow() {
        System.out.println("画一只猫！");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Shape shape = new Cycle();//向上转型，父类引用指向子类对象
        Shape shape2 = new Dog();
        Shape shape3 = new Cat();
        shape.drow();//可以通过父类引用调用子类的重写方法
        shape2.drow();
        shape3.drow();

    }
}

在这里我们可以看到，我们调用的是同一个drow（）方法，但呈现出来的确是不同的效果

也就证实了上面所说的一句话，抽象类最大的意义就是被继承的。

不同的类来继承抽象类，通过重写抽象类中的抽象方法来实现不同的功能，这个就叫多态。

其实结合例子，多态是很好理解的，给大家总结一下要点：

1.抽象类和抽象方法都被abstract修饰，同时从抽象类不能被实例化

2.抽象类中不一定包含抽象方法，可能只有普通方法，但含有抽象方法的类一定是抽象类

3.当普通类继承抽象类时，在普通类中一定要重写抽象类中的抽象方法

4.抽象类存在的最大意义，就是为了被继承

5.抽象类中可以存在构造方法，在子类实例化的时候，帮助父类成员初始化

6.当一个抽象类A继承了抽象类B，此时抽象A不需要重写B中的抽象方法，但是当普通类C继承了A就需要重写所有抽象类中的抽象方法

二.接口

什么是接口？

接口就是公共行为的规范，大家在实现时，只要符合规范标准，就可以通用。

在java中，接口可以看成是：多个类的公共规范，是以一种引用数据类型。

接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字

就定义了一个接口。

public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}

接口不能直接使用，必须要有一个 " 实现类 " 来 " 实现 " 该接口，实现接口中的所有抽象方法。

public class 类名称 implements 接口名称{
// ...
}

注意：子类和父类之间是 extends 继承关系，类与接口之间是 implements 实现关系。

接口实现多态

我们通过一个简单的例子来理解，大家一看就懂了

interface IShape{
    int a = 10;
    void drow();
}
class Cycle implements IShape{
    @Override
    public void drow() {
        System.out.println("画一个圆圈！");
    }
}

class Dog implements IShape{
    @Override
    public void drow() {
        System.out.println("画一只狗！");
    }
}

class Cat implements IShape{
    @Override
    public void drow() {
        System.out.println("画一只猫！");
    }
}
public class Test {
    public static void main(String[] args) {
        Cycle cycle = new Cycle();
        Dog dog= new Dog();
        Cat cat = new Cat();
        //这里的IShape就相当于抽象类中的父类，写成一个引用类型的数组
        IShape[] shape = {cycle,dog,cat};
        for (int i = 0; i < shape.length; i++) {
            shape[i].drow();
        }


    }
}

其实抽象类和接口非常的相似。

interface IShape{
    int a = 10;//接口中的成员变量默认都是public static final
    public static final int b = 20;
    void drow();//接口中的方法默认都是abstract修饰的
    abstract void  drow2();
}

接口支持多继承

java当中类与类之间是不支持多继承的，但是一个类可以实现多个接口，间接解决了java中不能多继承的问题

class Animal{
    public String name;
    public Animal(String name){//父类的构造方法帮助父类成员初始化
        this.name = name;
    }
}

class Duck extends Animal implements IFly,IRuning,ISwim{
    //duck类继承Animal类同时实现了三个接口，解决了java中多继承的问题
    @Override
    //重写不同接口中的方法来实现不同的功能
    public void fly() {
        System.out.println(this.name + "正在天上飞！");
    }

    @Override
    public void Iswim() {
        System.out.println(this.name + "正在水上游泳！");

    }

    @Override
    public void run() {
        System.out.println(this.name + "正在地上跑！");
    }

    //子类构造方法，在实现子类对象时会先调用父类的构造方法
    //在给实现子类的构造方法前，先要用super()调用实现父类的构造方法，比较先有父后有子呀！
    //因为父类自己定义了构造方法，编译器不会自动给给子类构造方法中添加super();
    // 来实现父类的构造方法，需要我们自己实现
    public Duck(String name){
        super(name);
    }
}
interface IFly{//三个接口，对应三种不同的行为
    void fly();
}

interface ISwim{
    void Iswim();
}
interface IRuning{
    void run();
}


public class Test2 {
    public static void main(String[] args) {
        Duck duck = new Duck("丑小鸭");
        duck.fly();
        duck.run();
        duck.Iswim();

    }
}

总结：

1.接口是使用interface来定义的

2.接口中不能有具体的实现方法，但是有两种另外

静态方法可以有具体的实现（static）以及被default关键字修饰的方法

3.接口中默认的成员变量是 public static final 默认的成员方法是public abstract

4.类和接口之间用关键字implement来进行关联，当一个类实现这个接口后，要重写接口中的抽象方法

5.接口不能通过new关键字来实例化，当接口中存在default方法时，可以重写也可以不重写

6.接口中不能有构造方法和代码块

8.一个类不想实现接口当中的方法，可以被定义为抽象类

三.抽象类和接口的区别

Java中接口和抽象类的定义语法分别为interface与abstract关键字。

相同点：

在普通类实现接口和继承抽象类时，接口和抽象类当中的抽象方法，必须重写

不同点：

1.抽象类中的抽象方法的修饰符只能为public或者protected，默认为public；接口中的方法默认使用public修饰
2.接口成员变量默认为public static final，必须赋初值，不能被修改。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；
3.实现接口的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承。
4.接口强调特定功能的实现，而抽象类强调所属关系。
5.抽象类可以包含方法、构造方法，方法可以实现，但是构造方法不能用于实例化，主要用途是被子类调用