（四）抽象类和接口（实例）

转载https://blog.csdn.net/chajinglong/article/details/78855420

1. 通过对象多态性可以发现，子类发生了向上转型关系之后，所调用的全部方法，都是被覆写过的方法。

abstract class A {
    public abstract  void print();
};
class B extends A{
    @Override
    public  void  print(){
        System.out.println("Hello Abstract");
    }
};
public  class AbstractCaseDemo01{
    public static void main(String[] args) {
        A a = new B();
        a.print();
    }
}

结果：

Hello Abstract

接口实例化；

public interface Aa{
    void pirnt();
};

class Bb implements  Aa{
    @Override
    public void pirnt() {
        System.out.println("Hello interface");
    }
};
class InterfaceCaseDemo01 {
    public static void main(String[] args) {
        Aa a = new Bb();
        a.pirnt();
    }
}

结果：

Hello interface

2. 抽象类的实际使用场景–设计模式（模板设计）

abstract class Animal {
    public String name;
    public int age;
    public  Animal (String name,int age){
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
    public void call(){
        System.out.println(this.getContent()) ;    // 输出内容
    }

    public abstract String getContent();
};

class Cat extends  Animal{
    public String call;
    public Cat(String name,int age ,String call){
        super(name,age);
        this.call = call;
    }
    @Override
    public String getContent(){
        return  "姓名："+getName()+", 年龄:"+getAge()+", " +
                "叫声："+this.call;
    }
};

class Dog extends  Animal{
    public String call;
    public Dog(String name,int age ,String call){
        super(name,age);
        this.call = call;
    }
    @Override
    public String getContent(){
        return  "姓名:"+getName()+", 年龄:"+getAge()+", 叫声："+this.call;
    }
};

class AbstractCaseDemo02{
    public static void main(String[] args) {
        //声明Animal对象
        Animal A1 = null;
        Animal A2 = null;
        A1 = new Cat("猫",2,"喵喵");
        A2 = new Dog("狗",3,"汪汪");
        A1.call();
        A2.call();
    }
}

结果：

姓名：猫, 年龄:2, 叫声：喵喵
姓名:狗, 年龄:3, 叫声：汪汪

3. 接口的实际应用–制定标准

 interface Usb {
   void start();
   void stop();
}
class Computer {
    public static void plugin(Usb usb) {
        usb.start();
        System.out.println("=======Usb 设备工作======");
        usb.stop();
    }
}

class Flash implements  Usb{
    @Override
    //覆写方法
    public void start(){
        System.out.println("Usb start to work!");
    }
    @Override
    public void stop(){
        System.out.println("Usb stop to work!");
    }
}

class Print implements  Usb{
    @Override
    //覆写方法
    public void start(){
        System.out.println("Print start to work!");
    }
    @Override
    public void stop(){
        System.out.println("Print stop to work!");
    }
}
public class InterfaceCaseDemo03{
    public static void main(String[] args) {
        Computer.plugin(new Flash());
        System.out.println("-----------------------------------");
        Computer.plugin(new Print());
    }
}

结果：

=======Usb 设备工作======
Usb stop to work!
-----------------------------------
Print start to work!
=======Usb 设备工作======
Print stop to work!

4. 工厂设计模式–接口应用

 interface Fruit{
    void eat();
}
class apple implements Fruit{
    @Override
    public void eat(){
        System.out.println("eat an apple");
    }
}

class orange implements Fruit{
    @Override
    public void eat(){
        System.out.println("eat an orange");
    }
}
public class InterfaceCaseDemo04 {
    public static void main(String[] args) {
        Fruit f1 = new apple();
        f1.eat();

        Fruit f2 = new orange();
        f2.eat();

    }
}

结果：

eat an apple
eat an orange

客户端通过过渡端，得到特定子类的接口实例，返回接口实例给客户端，接口实例调用接口中的方法。

interface Fruit{
    void eat();
}
class apple implements Fruit{
    @Override
    public void eat(){
        System.out.println("eat an apple");
    }
}

class orange implements Fruit{
    @Override
    public void eat(){
        System.out.println("eat an orange");
    }
}
class  Factory{
    public  static  Fruit getInstance(String className){
        Fruit f = null;
        if("apple".equals(className)){
            f = new apple();
        }
        if("orange".equals(className)){
            f = new orange();
        }
        return  f;
    }
}
public  class InterfaceCaseDemo05{
    public static void main(String[] args) {
        Fruit f = Factory.getInstance("apple");
        f.eat();
    }
}

结果：

eat an apple

5. 代理模式–接口应用

interface netWork{
    void browse();
}
class Real implements netWork{
    @Override
    public void browse(){
        System.out.println("浏览网页信息...");
    }
}
class Proxy implements  netWork{
    private netWork network;
    public Proxy (netWork network){
        this.network= network;
    }
    public  void check(){
        System.out.println("检查客户是否合法");
    }
    @Override
    public void browse(){
        this.check();
        // 调用真实的主题操作，这里调用的是真实类里的对象。
        this.network.browse();
    }
}

public class proxyDemo {
    public static void main(String[] args) {
        //指定代理操作，这里两次向上转型操作，第一次向上是实例化代理类，
        //第二次向上转型是括号中，把真实类对象传入，以便在代理类中调用真实类中的方法。
        netWork net = new Proxy(new Real());
        net.browse();
    }
}

结果：

检查客户是否合法
浏览网页信息...

6. 适配器模式

 interface Window{        // 定义Window接口，表示窗口操作
    public void open() ;    // 打开
    public void close() ;    // 关闭
    public void activated() ;    // 窗口活动
    public void iconified() ;    // 窗口最小化
    public void deiconified();// 窗口恢复大小
}

abstract class windowAdapter implements  Window{
    @Override
    public void open() {};
    @Override
    public void close() {};
    @Override
    public void activated() {};
    @Override
    public void iconified() {};
    @Override
    public void deiconified(){};
}

class WindowImp1 extends windowAdapter{
    @Override
    public void open(){
        System.out.println("窗户打开");
    }
    @Override
    public  void close(){
        System.out.println("窗户关闭");
    }
}


public class AdapterDemo {
    public static void main(String[] args) {
        Window w = new WindowImp1();
        w.open();
        w.activated();
        w.close();
    }
}

结果：

窗户打开
窗户关闭