java学习——抽象类与接口的应用

抽象类与接口的区别

抽象类应用——模板设计模式
接口的实际应用——标准
接口的应用——工厂设计模式（Factory）
接口的应用——代理设计模式（Proxy）

NO.	#####区别 ######	抽象类	接口
1	关键字	abstract class	interface
2	组成	构造方法、普通方法、抽象方法、static方法、常量、变量	抽象方法、全局变量
3	子类使用	class子类 extends 抽象类	class 子类 implements 接口,接口,…
4	权限	可以使用各种权限	只能使用public权限
5	关系	抽象类可以实现多个接口	接口不能继承抽象类，却可以继承多个父接口
6	限制	但继承局限	没有但继承局限
7	子类	抽象类和接口都必须有子类，子类必须要重写全部的抽象方法	抽象类和接口都必须有子类，子类必须要重写全部的抽象方法
8	实例化对象	依靠子类对象的向上转型进行对象的实例化	依靠子类对象的向上转型进行对象的实例化

抽象类应用——模板设计模式

package test;

public class testAbstract {
    public static void main(String[] args) {
        fun(new Robot());  //传递机器人行为子类
        fun(new Person()); //传递人类行为子类
        fun(new Pig());  //传递猪行为子类
    }
    public static void fun(Action act){
        act.command(Action.EAT);
        act.command(Action.SLEEP);
        act.command(Action.WORK);
    }
}
abstract class Action{  //定义一个抽象的行为类，行为不是具体的
    public static final int EAT = 1;
    public static final int SLEEP = 2;
    public static final int WORK = 4;

    public void command(int flag){
        switch (flag){
            case EAT:this.eat();break;
            case SLEEP:this.sleep();break;
            case WORK:this.work();break;
        }
    }
    //定义三个抽象方法
    public abstract void eat();
    public abstract void sleep();
    public abstract void work();
}
class Robot extends Action{
//重写父类的抽象方法
    @Override
    public void eat() {
        System.out.println("机器人靠充电补充能量");
    }

    @Override
    public void sleep() {

    }

    @Override
    public void work() {
        System.out.println("机器人可以不停的工作");
    }
}
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("人类需要工作");
    }
}
class Pig extends Action{

    @Override
    public void eat() {
        System.out.println("猪只知道吃");
    }

    @Override
    public void sleep() {
        System.out.println("猪吃完就睡");
    }

    @Override
    public void work() {

    }
}

接口的实际应用——标准

package test;
//接口的实际应用----标准
public class testInterface {
    public static void main(String[] args) {
        Computer computer = new Computer();//实例化电脑对象
        computer.plugin(new flash()); //插入USB接口设备
        computer.plugin(new print()); //插入USB接口设备
    }
}
//定义USB标准
interface USB{
    public void start();//USB开始工作
    public void stop();//USB停止工作
}
//定义计算机类
class Computer{
    public void plugin(USB usb){  //插入USB接口设备（子类对象）
        usb.start();
        usb.stop();
    }
}
//定义U盘子类
class flash implements USB{

    @Override
    public void start() {
        System.out.println("U盘开始使用");
    }

    @Override
    public void stop() {
        System.out.println("U盘停止使用");
    }
}

//定义打印机
class print implements USB{

    @Override
    public void start() {
        System.out.println("打印机开始工作");
    }

    @Override
    public void stop() {
        System.out.println("打印机停止工作");
    }
}

接口的应用——工厂设计模式（Factory）

package test;
//工厂设计模式
public class testFactory {
    public static void main(String[] args) {
        fruit f = Factory.getInstance("Apple");
        f.eat();
        f = Factory.getInstance("Orange");
        f.eat();
    }
}
//定义工厂类，此类不再产生新的属性
class Factory{
    /**
     * 取得指定类型的接口对象
     * @param className 要取得的类实例化对象标记
     * @return 如果指定标记存在，则返回fruit接口的实例化对象，否则返回null
     */
    public static fruit getInstance(String className){
        if ("Apple".equals(className)){  //是否为苹果类
            return new Apple();
        }else if ("Orange".equals(className)){  //是否为橘子类
            return new Orange();
        }else {
            return null;
        }
    }
}
interface fruit{
    public abstract void eat(); //定义抽象方法
}
class Apple implements fruit{  //定义接口子类

    @Override
    public void eat() {   //重写抽象方法
        System.out.println("jack正在吃苹果");
    }
}
class Orange implements fruit{

    @Override
    public void eat() {
        System.out.println("tom正在吃橘子");
    }
}

接口的应用——代理设计模式（Proxy）

package test;
//接口的应用----代理
public class testProxy {
    public static void main(String[] args) {
        network net = null;  //定义接口对象
        net = new Proxy(new Real()); //实例化代理，同时传入代理的真实操作
        net.browser();  //客户只关心上网浏览这一个功能
    }
}
//定义network接口
interface network{
    public void browser(); //定义浏览的抽象方法
}
class Real implements network{  //真实的上网操作
    @Override
    public void browser() {  //重写抽象方法
        System.out.println("我正在网上浏览信息");
    }
}
class Proxy implements network{  //代理上网
    private network net;
    public Proxy(network net){  //设置代理的真实操作
        this.net = net;  //设置代理的子类
    }
    public void check(){   //检查用的是哪个运营商代理
        System.out.println("我正在使用移动的数据网");
    }
    @Override
    public void browser() {
        this.check();
        this.net.browser();
    }
}