Définition : Le processus de détermination de la méthode à exécuter
a Question Certains lecteurs se demanderont si l'exécution d'une méthode ne dépend pas de l'objet d'exécution. dans les paramètres du code ? Pourquoi choisir ? b. Réponse
Si un objet correspond à plusieurs méthodes, vous devez faire une sélection
Les lecteurs auraient dû penser aux fonctionnalités de Java : le polymorphisme, c'est-à-dire multiple méthodes. Écrivez et rechargez. Je vais l'expliquer en détail ci-dessous. Java中的特性：多态，即重写 & 重载。下面我会详细讲解。
分类：静态分派 & 动态分派。下面我将详细讲解。
先看下面的代码
public class Test {
static abstract class Human {
}
static class Man extends Human {
}
static class Woman extends Human {
}
// 执行代码
public static void main(String[] args) {
Human man = new Man();
// 变量man的静态类型 = 引用类型 = Human：不会被改变、在编译器可知
// 变量man的动态类型 = 实例对象类型 = Man：会变化、在运行期才可知
}
}即：
变量的静态类型 = 引用类型 ：不会被改变、在编译器可知
变量的动态类型 = 实例对象类型 ：会变化、在运行期才可知
下面，我将详细讲解Java中的分派类型：静态分派 & 动态分派
定义 根据 变量的静态类型 进行方法分派 的 行为
即根据 变量的静态类型 确定执行哪个方法
发生在编译期，所以不由 Java 虚拟机来执行
应用场景 方法重载（OverLoad）
实例说明
public class Test {
// 类定义
static abstract class Human {
}
// 继承自抽象类Human
static class Man extends Human {
}
static class Woman extends Human {
}
// 可供重载的方法
public void sayHello(Human guy) {
System.out.println("hello,guy!");
}
public void sayHello(Man guy) {
System.out.println("hello gentleman!");
}
public void sayHello(Woman guy) {
System.out.println("hello lady!");
}
// 测试代码
public static void main(String[] args) {
Human man = new Man();
Human woman = new Woman();
Test test = new Test();
test.sayHello(man);
test.sayHello(woman);
}
}
// 运行结果
hello,guy!
hello,guy!根据上述的讲解，大家应该明白运行结果的原因：
方法重载（OverLoad） = 静态分派 = 根据 变量的静态类型 确定执行（重载）哪个方法
所以上述的方法执行时，是根据变量（man、woman）的静态类型（Human）确定重载sayHello()中参数为Human guy的方法，即sayHello(Human guy)
特别注意
可通过 强制类型转换 改变 变量的静态类型
Human man = new Man(); test.sayHello((Man)man); // 强制类型转换 // 此时man的静态类型从 Human 变为 Man // 所以会调用sayHello()中参数为Man guy的方法，即sayHello(Man guy)
问题描述：
背景 现需要进行静态分派
问题 程序中 没有显示指定 静态类型
解决方案 程序会根据 静态类型的优先级 从而选择 优先的静态类型进行方法分配。
实例说明
public class Overload {
private static void sayHello(char arg){
System.out.println("hello char");
}
private static void sayHello(Object arg){
System.out.println("hello Object");
}
private static void sayHello(int arg){
System.out.println("hello int");
}
private static void sayHello(long arg){
System.out.println("hello long");
}
// 测试代码
public static void main(String[] args) {
sayHello('a');
}
}
// 运行结果
hello char因为‘a’是一个char类型数据（即静态类型是char），所以会选择参数类型为char的重载方法。
若注释掉sayHello(char arg)方法，那么会输出
hello int
因为‘a’除了可代表字符串，还可代表数字97。因此当没有最合适的<strong>sayHello(char arg)</strong>方式进行重载时，会选择第二合适（第二优先级）的方法重载，即 <strong>sayHello(int arg)</strong>
总结：当没有最合适的方法进行重载时，会选优先级第二高的的方法进行重载，如此类推。
优先级顺序为：
char>int>long>float>double>Character>Serializable>Object>...
其中...为变长参数，将其视为一个数组元素。变长参数的重载优先级最低。
因为 char 转型到 byte 或 short 的过程是不安全的，所以不会选择参数类型为byte 或 short的方法进行重载，故优先级列表里也没有。
上面讲解的主要是 基本数据类型的优先级匹配问题
若是引用类型，则根据 继承关系 进行优先级匹配
注意只跟其编译时类型（即静态类型）相关
定义 根据 变量的动态类型 进行方法分派 的 行为
即根据 变量的动态类型 确定执行哪个方法
应用场景 方法重写（Override）
实例说明
// 定义类
class Human {
public void sayHello(){
System.out.println("Human say hello");
}
}
// 继承自 抽象类Human 并 重写sayHello()
class Man extends Human {
@Override
protected void sayHello() {
System.out.println("man say hello");
}
}
class Woman extends Human {
@Override
protected void sayHello() {
System.out.println("woman say hello");
}
}
// 测试代码
public static void main(String[] args) {
// 情况1
Human man = new man();
man.sayHello();
// 情况2
man = new Woman();
man.sayHello();
}
}
// 运行结果
man say hello
woman say hello
// 原因解析
// 1. 方法重写（Override） = 动态分派 = 根据 变量的动态类型 确定执行（重写）哪个方法
// 2. 对于情况1：根据变量（Man）的动态类型（man）确定调用man中的重写方法sayHello()
// 3. 对于情况2：根据变量（Man）的动态类型（woman）确定调用woman中的重写方法sayHello()特别注意
对于代码中：
Human man = new Man(); man = new Woman(); man.sayHello(); // man称为执行sayHello()方法的所有者，即接受者。
invokevirtual指令执行的第一步 = 确定接受者的实际类型
invokevirtual
Java : répartition statique et répartition dynamique 🎜🎜2. Répartition statique 🎜🎜🎜🎜Définir le comportement de la répartition des méthodes en fonction du type statique de la variable🎜🎜🎜🎜🎜🎜C'est-à-dire déterminer quelle méthode exécuter en fonction du type statique de la variable🎜🎜🎜🎜 se produit au moment de la compilation, il n'est donc pas contrôlé par Java Machine virtuelle à exécuter 🎜🎜🎜🎜🎜🎜Surcharge de méthode de scénario d'application (Surcharge) 🎜🎜🎜🎜Exemple de description🎜 🎜🎜rrreee🎜Selon l'explication ci-dessus, tout le monde devrait comprendre la raison du résultat de l'opération : 🎜 🎜🎜🎜Surcharge de méthode (OverLoad) = Répartition statique = Déterminer la méthode à exécuter (surcharge) en fonction de le type statique de la variable🎜🎜🎜🎜Ainsi, lorsque la méthode ci-dessus est exécutée, elle est basée sur le type statique de la variable (man, woman) (Human) détermine que le paramètre dans le sayHello() surchargé est la méthode Human guy , c'est-à-dire sayHello(Human guy)🎜🎜🎜🎜Portez une attention particulière à🎜🎜a. Lorsque le type statique de la variable change🎜🎜vous pouvez modifier la variable via 🎜conversion de type forcée🎜 Type statique🎜rrreee🎜b. 🎜Description du problème :🎜🎜🎜🎜🎜🎜L'arrière-plan a maintenant besoin d'une répartition statique🎜🎜🎜🎜Problème Le type statique spécifié n'est pas affiché dans le programme🎜🎜🎜🎜Solution Le programme de solution sélectionnera le type statique préféré pour l'allocation de méthode en fonction de la priorité du type statique. 🎜🎜🎜🎜Exemple de description🎜rrreee🎜Parce que ‘a’ est une donnée de type char (c'est-à-dire que le type statique est char) , il sélectionnera donc la méthode surchargée dont le type de paramètre est char. 🎜🎜Si la méthode sayHello(char arg) est commentée, 🎜rrreee🎜 sera affiché car ‘a’ peut non seulement représenter une chaîne, mais aussi le nombre 97. Par conséquent 🎜Lorsqu'il n'y a pas de moyen 🎜🎜sayHello(char arg)🎜🎜 le plus approprié pour surcharger, la deuxième méthode la plus appropriée (deuxième priorité) sera sélectionnée pour surcharger, c'est-à-dire 🎜 🎜 sayHello(int arg)🎜🎜🎜Résumé : lorsqu'il n'y a pas de méthode la plus appropriée pour la surcharge, la méthode avec la deuxième priorité la plus élevée sera sélectionnée pour la surcharge, et ainsi de suite. 🎜🎜L'ordre de priorité est :🎜🎜char>int>long>float>double>Character>Sérialisable>Object>...🎜🎜où
... devient variable Argument long, traitez-le comme un élément de tableau. Les paramètres de longueur variable ont la priorité de surcharge la plus faible. 🎜🎜Étant donné que le processus de conversion de char en byte ou short n'est pas sécurisé, le type de paramètre ne sera pas sélectionné comme byte code> ou <code>short est surchargé, il ne figure donc pas dans la liste des priorités. 🎜🎜Attention particulière🎜🎜🎜🎜L'explication ci-dessus concerne principalement le problème de correspondance de priorité des 🎜types de données de base🎜🎜🎜🎜🎜S'il s'agit d'un type de référence, la correspondance de priorité est basée sur la 🎜relation d'héritage🎜🎜🎜🎜🎜 Veillez à compiler uniquement avec le type de temps (c'est-à-dire le type statique) lié🎜🎜3. Répartition dynamique🎜🎜🎜🎜Définissez le comportement de la répartition de la méthode en fonction du type dynamique de la variable🎜🎜🎜🎜C'est-à-dire déterminez quelle méthode utiliser. exécuter en fonction du type dynamique de la variable🎜🎜🎜🎜Méthode du scénario d'application Override (Override) 🎜🎜🎜🎜Exemple de description🎜🎜🎜rrreee🎜Attention particulière🎜🎜Pour le code : 🎜rrreee🎜🎜 🎜 La première étape de l'exécution de l'instruction invokevirtual = Déterminer le type réel du récepteur 🎜🎜🎜🎜 La deuxième étape de l'exécution de l'instruction invokevirtual = 🎜Résoudre la méthode de classe référence de symbole dans le pool constant à une référence directe différente🎜🎜
La deuxième étape est l'essence de la réécriture de méthode (Override)
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
