method overriding through interface VS method overriding through inheritence

[Satyajeet Kadam]

Q1)PLease explain me method overriding through interface VS method overriding through inheritence with code?

[Greg Stevens]

Classes that implement interfaces don't override methods they implement them. There was never
a previous definition of the method to override. They are providing the first definition. This mechanism
of stating that a class will have a method but not providing a default implementation is useful if a set of
objects all do a certain activity, but there is no default way for doing it. They each do it their own way.

  
public interface Instrument
{
   public void play(double volume); // we are using interface because it doesn't make sense to provide
                                                           // default way for instrument to play - too much variety

   public void tune();                         // same reasoning here

   // notice these methods have no body, because it doesn't make sense to give generic behavior
}  

public class Guitar implements Instrument
{
   // we're not overriding play() because there is no default definition, we are implementing it
   public void play(double volume)
   {
      // play guitar music here
   }

   // same here
   public void tune()
   {
      // do guitar tuning here
   }
}

public class Piano implements Instrument
{
   // Piano is also an Instrument so it must have play and tune
   // again, not overriding, implementing
   public void play(double volume)
   {
      // play piano music here
   }

   public void tune()
   {
      // do piano tuning here
   }
}

[Greg Stevens]

Also interfaces can be used to describe a class that has two or more different sets of behavior. A class
can only have one superclass (inheritance), but it can implement the behavior of any number of interfaces.
Perhaps it will implement seemingly unrelated behavior that would never be described through inheritance
but can be expressed with interfaces:

   
public interface Weapon
{
   public void attack(); // weapons can attack in many different ways, no default attack description
                                   // it will be up to the class that [i]implements[/i] this interface to describe attack
} 

// Guitar will now have seemingly unrelated behavior of Instrument and Weapon - can't do this with inheritance
public class Guitar implements Instrument, Weapon  
{  
  // we're not overriding play() because there is no default definition, we are implementing it  
  public void play(double volume)  
  {  
   // play guitar music here  
  }  
  
  // same here  
  public void tune()  
  {  
    // do guitar tuning here  
  } 

  public void attack()
  {
      // swing guitar at opponent or victim
  }
}  
   
public class Piano implements Instrument, Weapon
{  
  // Piano is also an Instrument so it must have play and tune  
  // again, not overriding, implementing  
   public void play(double volume)  
   {  
      // play piano music here  
   }  
  
    public void tune()  
    {  
       // do piano tuning here  
    } 

   public void attack()
   {
      // drop piano from window onto victim's head
   }
} 

[Greg Stevens]

Concerning inheritance and overriding part of your question

You should read Sun's bicycle inheritance tutorial. Notice that the more specific type of bicycle class still uses most of the superclass's
definition (fields and methods) but may override a method or initialize some of the instance variables to different values.