关于接口:java基础-java接口和抽象类的异同分析

8次阅读

共计 3359 个字符，预计需要花费 9 分钟才能阅读完成。

在 java 中，通常初学者搞不懂接口与抽象类，这也是面试比拟容易问到的一个问题。上面我来谈谈本人的了解。如有不妥之处，还望批评指正，不胜感激。

[TOC]

咱们定义一个抽象类 person.class 示意类（人）:

// 应用关键字 abstract
public abstract class person {
    // 吃货色的形象办法, 曾经有所实现
    public void eat(){System.out.println("我是形象办法吃货色");
    }
    
    //public 润饰的空实现的办法
    public void run(){}
    
    // 无润饰，空实现
    void walk(){}
    
    //protected 润饰的办法，空实现
    protected void sleep(){}
    
    //private 润饰的空实现办法
    private void read(){}
}

1. 抽象类应用 abstract 润饰，能够有形象办法，也能够齐全没有形象办法，也能够是实现了的办法，然而所有的办法必须实现，空实现 (public void walk(){}) 也是实现的一种，而不能写 ~~public void eat()~~, 前面必须带大括号。
2. 办法修饰符能够使 public,protected,private，或者是没有，没有默认为只能在同一个包上面继承, 如果是private 那么子类继承的时候就无奈继承这个办法，也没有方法进行批改.
上面咱们来写一个 Teacher.class 继承抽象类

同一个包下继承：

不同的包上面继承：

同个包下正确的代码如下(不重写公有的办法)：

public class teacher extends person {
    @Override
    public void run(){System.out.println("我是实体类的办法跑步");
    }
    @Override
    void walk(){System.out.println("我是实体类的办法走路");
    }
    @Override
    protected void sleep(){System.out.println("我是实体类的办法睡觉");
    }
}

后果如下 ( 没有笼罩抽象类吃货色的办法，所以会调用抽象类默认的):

上面代码是重写了 eat() 办法的代码，重写是即便没有应用 @Override 也是起作用的：

public class teacher extends person {public void eat(){System.out.println("我是实体类的办法吃货色");
    }
    @Override
    public void run(){System.out.println("我是实体类的办法跑步");
    }
    @Override
    void walk(){System.out.println("我是实体类的办法走路");
    }
    @Override
    protected void sleep(){System.out.println("我是实体类的办法睡觉");
    }
}

后果如下，吃货色的办法被笼罩掉了：

抽象类不能被实例化，比方：

子类能够实现抽象类的办法，也能够不实现，也能够只实现一部分，这样跑起来都是没有问题的，不实现的话，调用是默认应用抽象类的空实现，也就是什么都没有输入，要是抽象类有实现，那么会输入抽象类默认办法。

比方：

抽象类中能够有具体的办法以及属性（成员变量）
抽象类和一般类之间有很多雷同的中央，比方他们都能够都动态成员与动态代码块等等。

接口就是对办法或者动作的形象，比方 person.class 想要成为老师，能够实现老师的接口，能够了解为减少能力。

接口不容许定义没有初始化的属性变量，能够定义 public static final int i=5;, 以及public int number =0;, 但不容许public int num; 这样定义，所有 private 的变量都不容许呈现，上面是图片

定义 public int number =0; 默认是 final 润饰的，所以也不能扭转它的值:

上面是正确的接口代码：Teacher.java

public interface Teacher {
    public static final int i=5;
    public int number =0;
    public void teach();
    void study();}

实现类 TeacherClass.java

public class TeacherClass implements Teacher{
    @Override
    public void teach() {System.out.println("我是一名老师，我要教书");
        System.out.println("接口的 static int 是："+i);
    }

    @Override
    public void study() {System.out.println("我是一名老师，我也要学习");
        System.out.println("接口的 int number 是："+number);
    }
}

测试类 Test.java

public class Test {public static void main(String[] args){TeacherClass teacherClass = new TeacherClass();
        teacherClass.study();
        teacherClass.teach();
        System.out.println("-----------------------------------------------------");
        Teacher teacher =teacherClass;
        teacher.study();
        teacher.teach();}
}

后果：

剖析：接口外面所定义的成员变量都是 final 的，不可变的，实现接口必须实现接口外面所有的办法，不能只实现一部分，没有应用 static final 润饰的，默认也是final，同时必须有初始化的值，接口不能间接创建对象，比方~~Teacher teacher = new Teacher()~~，然而能够先创立一个接口的实现类，而后再赋值于接口对象。

抽象类	接口
应用关键字 `abstract` 润饰	应用关键字`interface`
应用关键字 `extends` 实现继承，能够只实现一部分办法，一部分不实现，或者不实现也能够	`implements`来实现接口，实现接口必须实现外面都有的办法
抽象类外面的办法能够是空实现，能够默认实现，然而必须要带{}	接口外面的办法都没有实现体，也就是{}
抽象类中能够有具体的办法以及属性，也能够有动态代码块，动态成员变量	接口外面不能有一般成员变量，必须都是不可变的 `final` 成员变量，而且所有的成员变量都必须是`public`
抽象类外面的办法能够是 `public`,`protect`,`private`, 然而`private` 无奈继承，所以很少人会这么写，如果没有修饰符，那么只能是同一个包上面的类能力继承	接口的办法只能是 `public` 或者无修饰符，所有的 `private` 润饰都是会报错的
如果有改变，增加新的办法，能够间接在抽象类中实现默认的即可，也能够在实现类中实现	接口减少新办法必须在接口中申明，而后在实现类中进行实现
抽象类不能间接创建对象	接口也不能间接创建对象，能够赋予实现类的对象
抽象类能够有 `main` 办法，而且咱们能够间接运行，抽象类也能够有结构器	接口不能有 `main` 办法，接口不能有结构器

那么咱们什么时候应用接口什么时候应用抽象类呢？

java 有一个毛病，只能实现单继承，集体感觉接口是为了补救单继承而设计的。

接口是对实质的形象，比方人，能够设计为 person.class 这个抽象类，提供相干的办法，属性，然而接口是只提供办法的，也就是像减少性能的，那么也就是对办法的形象。

如果须要默认实现，或者基本功能一直扭转，那么倡议应用抽象类，如果只是减少一种办法，那么倡议应用接口，如果想实现多重继承，只能是接口与抽象类一起应用以达到想要实现的性能。

本文章是初学时的记录，仅是高级的比照，深刻学习还需各位放弃 Keep going~

此文章仅代表本人（本菜鸟）学习积攒记录，或者学习笔记，如有侵权，请分割作者删除。人无完人，文章也一样，文笔稚嫩，在下不才，勿喷，如果有谬误之处，还望指出，感激不尽~

技术之路不在一时，山高水长，纵使迟缓，驰而不息。Keep going~

公众号：秦怀杂货店

正文完