appel non méthode abstraite dans la classe abstraite java

J'ai 3 classes. Il semble question de base. Mais je ne peux pas trouver la réponse sur google.

public abstract class Test {

    void t1()
    {
        System.out.println("super");

    }

}
 public class concret extends Test{

    void t1()
    {
        System.out.println("child");

    }
    void t2()
    {
        System.out.println("child2");

    }

}

public class run {
    public static void main(String[] args) {
        Test t=new concret();

        t.t1();
    }

}

Comment dois-je appeler la classe abstraite t1 méthode? Depuis je ne peux pas créer un objet de la classe abstraite comment dois-je appeler t1 dans la classe abstraite?
Merci.

Je ne vois pas de classes abstraites.
et où est la classe abstraite?
désolé. édité..
Vous pourriez l'appeler super.t1() dans le t1 méthode de concret, mais en dehors de qui il n'y a pas un moyen de fois qu'il l'a remplacée.
Connexes: Pourquoi est super.super.méthode(); pas permis en Java?

OriginalL'auteur Dilis | 2014-12-03

java

9

Soit vous créez une classe concrète qui n'est pas remplacer la méthode, ou à l'intérieur d'une classe concrète qui ne remplacer la méthode, vous pouvez appeler super.t1(). Par exemple:
```
void t1()
{
    super.t1(); //First call the superclass implementation
    System.out.println("child");
}
```
Si vous avez seulement une instance d'un objet qui remplace une méthode, vous ne peut pas appel de la méthode originale de "l'extérieur" de la classe, parce que ce serait briser l'encapsulation... le but primordial est de remplacer le comportement de la méthode d'origine.

Merci.Je comprends ... je ne comprends encapsulation partie?
Vérifier why-is-super-super-method-not-allowed-in-java pour voir comment il pourrait être en violation de l'encapsulation.

OriginalL'auteur Jon Skeet

Voir la suite de tests:

public abstract class BaseClass {
public void doStuff() {
System.out.println("Called BaseClass Do Stuff");
}
public abstract void doAbstractStuff();
}
public class ConcreteClassOne extends BaseClass{
@Override
public void doAbstractStuff() {
System.out.println("Called ConcreteClassOne Do Stuff");
}
}
public class ConcreteClassTwo extends BaseClass{
@Override
public void doStuff() {
System.out.println("Overriding BaseClass Do Stuff");
}
@Override
public void doAbstractStuff() {
System.out.println("Called ConcreteClassTwo Do Stuff");
}
}
public class ConcreteClassThree extends BaseClass{
@Override
public void doStuff() {
super.doStuff();
System.out.println("-Overriding BaseClass Do Stuff");
}
@Override
public void doAbstractStuff() {
System.out.println("Called ConcreteClassThree Do Stuff");
}
}
public class Test {
public static void main(String[] args) {
BaseClass a = new ConcreteClassOne();
a.doStuff(); //Called BaseClass Do Stuff
a.doAbstractStuff(); //Called ConcreteClassOne Do Stuff
BaseClass b = new ConcreteClassTwo();
b.doStuff(); //Overriding BaseClass Do Stuff
b.doAbstractStuff(); //Called ConcreteClassTwo Do Stuff
BaseClass c = new ConcreteClassThree();
c.doStuff(); //Called BaseClass Do Stuff
//-Overriding BaseClass Do Stuff
c.doAbstractStuff(); //Called ConcreteClassThree Do Stuff
}
}

OriginalL'auteur Alan Hay

1

utiliser le mot clé "super" pour faire
```
void t1()
{  super.t1();
System.out.println("child");
}
```
Assurez-vous d'utiliser que dans le remplacé la méthode bien que.

OriginalL'auteur ShreyJo10
0

Classe abstraite désigne la classe a la abstract modificateur avant la class mot-clé. Cela signifie que vous pouvez déclarer des méthodes abstraites, qui ne sont mis en œuvre dans les classes concrètes.

Par exemple :
```
public abstract class Test {
public abstract void foo();
}
public class Concrete extends Test {
public void foo() {
System.out.println("hey");
}
}
```
Ceci ne répond pas à la question. L'OP veut savoir comment faire pour appeler le code de la méthode de la classe de base sur l'instance de la classe dérivée si la classe dérivée de remplacer cette méthode. Classe de Base étant abstraite a en fait rien à voir avec le problème de l'OP est en train de décrire.

OriginalL'auteur Stav Saad
0

Votre code semble appeler t1(). Cependant, c'est d'appeler le béton t1 (), parce que le résumé t1() a été remplacée par le béton de classe.

Si vous souhaitez appeler le résumé t1 méthode de code principal, ne remplacent pas les t1() dans le béton.

Ou vous pouvez créer une méthode dans la classe de béton par exemple:
```
    public void invokeSuperT1(){
super.t1();
}
```
OriginalL'auteur Rami Del Toro

Créer un anonyme Intérieur de la classe,

Classe abstraite:

 abstract class  Test{
abstract void t();
public void t1(){
System.out.println("Test");
}
}

Ici est de savoir comment créer anonyme intérieure:

Test test = new Test() {
@Override
void t() {
//you can throw exception here, if you want
}
};

Appeler l'intermédiaire de la classe de l'objet créé pour la classe abstraite,

test.t1();

OriginalL'auteur Praveen

Vous devez vous connecter pour publier un commentaire.