Java中抽象类与接口（结合例子）

     最近回顾了一下有关抽象类与接口部分的知识，所以对这块儿的知识做了一下小小的总结，此文从两者的定义，使用原则和使用限制作以总结。

1.抽象类的定义：

    抽象类只是在普通类的基础上扩充了一些抽象方法而已，而抽象方法指的是只进行了声明，而没有实现的方法（即就是没有方法体）。抽象类和抽象方法使用关键字 abstract 来定义。

举个栗子：

abstract class A{
    public A(){
        this.print();
    }
    
     //定义抽象方法
    public abstract  void print();
}

2.抽象类的使用规则：

（1）所有的抽象类必须有子类（因此abstract与final不能同时使用）；

（2）抽象类的子类必须覆写抽象类的所有抽象方法,[此处在覆写的时候要考虑权限问题，权限尽量都是用public]（abstract与private不能同时使用）

（3）抽象类的对象可以通过多态性，利用子类对其进行实例化，而不能直接产生实例化对象

（4）子类不能通过super关键字调用父类的抽象方法

举个栗子：

abstract  class Person2{
    private String name;
    public String getName(){
      return this.name;

    }
    public void setName(String name){
        this.name=name;

    }


    public abstract  void getPersonInfo();
}

class Student2 extends Person2{

    public void getPersonInfo(){
        System.out.println("I am a student");
    }
}



public class TestAbstract {
    public static void main(String[] args) {
        Person2 per =new Student2();
        per.getPersonInfo();//被调用的是覆写后的方法
    }

截图：

3.抽象类的相关规定：

（1）抽象类也允许提供构造方法，并且子类也照样遵循对象实例化流程，先调用父类的构造方法，然后调用子类构造方法；

（2）abstract 与 final不能一起使用【因为抽象类必须有子类，而final在java中被称为终结器，被final修饰的类不能有子类，所以abstract与final不能同时使用】；

（3）abstract 与 private 不能使用；

（4）抽象类允许不定义任何的抽象方法，但是此时抽象类还是无法直接创建实例化对象

4.接口的定义：

    接口就是抽象方法与全局常量的集合，在Java中使用关键字 interface 来定义接口

5.接口的使用规则：

（1）子类如果想要使用接口，那么就必须使用implements关键字来实现接口；

（2）打破了Java中单继承的局限性，接口是多实现；

（3）对于接口的子类（不是抽象类）必须覆写接口中的全部抽象方法，之后可以利用子类的向上转型通过实例化子类来得到接口的实例化对象；

    举个栗子：

interface IMessage{
    public static final String MsG="I am a biter";
    public abstract void print();
}

interface  INews{
    public abstract String getNews();
}

class MessageImpl implements IMessage,INews{
    public String getNews() {
        return IMessage.MsG;
    }

    public void print() {
        System.out.println(IMessage.MsG);
    }
}


public class TestInterface {
    public static void main(String[] args) {
    IMessage msg=new MessageImpl();
    msg.print();

    INews news=(INews)msg;
        System.out.println(news.getNews());
    }
}

（4）接口中只允许使用public权限，不管是属性还是方法，其权限都是public；

（5）当一个子类既需要实现接口，又需要继承抽象类时，应先使用 关键字 extends 继承一个抽象类，然后使用关键字 implements 实现多个接口

     举个栗子：

interface IMessage{
    public void print();
}

abstract class News{
    public abstract void getNews();
}

class Message extends News implements IMessage{
    public void print() {
        System.out.println("I am bitter");
    }

    @Override
    public void getNews() {
        System.out.println("I am News");
    }
}


public class TestInterface{
    public static void main(String[] args) {
        IMessage m=new Message();
        m.print();

        News n=new Message();
        n.getNews();

    }
}

运行结果：

有这个栗子可以得出：抽象类和接口实例化对象的时候是通过其子类向上转型实例化对象的，不能直接实例化对象。

（6）抽象类是可以通过implements关键字实现接口的，但是接口不可以通过extends关键字继承抽象类的；

     举个栗子：

package com.basic.oop_conclusion;

interface  Person {
    public  void print();
}

abstract class Student implements Person{
   private String name="张三";
   private int age=10;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public abstract  void getInfo();
}

class Pupil extends Student{
    public void print(){
        System.out.println("这是一个小学生的信息");
    }

    public void getInfo(){
        System.out.println(super.getName()+":"+super.getAge());
    }
}

public class RelationShip {
    public static void main(String[] args) {
        Student stu=new Pupil();
        stu.getInfo();

    }
}

运行结果：

（7）接口不能通过extends关键字继承抽象类，但是可以通过extends关键字来继承多个接口；

    举个栗子：

package com.basic.oop_conclusion;

interface Computer{
    public void printComputer();

}

interface  OperationSystem{
    public void printOS();
}

interface buyComputer extends Computer,OperationSystem{
    @Override
    void printComputer();

    @Override
    void printOS();
}

class MyComputer implements buyComputer{
    @Override
    public void printComputer() {
        System.out.println("我的电脑是DELL");
    }

    @Override
    public void printOS() {
        System.out.println("我的电脑的操作系统是Windows 10");

    }

    public void print(){
        this.printComputer();
        this.printOS();
    }
}
public class Mian1 {
    public static void main(String[] args) {
        MyComputer mc=new MyComputer();
        mc.print();
    }
}

运行结果：

5.抽象类与接口的区别

综上所述：

可以总结接口与抽象类的区别表现在一下几个方面：

（1）定义：抽象类是在普通类的基础上增加类抽象方法；

                    接口则是由抽象方法和全局常量构成；

（2）关键字：抽象类使用abstract关键字定义，接口则是由关键字 interface 定义；

                       子类使用关键字 extends继承抽象类，使用关键字 implements 实现接口；

（3）权限：抽象类可以使用各种权限，接口只能使用public；

（4）子类限制：一个子类只能继承一个抽象类，但是可以实现多个接口【抽象类是单继承，接口是多实现】；

（5）两者的关系：一个抽象类可以实现多个接口，但是接口不能继承抽象类；

 

此文仅是本人自己的理解，如有错误和不足之处，欢迎提出批评和建议！