Java接口和抽象类

Xc_.xC

已于 2022-09-17 09:41:58 修改

阅读量135

点赞数

文章标签： java

于 2022-09-16 19:06:06 首次发布

本文链接：https://blog.csdn.net/qq_52215881/article/details/126892872

版权

抽象类：

1，什么是抽象类？

回忆以下什么是类：

类是概念上的，它的作用则是赋予对象特性，从而形成一个实体，即对象是一个真实的模型，所以综上所述：类是描述了一组有相同特性（属性）和相同行为（方法）的一组对象的集合。

类到对象是实例化，对象到类是抽象化。

而抽象类是：

类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类。

类本身是不存在的，所以是无法进行实例化的

2，抽象类怎么定义？

[修饰符列表] abstract class 类名{

类体；

}

抽象类需要注意的点：

1，抽象类属于什么类型？

抽象类是类的一种特殊形式，也是引用数据类型。

2，抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。

3，final和abstract不能联合使用，这两个关键字是对立的

4，抽象类的子类可以是抽象类（不需要把所有的抽象方法都）

5，抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的

6，抽象方法：

抽象方法表示没有实现的方法，没有方法体的方法。

例如：public abstract void doSome();

抽象方法的访问控制修饰符不能是private，同时也不能用final修饰。

注意：Java中没有方法体的方法不一定都是抽象方法，

7，如果一个类中有抽象方法，这个类必定是抽象类。

反之不一定，抽象类中可以有普通方法，但是不能有静态方法（可以有静态变量）。

8，子类（非抽象类）继承抽象类，必须要实现（重写）父类所有的抽象方法，实现的时候要注意访问控制权限的问题

定义抽象类代码示例：

public abstract class Person {
    private String name;//普通属性变量
    public int a=10;
    //构造方法
    public Person(){
        System.out.println("抽象父类的无参构造");
    }
    public Person(String name){
        System.out.println("抽象父类的有参构造");
    }
    //普通方法
    public String   getName(){
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    //抽象方法
    public abstract void getPerson();
}
class Student extends Person{

    @Override
    public void getPerson() {
        System.out.println("子类实现抽象父类的方法");
    }
}
class Test01{
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        String name = student.getName();
        System.out.println(name);
        System.out.println(student.a);
        student.getPerson();
    }
}
结果：抽象父类的无参构造
      张三
      10
      子类实现抽象父类的方法

为什么要使用抽象类？

1，降低接口实现类对接口实现过程难度，将接口中不需要使用抽象方法交给抽象类进行完成（实现），这样接口实现类只要对接口需要的方法进行重写

2，实现代码的复用（其实是继承机制的作用，主要作用还是 1）

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的。

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类将实物抽象类中的事物的共性的东西提取出来，抽象成一个高层的类。子类将其继承时，也就可以使用这个父类的属性和方法。也就实现了代码的复用。

子类中也可加上自己所特有的属性和方法。也就实现了多态。

1，的代码示例：

public interface MyAbstract {
    public abstract void doSome();
    public abstract void doOther();
}
abstract class A implements MyAbstract{
    @Override
    public void doSome() {
        System.out.println("");
    }
    public abstract void doOther();
}
class B extends A{
    @Override
    public void doOther() {

    }
}

接口：

1，什么是接口？

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过实现接口的方式，从而来继承接口的抽象方法。

接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

2.接口与类相似点：

一个接口可以有多个方法。

接口也是一种引用数据类型

接口文件保存在 .java 结尾的文件中，文件名使用接口名。

接口的字节码文件保存在 .class 结尾的文件中。

接口相应的字节码文件必须在与包名称相匹配的目录结构中。

3.接口与类的区别：

接口不能用于实例化对象。

接口没有构造方法。

接口中所有的方法必须是抽象方法，Java 8 之后接口中可以使用 default 关键字修饰的非抽象方法。

接口不能包含成员变量，除了 static 和 final 变量。

接口不是被类继承了，而是要被类实现。

接口支持多继承。

注意extends和implements可以共存，extends在前implements在后

4.接口特性

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错，现在不一定，有改动）。

接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。

接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

接口中的方法，不写修饰符就默认是public

注意：

注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

注：JDK 1.8 以后，接口允许包含具体实现的方法，该方法称为"默认方法"，默认方法使用 default 关键字修饰。更多内容可参考 Java 8 默认方法。

注：JDK 1.9 以后，允许将方法定义为 private，使得某些复用的代码不会把方法暴露出去。更多内容可参考 Java 9 私有接口方法。

5.接口的声明

接口的声明语法格式如下：

[修饰符列表] interface 接口名称 {
// 声明变量 接口不能包含成员变量，除了 static 和 final 变量。
// 抽象方法

}

