Abstract classes vs. Interfaces

Quote:

Original post by Anonymous Poster Both abstract classes and interfaces define methods. They do not implement them though.

Quote:

Original post by Anonymous Poster Base class and abstract class are not at all mutually exclusive.

Quote:

Original post by Anonymous Poster Yes, an abstract class can implement some of its methods, whereas interfaces cannot. My main point though was that abstract classes are considered abstract because they don't implement methods (for at least one method, though this is more of a modern language difference).

Quote:

Original post by Anonymous Poster Except that I did say I was wrong and already cleared it up.

Quote:

Regardless of which language you use, abstract classes are not mutually exclusive from base classes, as your post says. Maybe you should take your own advice here.

Quote:

since the OP did not ask about implementation, only about the differences.

Quote:

Original post by angrytofu So can anyone give me a example where doing something is easier because of using a custom interface ? I never have the need to use a interface I guess since everything I make is simple. I am still waiting for the day I will realize to use one.

interface MessageTarget{    void SendMessage(string Message);}public class MessageToFile: MessageTarget{    void SendMessage(string Message){  /* ToFile(Message); */  }}public class MessageToScreen: MessageTarget{    void SendMessage(string Message){  /*  ToScreen(Message);  */  }}public class SomeModule{    private MessageTarget   OutputTarget;    public void SomeMethod(){         OutputTarget.SendMessage("Hey! In Some Method!");    }}

Quote:

It doesn't become of 'type I'.

IInterface{   bool Initialise(** initialisation parameters **);   void Update(void);   void Print(** Print Format **);};class CClassA : IInterface{   int m_nA;   String* m_sB;   bool Initialise(** init params **)   {       m_sB = psB;       m_nA = pnA;       return true;   }};class CClassB : IInterface{   float m_fA;   bool Initialise(** init params **)   {      m_fA = pfA;      return true;   }};main(){   IInterface ii;   CClassA ca = new CClassA();   CClassB cb = new CClassB();   // Use CClassA defined functions   ii = (IInterface)ca;   ii.Initialise(** params **);   ii.Update();   ii.Print(** print format **);   // Use CClassB defined functions   ii = (IInterface)cb;   ii.Initialise(** params **);   ii.Update();   ii.Print(** print format **);   }

Quote:

Original post by angrytofu I understand everything from that link except one thing How can emp contain anything ? I though emp (which is the interface) cannot contain data? About the example above. I don't really know C++ too well so do not completely understand private void InterfaceExample_Click(object sender, System.EventArgs e) { try { IEmployee emp; Emp_fulltime2 emp1 = new Emp_fulltime2(); //has to be casted because of the interface! emp = (IEmployee) emp1; emp.ID = "2234"; emp.FirstName= "Rahman" ; emp.LastName = "Mahmoodi" ; //call add method od the object MessageBox.Show(emp.Add().ToString()); //call the CalculateWage method MessageBox.Show(emp.CalculateWage().ToString()); } catch(Exception ex) { MessageBox.Show(ex.Message); } }

Quote:

Original post by Anonymous Poster Quote: Original post by CTar Quote: Original post by Anonymous Poster Yes, an abstract class can implement some of its methods, whereas interfaces cannot. My main point though was that abstract classes are considered abstract because they don't implement methods (for at least one method, though this is more of a modern language difference). No. Abstract classes is used instead of concrete classes, when you need a class which should never itself be constructed, but contains implementation details. Interfaces, on the other hand, just makes sure classes (abstract or concrete) follow an interface. No what? You are saying two things here, both of which are very wrong. 1) that abstract classes have to contain implementation details 2) that interfaces make sure classes follow an interface. Interfaces are completely independant of the class paradigm.