精华内容
下载资源
问答
  • 对java来说,绑定分为静态绑定和动态绑定;或者叫做前期绑定和后期绑定静态绑定(早绑定 编译器绑定):在程序执行前方法已经被绑定,此时由编译器或其它连接程序实现。例如:C。针对java简单的可以理解为程序编译期的...

    程序绑定的概念:

    绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对java来说,绑定分为静态绑定和动态绑定;或者叫做前期绑定和后期绑定

    静态绑定(早绑定 编译器绑定):

    在程序执行前方法已经被绑定,此时由编译器或其它连接程序实现。例如:C。

    针对java简单的可以理解为程序编译期的绑定;这里特别说明一点,java当中的方法只有final,static,private和构造方法是前期绑定

    动态绑定(迟绑定 运行期绑定):

    后期绑定:在运行时根据具体对象的类型进行绑定。

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

    动态绑定的过程:

    虚拟机提取对象的实际类型的方法表;

    虚拟机搜索方法签名;

    调用方法。

    关于绑定相关的总结:

    在了解了三者的概念之后,很明显我们发现java属于后期绑定。在java中,几乎所有的方法都是后期绑定的,在运行时动态绑定方法属于子类还是基类。但是也有特殊,针对static方法和final方法由于不能被继承,因此在编译时就可以确定他们的值,他们是属于前期绑定的。特别说明的一点是,private声明的方法和成员变量不能被子类继承,所有的private方法都被隐式的指定为final的(由此我们也可以知道:将方法声明为final类型的一是为了防止方法被覆盖,二是为了有效的关闭java中的动态绑定)。java中的后期绑定是有JVM来实现的,我们不用去显式的声明它,而C++则不同,必须明确的声明某个方法具备后期绑定。

    java当中的向上转型或者说多态是借助于动态绑定实现的,所以理解了动态绑定,也就搞定了向上转型和多态。

    前面已经说了对于java当中的方法而言,除了final,static,private和构造方法是前期绑定外,其他的方法全部为动态绑定。而动态绑定的典型发生在父类和子类的转换声明之下:

    比如:Parent p = new Children();

    其具体过程细节如下:

    1:编译器检查对象的声明类型和方法名。假设我们调用x.f(args)方法,并且x已经被声明为C类的对象,那么编译器会列举出C类中所有的名称为f的方法和从C类的超类继承过来的f方法

    2:接下来编译器检查方法调用中提供的参数类型。如果在所有名称为f 的方法中有一个参数类型和调用提供的参数类型最为匹配,那么就调用这个方法,这个过程叫做“重载解析”

    3:当程序运行并且使用动态绑定调用方法时,虚拟机必须调用同x所指向的对象的实际类型相匹配的方法版本。假设实际类型为D(C的子类),如果D类定义了f(String)那么该方法被调用,否则就在D的超类中搜寻方法f(String),依次类推

    展开全文
  • 今天小编就为大家分享一篇vue实现条件判断动态绑定样式的方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • vue实现条件判断动态绑定样式

    万次阅读 2018-05-24 19:23:59
    在我们做前端页面的时候,为了美观和直观,我们希望通过条件判断来让页面显示不同的样式,如下图所示:当值为“是”时,显示绿色的标签,当值为“否”时,显示为灰色的标签。标签的样式分别为:<el-tag type=...

    在我们做前端页面的时候,为了美观和直观,我们希望通过条件判断来让页面显示不同的样式,如下图所示:


    当值为“是”时,显示绿色的标签,当值为“否”时,显示为灰色的标签。

    标签的样式分别为:

    <el-tag type="success">绿色标签</el-tag>

    <el-tag type="info">灰色标签</el-tag>

    关键在于type的样式部分,我们利用vue的样式绑定,结合三元表达式使用

    :type="{条件} ? {如果为真} : {否则}"

    在代码中:

    <el-tag size="medium" :type="scope.row.is_multiple === '否' ? 'info' : 'success'" >{{

        scope.row.is_multiple }}
    </el-tag>

    这样效果即可出来了。



    展开全文
  • 一、动态绑定指在执行期间(run,分配内存)而非编译期间判断所引用对象的实际类型,根据实际类型调用相关方法。其存在的必要条件要有继承要有重写父类引用指向子类对象package practice;class Animal{private String ...

    一、动态绑定

    指在执行期间(run,分配内存)而非编译期间判断所引用对象的实际类型,根据实际类型调用相关方法。

    其存在的必要条件

    要有继承

    要有重写

    父类引用指向子类对象

    package practice;

    class Animal{

    private String name;

    Animal(String name){

    this.name=name;

    }

    public void enjoy(){

    System.out.println("叫声........");

    }

    }

    class Cat extends Animal{

    private String eyescolor;

    Cat(String name,String color){

    super(name);

    this.eyescolor=color;

    }

    public void enjoy(){

    System.out.println("猫叫.........");

    }

    }

    class Dog extends Animal{

    private String furcolor;

    Dog(String name,String color){

    super(name);

    this.furcolor=color;

    }

    public void enjoy(){

    System.out.println("狗叫。。。。。。");

    }

    }

    class Lady{

    private String name;

    Animal pet;

    Lady(String name,Animal animal){

    this.name=name;

    this.pet=animal;

    }

    public void myPetEnjoy(){

    pet.enjoy();//根据new的对象来决定调用哪一个方法

    }

    }

    public class TestLady {

    public static void main(String args[]){

    Cat cat=new Cat("mimi","black");

    Dog dog=new Dog("wangwang","white");

    Lady l1=new Lady("lili",cat);

    Lady l2=new Lady("wenwne",dog);

    l1.myPetEnjoy();

    l2.myPetEnjoy();

    }

    }

    结果:猫叫.........

    狗叫。。。。。。

    共有三个enjoy()函数,所以myPetEnjoy()函数中具体调用哪一个enjoy()函数由new的对象来决定

    二、抽象类及抽象方法

    抽象方法类似c++中的纯虚函数

    含有抽象方法的类必须声明为抽象类

    抽象类不能被实例化,也可以理解为没有构造函数,抽象方法必须被重写

    package practice;

    abstract class Animal{

    abstract void getinfo();

    }

    class Pig extends Animal{

    private String name;

    private int height;

    private int weight;

    Pig(String name, int height, int weight) {

    this.name=name;

    this.height=height;

    this.weight=weight;

    }

    void getinfo(){

    System.out.println("name:"+name+" "+"height:"+height+" "+"weight:"+weight);

    }

    }

    public class _abstract {

    public static void main(String args[]){

    Pig pig=new Pig("lulu",20,30);

    pig.getinfo();

    }

    }

    结果:name:lulu height:20 weight:30

    三、接口

    classextendsimplements

    一种特殊的抽象类

    只包含public static final常量和抽象方法,但是abstract可以省略

    接口特性:

    多重实现(一个类可以实现多继承)

    接口中只能定义抽象方法,而且这些方法只能默认为public

    接口可以继承其他接口 package practice;

    interface Singer{

    public int age=20;

    public void sing();

    public void sleep();

    }

    interface Painter{

    public int age=30;

    public void paint();

    public void sleep1();

    }

    class People implements Singer,Painter{

    @Override

    public void sing() {

    // TODO Auto-generated method stub

    System.out.println("I'm singing......");

    }

    @Override

    public void sleep() {

    // TODO Auto-generated method stub

    System.out.println("I'm sleep......");

    }

    @Override

    public void paint() {

    // TODO Auto-generated method stub

    System.out.println("I'm sleeping....");

    }

    @Override

    public void sleep1() {

    // TODO Auto-generated method stub

    System.out.println("You are sleeping...");

    }

    }

    public class TestInterface {

    public static void main(String args[]){

    People people=new People();

    people.sing();

    people.sleep();

    people.paint();

    people.sleep1();

    }

    结果:I'm singing......

    I'm sleep......

    I'm sleeping....

    You are sleeping...

    展开全文
  • 对java来说,绑定分为静态绑定和动态绑定;或者叫做前期绑定和后期绑定.静态绑定:在程序执行前方法已经被绑定(也就是说在编译过程中就已经知道这个方法到底是哪个类中的方法),此时由编译器或其它连接程序实现。...

    程序绑定的概念:

    绑定指的是一个方法的调用与方法所在的类(方法主体)关联起来。对java来说,绑定分为静态绑定和动态绑定;或者叫做前期绑定和后期绑定.

    静态绑定:

    在程序执行前方法已经被绑定(也就是说在编译过程中就已经知道这个方法到底是哪个类中的方法),此时由编译器或其它连接程序实现。例如:C。

    针对java简单的可以理解为程序编译期的绑定;这里特别说明一点,java当中的方法只有final,static,private和构造方法是前期绑定

    动态绑定:

    后期绑定:在运行时根据具体对象的类型进行绑定。

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

    动态绑定的过程:

    虚拟机提取对象的实际类型的方法表;

    虚拟机搜索方法签名;

    调用方法。

    关于final,static,private和构造方法是前期绑定的理解

    对于private的方法,首先一点它不能被继承,既然不能被继承那么就没办法通过它子类的对象来调用,而只能通过这个类自身的对象来调用。因此就可以说private方法和定义这个方法的类绑定在了一起。

    final方法虽然可以被继承,但不能被重写(覆盖),虽然子类对象可以调用,但是调用的都是父类中所定义的那个final方法,(由此我们可以知道将方法声明为final类型,一是为了防止方法被覆盖,二是为了有效地关闭java中的动态绑定)。

    构造方法也是不能被继承的(网上也有说子类无条件地继承父类的无参数构造函数作为自己的构造函数,不过个人认为这个说法不太恰当,因为我们知道子类是通过super()来调用父类的无参构造方法,来完成对父类的初始化, 而我们使用从父类继承过来的方法是不用这样做的,因此不应该说子类继承了父类的构造方法),因此编译时也可以知道这个构造方法到底是属于哪个类。

    对于static方法,具体的原理我也说不太清。不过根据网上的资料和我自己做的实验可以得出结论:static方法可以被子类继承,但是不能被子类重写(覆盖),但是可以被子类隐藏。(这里意思是说如果父类里有一个static方法,它的子类里如果没有对应的方法,那么当子类对象调用这个方法时就会使用父类中的方法。而如果子类中定义了相同的方法,则会调用子类的中定义的方法。唯一的不同就是,当子类对象上转型为父类对象时,不论子类中有没有定义这个静态方法,该对象都会使用父类中的静态方法。因此这里说静态方法可以被隐藏而不能被覆盖。这与子类隐藏父类中的成员变量是一样的。隐藏和覆盖的区别在于,子类对象转换成父类对象后,能够访问父类被隐藏的变量和方法,而不能访问父类被覆盖的方法)

    由上面我们可以得出结论,如果一个方法不可被继承或者继承后不可被覆盖,那么这个方法就采用的静态绑定。

    java的编译与运行

    java的编译过程是将java源文件编译成字节码(jvm可执行代码,即.class文件)的过程,在这个过程中java是不与内存打交道的,在这个过程中编译器会进行语法的分析,如果语法不正确就会报错。

    Java的运行过程是指jvm(java虚拟机)装载字节码文件并解释执行。在这个过程才是真正的创立内存布局,执行java程序。

    java字节码的执行有两种方式: (1)即时编译方式:解释器先将字节编译成机器码,然后再执行该机器码;(2)解释执行方式:解释器通过每次解释并执行一小段代码来完成java字节码程序的所有操作。(这里我们可以看出java程序在执行过程中其实是进行了两次转换,先转成字节码再转换成机器码。这也正是java能一次编译,到处运行的原因。在不同的平台上装上对应的java虚拟机,就可以实现相同的字节码转换成不同平台上的机器码,从而在不同的平台上运行)

    前面已经说了对于java当中的方法而言,除了final,static,private

    和构造方法是前期绑定外,其他的方法全部为动态绑定。

    而动态绑定的典型发生在父类和子类的转换声明之下:

    比如:Parent p = new Children();

    其具体过程细节如下:

    1:编译器检查对象的声明类型和方法名。

    假设我们调用x.f(args)方法,并且x已经被声明为C类的对象,那么编译器会列举出C 类中所有的名称为f 的方法和从C 类的超类继承过来的f 方法。

    2:接下来编译器检查方法调用中提供的参数类型。

    如果在所有名称为f 的方法中有一个参数类型和调用提供的参数类型最为匹配,那么就调用这个方法,这个过程叫做“重载解析”。

    3:当程序运行并且使用动态绑定调用方法时,虚拟机必须调用同x所指向的对象的实际类型相匹配的方法版本。

    假设实际类型为D(C的子类),如果D类定义了f(String)那么该方法被调用,否则就在D的超类中搜寻方法f(String),依次类推。

    JAVA 虚拟机调用一个类方法时(静态方法),它会基于对象引用的类型(通常在编译时可知)来选择所调用的方法。相反,当虚拟机调用一个实例方法时,它会基于对象实际的类型(只能在运行时得知)来选择所调用的方法,这就是动态绑定,是多态的一种。动态绑定为解决实际的业务问题提供了很大的灵活性,是一种非常优美的机制。

    与方法不同,在处理java类中的成员变量(实例变量和类变量)时,并不是采用运行时绑定,而是一般意义上的静态绑定。所以在向上转型的情况下,对象的方法可以找到子类,而对象的属性(成员变量)还是父类的属性(子类对父类成员变量的隐藏)。

    Java代码

    public class Father {

    protected String name = "父亲属性";

    }

    public class Son extends Father {

    protected String name = "儿子属性";

    public static void main(String[] args) {

    Father sample = new Son();

    System.out.println("调用的属性:" + sample.name);

    }

    }

    结论,调用的成员为父亲的属性。

    这个结果表明,子类的对象(由父类的引用handle)调用到的是父类的成员变量。所以必须明确,运行时(动态)绑定针对的范畴只是对象的方法。

    现在试图调用子类的成员变量name,该怎么做?最简单的办法是将该成员变量封装成方法getter形式。

    代码如下:

    Java代码

    public class Father {

    protected String name = "父亲属性";

    public String getName() {

    return name;

    }

    }

    public class Son extends Father {

    protected String name = "儿子属性";

    public String getName() {

    return name;

    }

    public static void main(String[] args) {

    Father sample = new Son();

    System.out.println("调用的属性:" + sample.getName());

    }

    }

    结果:调用的是儿子的属性

    java因为什么对属性要采取静态的绑定方法。这是因为静态绑定是有很多的好处,它可以让我们在编译期就发现程序中的错误,而不是在运行期。这样就可以提高程序的运行效率!而对方法采取动态绑定是为了实现多态,多态是java的一大特色。多态也是面向对象的关键技术之一,所以java是以效率为代价来实现多态这是很值得的。

    注:以上内容大部分来自互联网,小部分是个人见解,绝非权威性言论。如有语言表达不当或者表述不正确的地方,万望指教。

    参考:

    http://blog.csdn.net/zhangjk1993/article/details/24066085

    展开全文
  • 一个java程序的执行要经过编译和执行(解释)这两个步骤,同时java又是面向对象的编程语言。当子类和父类存在同一个方法,子类重写了父类的方法,程序在运行时调用方法是调用...另一种就是动态绑定,亦称为后期绑定...
  • 一、问题Java方法调用过程中,Jvm是如何知道调用的是哪个类的方法?Jvm又是如何处理?...绑定又分为静态绑定和动态绑定。静态绑定静态绑定是在程序执行前就已经被绑定了(也就是在程序编译过程中就已经...
  • vue动态绑定class练习。 :class=“{ ‘类名1':条件表达式,‘类名2':条件表达式… }” *> (item,i) key=i class=item click=clickIndex class={ xss=removed> [removed] export default { data() {...
  • Java JVM 多态(动态绑定)@author ixenos摘要:绑定、动态绑定实现多态、多态的缺陷、纯继承与扩展接口、向下转型与RTTI绑定将一个方法的调用和一个方法的主体关联起来,称作(方法调用)绑定:1.前期绑定:在程序执行...
  • uni-app条件动态绑定样式

    千次阅读 2020-10-22 13:49:40
    图片是否显示, 因为图片是绝对定位, 文本需要缩进行,这里动态绑定是否缩进行 直接看代码吧,不难 <template> <view class="yh-list"> <!--顶部搜索导航栏 S --> <uni-nav-bar-classify ...
  • vue做管理系统中经常会遇到这样的需求: 根据获取数据中不同的值让页面...给标签使用:绑定样式,如颜色 :color="error" 使用三元表达式判断获取的值然后给样式赋值,例如: <v-icon :color="props.item.status=...
  • 分类 电脑编程网整理 20091114 简介:这是asp.net根据条件动态生成GridView,并动态绑定列,且可对其进行编辑的实现的详细页面,介绍了和生成html,有关的知识,加入收藏请按键盘ctrl+D,谢谢大家的观看!...
  • 动态绑定与静态绑定

    2021-03-27 12:14:24
    动态绑定需要的条件: 1.以指针形式 2.用的必须是虚函数 3.必须是向上转型:(通俗的来讲就是基类指针指向->派生类对象) 前两点很好理解 主要是第三点 首先我们需要知道的就是子类拥有基类的“一切”--------非...
  • 根据用户需要,一个页面中,有几个不同的button,点击不同的button,可在下方同一区域产生gridview,(当然他们的gridview是不同的)。之前用MultiView来控制,用了几个... 于是就想到用这种动态的方式实现。Html中只有一
  • vue动态绑定class练习。:class=“{ ‘类名1':条件表达式,‘类名2':条件表达式… }”v-for="(item,i) of list":key="i"class="item"@click="clickIndex=i":class="{'click':i==clickIndex}">export default {...
  • vue动态绑定class练习。 :class=“{ ‘类名1’:条件表达式,‘类名2’:条件表达式… }” &amp;amp;lt;template&amp;amp;gt; &amp;amp;lt;div class=&amp;quot;app-*&amp;quot;&amp;...
  • 该怎样实现动态绑定? 如图片中写3个if,那么只能获取第一个“0”的纪录。 如果用 if( “0”.equals(“?”) || “7”.equals(“?”)||“0”.equals(“?”)){ //执行语句 } 这样的语句进行判断就会出现短路,...
  • 一般家庭网络的公网IP都是不固定的,而我又想通过域名来访问自己服务器上的应用,也就是说:需要通过将域名绑定动态IP上来实现这个需求。于是乎,我开始探索实现的技术方案。通过在网上查阅一系列的资料后,发现...
  • 若想在帆软中实现带下拉选的查询条件内容来自字典表或者自定义条件查询出来的数据库信息,要做的事共3步,***首先创建查询条件的模板参数,其次创建好作为查询条件的数据集,最后实现查询条件与数据集的绑定***,...
  • 多态是面向对象程序设计语言中...二、C++如何实现动态绑定 三、多态成立的条件 四、抽象基类和纯虚函数(pure virtual function) 五、虚析构函数 c++支持编译时多态(静态多态)和运行时多态(动态多态),运算符...
  • 1.动态绑定发生在程序执行时(而非编译期)判断所引用对象的实际类型,根据实际类型调用相应的方法。...3.动态绑定实现了程序的可扩展性。 4.多态存在的条件:继承、重写、父类引用指向子类对象 ...
  • 背景知道吗?自定义类型的实例为空时,函数方法在不访问私有属性时,可以正常...这问题在过去几个月反复出现都没找到原因,最终在修改对象读取读取数据初始化代码的时候,才明白是某些特殊条件成立,返回对象是空造成
  • 因此,动态绑定实现了OOP的多态性。当然,通过动态绑定,因为可以消除用于多选场景的条件逻辑,从而可以降低程序的复杂度。 动态绑定是Objective-C的一种继承特性,它不需要任何特定的API。使用动态绑定可以将消息...
  • C++中函数的动态绑定

    2018-10-24 20:22:23
    所谓动态绑定,其实就是接口的实现由派生类完全覆盖。 就是说原本声明的类型是基类B,但是调用函数的时候执行的却是不同派生类(由初始化或者赋值的时候定义)D的函数。动态绑定出现的条件有两个 只有虚函数才能进行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 818
精华内容 327
关键字:

动态绑定实现条件