关于声明接口修饰符列表：

1，接口的声明，修饰符的使用和类的声明是一致的，（当前，前提类是外部类，不是所谓的内部类），都只能使用public或者什么都不写，默认权限（这里的默认权限不是default，可以理解为friendly，但是java没有这个关键字，但权限上可以理解为default），无论是private还是protected都是不可以的。

2，这里对于接口声明的默认修饰符，可不是像接口中的方法那样，不写修饰符就默认是public了，接口的声明不写修饰符就是default权限，只能同包的类可以访问，其他包是不行的

代码示例：

interface MyAbstract {
    //静态变量
    static String name="张三";
    //常量
    final int b=10;
    //抽象方法
    public abstract void doSome();
    public abstract void doOther();
    //该方法称为"默认方法"
    default void xxx(){
        System.out.println("接口默认方法");
    }
}
class A implements MyAbstract{
    @Override
    public void doSome() {
        System.out.println("实现接口doSome()方法");
    }
    @Override
    public void doOther(){
        System.out.println("实现接口doOther()方法");
    }
}
class Test02{
    public static void main(String[] args) {
        A a = new A();
        System.out.println(a.name);
        System.out.println(a.b);
        a.xxx();
        a.doSome();
        a.doOther();
    }
}
结果：张三
      10
      接口默认方法
      实现接口doSome()方法
      实现接口doOther()方法

6.抽象类和接口的区别

抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。

抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。

接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。（有改动）

一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。

接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。

接口中的方法都是公有的。（有改动）

代码示例：

接口支持多继承。

注意extends和implements可以共存，extends在前implements在后

public interface  Food {

}
interface Fruits{

}
abstract class Things{

}
abstract class Water{

}

//正确形式
class Apple extends Things implements Fruits,Food{

}
//编译错误，需要extends在前implements在后
class Banana implements Fruits,Food extends Things {

}
//编译错误，接口是支持多实现的，类的继承是单继承的，但是可以多重继承（一个串一个）
class Watermelon  extends Things,Water implements Fruits,Food  {

}

为什么要使用接口？

Java接口的意义和作用有以下几点：

1、定义接口的重要性：在Java编程，abstract class 和interface是支持抽象类定义的两种机制。正是由于这两种机制的存在，才使得Java成为面向对象的编程语言。

2、定义接口有利于代码的规范：对于一个大型项目而言，架构师往往会对一些主要的接口来进行定义，或者清理一些没有必要的接口。这样做的目的一方面是为了给开发人员一个清晰的指示，告诉他们哪些业务需要实现;同时也能防止由于开发人员随意命名而导致的命名不清晰和代码混乱，影响开发效率。

3、有利于对代码进行维护：比如你要做一个画板程序，其中里面有一个面板类，主要负责绘画功能，然后你就这样定义了这个类。可是在不久将来，你突然发现现有的类已经不能够满足需要，然后你又要重新设计这个类，更糟糕是你可能要放弃这个类，那么其他地方可能有引用他，这样修改起来很麻烦。如果你一开始定义一个接口，把绘制功能放在接口里，然后定义类时实现这个接口，然后你只要用这个接口去引用实现它的类就行了，以后要换的话只不过是引用另一个类而已，这样就达到维护、拓展的方便性。

4、保证代码的安全和严密：一个好的程序一定符合高内聚低耦合的特征，那么实现低耦合，定义接口是一个很好的方法，能够让系统的功能较好地实现，而不涉及任何具体的实现细节。这样就比较安全、严密一些，这一思想一般在软件开发中较为常见

总结：

使用接口（面向接口编程）能在一定程度上解耦合

代码演示：

public class Test05{
    public static void main(String[] args) {
        //如果你想要实现Pig类飞翔
    //Flyable flyable=new Pig();
        //如果你想要实现Birds类飞翔
    Flyable flyable=new Birds();

    //这是不需要改变的（和继承优点像，但是接口只记录行为，跟符合要求）
    flyable.fly();
    }
}

//动物类:父类
class Animals {
}

//可飞翔的接口（是一对翅膀）
//能插拔的就是接口
//接口通常提取的是行为动作。
interface Flyable{
    void fly();
}

//猫类，如果你不想让他飞，就不实现接口
//没有实现接口表示没有翅膀，无法飞行
class Cat01 extends Animals{
}

//猪类，如果你想让他飞就实现接口
class Pig  extends Animals implements Flyable{
    @Override
    public void fly() {
        System.out.println("有一只会飞的猪");
    }
}

//鸟类，如果你想让他飞就实现接口
class Birds extends Animals implements Flyable{

    @Override
    public void fly() {
        System.out.println("我是一只自由飞翔的小鸟");
    }
}