Une classe abstraite peut-elle avoir un constructeur?

, Vous devez définir un constructeur dans une classe abstraite si vous êtes dans l'une de ces situations:

• vous voulez faire quelque initialisation (aux champs de la classe abstraite) avant le l'instanciation d'une sous-classe en fait a lieu
• vous avez défini les champs finaux dans le classe abstraite mais vous n'avez pas les initialiser dans la déclaration lui-même; dans ce cas, vous DEVEZ avoir un constructeur pour initialiser ces champs

noter que:

• , vous pouvez définir plus d'un constructeur (avec différents arguments)
• vous pouvez (devez?) définir l'ensemble de votre les constructeurs protégés (ce qui les rend public is inutile anyway)
• votre constructeur de sous-classe peut appeler un constructeur de l'abstrait classe; il peut même appeler (s'il n'y a pas de constructeur no-arg dans la classe abstraite)

dans tous les cas, n'oubliez pas que si vous ne définissez pas un constructeur, alors le compilateur générera automatiquement un pour vous (celui-ci est public, n'a pas d'argument, et ne fait rien).

Oui, il peut avoir un constructeur et qu'il est défini et se comporte comme n'importe quel autre constructeur de la classe. Sauf que les classes abstraites ne peuvent pas être instanciées directement, seulement étendues, de sorte que l'utilisation est toujours à partir du constructeur d'une sous-classe.

Oui ! les classes Abstraites peuvent avoir des constructeurs !

Oui, lorsque nous définissons une classe d'une Classe Abstraite, il ne peut pas être instanciée, mais cela ne signifie pas une classe Abstraite ne peut pas avoir de constructeur. Chaque classe abstraite doit avoir une sous-classe concrète à mettre en œuvre les méthodes abstraites de la classe abstraite.

lorsque nous créons un objet de n'importe quelle sous-classe tous les constructeurs dans le correspondant arbre d'héritage sont invoqués dans l'approche. Le même cas s'applique aux classes abstraites. Bien que nous ne pouvons pas créer un objet d'une classe abstraite, lorsque nous créons un objet d'une classe qui est en béton et sous-classe de la classe abstraite, le constructeur de la classe abstraite est automatiquement appelée. Nous pouvons donc avoir un constructeur dans des classes abstraites.

Note: une classe non abstraite ne peut pas avoir de méthodes abstraites, mais une classe abstraite peut avoir non abstraites. La raison est similaire à celle des constructeurs, la différence étant au lieu d'être invoquée automatiquement nous pouvons appeler super(). En outre, il n'y a rien comme un constructeur abstrait car il n'a aucun sens du tout.

