Classe abstraite et interface en Java

View more Tutorials:

1- Introduction

Dans ce document, je vais vous guider sur l'Interface et Classe Abstract  ( Abstract  Class). Analyser également les similitudes et les différences entre eux.

2- Classe abstraite (Abstract Class)

Classe abstraite (Abstract Class). Voyez l’exemple d’une classe comme:
// C'est une classe abstraite.
// Il doit être déclaré comme abstrait, car il a une méthode abstraite.
public abstract class ClassA  {

	// C'est une classe abstraite.
	// Il n'a pas de corps (body).
	// Access modifier de cette méthode est public
	public abstract void doSomething();

	// Access modifier de cette méthode est protected.
	protected abstract String doNothing();
	// Cette méthode  ne déclare pas access modifier.
	// Access modifier est par défaut.
	abstract void todo() ;
}

// C'est une classe abstraite.
// Il est déclaré être abstract,
// même s'il n'a pas de méthode abstraites.
public abstract class ClassB   {

}
Les caractéristiques d'une classe abstraite sont :
  1. Il est déclaré abstrait (abstract).
  2. Il peut déclarer 0, 1 ou plus de méthodes abstraites internes.
  3. Impossible d'initialiser un objet directement à partir d'une classe abstraite.
 
 
 
 

3- L'exemple avec classs abstraite

Voyez l'illustration:
 
AbstractJob.java
package org.o7planning.tutorial.abs;

// Une classe abstraite (Simuler un travail).
// Elle a déclaré deux méthodes abstraites.
public abstract class AbstractJob {

	public AbstractJob() {

	}

	// C'est une méthode abstraite.
	// Cette méthode retourne le nom du travail.
	public abstract String getJobName();

	// C'est une méthode abstraite
	public abstract void doJob();

}
JavaCoding.java
package org.o7planning.tutorial.abs;

// Cette classe réalise toutes les méthodes abstraites de la classe parent.
public class JavaCoding extends AbstractJob {

	public JavaCoding() {
	}

	// Implémentez les méthodes abstraites déclarées dans la classe parent
	@Override
	public void doJob() {
		System.out.println("Coding Java...");
	}

	// Implémentez les méthodes abstraites déclarées dans la classe parent.
	// Cette méthode aura le corps (corps).
	// Et retourne le nom du travail.
	@Override
	public String getJobName() {
		return "Coding Java";
	}

}
ManualJob.java
package org.o7planning.tutorial.abs;

// ManualJob - (Simulation d'un emploi universel)
// La classe parent  (AbstractJob) a deux méthodes abstraites.
// Cette classe fait seulement une méthode abstraites de la classe parente.
// donc il est forcé de déclarer comme abstraite.
public abstract class ManualJob extends AbstractJob {

	public ManualJob() {

	}

	// Implémentez les méthodes abstraites de la classe parente.
	@Override
	public String getJobName() {
		return "Manual Job";
	}

}
BuildHouse.java
package org.o7planning.tutorial.abs;

// Cette classe hérite de la classe abstraite ManualJob
// BuildHouse n'est pas déclarée comme abstraite.
// Donc, il doit implémenter toutes les méthodes abstraites restantes
public class BuildHouse extends ManualJob {

	public BuildHouse() {

	}

	// Implémentez les méthodes abstraites de la classe parente.
	@Override
	public void doJob() {
		System.out.println("Build a House");
	}

}
Exemple de démonstration 
 
JobDemo.java
package org.o7planning.tutorial.abs;

public class JobDemo {

	public static void main(String[] args) {

		// Créer un objet AbstractJob
		// De Constructor de la classe JavaCoding.
		AbstractJob job1 = new JavaCoding();

		// Appelez la méthode doJob ().
		job1.doJob();

		// La méthode getJobName est abstraite dans la classe AbstractJob
		// Mais il a été implémenté dans une certaine sous-classe (JavaCoding).
		// Donc,vous pouvez l'appeler.
		String jobName = job1.getJobName();

		System.out.println("Job Name 1= " + jobName);

		// Créer un objet AbstractJob
		// De Constructor de la classe BuildHouse.
		AbstractJob job2 = new BuildHouse();

		job2.doJob();

		String jobName2 = job2.getJobName();

		System.out.println("Job Name 2= " + jobName2);

	}
}
Les résultats de l'exécution de l'exemple:
 

4- Overview of the interface

Nous savons qu'une classe ne peut étendre seulement d'une classe parente. 
// B est la sous-classe de la classe A, ou en d'autres termes, B est étendu de A.
// Java ne permet qu'une classe s'étend sur une seule autre classe.
public class B extends A  {
   // ....
}

// Dans le cas non spécifiés classe B s'étend d'une classe particulière.
// Par défaut, comprenez que B s'étend de la classe Object.
public class B  {

}

// Cette déclaration et ce qui précède est équivalente.
public class B extends Object  {

}
Mais une classe peut étendre de plusieurs Interface 
 
// Une classe ne peut étendre seulement d'une classe parent
// Mais peut implémenter (s'étend) à partir de plusieurs interfaces.
public class Cat extends Animal implements CanEat, CanDrink {

