Règles de réécriture de méthode La
liste des paramètres et la liste des paramètres de la méthode réécrite doivent être exactement les mêmes.
Le type de retour et le type de retour de la méthode remplacée peuvent être différents, mais doivent être une classe dérivée de la valeur de retour de la classe parente (le type de retour de java5 et des versions antérieures doit être le même, et le type de retour de java7 et des versions ultérieures peut être différent).
L'autorité d'accès ne peut pas être inférieure à l'autorité d'accès de la méthode remplacée dans la classe parente. Par exemple: si une méthode de la classe parent est déclarée comme publique, le remplacement de la méthode dans la classe enfant ne peut pas être déclaré comme protégé.
Les méthodes membres de la classe parent ne peuvent être remplacées que par ses sous-classes.
Une méthode déclarée comme finale ne peut pas être remplacée.
Une méthode déclarée comme statique ne peut pas être remplacée, mais elle peut être déclarée à nouveau.
Si la sous-classe et la superclasse sont dans le même package, la sous-classe peut remplacer toutes les méthodes de la superclasse, à l'exception des méthodes déclarées comme privées et finales.
La sous-classe et la classe parente ne sont pas dans le même package, donc la sous-classe ne peut remplacer que les méthodes non finales de la classe parente déclarée comme publique et protégée.
La méthode substituée peut lever n'importe quelle exception non obligatoire, que la méthode remplacée lève ou non une exception. Cependant, la méthode substituée ne peut pas lever une nouvelle exception obligatoire, ou une exception obligatoire plus large que celle déclarée par la méthode surchargée, et vice versa.
La méthode de construction ne peut pas être remplacée.
Si vous ne pouvez pas hériter d'une méthode, vous ne pouvez pas remplacer cette méthode.
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();
}
}
/*以上实例编译运行结果如下：
TestDog.java:30: cannot find symbol
symbol : method bark()
location: class Animal
b.bark();
^
Utilisation du mot-clé Super
Lorsque vous devez appeler la méthode remplacée de la classe parente dans la 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类的方法
}
}
/*以上实例编译运行结果如下：
动物可以移动
狗可以跑和走
Surcharge La surcharge
est dans une classe avec le même nom de méthode mais des paramètres différents. Le type de retour peut être identique ou différent.
Chaque méthode (ou constructeur) surchargée doit avoir une liste unique de types de paramètres.
L'endroit le plus courant est la surcharge du constructeur.
Règles de rechargement:
La méthode surchargée doit changer la liste des paramètres (le nombre de paramètres ou de types est différent); la
méthode surchargée peut changer le type de retour; la
méthode surchargée peut changer le modificateur d'accès; la
méthode surchargée peut déclarer nouveau ou Vérifiez les exceptions plus largement; les
méthodes peuvent être surchargées dans la même classe ou dans une sous-classe.
Le type de valeur de retour ne peut pas être utilisé comme critère pour distinguer les fonctions surchargées.
Polymorphisme Java
Cas d'utilisation polymorphes
class Person
{
public void fun1()
{
System.out.println("1.Person{fun1()}") ;
}
public void fun2()
{
System.out.println("2.Person{fun2()}") ;
}
}
// Student类扩展自Person类，也就继承了Person类中的fun1()、fun2()方法
class Student extends Person
{
// 在这里覆写了Person类中的fun1()方法
public void fun1()
{
System.out.println("3.Student{fun1()}") ;
}
public void fun3()
{
System.out.println("4.Studen{fun3()}") ;
}
}
class TestJavaDemo1
{
public static void main(String[] args)
{
// 此处，父类对象由子类实例化
Person p = new Student() ;
// 调用fun1()方法，观察此处调用的是哪个类里的fun1()方法
p.fun1() ;
p.fun2() ;
}
}
//运行结果
/*
3.Student{fun1()}
2.Person{fun2()}
- Transition ascendante
public class Animal {
public void eat(){
System.out.println("animal eatting...");
}
}
public class Cat extends Animal{
public void eat(){
System.out.println("我吃鱼");
}
}
public class Dog extends Animal{
public void eat(){
System.out.println("我吃骨头");
}
public void run(){
System.out.println("我会跑");
}
}
public class Main {
public static void main(String[] args) {
Animal animal = new Cat(); //向上转型
animal.eat();
animal = new Dog();
animal.eat();
}
}
//结果:
//我吃鱼
//我吃骨头
Il s'agit de la transformation ascendante, Animal animal = new Cat (); transforme l'objet enfant Cat en objet parent Animal. À ce stade, la méthode appelée par la référence animale est une méthode de sous-classe.
- Abattu
class A {
public void print() {
System.out.println("A:print");
}
}
class B extends A {
public void print() {
System.out.println("B:print");
}
}
public class Test{
public static void main(String args[])
{
A a = new B(); //通过子类去实例化父类
a.print();
}
}
//B:print
Le downcasting consiste à transformer l'objet parent en objet enfant.
Animal a = new Cat();
Cat c = ((Cat) a);
c.eat();
//输出 我吃鱼
Dog d = ((Dog) a);
d.eat();
// 报错 ： java.lang.ClassCastException：com.chengfan.animal.Cat cannot be cast to com.chengfan.animal.Dog
Animal a1 = new Animal();
Cat c1 = ((Cat) a1);
c1.eat();
// 报错 ： java.lang.ClassCastException：com.chengfan.animal.Animal cannot be cast to com.chengfan.animal.Cat
Pourquoi le premier code ne signale-t-il pas une erreur? Par rapport à ce que vous savez déjà, car un lui-même est un objet Chat, il peut bien sûr être transformé en chat, et bien sûr il ne peut pas être transformé en chien.Avez-vous déjà vu le putain de phénomène d'un chien qui devient soudainement un chat?
Bien que a1 soit un objet Animal, il ne peut être abaissé vers aucun objet de sous-classe. Par exemple, si vous allez en archéologie et découvrez une nouvelle créature, vous savez que c'est un animal, mais vous ne pouvez pas dire directement, ah, c'est un chat, ou que c'est un chien.
class X {
public void show(Y y){
System.out.println("x and y");
}
public void show(){
System.out.println("only x");
}
}
class Y extends X {
public void show(Y y){
System.out.println("y and y");
}
public void show(int i){
}
}
class main{
public static void main(String[] args) {
X x = new Y();
x.show(new Y());
x.show();
}
}
//结果
//y and y
//only x
Y hérite de X et remplace la méthode show (Y y) dans X, mais ne remplace pas la méthode show ().
A ce moment, l'objet pointé par x avec un type de référence de X est Y. A ce moment, la méthode à appeler est déterminée par Y et sera recherchée à partir de Y en premier. Exécuter x.show (new Y ()) ;, la méthode est définie en Y, donc la méthode en Y est exécutée;
Mais quand x.show (); est exécuté, certaines personnes diront qu'il n'y a pas une telle méthode dans Y? Il semble trouver la méthode dans la classe parente, car la méthode de X est appelée.
En fait, il existe une méthode show () dans la classe Y. Cette méthode hérite de X, mais elle ne couvre pas cette méthode, elle n'est donc pas écrite explicitement en Y. On dirait qu'une méthode en X est appelée. En fait L'appel est toujours en Y.
// Hahaha je ne veux plus vivre