non seulement il peut, il fait toujours. Si vous n'en spécifiez pas un, alors il a un constructeur arg par défaut, comme toute autre classe. En fait, toutes les classes, y compris les classes imbriquées et anonymes, obtiendront un constructeur par défaut si l'un d'eux n'est pas spécifié (dans le cas des classes anonymes, il est impossible d'en spécifier un, donc vous obtiendrez toujours le constructeur par défaut).

un bon exemple d'une classe abstraite ayant un constructeur est le calendrier de la classe. Vous obtenez un objet Calendar en appelant Calendar.gettinstance (), mais il a aussi des constructeurs qui sont protégés. La raison pour laquelle ses constructeurs sont protégés est que seules ses sous-classes peuvent les appeler (ou classes dans le même paquet, mais puisqu'il est abstrait, cela ne s'applique pas). GregorianCalendar est un exemple d'une classe qui étend le calendrier.

Oui, il peut, les constructeurs de classes abstraites sont généralement utilisés pour les super appels pour les événements d'initialisation communs à toutes les sous-classes

Une classe abstraite peut avoir un constructeur, MAIS vous ne pouvez pas créer un objet de la classe abstraite alors, comment utilisez-vous ce constructeur?

chose est quand vous héritez cette classe de résumé dans votre sous-classe, vous pouvez passer des valeurs à son(résumé) constructeur par super(valeur) méthode dans votre sous-classe et non vous n'héritez pas d'un constructeur.

donc en utilisant super vous pouvez passer des valeurs dans un constructeur de la classe abstraite et aussi loin que je me souviens doit être la première déclaration dans votre méthode ou constructeur.

Bien qu'il existe beaucoup de bonnes réponses, je voudrais donner mes 2 cents.

constructeur ne construit pas l'objet . Il est utilisé pour initialiser un objet.

Oui, une classe Abstraite a toujours un constructeur. Si vous ne définissez pas votre propre constructeur, le compilateur donnera un constructeur par défaut à la classe Abstract. Ce qui précède s'applique à toutes les classes - imbriquées, abstraites, anonymes, etc.

Une classe abstraite (contrairement à l'interface) peut avoir des champs non-finaux non-statiques qui doivent être initialisés. Vous pouvez écrire votre propre constructeur dans la classe abstraite pour le faire. Mais, dans ce cas, il n'y aura pas de constructeur par défaut.

public abstract class Abs{
    int i;
    int j;
    public Abs(int i,int j){
        this.i = i;
        this.j = j;
        System.out.println(i+" "+j);
    }
}

soyez prudent en prolongeant au-dessus de la classe abstraite, vous devez explicitement appeler super de chaque constructeur. La première ligne de n'importe quel constructeur appelle super(). si vous n'appelez pas explicitement super(), Java le fera pour vous. Le code ci-dessous ne sera pas compilé:

public class Imp extends Abs{

public Imp(int i, int j,int k, int l){
    System.out.println("2 arg");
}
}

vous devez l'utiliser comme ci-dessous exemple:

public class Imp extends Abs{

public Imp(int i, int j,int k, int l){
    super(i,j);
    System.out.println("2 arg");
}
}

considérez ceci:

abstract class Product { 
    int value;
    public Product( int val ) {
        value= val;
    }
    abstract public int multiply();
}

class TimesTwo extends Product {
    public int mutiply() {
       return value * 2;
    }
}

la superclasse est abstraite et a un constructeur.

bien Sûr, la classe abstraite peut avoir un constructeur.Généralement, le constructeur de la classe est utilisée pour initialiser les champs.Ainsi, une classe abstraite constructeur permet d'initialiser les champs de la classe abstraite. Vous fourniriez un constructeur pour une classe abstraite si vous voulez initialiser certains champs de la classe abstraite avant l'instanciation d'une classe enfantine. Un constructeur de classe abstraite peut également être utilisé pour exécuter du code qui est pertinent pour chaque classe d'enfant. Cela empêche la duplication de code.

Nous ne pouvons pas créer une instance d'une classe abstraite,Mais nous pouvons créer des instances de ces classes sont dérivées de la classe abstraite. Ainsi, lorsqu'une instance de classe dérivée est créée, le constructeur de classe abstraite parent est automatiquement appelé.

Référence : Cet Article

dans une classe de béton, la déclaration d'un constructeur pour un type de béton Fnord expose effectivement deux choses:

• Un moyen de code peuvent demander la création d'une instance de Fnord

• un moyen par lequel une instance d'un type dérivé du qui est en construction peut demander que toutes les caractéristiques de la classe de base soient initialisées.

bien qu'il devrait peut-être y avoir un moyen de contrôler ces deux capacités séparément, pour chaque type concret, une définition permettra les deux. Bien que la première capacité ne soit pas significative pour une classe abstraite, la seconde capacité est tout aussi significative pour une classe abstraite que pour n'importe quelle autre, et donc sa déclaration est tout aussi nécessaire et utile.

comme décrit par javafuns ici , ceci est un exemple:

public abstract class TestEngine
{
   private String engineId;
   private String engineName;

   public TestEngine(String engineId , String engineName)
   {
     this.engineId = engineId;
     this.engineName = engineName;
   }
   //public gettors and settors
   public abstract void scheduleTest();
}


public class JavaTestEngine extends TestEngine
{

   private String typeName;

   public JavaTestEngine(String engineId , String engineName , String typeName)
   {
      super(engineId , engineName);
      this.typeName = typeName;
   }

   public void scheduleTest()
   {
     //do Stuff
   }
}

Oui, Les classes abstraites peuvent avoir des constructeurs !

Voici un exemple d'utilisation du constructeur dans la classe abstraite:

abstract class Figure { 

    double dim1;        
    double dim2; 

    Figure(double a, double b) {         
        dim1 = a;         
        dim2 = b;         
    }

    // area is now an abstract method 

   abstract double area(); 

}


class Rectangle extends Figure { 
    Rectangle(double a, double b) { 
        super(a, b); 
    } 
    // override area for rectangle 
    double area() { 
        System.out.println("Inside Area for Rectangle."); 
        return dim1 * dim2; 
    } 
}

class Triangle extends Figure { 
    Triangle(double a, double b) { 
        super(a, b); 
    } 
    // override area for right triangle 
    double area() { 
        System.out.println("Inside Area for Triangle."); 
        return dim1 * dim2 / 2; 
    } 
}

class AbstractAreas { 
    public static void main(String args[]) { 
        // Figure f = new Figure(10, 10); // illegal now 
        Rectangle r = new Rectangle(9, 5); 
        Triangle t = new Triangle(10, 8); 
        Figure figref; // this is OK, no object is created 
        figref = r; 
        System.out.println("Area is " + figref.area()); 
        figref = t; 
        System.out.println("Area is " + figref.area()); 
    } 
}

donc je pense que vous avez la réponse.

Abstract class peut avoir un constructeur bien qu'il ne puisse pas être instancié. Mais le constructeur défini dans une classe abstraite peut être utilisé pour l'instanciation de la classe de béton de cette classe abstraite. Cocher la case JLS :

C'est une erreur de compilation si une tentative est faite pour créer une instance d'une classe abstraite à l'aide d'une instance de classe création expression .

une sous-classe d'un classe abstraite qui n'est pas elle-même abstraite peut être instancié, résultant de l'exécution d'un constructeur pour la classe abstraite et, par conséquent, l'exécution des initialisateurs de champ par exemple, les variables de cette classe.

Oui. Et un constructeur de la classe abstraite est appelée lorsqu'une instance d'une classe héritée est créé. Par exemple, ce qui suit est un programme Java valide.

// An abstract class with constructor
abstract class Base {
Base() { System.out.println("Base Constructor Called"); }
abstract void fun();
    }
class Derived extends Base {
Derived() { System.out.println("Derived Constructor Called"); }
void fun() { System.out.println("Derived fun() called"); }
    }

class Main {
public static void main(String args[]) { 
   Derived d = new Derived();
    }

}

C'est la sortie du code ci-dessus,

Constructeur De Base Appelé Constructeur Dérivé Appelé

références: entrez la description du lien ici

Puisqu'une classe abstraite peut avoir des variables de tous les modificateurs d'accès, ils doivent être initialisés aux valeurs par défaut, donc le constructeur est nécessaire. Comme vous instanciez la classe child, un constructeur d'une classe abstraite est invoqué et les variables sont initialisées.

au contraire, une interface ne contient que des variables constantes signifie qu'elles sont déjà initialisées. Donc l'interface n'a pas besoin d'un constructeur.

afin d'obtenir le chaînage du constructeur, la classe abstraite aura un constructeur. Le compilateur garde la déclaration Super () à l'intérieur du constructeur de la sous-classe, qui appellera le constructeur de la superclasse. S'il n'y avait pas de constructeur pour les classes abstraites, alors les règles java sont violées et nous ne pouvons pas réaliser le chaînage du constructeur.

Oui, une classe abstraite peut avoir un constructeur. Vous pouvez surcharger autant de constructeurs que vous voulez dans une classe abstraite. Ces entrepreneurs peuvent être utilisés pour initialiser l'état initial des objets étendant la classe abstraite. Comme nous le savons, nous ne pouvons pas faire un objet D'une classe abstraite parce que les objets sont créés par les "nouveaux" mots-clés et non par les constructeurs...ils ne sont là que pour initialiser l'état des objets de la sous-classe.

Oui sûrement vous pouvez en ajouter un, comme déjà mentionné pour l'initialisation des variables de classe abstraites. Mais si vous ne déclarez pas explicitement un, il a de toute façon un constructeur implicite pour "L'enchaînement de constructeur" à travailler.

le but du constructeur dans une classe est utilisé pour initialiser les champs mais pas pour"construire des objets". Lorsque vous essayez de créer une nouvelle instance d'un résumé super-classe, le compilateur vous donnera une erreur. Cependant, nous pouvons hériter D'un employé de classe abstraite et faire usage de son constructeur en définissant ses variables voir l'exemple ci-dessous

public abstract class Employee {
  private String EmpName;
  abstract double calcSalary();

  Employee(String name) {
    this.EmpName = name;// constructor of abstract class super class
  }
}

class Manager extends Employee{
 Manager(String name) {
    super(name);// setting the name in the constructor of sub class
 }
double calcSalary() {
    return 0;
 }
}

Oui..C'est comme n'importe quelle autre classe. Il peut avoir un constructeur et il est appelé après avoir créé l'objet pour la classe de base.