抽象类,接口以及策略模式的总结

• 抽象类

public abstract class Vehicle{// 类也就变成了抽象类

  public abstract void startup();// 抽象方法没有方法体！子类必须进行重写
  
  public void speedup(){
  };
  
  public void stop(){
  };
  
  public void run(){
  startup();
  speedup();
  stop():
  }
}

1.抽象类中可以没有抽象方法，但包含抽象方法的类必须声明为抽象类；

2.若子类是抽象类，可以不实现父类的抽象方法，否则必须实现父类的抽象方法；

3.抽象类允许有构造方法，可以在子类中调用，但是不能调用它来实例化抽象类；（抽象类是不能实例化成对象的，构造方法是用来给子类创建父类属性的）

• abstract只能用于修饰类和方法，不能和final一起使用

• 接口

  接口是从多个相似的类中抽象出来的规范，体现了规范和实现分离的设计哲学；

  接口不提供任何实现，它不能包含普通方法，接口内部定义的所有方法都是抽象方法！

  java8对接口进行了改进，允许在接口中定义默认方法和静态方法，这两类方法可以提供方法实现；

  • 定义

    [修饰符] interface 接口名 extends 父接口1，父接口2｛｝

  • 接口的成员

    接口可以定义成员变量、成员方法（抽象方法、静态方法、默认方法）

    1.接口中所有的成员都是public访问权限，public修饰符可以省略；

    2.接口中的成员变量都是静态常量，而static final修饰符都可以省略

    3.接口中的普通的成员方法都必须是抽象的，abstract修饰符可以省略；

    4.接口中的默认方法必须使用default修饰，静态方法必须使用static修饰，均不能省略。

    • 接口中不能包含构造方法和初始化块，只能包含静态常量，默认方法，抽象方法和静态方法

  • 接口的使用

    [修饰符] class 类名 extends 父类 implements 接口1，接口2，…{}

    1.一个类可以实现多个接口，implements；

    2.实现和继承类似，可以获得实现接口里定义的常量、方法；

    3.如果类不是抽象类，那么必须实现接口定义的全部抽象方法；

public interface C extend A,B{
  ~~public static final~~ int SIZE = 10;// 必须初始化，静态常量
  ~~public~~ abstract void sayGoodBye();
  ~~public~~ default int max(int x, int y){}// 属于实例的
  ~~public~~ static int min(int x, int y){} // 属于C接口的
 
}

public class X implements A, B{..}
public class Y implements C{...}

public class InterfaceUse {
    public static void main(String[] args) {
        System.out.println(Interface1.SIZE);
        System.out.println(Interface2.min(1,2));

        A a = new A();
        System.out.println(a.sum(1,2));
        System.out.println(a.max(1,2));
    }
}

class A implements Interface1,Interface2{
    @Override
    public int sum(int x, int y) {
        return x + y;
    }
}

class B implements Interface3{
    @Override
    public int sum(int x, int y) {
        return x + y;
    }

    @Override
    public void sort(int[] array) {
        Arrays.sort(array);
    }
}

public interface Interface1 {

    int SIZE = 10;
    int sum(int x, int y);
}


public interface Interface2 {

    default int max(int x, int y){
        return x > y ? x : y;
    }

    static int min(int x, int y){
        return x > y ? y : x;
    }
}


public interface Interface3 extends Interface1, Interface2{

    void sort(int[] array);
}

- 接口中的**默认方法**可以**重写**，只能通过实现类的**对象**调用；

- 接口中**静态变量**可以通过**实现类**或者**实现类的实例**访问到，而**静态方法**就**不能**通过实现类或者实现类的实例调用；静态方法只能通过**接口.静态方法**调用；

public class InterfaceUse {

  public static void main(String[] args) {

    System.out.println(Interface1.SIZE);
    System.out.println(Interface2.min(1,2));
    System.out.println(Interface1.min(Interface1.SIZE,2));
    // 接口的静态方法只能调用静态成员;

    A a = new A();

    System.out.println(a.sum(1,2));

    System.out.println(a.max(1,2));

  }

}

