Remplacement/surcharge Java

Override

Override est la réécriture par la sous-classe du processus d'implémentation des méthodes de la classe parent qui autorisent l'accès ! Ni la valeur de retour ni les paramètres formels ne peuvent être modifiés. Autrement dit, le shell reste inchangé et le noyau est réécrit !

L'avantage de la substitution est que les sous-classes peuvent définir leur propre comportement spécifique selon les besoins.

C'est-à-dire que la sous-classe peut implémenter les méthodes de la classe parent selon les besoins.

Dans les principes orientés objet, la substitution signifie que toute méthode existante peut être remplacée. L'exemple est le suivant :

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{

   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象

      a.move();// 执行 Animal 类的方法

      b.move();//执行 Dog 类的方法
   }
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

动物可以移动
狗可以跑和走

Comme vous pouvez le voir dans l'exemple ci-dessus, bien que b appartienne au type Animal, il exécute la méthode move de la classe Dog.

En effet, lors de la phase de compilation, seul le type référence du paramètre est vérifié.

Cependant, au moment de l'exécution, la machine virtuelle Java (JVM) spécifie le type d'objet et exécute les méthodes de l'objet.

Donc, dans l'exemple ci-dessus, la compilation réussit car la méthode move existe dans la classe Animal. Cependant, au moment de l'exécution, la méthode de l'objet spécifique est exécutée.

Considérons l'exemple suivant :

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}

public class TestDog{

   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象

      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      b.bark();
   }
}

Les résultats de compilation et d'exécution de l'exemple ci-dessus sont les suivants :

TestDog.java:30: cannot find symbol
symbol  : method bark()
location: class Animal
                b.bark();
                 ^

Ce programme générera une erreur de compilation car le type de référence de b, Animal, n'a pas de méthode d'écorce.

Règles de réécriture des méthodes

• La liste des paramètres doit être exactement la même que celle de la méthode remplacée

•        ; Le type de retour doit être exactement le même que le type de retour de la méthode remplacée

•  ; Les droits d'accès ne peuvent pas être inférieurs aux droits d'accès de la méthode substituée dans la classe parent. Par exemple : Si une méthode de la classe parent est déclarée publique, alors la méthode ne peut pas être déclarée protégée lors de son remplacement dans la sous-classe.

• Les méthodes membres d'une classe parent ne peuvent être remplacées que par ses sous-classes.

• Les méthodes déclarées finales ne peuvent pas être remplacées.

• Les méthodes déclarées statiques ne peuvent pas être remplacées, mais elles peuvent être déclarées à nouveau.

• Si la sous-classe et la classe parent sont dans le même package, la sous-classe peut remplacer toutes les méthodes de la classe parent, à l'exception des méthodes déclarées comme privées et finales.

• Si la sous-classe et la classe parent ne se trouvent pas dans le même package, la sous-classe ne peut remplacer que les méthodes non finales de la classe parent qui sont déclarées publiques et protégées.

• Une méthode substituée peut lever n'importe quelle exception non forcée, que la méthode substituée lève ou non une exception. Toutefois, une méthode substituée ne peut pas lever de nouvelles exceptions obligatoires ou des exceptions obligatoires plus larges que celles déclarées par la méthode substituée, et vice versa.

• Les constructeurs ne peuvent pas être remplacés.

• Si une méthode ne peut pas être héritée, elle ne peut pas être remplacée.

Utilisation du mot-clé Super

Lorsque vous devez appeler la méthode remplacée de la classe parent dans une sous-classe, utilisez le mot-clé super.

class Animal{

   public void move(){
      System.out.println("动物可以移动");
   }
}

class Dog extends Animal{

   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}

public class TestDog{

   public static void main(String args[]){

      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法

   }
}

L'exemple de compilation et les résultats d'exécution ci-dessus sont les suivants :

动物可以移动
狗可以跑和走

Surcharge (Surcharge)

La surcharge (surcharge) est dans une classe, le nom de la méthode est le même , mais les paramètres sont différents . Les types de retour peuvent être identiques ou différents.

Chaque méthode (ou constructeur) surchargée doit avoir une liste de types de paramètres unique.

Seuls les constructeurs peuvent être surchargés

Règles de surcharge

• La méthode surchargée doit changer la liste des paramètres

• La méthode surchargée peut changer le type de retour ;

• La méthode surchargée peut changer le modificateur d'accès

• Les méthodes surchargées peuvent déclarer un nouveau ou des exceptions vérifiées plus larges ; les méthodes

• peuvent être surchargées dans la même classe ou dans une sous-classe.

Instance

public class Overloading {
 
	public int test(){
		System.out.println("test1");
		return 1;
	}
 
	public void test(int a){
		System.out.println("test2");
	}	
 
	//以下两个参数类型顺序不同
	public String test(int a,String s){
		System.out.println("test3");
		return "returntest3";
	}	
 
	public String test(String s,int a){
		System.out.println("test4");
		return "returntest4";
	}	
 
	public static void main(String[] args){
		Overloading o = new Overloading();
		System.out.println(o.test());
		o.test(1);
		System.out.println(o.test(1,"test3"));
		System.out.println(o.test("test4",1));
	}
}

La différence entre l'écrasement et la surcharge