您当前的位置： 首页 > 学无止境 > 心得笔记 网站首页心得笔记

【第6章：面向对象（高级）】_抽象类与接口的应用

发布时间：2020-12-17 15:37:21编辑：雪饮阅读（）

 抽象类与接口都可被继承或实现后将子类的实例化进行向上转型然后调用其原本的抽象方法

abstract class A{
       abstract public void print1();
}
class B extends A{
       public void print1(){
              System.out.println("B->println1");
       }
}
interface AA{
       abstract public void print1();
}
class BB implements AA{
       public void print1(){
              System.out.println("BB->println1");
       }
}
public class Hello{
   public static void main(String args[]){
        A a=new B();
        a.print1();
        AA aa=new BB();
        aa.print1();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
B->println1
BB->println1
抽象类的应用-定义模板
abstract class Person{
       private String name;
       private int age;
       public String getName(){
              return this.name;
       }
       public int getAge(){
              return this.age;
       }
       public Person(String name,int age){
              this.name=name;
              this.age=age;
       }
       public void say(){
              System.out.println(this.getContent());
       }
       abstract public String getContent();
}
//人-学生模板
class Student extends Person{
       private float score;
       public String getContent(){
              return "姓名:"+this.getName()+"\t年龄:"+this.getAge()+"\t成绩:"+this.score;
       }
       public Student(String name,int age,float score){
              super(name,age);
              this.score=score;
       }
}
//人-工人模板
class Woker extends Person{
       private float salary;
       public String getContent(){
              return "姓名:"+this.getName()+"\t年龄:"+this.getAge()+"\t薪水:"+this.salary;
       }
       public Woker(String name,int age,float salary){
              super(name,age);
              this.salary=salary;
       }
}
public class Hello{
   public static void main(String args[]){
        Person student=new Student("snowDrink",24,100.0f);
        Person woker=new Woker("snowDrink",24,10000.0f);
        student.say();
        woker.say();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
姓名:snowDrink 年龄:24 成绩:100.0
姓名:snowDrink 年龄:24 薪水:10000.0
接口的应用-模拟计算机usb接口实现打印机与u盘接入过程
interface USB{
       abstract public void start();
       abstract public void stop();
}
class Computer{
       public static void plugin(USB usb){
              usb.start();
              System.out.println("-------usb设备工作------");
              usb.stop();
       }
}
class Flash implements USB{
        public void start(){
               System.out.println("u盘开始工作");
        }
        public void stop(){
               System.out.println("u盘停止工作");
        }
}
class Print implements USB{
       public void start(){
               System.out.println("打印机开始工作");
        }
        public void stop(){
               System.out.println("打印机停止工作");
        }
}
public class Hello{
   public static void main(String args[]){
        Computer.plugin(new Flash());
        Computer.plugin(new Print());
   }
}
D:\>javac Hello.java
 
D:\>java Hello
u盘开始工作
-------usb设备工作------
u盘停止工作
打印机开始工作
-------usb设备工作------
打印机停止工作
从接口过渡到工厂模式
对于接口的应用有如：
interface Fruit{
       abstract public void eat();
}
class Apple implements Fruit{
       public void eat(){
              System.out.println("-----吃苹果-----");
       }
}
class Orange implements Fruit{
       public void eat(){
              System.out.println("-----吃橘子-----");
       }
}
public class Hello{
   public static void main(String args[]){
        Fruit apple=new Apple();
                     apple.eat();
        Fruit orange=new Orange();
                     orange.eat();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
-----吃苹果-----
-----吃橘子-----
这种方式需要每次客户端（调用者）提供new的类型，所以可以有改进的地方。
工厂模式的实现
interface Fruit{
       abstract public void eat();
}
class Apple implements Fruit{
       public void eat(){
              System.out.println("-----吃苹果-----");
       }
}
class Orange implements Fruit{
       public void eat(){
              System.out.println("-----吃橘子-----");
       }
}
class factory{
       public static Fruit getInstance(String className){
              Fruit fruit=null;
              if(className.equals("Apple")){
                     fruit=new Apple();
              }
              if(className.equals("Orange")){
                     fruit=new Orange();
              }
              return fruit;
       }
}
public class Hello{
   public static void main(String args[]){
              Fruit fruit=factory.getInstance("Apple");
                     fruit.eat();
              fruit=factory.getInstance("Orange");
                     fruit.eat();
              fruit=factory.getInstance(null);
                     fruit.eat();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
-----吃苹果-----
-----吃橘子-----
Exception in thread "main" java.lang.NullPointerException
        at factory.getInstance(Hello.java:17)
        at Hello.main(Hello.java:32)
可以看到这种模式不用客户端调用者定义new的类型了，但是还是有点小问题需要改进，当接收null参数时候equals方法肯定是不存在的。
可以修改下equals调用者为参数，而参数为调用者，即调用者与参数互相调换，这时无论如何equals调用者都是存在equals方法的。
interface Fruit{
       abstract public void eat();
}
class Apple implements Fruit{
       public void eat(){
              System.out.println("-----吃苹果-----");
       }
}
class Orange implements Fruit{
       public void eat(){
              System.out.println("-----吃橘子-----");
       }
}
class factory{
       public static Fruit getInstance(String className){
              Fruit fruit=null;
              if("Apple".equals(className)){
                     fruit=new Apple();
              }
              if("Orange".equals(className)){
                     fruit=new Orange();
              }
              return fruit;
       }
}
public class Hello{
   public static void main(String args[]){
              Fruit fruit=factory.getInstance("Apple");
                     fruit.eat();
              fruit=factory.getInstance("Orange");
                     fruit.eat();
              fruit=factory.getInstance(null);
                     fruit.eat();
   }
}
D:\>java Hello
-----吃苹果-----
-----吃橘子-----
Exception in thread "main" java.lang.NullPointerException
        at Hello.main(Hello.java:33)
虽然也会有报错，但是这个报错已经不是因为没有equals方法，fruit已经返回给调用者了，只是调用者再次调用eat方法时候不存在eat方法罢了。
那么只需要再次对客户端调用eat方法进行处理下即可
interface Fruit{
       abstract public void eat();
}
class Apple implements Fruit{
       public void eat(){
              System.out.println("-----吃苹果-----");
       }
}
class Orange implements Fruit{
       public void eat(){
              System.out.println("-----吃橘子-----");
       }
}
class factory{
       public static Fruit getInstance(String className){
              Fruit fruit=null;
              if("Apple".equals(className)){
                     fruit=new Apple();
              }
              if("Orange".equals(className)){
                     fruit=new Orange();
              }
              return fruit;
       }
}
public class Hello{
   public static void main(String args[]){
              Fruit fruit=factory.getInstance("Apple");
              if(fruit!=null){
                     fruit.eat();
              }
              fruit=factory.getInstance("Orange");
              if(fruit!=null){
                     fruit.eat();
              }
              fruit=factory.getInstance(null);
              if(fruit!=null){
                     fruit.eat();
              }
   }
}
D:\>javac Hello.java
 
D:\>java Hello
-----吃苹果-----
-----吃橘子-----
接口应用-代理设计模式
interface Network{
       abstract public void browse();
}
class Real implements Network{
       public void browse(){
              System.out.println("-----正常上网-----");
       }
}
class Proxy implements Network{
       private Network network;
       public Proxy(Network network){
              this.network=network;
       }
       public void connect(){
              System.out.println("-----正在连接国外某某节点-------");
       }
       public void browse(){
              this.connect();
              this.network.browse();
       }
}
public class Hello{
   public static void main(String args[]){
              Network network=new Real();
              network.browse();
              network=new Proxy(network);
              network.browse();
   }
}
D:\>javac Hello.java
D:\>java Hello
-----正常上网-----
-----正在连接国外某某节点-------
-----正常上网-----
适配器模式
对于接口如果有子类则必须实现该接口的所有方法，但是如果子类只是想要用接口的一部分方法而没有必要实现其所有抽象方法就可以用适配器模式，其原理就是用一个过渡类实现了接口的所有方法（伪实现）然后我们再去继承该过渡类然后仅仅覆写我们要的部分方法即可。
interface Window{
       abstract public void open();
       abstract public void close();
       abstract public void activated();
       abstract public void deiconified();
}
abstract class WindowAdapter implements Window{
       public void open(){}
       public void close(){}
       public void activated(){}
       public void deiconified(){}
}
class SimpleWindow extends WindowAdapter{
       public void open(){
              System.out.println("------窗口打开了------");
       }
       public void close(){
              System.out.println("------窗口关闭了------");
       }
}
public class Hello{
   public static void main(String args[]){
              Window simpleWin=new SimpleWindow();
              simpleWin.open();
              simpleWin.close();
   }
}
D:\>javac Hello.java
D:\>java Hello
------窗口打开了------
------窗口关闭了------
抽象类内部的接口
抽象类内部还可以定义接口，但内部接口默认可以不用实现
abstract class A{
       interface B{
              abstract public void printB();
       }
       abstract public void printA();
}
 
class C extends A{
       public void printA(){
              System.out.println("----printA----");
       }
}
public class Hello{
   public static void main(String args[]){
              A a=new C();
              a.printA();
   }
}
D:\>javac Hello.java
D:\>java Hello
----printA----
对于抽象类内部的接口如果也要实现，则在子类中也要定义内部类对其抽象类中的接口进行实现。
abstract class A{
       interface B{
              abstract public void printB();
       }
       abstract public void printA();
}
 
class C extends A{
       public void printA(){
              System.out.println("----printA----");
       }
       class D implements B{
              public void printB(){
                     System.out.println("----printB----");
              }
       }
}
public class Hello{
   public static void main(String args[]){
              A.B b=new C().new D();
              b.printB();
   }
}
D:\>javac Hello.java
 
D:\>java Hello
----printB----
接口中的抽象类
和上面正好相反，接口中也可以定义内部类为抽象类，那么对其子类实现及其子类对接口中的抽象类的实现也就自然变成先实现再继承了。
interface A{
       abstract class B{
              abstract public void printB();
       }
       abstract public void printA();
}
 
class C implements A{
       public void printA(){
              System.out.println("----printA----");
       }
       class D extends B{
              public void printB(){
                     System.out.println("----printB----");
              }
       }
}
public class Hello{
   public static void main(String args[]){
              A.B b=new C().new D();
              b.printB();
   }
}