design pattern query

This extends Avi's answer and addresses the comments.

The points of the code:

1. abstract base class to emphasize IS A relationships
2. Template pattern to ensure the steps are in the right order
3. Strategy Pattern - an abstract class is as much a interface (little "i") as much as a Interface (capital "I") is.
4. Extend the base and not use an interface.
5. No coupling of concrete classes. Coupling is not an issue of abstract vs interface but rather good design.

    public abstract Animal {
        public abstract bool Escape(){}
        public abstract string SaySomething(){}
    }

    public Wabbit : Animal {
        public override bool Escape() {//wabbit hopping frantically }
        public override string SaySomething() { return @"What's Up Doc?"; }
    }


    public abstract class Killer {
        protected Animal food;
        protected abstract void Catch(){}
        protected abstract void Kill(){}
        protected abstract void Clean(){}

        protected abstract string Lure(){}

        // this method defines the process: the methods and the order of
        // those calls. Exactly how to do each individual step is left up to sub classes.
        // Even if you define a "PigKiller" interface we need this method
        // ** in the base class ** to make sure all Killer's do it right. 
        // This method is the template (pattern) for subclasses. 
        protected void FeedTheFamily(Animal somethingTasty) {
            food = somethingTasty;
            Catch();
            Kill();
            Clean();
        }

    }
    public class WabbitHunter : Killer {
        protected override Catch() { //wabbit catching technique }
        protected override Kill() { //wabbit killing technique }
        protected override Clean() { //wabbit cleaning technique }
        protected override Lure() { return "Come here you wascuhwy wabbit!"; }

    }

    // client code ********************
    public class AHuntingWeWillGo {
        Killer hunter;
        Animal prey;

        public AHuntingWeWillGo (Killer aHunter, Animal aAnimal) {
            hunter = aHunter;
            prey = aAnimal;
        }

        public void Hunt() {
            if ( !prey.Escape() ) hunter.FeedTheFamily(prey)
        }
    }


    public static void main () {
        // look, ma! no coupling. Because we pass in our objects vice
        // new them up inside the using classes

        Killer ElmerFudd = new WabbitHunter();
        Animal BugsBunny = new Wabbit();
        AHuntingWeWillGo safari = new AHuntingWeWillGo( ElmerFudd, BugsBunny );

        safari.Hunt();
   }

The problem you are facing refer to part of OOP called polymorphism

Instead of abstract class i will be using a interface, the difference between interface an abstract class is that interface have only method descriptors, a abstract class can have also method with implementation.

public interface InterfaceOfPigKiller {

  void catchPig(); 
  void cleanPig();
  void killPig();
}

In the abstract class we implement two of three available methods, because we assume that those operation are common for every future type that will inherit form our class.

public abstract class AbstractPigKiller implements InterfaceOfPigKiller{

  private Ping pig; 

  public void catchPig() {
    //the logic of catching pigs. 
  } 

  public void cleanPig() {
   // the logic of pig cleaning. 
  }

}

Now we will create two new classes:

• AnimalKiller - The person responsible for pig death.

• AnimalSaver - The person responsible for pig release.

public class AnimalKiller extends AbstractPigKiller { 

 public void killPig() {
   // The killing operation
 }

}

public class AnimalSaver extends AbstractPigKiller {

 public void killPing() {
   // The operation that will make pig free
 }

}

As we have our structure lets see how it will work.

First the method that will execute the sequence:

public void doTheRequiredOperation(InterfaceOfPigKiller killer) {

   killer.catchPig();
   killer.cleanPig();
   killer.killPig();
}

As we see in the parameter we do not use class AnimalKiller or AnimalSever. Instead of that we have the interface. Thank to this operation we can operate on any class that implement used interface.

Example 1:

public void test() {

  AnimalKiller aKiller = new AnimalKiller();// We create new instance of class AnimalKiller and assign to variable aKiller with is type of `AnimalKilleraKiller `
  AnimalSaver aSaver = new AnimalSaver(); //

  doTheRequiredOperation(aKiller);
  doTheRequiredOperation(aSaver);


}

Example 2:

public void test() {

  InterfaceOfPigKiller aKiller = new AnimalKiller();// We create new instance of class AnimalKiller and assign to variable aKiller with is type of `InterfaceOfPigKiller `
  InterfaceOfPigKiller aSaver = new AnimalSaver(); //

  doTheRequiredOperation(aKiller);
  doTheRequiredOperation(aSaver);


}

The code example 1 and 2 are equally in scope of method doTheRequiredOperation. The difference is that in we assign once type to type and in the second we assign type to interface.

Conclusion

We can not create new object of abstract class or interface but we can assign object to interface or class type.