抽象类与接口

---

前言

提示：这里可以添加本文要记录的大概内容：
例如：1、掌握抽象类的定义与使用并理解抽象类的组成特点。
2、掌握包装类的特点，并且可以利用包装类实现字符串与基本数据类型的转换处理
3、掌握接口的定义与使用，理解接口设计的目的。
4、理解泛型的作用以及相关定义语法。

---

提示：以下是本篇文章正文内容

一、抽象类

抽象类与普通类相比唯一增加的就是抽象方法的定义，同时抽象类在使用时要求必须被子类所继承，并且子类必须覆写全部抽象方法

抽象类的基本定义

抽象类需要使用abstract class 进行定义，并且在一个抽象类中也可以利用abstract 关键字定义若干个抽象方法。
范例：定义抽象类

package abstract1;

abstract class Message {      //定义抽象类
    private String type;       //消息类型
    public abstract String getInfo();   //抽象方法
    public void setType(String type){   //普通方法   
        this.type = type;
    }
    public String getType(){        //普通方法
        return this.type;
    }
}

抽象类并不是一个完整的类
1、抽象类必须提供子类，子类使用extends继承一个抽象类
2、抽象类的子类(不是抽象类)一定要写覆盖抽象类的全部方法
3、抽象类的实例化可以利用对象多态性通过子类向上转型的方式完成

范例：使用抽象类

package abstract1;

abstract class Message1 {      //定义抽象类
    private String type;       //消息类型
    public abstract String getInfo();   //抽象方法
    public void setType(String type){   //普通方法
        this.type = type;
    }
    public String getType(){        //普通方法
        return this.type;
    }
}
class DmeanMessage extends Message1{

    @Override
    public String getInfo() {  //方法覆写，定义方法体
        return super.getType();
    }
}
public class Message{
    public static void main(String[] args) {
        Message1 message1 = new DmeanMessage();   //对象实例化
        message1.setType("Java");       //调用父类继承方法
        System.out.println(message1.getInfo());//调用被覆写的方法
    }
}
程序输出结果：
Java

模板设计模式

1、机器人类：补充能量(eat) + 工作(work)
2、人类： 吃饭（eat）+睡觉(sleep)+工作(work)
3、狗类： 吃饭（eat）+睡觉(sleep)

package monam;

abstract class Action {     //定义公共类
    public static final int EAT = 1;      //定义操作命令
    public static final int SLEEP = 5;   //定义操作命令
    public static final int work = 10;  //定义操作命令
    public void commend(int code){  //执行命令
        switch (code){
            case EAT:
                this.eat() ;        //执行命令方法
                break;
            case SLEEP:
                this.sleep();       //执行命令方法
                break;
            case work:
                this.work();        //执行命令方法
                break;
            case EAT+work+SLEEP:   //组合命令
                this.eat();       //执行命令方法
                this.sleep();
                this.work();
                break;
        }
    }
    public abstract void eat();       //定义抽象方法
    public abstract void sleep();     //定义抽象方法
    public abstract void work();      //定义抽象方法
}

package monam;

class Robot extends Action{   //定义机器人类

    @Override
    public void eat() {   //方法覆写
        System.out.println("需要插电源");
    }

    @Override
    public void sleep() {}

    @Override
    public void work() {     //方法覆写
        System.out.println("输入指定程序工作");
    }
}

package monam;

class Person extends Action{       //定义人类
    @Override
    public void eat() {   //方法覆写
        System.out.println("该吃饭吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("困了就睡觉");
    }

    @Override
    public void work() {
        System.out.println("找工作");
    }
}

package monam;

class dog extends Action{      //定义狗类
    @Override
    public void eat() {    //方法覆写
        System.out.println("吃饭碗的食物");
    }

    @Override
    public void sleep() {
        System.out.println("困了就睡觉");
    }

    @Override
    public void work() {

    }
}

package monam;

public class JavaDemo {
    public static void main(String[] args) {
        Action action = new Robot();         //实例化对象
        Action action1 = new Person();
        Action action2 = new dog();
        System.out.println("------机器人行为------");
        action.commend(Action.EAT);
        action.commend(Action.work);
        System.out.println("------人类的行为------");
        action1.commend(Action.work+Action.EAT+Action.SLEEP);
        System.out.println("------狗的行为------");
        action2.sleep();
        action2.eat();
    }
}
输出返回结果：
------机器人行为------
需要插电源
输入指定程序工作
------人类的行为------
该吃饭吃饭
困了就睡觉
找工作
------狗的行为------
困了就睡觉
吃饭碗的食物

二、接口

在Java中接口属于一种特殊的类，需要用interface关键字进行定义，在接口中可以定义全局常量、抽象方法(必须是public访问权限)、default方法以及static方法
范例：定义标准接口

interface iinterface {   //定义接口
    public static final String INFO = "Java";    //定义全局常量
    public abstract String getInfo();    //抽象方法
}

使用原则如下：
1、接口需要被子类实现，子类利用implement可以定义多个父接口。
2、子类如果不是抽象类，一定要覆写接口中的抽象方法。
3、接口对象可以利用子类对象向上转型进行实例化。

提示：关于extends、implement关键字的顺序

子类可以继承父类也可以实现父接口，基本语法：
class 子类 [extends  父类]  [implement 接口1、接口2、接口3、……] {}
如果混合要采用先继承在实现的顺序完成

范例：使用接口

public class JavaDEmo {
    public static void main(String[] args) {
        MEssage mEssage =new MEssage();   //实例化对象
        System.out.println(mEssage.getInfo());
    }
}
interface IMessage{
    public static final String INFO = "Java";   //定义全局常量
    public abstract String getInfo();     //抽象方法
}
class MEssage implements IMessage{

    @Override
    public String getInfo() {   //覆写抽象方法
        return "我是好人";
    }
}
程序输出结果：
我是好人

范例：子类实现多个父接口

public class JavaDEmo {
    public static void main(String[] args) {
        MEssage mEssage =new MEssage();   //实例化对象
        System.out.println(mEssage.getInfo());
    }
}
interface IMessage{
    public static final String INFO = "Java";   //定义全局常量
    public abstract String getInfo();     //抽象方法
}
interface ICanner{
    public abstract String conner();
}
class MEssage implements IMessage,ICanner{ //实现多个接口

    @Override
    public String getInfo() {   //覆写抽象方法
        return "我是好人";
    }

    @Override
    public String conner() {
        return "age="+19;
    }
}
程序输出结果：
我是好人

范例：接口强制转换

public class JavaDEmo {
    public static void main(String[] args) {
        MEssage mEssage =new MEssage();   //实例化对象
        Object obj = mEssage;       //使用Object接受引用类型
        ICanner iCanner = (MEssage)obj;     //对象强制为换位ICanner接口实例  
        System.out.println(iCanner.conner());
    }
}
程序输出结果：
age=19

---

提示：关于接口的简化定义

完整定义：interface iinterface {   //定义接口
		    	public static final String INFO = "Java";    //定义全局常量
			    public abstract String getInfo();    //抽象方法
		  }
简化定义：
			interface iinterface {   //定义接口
				String INFO = "Java";    //定义全局常量
				String getInfo();    //抽象方法
		 }

在面向对象中，抽象类也是必不可少的一种结构。可以先继承后接口的形式
范例：子类继承抽象类同时实现接口

public class JavaDEmo {
    public static void main(String[] args) {
        MEssage mEssage =new MEssage();   //实例化对象
        System.out.println(mEssage.getInfo());
    }
}
interface IMessage{
    public static final String INFO = "Java";   //定义全局常量
    public abstract String getInfo();     //抽象方法
}
interface ICanner{
    public abstract boolean conner();
}
abstract class Data{
    public abstract boolean getData();
}
class MEssage extends Data implements IMessage,ICanner{ //实现多个接口

    @Override
    public String getInfo() {   //覆写抽象方法
        if (this.conner()){
            if (this.getData()){
                return "Jaba";
            }else {
                return "无法访问";
            }
        }
        return IMessage.INFO;//获取消息
    }

    @Override
    public boolean conner() {
        return true;
    }

    @Override
    public boolean getData() {
        return false;
    }
}
程序输出结果：
无法访问

Java中的extends关键字除了具有类继承的作用外，也可以在接口上使用以实现接口的继承关系，并可以同时实现多个父接口。
范例：使用extends继承多个父接口

public class JavaDEmo1 {
    public static void main(String[] args) {
        Message message = new Message();    //子类实例化父类接口
        System.out.println(message.connet());
    }
}
interface IMessage1{
    String INFO = "Java";   //全局常量
    String getInfo();    //抽象方法
}
interface ICooner{     
    public Boolean connet();  //抽象方法
}
interface Iser extends IMessage1,ICooner{    //接口多继承
    public String servic();   //抽象方法
}
class Message implements Iser{   //三个接口的子类

    @Override
    public String getInfo() {   //方法覆写
        return IMessage1.INFO;
    }

    @Override
    public Boolean connet() {  //方法覆写
        return true;
    }

    @Override
    public String servic() {   //方法覆写
        return "Java第一";
    }
}
程序输出结果：
true

抽象类与接口的区别

区别	抽象类	接口
关键字	abstract class	interface
组成	常、变量、抽象、普通、构造方法	全局常量、抽象、普通、静态方法
权限	可以使用各种权限	只能是public
关系	一个抽象类可以实现多个接口	接口不能够继承抽象类、却可以实现多接口
使用	子类使用extends继承抽象类	子类使用implements实现接口
设计模式	模板设计模式	工厂设计模式、代理设计模式
局限	一个子类只能够继承一个抽象类	一个子类可以实现多个接口

总结

1、Java可以创建抽象类，专门用来当作父类。抽象类的作用相当于"模板"，目的是依据其格式来修改并创建新的类。
2、抽象类的方法分为两种：一种是普通方法、一种是以abstract关键字开头的抽象方法，抽象方法没有方法体。
3、抽象类不能直接通过new实例化对象，必须通过子类对象的向上转型进行实例化操作。
4、接口是方法和全局变量的集合，接口必须被子类实现，一个接口可以使用extends同时继承多个接口，一个子类通过implments关键字实现多个接口。