Question

I wrote these two classes that simple encrypt and decrypt strings:

Encode.php

    class Encode {
        protected funcion do_encode($string) { .. }
    }


Decode.php

    class Decode {
        protected funcion do_decode($string) { .. }
    }

What I would like to do is:

Encrypt.php

    class Encrypt extends Encode, Decode {
        protected $stuff_for_parents;

        function __construct($configs) {
            $this->stuff_for_parents = $configs['SomeConf'];
        }

        public function encode($string) { $this->do_encode($string); }
        public function decode($string) { $this->do_decode($string); }
    }

But we cannot include more than one class, so: fail.
Now my questions are:

1. Is it a design problem? Cause this scenario doesn’t look weird to me, does it?
2. Is there another way to have one object that uses both the functions in the different classes? Sort of $encrypt->encode($str); $encrypt->decode($str);

Answer 1

If you want Encode and Decode to be separate classes, you can create instances of them within Encrypt. For example:

<?
class Encrypt {
  private $encoder;
  private $decoder;
  public function __construct() {
    $this->encoder = new Encode();
    $this->decoder = new Decode();
  }
  public function encode($string) {
    return $this->encoder->encode($string);
  }
  public function decode($string) {
    return $this->decoder->decode($string);
  }
}
?>

In that example Encode and Decode must be concrete classes. But you might want to consider using interfaces instead. Interfaces are useful if you think you might need to use different types of Encode and Decode objects, in different situations. For example, maybe you have a TripleDESEncode class and a BlowfishEncode class. They can both implement a common interface, like this:

<?
interface IEncode {
  public function encode($string);
}
class TripleDESEncode implements IEncode {
  public function encode($string) {...}
}
class BlowfishEncode implements IEncode {
  public function encode($string) {...}
}
?>

In that case, you may want to create the particular instances you want to use first, and then pass them into the constructor of Encrypt. This is called dependency injection:

<?
class Encrypt {
  public function __construct(IEncode $encoder, IDecode $decoder) {
    $this->encoder = $encoder;
    $this->decoder = $decoder;
  }
  ...
}

$myEncrypt = new Encrypt(new BlowfishEncode(), new BlowfishDecode());
echo $myEncrypt->encode('test');
?>