Question

结构

-ClassA
|---|
|---ClassAImplA
|---ClassAImplB
-Main

A类：

public interface ClassA {

    public void execute();

}

实施A：

public class ClassAImplA implements ClassA 
{
    private int a = 5;

    public ClassAImplA (int a){setA(a);}
    @Override
    public void execute() {
        System.out.println(a);

    }
    public int getA() {
        return a;
    }
    public void setA(int a) {
        this.a = a;
    }

实施B：

public class ClassAImplB implements ClassA 
{
    private boolean b = false;

     public ClassAImplB (int a){setB(b);}
    @Override
    public void execute() {
        System.out.println(b);

    }
    public booelan getB() {
        return b;
    }
    public void setA(boolean b) {
        this.b = b;
    }

主：

public class main {

    /**
     * @param args
     */
    public static  void main(String[] args) {
        ClassAImplA param1 = new ClassAImplA(10);
        ClassA = param1;
    }


}

通过这样做，我使ClassA可以互换，但I失去了访问参数int a的功能。有没有办法让它可以互换，仍然可以访问int a，或者在ClassAImplB的情况下，字段为boolean b？

Answer 1

有一种方法，但这不是一个好主意，因为它违背了目的：

ClassAImplA param1 = new ClassAImplA(10);
ClassA = param1;
if (param1 instanceof ClassAImplA) {
    param1x = (ClassAImplA) param1;
    System.out.println(param1x.getA());
}

但不要这样做。它违背了模式的目的。模式的目的是使用ClassA类型的对象，无需知道它们是如何工作的。 getA方法仅在ClassAImplA中定义，它是一个与ClassA类型的用户无关的实施细节。他们不应该知道。它是隐藏的。这称为良好的封装和信息隐藏。

Answer 2

你还需要一个使用合成的类来决定需要哪种实现。

 public ClassHelper{
     private A a;

     public ClassHelper(A a){
      this.a = a;
     }

     public void execute() {
      this.a.execute();
}


 }  


  public class main {

/**
 * @param args
 */
public static  void main(String[] args) {
    ClassHelper param1 = new ClassHelper(new ClassAImplA(10));
    param1.execute();

   //or when you need classBIMpl

   param1 = new ClassHelper(new ClassAImplB(true));
    param1.execute();


}

}

关于访问implA或implB成员的能力，没有你不能用这种模式具有灵活性，这种模式的重点是调用者不需要了解实现细节。

Answer 3

为策略定义接口，使用不同的重载方法定义Factory以创建类的具体实例。当然，方法是键入接口而不是具体类。

界面。

public interface Strategy {
  void execute();
}

第一个实施。

public class ConcreteStrategy implements Strategy {

  private boolean a;

  public ConcreteStrategy(final boolean a) { this.a = a; }

  public void execute() {}
}

第二个实施。

public class AnotherConcreteStrategy implements Strategy {

  private int a;

  public AnotherConcreteStrategy(final int a) { this.a = a; }

  public void execute() {}
}

工厂。

public class Factory {

  public static Strategy create(final boolean a) {
    return new ConcreteStrategy(a);
  }

  public static Strategy create(final int a) {
    return new AnotherConcreteStrategy(a);
  }
}

策略模式无法访问getter

结构

A类：

实施A：

实施B：

主：

3 个答案: