devstory

Classe abstraite et interface en Java

  1. Introduction
  2. Classe abstraite (Abstract Class)
  3. Les exemples de la classs abstraite
  4. Tổng quan về Interface
  5. Structure de l'Interface
  6. La classe implémente l'interface

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 : 

Coding Java...
Job Name 1= Coding Java
Build a House
Job Name 2= Manual Job

4. Tổng quan về 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 { 
     // ....
}
Các đặc điểm của interface
  • L'interface a toujours un modificateur : interface publique, que vous déclariez clairement ou non.
  • S'il y a des champs (field), ils sont : public static final, que vous déclariez clairement ou non.
  • 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.
  • 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 :
Drink SEVEN UP
Tom cat eat ...
Mouse eat ...
catEat1 is Cat? true
Mouse drink ...

Java Basic

Show More

Java Basic

Show More

Articles les plus récents

Show More