2020.2.8 抽象类、模板方法设计模式、接口、工厂方法

抽象类

抽象方法：只要方法的声明，没有方法的实现。以分号结束：abstract int abstractMethod(int a);

抽象类不能被实例化。抽象类是用来作为父类被继承的，抽象类子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。（只要类中有一个抽象方法，那么这个类就是一个抽象类。）

public abstract class Animal{
     public abstract void test();
     public abstract void move();
  }

class Dog extends Animal{
     public void test(){
         ......
         }
      public void move(){
          ......
          }
  }

abstract class Bird extends Animal{//抽象类可以继承抽象
    public void move(){
        ......
        }
    public abstract void test();
 }

抽象类不可用final声明，因为它修饰的类是最终的类，不能被继承。

模板方法设计模式

抽象类体现的就是一种模板的设计，抽象类作为多个子类的通用模板。

public abstract class Template{
      public abstract void code();
      public final void getTime(){//只能给父类用，不可重写
           long start = System.currentTimeMillis();//当前时间
           code();
           long end = System.cuurentTimeMillis();
           System.out.println("code方法执行的时间："+(end-start));
           }
    }

class TestTmp extends Template{
    public void code(){
         int k = 0;
         for(int i=0;i<5000;i++){
              k+=1;
              }
          System.out.println(k);
          }
  }
            
//测试
TestTmp t = new TestTmp();
t.getTime();

接口

有了接口可以实现多重继承的效果。
接口（interface）是抽象方法和常量值的定义的集合。
一个类可以实现多个接口，接口可以继承其他接口。
特点：
接口中的所有成员变量都默认是由public static final修饰；
接口中所有的方法都默认是由public abstract修饰的；
接口没有构造器；
接口采用多层继承机制。

让我们来举个栗子：

public interface TestIn{
   int ID = 1；//相当于public static final int ID = 1;
   void test();//相当于public abstract void test();
}

public interface TestIn1{
    void test1();
}
public class TestInmp1 implements TestIn,TestIn1{
    public void test(){
         ......
    }
    public void test1(){
         ......
    }
}

public interface TestIn2 extends TestIn1{
 接口可以继承接口
}

如果一个类既继承父类，又实现接口，那么先继承，再实现。

public class Test extends Person implements TestIn{
     ......
}

有时我们要在父类增加一些方法，就不能在父类上下手，只能新建一个接口，在接口上扩展方法，其他需要子类自行实现。

例，描述会唱歌的厨子是个老师。

public abstract class Person{
      int age;
      String name;
      public abstract void showInfo();
}

//厨艺接口
public interface Cook{
   void sooking();
}

//歌唱接口
public interface Sing{
    void singing();
}

//描述会唱歌的厨子是一个老师
public class SCteacher extends Person implements Cook,Sing{
   String course;
   public void setInfo(){
      super.age = 22;
      super.name = "大可爱";
      this.course = "计算机";
   }
   public void showInfo(){
      System.out.println(super.age);
      System.out.println(super.name);
      System.out.println(this.course);
   }
   public void sooking(){
      ......
   }
   public void singing(){
      ......
   }
}

总结：
抽象类是对于一类事物的高度抽象，其中既有属性也有方法；
接口是对方法的抽象，也就是对一系列动作的抽象。

当需要对一类事物抽象的时候，应该是使用抽象类，好形成一个父类；
当需要一系列的动作抽象，就使用接口，需要使用这些动作的类去实现相应的接口即可。

工厂方法

通过工厂把new对象隔离，通过产品的接口可以接受不同实际产品的实现类，实例类名的改变不影响其他合作开发人员的编程。

例：

//产品的信息介绍
public interface BWM{
   void showInfo();
}
class BWM3 implements BWM{
    public void showInfo(){
       System.out.println("这是宝马3系车")；
    }
}

//汽车生产工厂接口
public interface BWMFactory{
    BWM productBWM();
}
class BWM3Factory implements BWMFactory{
   public BWM productBWM(){
      System.out.println("生产宝马3系车");
      return new BWM3;
}

//测试
public class Test{
   public static void main(String[] args){
      BWM b3 = new BWM3Factory().productBWM();
      b3.showInfo();
   }
}
测试结果：生产宝马3系车
         这个是宝马3系车