class A implements Interface1,Interface2{

  @Override

  public int sum(int x, int y) {

    return x + y;

  }

}

class B implements Interface3{

  @Override

  public int sum(int x, int y) {

    return x + y;

  }

  @Override

  public void sort(int[] array) {

    Arrays.sort(array);

  }

}

• 为什么需要接口？

  • 类可以：1.继承父类;2.实现接口

    继承：单继承子类只能继承一个父类；

    实现：一个类可以实现多个接口;

  • 类+接口实现对一类事物的完全抽象

    • 类相对于对象是抽象的,类的方法是具体的

    • 接口：抽象方法、抽象行为、抽象功能

  • 实例：

// 普通模式
public class Strategy {
    public static void main(String[] args) {
        Door door = new Door();
        door.open();
        door.close();
    }
}

class Door {
    public void open() {
        System.out.println("开门");
    }

    public void close(){
        System.out.println("关门");
    }
}

• 改进**[策略模式]**

// 1.创建一个接口
public interface Strategy {
   public int doOperation(int num1, int num2);
}

// 2.创建实现接口的实现类
public class OperationAdd implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 + num2;
   }
}

public class OperationSubtract implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 - num2;
   }
}

public class OperationMultiply implements Strategy{
   @Override
   public int doOperation(int num1, int num2) {
      return num1 * num2;
   }
}

// 3.创建Context类
public class Context {
   private Strategy strategy; // 相当于引用接口的类
 
   public Context(Strategy strategy){
      this.strategy = strategy;
   }
 
   public int executeStrategy(int num1, int num2){
      return strategy.doOperation(num1, num2);
   }
}

// 4.使用 Context 来查看当它改变策略 Strategy 时的行为变化
public class StrategyPatternDemo {
   public static void main(String[] args) {
      Context context = new Context(new OperationAdd());    
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationSubtract());      
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationMultiply());    
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   }
}
output:
10 + 5 = 15
10 - 5 = 5
10 * 5 = 50

• 门锁实例

public class StrategyUse {
    public static void main(String[] args) {
        Door door1 =new Door();
        door1.setLock(new FaceLock());
        door1.lockOpen();
        door1.lockClose();

        Door door2 =new Door();
        door2.setLock(new FingerPrintLock());
        door2.lockOpen();
        door2.lockClose();
    }
}

interface Lock{
    void open();
    void close();
}

class FaceLock implements Lock {

    @Override
    public void open() {
        System.out.println("面部解锁开门");
    }

    @Override
    public void close() {
        System.out.println("面部解锁关门");
    }
}

class FingerPrintLock implements Lock {

    @Override
    public void open() {
        System.out.println("指纹解锁开门");
    }

    @Override
    public void close() {
        System.out.println("指纹解锁关门");
    }
}

class Door {
    private Lock lock;

    public void setLock(Lock lock) {
        this.lock =lock;
    }

    public void lockOpen() {
        lock.open();
    }

    public void lockClose() {
        lock.close();
    }
}

• 登录实例

public class UserLog {
    public static void main(String[] args) {

        LogInScreen logInScreen = new LogInScreen(new AcountLogIn());
        logInScreen.LogIn();
        logInScreen = new LogInScreen(new ScanLogIn());
        logInScreen.LogIn();
        logInScreen = new LogInScreen(new MobileLogIn());
        logInScreen.LogIn();
    }
}

interface LogInMethod{
    void logIn();
}

class AcountLogIn implements LogInMethod{

    @Override
    public void logIn() {
        System.out.println("输入账号密码登录！");
    }
}

class MobileLogIn implements LogInMethod {

    @Override
    public void logIn() {
        System.out.println("输入手机号验证码登录");
    }
}

class ScanLogIn implements LogInMethod {

    @Override
    public void logIn() {
        System.out.println("请扫码登录");
    }
}

class LogInScreen {
    private LogInMethod logInMethod;

    public LogInScreen(LogInMethod logInMethod) {
        this.logInMethod = logInMethod;
    }

    public void LogIn() {
        logInMethod.logIn();
    }
}