精华内容
下载资源
问答
  • java 多态 动态绑定

    2014-10-13 19:15:16
    public class TestMethod { public static void main... /* 动态绑定 * 在调用成员方法时,会将方法和对象的实际内存进行绑定,调用实际内存中的方法。 * * 函数参数不用到动态绑定 * 所以test(a1)
    package com.bjpowernode.mybatis.test;
    
    public class TestMethod {
    
    	public static void main(String[] args) {
    
    		/* 动态绑定
    		 * 在调用成员方法时,会将方法和对象的实际内存进行绑定,调用实际内存中的方法。
    		 * 
    		 * 函数参数不用到动态绑定
    		 * 所以test(a1)就调用第一个
    		 * 
    		 * 
    		A a = new A();
    		test(a);	//
    		
    		B b = new B();
    		test(b);
    		
    		A a1 = new B();
    		test(a1);
    		
    		*/
    		A a = new A();
    		System.out.println(a.getResult());
    		
    		B b = new B();
    		System.out.println(b.getResult());
    		
    		A a1 = new B();
    		System.out.println(a1.getResult());
    		
    	}
    	
    	public static void test( A a) {
    		System.out.println("Type of the param is A");
    	}
    	
    	public static void test( B b) {
    		System.out.println("Type of the param is B");
    	}
    
    }
    /*
    class A {
    	
    	private int i = 10;
    	
    	public int getResult() {
    		return i + 10;
    	}
    }
    class B extends A {
    	
    	private int i = 20;
    	
    	public int getResult() {
    		return i + 20;
    	}
    }
    执行结果
     *  20
     *	40
     *	40
     * 最基本的动态调用
     * 多态: 一个对象,在环境不同的条件下,会表现出不同的行为
     * 动态绑定: 在调用成员方法时,会将方法和对象的实际内存进行绑定,调用实际内存中的方法。
     * 	     注意: 只局限于成员方法
     * */
    
    
    /*
    class A {
    	
    	private int i = 10;
    	
    	public int getResult() {
    		return i + 10;
    	}
    }
    class B extends A {
    	
    	private int i = 20;
    	
    }
    这种情况呢?子类没有继承父类的成员方法,而继承了父类的成员变量呢?
     *执行结果:
     *	20
     *	20
     *	20
     * A a = new B();
     * 1. 子类没有重写父类的方法,但是会继承下来,所以B中有一个叫getResuult()的方法,只是看不到,
     * 2. 这个方法实际内存地址是A类对象的,在运行期调用方法时,JVM发现B对象中这个方法的地址与类B不匹配,
     * 		而是与类A对象的地址象吻合,那么他就会调用类A中的getResult方法,上面说过了,成员变量i不参加动态绑定
     * 		所以即使B对象中有i也不会用他的,而是用A对象的.
     * 3.出现这种情况的前提是B对象没有重写A对象的方法.
     * */
    
    /*
    class A {
    	
    	private int i = 10;
    	
    	public int getResult() {
    		return getI() + 10;
    	}
    	
    	public int getI() {
    		return i;
    	}
    }
    class B extends A {
    	
    	private int i = 20;
    }
    
    这种情况呢? 虽然子类没有重写父类的成员方法,而是重写了get方法?
     * 执行结果:
     *  20
     *	30
     *  30
     * 为什么出现这种情况?
     * 还是那句话: 只有成员方法参加多态的运行. 不管你是在哪调用的,即使你在成员方法中调用
     * 			一个方法,只要是子类重写了,那么就多态.
     * 根据上一个例子: 它调用父类的getResult时,内部有一个getI(),这时候要多态了,发现子类
     * 				重写了,那么就调用子类的,返回20
     */
    /*
    class A {
    	
    	private int i = 10;
    	
    	public int getResult() {
    		return getI() + 10;
    	}
    	
    	public int getI() {
    		return i;
    	}
    }
    class B extends A {
    	
    	private int i = 20;
    	
    }
    这种情况就更明了了.
     * 执行结果:
     *  20
     *	20
     *	20
     * 
     * */
    
    class A {
    	
    	private int i = 10;
    	
    	public int getResult() {
    		return getI() + 10;
    	}
    	
    	public int getI() {
    		return i;
    	}
    }
    class B extends A {
    	
    	private int i = 20;
    	
    	public int getResult() {
    		return getI() + 20;
    	}
    }
    /*
    * 执行结果:
    *  20
    *  30
    *  30
    * 
    * */

    展开全文
  • 针对 Java 简单的可以理解为程序编译期的绑定绑定的是类信息 Java 中的方法只有 final,static,private,重载方法和构造方法是静态绑定 所有的变量都是静态绑定 动态绑定(后期绑定) 编译器在编译阶段不知道要调用...

    class Animal {

    public void cry() {

    System.out.println("xxx");

    }

    }

    class Cat extends Animal {

    public void cry() {

    System.out.println("yyy");

    }

    public void bite() {

    System.out.println("zzz");

    }

    }

    public class PolymorphicTest {

    public static void main(String ...args) {

    Animal cat = new Cat();

    cat.cry(); // yyy

    ((Cat)cat).bite(); // zzz

    }

    }

    多态存在的三个必要条件:继承、重写、父类变量引用子类对象

    数据转型

    向上转型(up casting):就是将子类的对象转型成父类的引用(就是父类引用指向了子类的对象,此时此引用只能访问父类的成员)。

    向下转型(down casting):将向上转型的引用再转回来,就叫向下转型(此时引用能访问子类的成员变量)

    多态中成员的特点

    在多态中成员函数的特点:动态绑定

    在编译时期:参阅引用型变量所属的类中是否有调用的方法。如果有,编译通过,如果没有编译失败

    在运行时期:参阅对象所属的类中是否有调用的方法

    简单总结就是:成员函数在多态调用时,编译看左边,运行看右边

    在多态中,成员变量的特点:静态绑定

    无论编译和运行,都参考左边(引用型变量所属的类)

    在多态中,静态成员函数的特点:静态绑定

    无论编译和运行,都参考左边

    因为静态只看类,没有重写,只有隐藏

    多态好处

    不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上,从而导致该引用调用的具体方法随之改变,即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态,这就是多态性。多态性的实现主要通过动态绑定

    程序绑定

    程序绑定是一个成员的调用与成员所在的类(成员主体)关联起来。对 Java 来说,绑定分为静态绑定和动态绑定

    静态绑定(前期绑定)

    在编译期已经可以确定的信息,就在程序执行前被绑定,此时由编译器或其它连接程序实现。针对 Java 简单的可以理解为程序编译期的绑定,绑定的是类信息

    Java 中的方法只有 final,static,private,重载方法和构造方法是静态绑定

    所有的变量都是静态绑定

    动态绑定(后期绑定)

    编译器在编译阶段不知道要调用哪个方法,在运行时根据具体对象的类型进行绑定,绑定的是对象信息

    若一种语言实现了后期绑定,同时必须提供一些机制,可在运行期间判断对象的类型,并分别调用适当的方法。也就是说,编译器此时依然不知道对象的类型,但方法调用机制能自己去调查,找到正确的方法主体。不同的语言对后期绑定的实现方法是有所区别的。但我们至少可以这样认为:它们都要在对象中安插某些特殊类型的信息

    重写方法使用的是动态绑定

    方法调用

    以 obj.func(param) 为例,隐式参数 obj 声明为 Cat 类的对象

    编译器查看对象的声明类型和方法名

    需要注意的是,有可能存在多个名字为 func 但参数签名不一样的方法。例如,可能存在方法 func(int) 和 func(String)。编译器将会一一列举所有 Cat 类中名为 func 的方法和其父类 Animal 中访问属性为 public 且名为 func 的方法(超类中的私有方法不可访问)

    这样,编译器就获得了所有可能被调用的候选方法列表

    接下来,编译器将检查调用方法时提供的参数签名

    如果在所有名为 func 的方法中存在一个与提供的参数签名完全匹配的方法,那么就选择这个方法。这个过程被称为重载解析(overloading resolution)。例如,如果调用 func("hello"),编译器会选择 func(String),而不是 func(int)。由于自动类型转换的存在,例如 int 可以转换为 double,Cat 可以转换成 Animal 等,如果没有找到与调用方法参数签名匹配的方法,就进行类型转换后再继续查找。如果编译器没有找到与参数类型匹配的方法,或者发现经过类型转换后有多个方法与之匹配,那么编译错误

    这样,编译器就获得了需要调用的方法名字和参数类型

    如果是 private、static、final,或者是构造方法,那么编译器将可以准确地知道应该调用哪个方法,这种调用方式称为静态绑定。与此对应的是,调用的方法依赖于隐式参数的实际类型,这就需要在运行时通过动态绑定确定调用方法,比如上面的 cat.cry()

    当程序运行,并且釆用动态绑定调用方法时,JVM 一定会调用与 obj 所引用对象的实际类型最合适的那个类的方法。我们已经假设 obj 的实际类型是 Cat,它是 Animal 的子类,如果 Cat 中定义了 func(String),就调用它,否则将在 Animal 类及其父类中寻找

    方法表

    每次调用方法都要进行搜索,时间开销相当大,因此,JVM 预先为每个类创建了一个方法表,其中列出了所有方法的名称、参数签名和所属的类。这样一来,在真正调用方法的时候,JVM 仅查找这个表就行了。在上面的例子中,JVM 搜索 Cat 类的方法表,以便寻找与调用 func("hello") 相匹配的方法。这个方法既有可能是 Cat.func(String),也有可能是 Animal.func(String)。注意,如果调用 super.func("hello"),编译器将对父类的方法表进行搜索

    假设 Animal 类包含 cry()、getName()、getAge() 三个方法,那么它的方法表如下:

    cry() -> Animal.cry()

    getName() -> Animal.getName()

    getAge() -> Animal.getAge()

    实际上,Animal 有默认的父类 Object,会继承 Object 的方法,所以上面列举的方法并不完整

    假设 Cat 类覆盖了 Animal 类中的 cry() 方法,并且新增了一个方法 climbTree(),那么它的参数列表为:

    cry() -> Cat.cry()

    getName() -> Animal.getName()

    getAge() -> Animal.getAge()

    climbTree() -> Cat.climbTree()

    在运行的时候,调用 obj.cry() 方法的过程如下:

    JVM 首先提取 obj 的实际类型的方法表,可能是 Animal 类的方法表,也可能是 Cat 类及其子类的方法表

    JVM 在方法表中搜索与 cry() 签名匹配的方法,找到后,就知道它属于哪个类了

    JVM 调用该方法

    总结

    先通过对象类型与方法名在方法表中找

    通过参数签名进行重载解析

    确认属于静态绑定还是动态绑定,最后调用

    展开全文
  • java-动态绑定机制

    java-多态 动态绑定机制

    p315
    请添加图片描述

    展开全文
  • 主要介绍了Java多态动态绑定原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java多态数据绑定

    2018-10-29 19:23:50
    java多态数据绑定 原文链接:详情链接地址 java多态数据绑定 http://licocom.com/archives/852 最近在看书的时候发现了一个事例,觉得非常的生动,便记录下来。 在此事例中我们可以生动的看到继承,调用,多态,数据...

    java多态数据绑定
    原文链接:详情链接地址 java多态数据绑定
    http://licocom.com/archives/852
    最近在看书的时候发现了一个事例,觉得非常的生动,便记录下来。

    在此事例中我们可以生动的看到继承,调用,多态,数据绑定等,多种事例。

    1.继承调用父类的方法,构造器。

    2.多态

    3.数据动态绑定

    第一:继承调用父类的方法,构造器。

    有两种角色:雇员,经理。经理—>(属于)雇员

    那么创建雇员类,获取薪水的方法为getSalary,经理继承于雇员获取其所有属性方法,

    但获取薪水的算法不同,所以对原有获取薪水进行重写。

    原有方法在Employee内,

    public void raiseSalary(double byPercent) {
    
      double raise = salary * byPercent / 100;
    
      salary += raise;
    }
    

    那么经理类继承于雇员类,修改不同的获得薪水方法,我们采用super调用。

    public double getSalary() {
    
      double baseSalary = super.getSalary();
    
      return baseSalary + bonus;
    }
    

    调用父类方法,不仅如此,我们也可修改调用父类的构造器,且必须放在方法刚开始。

    public Manager(String n, double s, int year, int month, int day) {
    
      super(n, s, year, month, day);
    
      bonus = 0;
    }
    

    在这必须对父类构造器调用,并默认赋值。

    第二:多态可以指示多种实际类型的现象被称为多态。

    Employeeone[] staff = new Employeeone[3];
    
    staff[0] = boss;
    
    staff[1] = new Employeeone("he", 5000, 1888, 10, 16);
    
    staff[2] = new Employeeone("ne", 4000, 1567, 12, 10);
    
    for(Employeeone e:staff) {
    
    System.out.print("name="+e.getName()+",salary="+e.getSalary());
    

    }
    如上,我们staff数组分别存放雇员,经理类,而遍历对象e可以根据不同的类,

    指向不同的方法,当e引用Manager类,e.getSalary() 调用的是经理的,

    当e引用Employee,e.getSalary()调用的是雇员,这里便是数据的动态绑定。

    运行代码如下:

    MessageTest 主类
    import com.licocom.practice.Employee;

    public class MessageTest {
    
    public static void main(String[] arge) {
    
    Manager boss = new Manager("coco", 9000, 1955, 12, 15);
    
    boss.setBonus(9000);
    
    Employeeone[] staff = new Employeeone[3];
    

    staff[0] = boss;

    staff[1] = new Employeeone(“he”, 5000, 1888, 10, 16);

    staff[2] = new Employeeone(“ne”, 4000, 1567, 12, 10);

    for(Employeeone e:staff) {

    System.out.print(“name=”+e.getName()+",salary="+e.getSalary());

    }
    }
    }
    Messang类
    public class Manager extends Employeeone {

    private double bonus;
    
    public Manager(String n, double s, int year, int month, int day) {
    
    super(n, s, year, month, day);
    

    bonus = 0;

    }

    public double getSalary() {
    
    double baseSalary = super.getSalary();
    

    return baseSalary + bonus;
    }

    public void setBonus(double b) {
    
    bonus = b;
    
    }
    

    }
    Employee类

    import java.util.Date;
    
    import java.util.GregorianCalendar;//时间类
    
    public class Employeeone {
    
    private String name;
    
    private double salary;
    
    private Date hireDay;
    
    public Employeeone(String n, double s, int year, int month, int day) {
    
    name = n;
    
    salary = s;
    
    GregorianCalendar calendar = new GregorianCalendar(year, month - 1, day);
    
    hireDay = calendar.getTime();
    

    }

    public String getName() {
    
    return name;
    

    }

    public double getSalary() {
    
    return salary;
    

    }

    public Date gethireDay() {
    
    return hireDay;
    

    }

    public void raiseSalary(double byPercent) {
    
    double raise = salary * byPercent / 100;
    
    salary += raise;
    
    }
    

    }
    此为正式代码的三个类,结构非常轻巧,引用经典。

    面向开发需求,记录学习之路♪(^∀^●)ノ

    展开全文
  • Java多态动态绑定

    2019-12-18 14:06:03
    文章目录Java多态之动态绑定引用变量的类型编译时类型运行时类型方法绑定静态绑定动态绑定方法表 Java多态之动态绑定 上篇回顾:多态是面向对象程序设计非常重要的特性,它让程序拥有 更好的可读性和可扩展性。 ...
  • JAVA多态动态绑定

    2017-12-27 17:37:57
    新建一个对象时,有声明类型和实际类型之分,如Person p = new Male(); Person为声明类型,Male为实际类型,如果使用p去调用方法已经被重写,那么p调用该方法时,调用的是Male里的被重写的方法。
  • java多态动态绑定

    2020-07-25 20:58:29
    如果是在编译时期解析,那么就称之为静态绑定(static binding),如果方法的调用是在运行时期解析,那就是动态绑定(dynamic binding)或者延迟绑定(late binding)。 多态使得父类型的引用变量可以引用子类型的...
  • java多态动态绑定

    2018-11-17 23:14:19
    有关java多态学习的收获is-a原则动态绑定 is-a原则 "is-a"原则,它表明子类的每一个对象也是超类的一个对象。例如没一个经理都是雇员,因此将Manager设计为Employee的子类是不用多想的,...
  • JAVA 多态动态绑定

    2017-01-25 17:46:24
    动态绑定:程序运行自动选择调用那个对象的方法 虚拟机一定调用引用对象的”实际类“的最适合的方法。虚拟机预先为每一个类创建一个 方法表,在运行时,虚拟机会查这个表。首先适配实际类的方法,否则在超类中...
  • 大家可能都知道Java面向对象的三大特性,封装,继承,多态,其中动态绑定就与多态有关,那什么是动态绑定呢? 1.动态绑定(auto binding):也叫后期绑定,在运行时,虚拟机根据具体对象的类型进行绑定,或者说是...
  • JAVA多态动态绑定机制

    千次阅读 2018-10-19 17:27:51
    对于多态,大家基本上都很熟悉,日常开发用的也挺多,一句话概括:父类引用指向...为了弄清楚多态,我们需要引入jvm方法调用的静态和动态绑定机制的概念, jvm静态绑定机制 Public class Utils{ private stati...
  • Java面向对象三大特性之多态,动态绑定多态绑定静态绑定静态绑定的特点动态绑定总结参考 多态 什么是多态呢? 我们知道引用变量是用来操作对象的。 eg:Dog dog = new Dog(); 我们创建一个Dog类的对象,用dog这个引用...
  • java 多态绑定

    2014-03-12 09:59:39
    绑定即方法调用与方法体关联起来。绑定分前期绑定和后期绑定。  在面向过程语言中,都是前期绑定的,C中的先定义(声明)后调用保证了前期绑定能够顺利进行。...后期绑定也称为动态绑定或运行时绑定
  • java多态动态绑定

    2016-04-11 23:55:45
    java多态存在的三个必要条件:要有继承、要有重写、父类变量引用子类对象。 当使用多态方式调用方法时: a. 首先检查父类中是否有该方法,如果没有,则编译错误;如果有,则检查子类是否覆盖了该方法。 b. 如果...
  • JAVA多态动态绑定

    2020-06-14 16:42:59
    在我们写继承时,对同一基类写继承,不同的子类可能需要重写不同的实现方法,产生不同的执行结果。 我们在调用这些方法时,因为这些方法所使用的类不同,会写很多重载的代码,很... 这时就用到了我们的多态,举个例子:
  • Java多态动态绑定

    2019-09-27 05:41:37
    2.动态绑定 父类有多个子类,且多个子类都继承了父类中某个方法并以不同实现重写了。由于多态,父类引用可能指向的是子类对象,在使用父类引用调用该方法时,虚拟机可以在运行时决定调用对象的实际类型中的实现,...
  • Java中除了static方法和final方法(private属于final方法)之外,其它所有的方法都是动态绑定。 下面是书中“几何形状”的例子: package com.ran.unit8; import java.util.Random; /** * 动态绑定 */ class ...
  • 在上一篇文章《详解Java中的覆写与重载》中介绍了什么是覆写以及重载,如何理解区分这两者的概念还是十分重要的。而谈到覆写和重载又会引入一个概念,那就是多态多态有两种具体的表现,那就是上面所说的覆写以及...
  • 网上很多的文章并不能让我真正的理解多态,准备深入分析一下Java多态o( ̄ヘ ̄o#)。
  • 解释java多态动态绑定、静态绑定、向上转型、传值引用和传值引用的相关特性。
  • Java多态机制的实现依赖于其动态绑定。 (本文默认读者已经了解Java程序的编译和运行时问题。)1、程序绑定的概念 绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。  对Java来说,绑定分为静态绑定...
  • Java多态动态绑定

    2016-12-14 07:58:43
    Java中,父类的变量可以引用父类的实例,也可以引用子类的实例。package syc; public class Demo { public static void main(String[] args) { Animal obj = new Animal(); obj.cry(); obj = new Cat();

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,626
精华内容 15,850
关键字:

java多态动态绑定

java 订阅