  // ....
}
Les caractéristiques de l'interface
  1. L'interface a toujours un modificateur : interface publique, que vous déclarez clairement ou non.
  2. S'il y a des champs (field), ils sont : public static final, que vous déclarez clairement ou non.
  3. Ses méthodes sont la méthode abstraite, c'est-à-dire sans corps de fonction et tous ont un modificateur est : public abstract, que vous déclarez ou non.
  4. Interface n'a pas de Constructeur.

5- Structure de l'Interface

NoAccessModifierInterface.java
package org.o7planning.tutorial.itf;

// C'est une interface non seulement spécifier 'access modifier'.
// Access modifier est par défaut.
// Seules les classes avec package peuvent implémenter cette interface.
interface NoAccessModifierInterface {

}
CanMove.java
package org.o7planning.tutorial.itf;

// Cette interface définit une norme
// Des choses qui ont la capacité de se déplacer.
public interface CanMove {

	// Les méthodes dans l'interface sont toujours abstraites et publiques.
	public abstract void run();

	// Même si vous ne spécifiez pas 'abstract public', java comprend toujours.
	void back();

	// Vitesse.
	public int getVelocity();

}
CanDrink.java
package org.o7planning.tutorial.itf;

// Cette interface définit une norme
// sur les choses capables de boire.
public interface CanDrink {

	// Les champs dans l'interface sont toujours 'public static final'. 
	// Si vous devez déclarer clairement si oui ou non java toujours implicite.
	public static final String PEPSI = "PEPSI";
	final String NUMBER_ONE = "NUMBER ONE";
	String SEVENUP = "SEVEN UP";

	public void drink();

}
CanEat.java
package org.o7planning.tutorial.itf;

// Cette interface définit une norme
// à propos de choses capables de manger.
public interface CanEat {

	public void eat();
}

6- La classe implémente l'interface

Animal.java
package org.o7planning.tutorial.cls;

import org.o7planning.tutorial.itf.CanMove;

// Animal (animal).
// Cette classe s'étend de la classe Object (bien que non clairement).
// Et a déclaré la mise en œuvre actuelle (ou appelé héritage) interface CanMove .
// Interface CanMove a trois méthodes abstraites.
// Cette classe implémente seulement une méthode.
// Donc elle est obligée déclarer abstraite
// Les méthodes abstraites restantes seront mises en œuvre sous-classes.
public abstract class Animal implements CanMove {

	// Implémentez la méthode d'exécution () de l'interface CanMove.
	@Override
	public void run() {
		System.out.println("Animal run...");
	}

}
Cat.java
package org.o7planning.tutorial.cls;

import org.o7planning.tutorial.itf.CanDrink;
import org.o7planning.tutorial.itf.CanEat;

// Classe Cat s'étend de la classe animale et appliquer deux interfaces, CanEat CanDrink.
// Cat est une classe commune (Il n'a pas été déclarée comme abstraite).
// donc, il doit implémenter toutes les méthodes abstraites de l'Interface.
public class Cat extends Animal implements CanEat, CanDrink {

	private String name;

	public Cat(String name) {
		this.name = name;
	}

	public String getName() {
		return this.name;
	}

	// Implémentez la méthode d'interface CanMove.
	@Override
	public void back() {
		System.out.println(name + " cat back ...");
	}

	// Implémentez la méthode d'interface CanMove.
	@Override
	public int getVelocity() {
		return 110;
	}

	// Implémentez la méthode d'interface CanEat.
	@Override
	public void eat() {
		System.out.println(name + " cat eat ...");
	}

	// Implémentez la méthode d'interfac CanDrink.
	@Override
	public void drink() {
		System.out.println(name + " cat drink ...");
	}

}
Mouse.java
package org.o7planning.tutorial.cls;

import org.o7planning.tutorial.itf.CanDrink;
import org.o7planning.tutorial.itf.CanEat;

public class Mouse extends Animal  implements CanEat, CanDrink {

  @Override
  public void back() {
      System.out.println("Mouse back ...");
  }

  @Override
  public int getVelocity() {
      return 85;
  }

  @Override
  public void drink() {
      System.out.println("Mouse drink ...");
  }

  @Override
  public void eat() {
      System.out.println("Mouse eat ...");
  }

}
AnimalDemo.java
package org.o7planning.tutorial.cls;

import org.o7planning.tutorial.itf.CanEat;

public class AnimalDemo {

	public static void main(String[] args) {

		// Hérites le champ statique de l'interface CanDrink.
		System.out.println("Drink " + Cat.SEVENUP);

		// Créer un objet CanEat
		// Un objet déclaré être CanEat.
		// Mais en fait, c'est la Cat
		CanEat canEat1 = new Cat("Tom");

		// Créer un objet CanEat
		// Mais en fait, c'est la Mouse.
		CanEat canEat2 = new Mouse();

		// Le polymorphisme (Polymorphism)est montré ici.
		// Java connaît les types d'objets réels.
		// ==> Tom cat eat ...
		canEat1.eat();
		// ==> Mouse eat ...
		canEat2.eat();

		boolean isCat = canEat1 instanceof Cat;

		System.out.println("catEat1 is Cat? " + isCat);

		// ​​​​​​​ (Cast).
		if (canEat2 instanceof Mouse) {
			Mouse mouse = (Mouse) canEat2;

			// Appelez la méthode de la boisson (Hérité de CanDrink).
			mouse.drink();
		}

	}
}
Les résultats de l'exécution de l'exemple:

View more Tutorials: