Comment et quand utiliser une classe abstraite
Ceci est mon programme de test en Java. Je veux savoir dans quelle mesure la classe abstraite est plus importante ici et pourquoi nous utilisons la classe abstraite pour cela.
Est-ce une méthode obligatoire ou la meilleure méthode; si c'est le cas, comment?
class Shape1 {
int i = 1;
void draw() {
System.out.println("this is shape:" + i);
}
}
class Shape2 {
int i = 4;
void draw() {
System.out.println("this is shape2:" + i);
}
}
class Shape {
public static void main(String args[]) {
Shape1 s1 = new Shape1();
s1.draw();
Shape2 s2 = new Shape2();
s2.draw();
}
}
Vous utiliseriez ici une classe ou une interface abstraite afin de créer une classe/interface de base commune qui fournit la méthode void draw(), par exemple.
abstract class Shape() {
void draw();
}
class Circle extends Shape {
void draw() { ... }
}
...
Shape s = new Circle();
s.draw();
J'utiliserais généralement une interface. Cependant, vous pouvez utiliser une classe abstraite si:
- Vous devez/souhaitez fournir des fonctionnalités communes ou des membres de la classe (par exemple le membre
int iDans votre cas). - Vos méthodes abstraites ont autre chose qu'un accès public (qui est le seul type d'accès autorisé pour les interfaces), par exemple dans mon exemple,
void draw()aurait la visibilité du package.
Une classe abstraite a une relation de type "est-un" avec vos sous-classes. Ainsi, par exemple, vous pourriez avoir une classe abstraite Shape qui contient des éléments de toute forme (comme une fonction de dessin), puis une classe SquareShape. Chaque forme carrée est une forme, mais toutes les formes ne sont pas des formes carrées.
Dans votre exemple, vous avez 2 types de formes et une classe qui en possède 2. Ce n'est pas une relation que vous devez définir avec abstract je pense.
Vous voudrez peut-être faire quelque chose avec vos noms, car il s'agit d'un assez petit exemple, il est difficile de voir les implications réelles des fichiers et comment ils devraient fonctionner.
exemple d'exemple pour l'utilisation d'une classe abstraite en Java.
package use_of_abstract;
abstract class Shapes
{
int i=1;
abstract void draw();
abstract void color(String mycolor);
//not an abstract method
void fill()
{
System.out.println("Non-Abstract Method -> Fill");
}
//not an abstract method
String anotherMethod(String input)
{
return input + " additional text";
}
}
package use_of_abstract;
public class Shape_One extends Shapes
{
int i=1;
@Override
void draw()
{
System.out.println("This is Shape One:"+i);
}
@Override
void color(String mycolor)
{
System.out.println("This is Shape One:"+mycolor);
}
@Override
String anotherMethod(String anotherMethod)
{
System.out.println("This is Shape One:"+anotherMethod);
return anotherMethod;
}
}
package use_of_abstract;
public class Shape_Two extends Shapes
{
int i=2;
@Override
void draw()
{
System.out.println("This is Shape Two :"+i);
}
@Override
void color(String mycolor)
{
System.out.println("This is Shape Two Color:"+mycolor);
}
@Override
String anotherMethod(String anotherMethod)
{
System.out.println("This is Shape Two:"+anotherMethod);
return anotherMethod;
}
}
package use_of_abstract;
import Java.awt.Color;
public class Shape_Main
{
public static void main(String args[])
{
Shape_One s1;
Shape_Two s2;
s1=new Shape_One();
s2= new Shape_Two();
s1.draw();
s2.draw();
s1.fill();
s2.fill();
s1.color("Blue");
s2.color("Green");
s1.anotherMethod("HELLO..............Its Another Method 1");
s2.anotherMethod("HELLO..............Its Another Method 2");
}
}
Une classe abstraite est une classe, qui a au moins une méthode non implémentée, ou le mot-clé abstrait. Par exemple, une méthode abstraite peut ressembler à ceci:
public abstract String myMethod(String input);
(notez que la méthode se termine par un point-virgule).
Et une classe peut ressembler à ceci:
public abstract class MyClass {
public abstract String myMethod(String input);
public String anotherMethod(String input) {
return intput + " additional text";
}
}
Une classe abstraite ne peut pas être instanciée. Les classes abstraites nécessitent une sous-classe pour implémenter le comportement manquant afin qu'il puisse être instancié.
L'objectif principal d'une classe abstraite est de fournir une implémentation partagée de comportements communs - en promouvant la réutilisation du code.
Dans Java le même effet peut être obtenu en utilisant une composition de classes au lieu de l'héritage de classes abstraites largement définies. Cela permet des classes plus modulaires et spécifiques à la fonction favorisant la réutilisation du code, ce qui augmente la maintenabilité.
Mon conseil serait de n'utiliser la classe abstraite que lorsque cela est strictement nécessaire, et en particulier d'éviter de l'utiliser comme un sac fourre-tout plein de toutes sortes de fonctionnalités.
Dans Scala on utiliserait des traits, qui sont une manière élégante de résoudre ce problème. Il faut cependant beaucoup d'attention pour y arriver.
Classe abstraite, comme son nom l'indique est abstraite.
La classe abstraite ne parle pas de la partie implémentation. En fait, nous étendons la classe abstraite pour fournir l'implémentation de ses méthodes abstraites. Il peut également avoir des méthodes non abstraites.
Vérifiez ici: tilisation de la classe abstraite en Java
MODIFIER:
Exemple de code:
abstract class Shapes {
int i=1;
abstract void draw();
// Remember : Non-abstract methods are also allowed
void fill() {
System.out.println("Non abstract method - fill");
}
}
class Shape1 extends Shapes {
int i=1;
void draw(){
System.out.println("This is Shape 1:"+i);
}
}
class Shape2 extends Shapes {
int i=2;
void draw() {
System.out.println("This is Shape 2:"+i);
}
}
class Shape {
public static void main(String args[])
{
Shape1 s1 = new Shape1();
s1.draw(); // Prints This is Shape 1:1
Shape2 s2 = new Shape2();
s2.draw(); // Prints This is Shape 2:2
}
}
Choses courantes + Choses peu communes = Classe abstraite
Quand utiliser?
Une classe abstraite est mieux adaptée aux scénarios où il y a beaucoup de code réutilisable que vous ne voulez pas écrire encore et encore + Il y a peu de choses qui sont spécifiques à chaque classe.
Exemple?
La cérémonie:
Choses courantes: Sing Anthem, Hoist Flag, etc.
Choses spécifiques: Drapeau indien, hymne indien (pour l'Inde), drapeau chinois, hymne chinois (pour la Chine) etc.
Comment l'utiliser?
1) Créez une classe abstraite
2) Mettez tout dans les méthodes publiques qui sont courantes
3) Mettez tout dans des méthodes abstraites spécifiques aux classes enfants
Où est l'exemple de code?
Classe de base:
public abstract class BaseCeremony{
Flag natonalFlag;
Anthem anthem;
//**** Common Task ******//
public void startCeremony(){
configure();
hoistFlag();
singAnthem();
}
public void hoistFlag(){
natonalFlag.hoist();
}
public void singAnthem(){
anthem.anthem();
}
private void configure(){
natonalFlag = provideFlag();
anthem = provideAnthem();
}
//**** Differs in all part ******//
public abstract Flag provideFlag();
public abstract Anthem provideAnthem();
}
Dans la classe enfant, il vous suffit de fournir l'implémentation de la partie inhabituelle.
ChildClass
public class IndianCeremony extends BaseCeremony{
public Flag provideFlag(){
return new IndianFlag();
}
public Anthem provideAnthem(){
return new IndianAnthem();
}
}
Prime
- Une classe abstraite est une classe incomplète, c'est pourquoi vous ne pouvez pas créer ses objets.
- Une classe abstraite doit avoir au moins une méthode abstraite pour être considérée comme une classe abstraite
- Exemple d'implémentation de classe abstraite dans Android