Classe abstraite et interface en Java

View more Tutorials:

1- Introduction

Dans ce document, je vous donnerai des instructions sur l'Interface et Classe Abstract  (Abstract Class ). Nous allons 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.
// Elle doit être déclarée comme abstraite, car elle a une méthode abstraite.
public abstract class ClassA  {

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

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

// C'est une classe abstraite.
// Elle doit être déclarée comme abstraite
// même si elle n'a pas de méthode abstraites.
public abstract class ClassB   {

}
Les caractéristiques d'une classe abstraite :
  1. Elle est déclarée abstraite (abstract).
  2. Elle 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- Les exemples de la 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 renvoie 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 implémente toutes les méthodes abstraites de la classe mère.
public class JavaCoding extends AbstractJob {

	public JavaCoding() {
	}

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

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

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

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

	public ManualJob() {

	}

	// Implémente les méthodes abstraites de la classe mère.
	@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émente les méthodes abstraites de la classe mère.
	@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 JavaCoding.
		AbstractJob job1 = new JavaCoding();

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

		// La méthode getJobName est abstraite dans la classe AbstractJob
		// Mais elle a été implémentée 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 BuildHouse.
		AbstractJob job2 = new BuildHouse();

		job2.doJob();

		String jobName2 = job2.getJobName();

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

	}
}
Exécution de l'exemple :

4- Overview of the interface

Nous savons qu'une classe ne peut étendre seulement d'une classe mère. 
// 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 où on ne spécifie pas la classe B qui s'étend d'une classe particulière.
// Par défaut, comprenons 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 mère.
// Mais elle 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éclariez clairement ou non.
  2. S'il y a des champs (field), ils sont : public static final, que vous déclariez clairement ou non.
  3. Ses méthodes sont abstraites, c'est-à-dire sans corps de fonction et tous ont un modificateur est : public abstract, que vous déclariez 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 spécifiée 'access modifier'.
// Ses access modifier sont 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
// sur les choses qui est capable 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 le 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'. 
	// Même si vous les déclarez ou non.
	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;

// Cette classe s'étend à partir d'Object.
// Et implémente l'interface CanMove.
// CanMove a 3 méthodes abstraites.
// Cette classe n'implémente qu'une seule méthode abstraite de CanMove.
// Elle doit donc être déclarée comme abstraite.
// Les autres méthodes abstraites à mettre en œuvre dans les sous-classes.
public abstract class Animal implements CanMove {

	// Implémente la méthode run() 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 Animal et implémente deux interfaces, CanEat CanDrink.
// Cat est une classe commune (Elle n'a pas été déclarée comme abstraite).
// donc, elle 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émente la méthode d'interface CanMove.
	@Override
	public void back() {
		System.out.println(name + " cat back ...");
	}

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

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

	// Implémente la méthode d'interface 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érite le champ statique de l'interface CanDrink.
		System.out.println("Drink " + Cat.SEVENUP);

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

		// Un objet déclaré comme CanEat.
		// Mais en fait, c'est 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;

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

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

View more Tutorials: