标签: static-binding

我正在为我的一个类做一个任务,在其中,我必须使用Java语法给出静态和动态绑定的示例.

我理解基本概念,即静态绑定在编译时发生,动态绑定在运行时发生,但我无法弄清楚它们实际上是如何工作的.

我在网上找到了一个静态绑定的例子,给出了这个例子:

public static void callEat(Animal animal) {
    System.out.println("Animal is eating");
}

public static void callEat(Dog dog) {
    System.out.println("Dog is eating");
}

public static void main(String args[])
{
    Animal a = new Dog();
    callEat(a);
}

并且这将打印"动物正在吃"因为调用callEat使用静态绑定,但我不确定为什么这被认为是静态绑定.

到目前为止,我所看到的所有来源都没有设法以我能够遵循的方式解释这一点.

早期和晚期绑定有什么区别？

我对动态绑定和静态绑定感到困惑.我已经读过在编译时确定对象的类型称为静态绑定,在运行时确定它称为动态绑定.

以下代码中会发生什么:

静态绑定还是动态绑定？
这显示了什么样的多态性？

class Animal
{
    void eat()
    {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal
{
    void eat()
    {
        System.out.println("Dog is eating");
    }
}

public static void main(String args[])
{
    Animal a=new Animal();
    a.eat();
}

我不知道怎么做...

function f1()
{
    var x = 10;
    function f2(fx)
    {
        var x;
        x = 6;
        fx();
    };

    function f3()
    {
        print x;
    };

    f2(f3);
};

对于以下两种绑定方法中的每一种,程序将打印什么？A)浅结合B)深度结合

谢谢您的帮助!

在python中(在2.7.6上测试),所有变量在编译时静态绑定到作用域.这个过程在http://www.python.org/dev/peps/pep-0227/和 http://docs.python.org/2.7/reference/executionmodel.html中有详细描述.

明确声明"如果名称绑定操作发生在代码块中的任何位置,则块中名称的所有使用都将被视为对当前块的引用."

函数是一个代码块,因此以下代码失败,因为x 它在使用后被赋值(因此在编译时它被定义为本地,因为它被赋值在函数中的某个地方,但在执行时,它在被绑定之前使用).

x = 1
def f():
    print x 
    x = 2
    print x

>>> f()

Traceback (most recent call last):
  File "<pyshell#46>", line 1, in <module>
    f()
  File "<pyshell#45>", line 2, in f
    print x
UnboundLocalError: local variable 'x' referenced before assignment

类也是代码块,因此我们应该观察到完全相同的行为.但这不是我观察到的.看看这个例子:

x = 1
class C():
    y = x + 10
    x = 2
    def __init__(self):
        print C.y

>>> C.x
2
>>> C.y
11      
>>> C()
11
<__main__.C instance at …

使用来自著名的学概念IBM红纸在RPG异常和错误处理,我已经写了一个服务程序QGPL/ERRFUNC实现像可重用的错误功能Assert,Throw,ThrowMsg,Rethrow,和GetErrorMsg.我一直在几个不同的程序中使用它们,并且它们一直运行良好.

刚才,我Throw在RPG ILE程序中使用了该函数,该程序还静态调用access与IFS文件系统上的流文件一起使用的C风格函数.该程序将无法使用"为符号Throw多次提供定义"的绑定错误进行编译.据我所知,使用编译时你不能绑定细节CRTBNDRPG的命令,但我无法评论我的H DFTACTGRP(*NO)规格,然后编译使用CRTRPGMOD,随后CRTPGM与附加参数DETAIL(*EXTENDED).这将打印出一个广泛的列表,列出了编译器在确定静态绑定到哪些过程时所查看的所有过程名称.这揭示了"投掷"的双重定义.在72页面列表的深处,QJVAJNI引用了IBM提供的服务程序(Java Native Interface),它包含一个名为"Throw"的导出过程.

现在最简单的解决方法就是简单地重命名我的"Throw"程序,修改并重新编译我的服务程序,然后修改并重新编译引用它的所有程序.我可能会遵循这个解决方案,但这种行为引发了一些令人不安的问题:

1. 为什么C风格的IFS函数使用Java本机接口来完成其工作？我看到的像服务计划进口QC2IFS和QC2POSIX那完全意义的上下文.看起来IBM在这里引入了一个我们不得不忍受的意外依赖.我确定它是引用它的C服务程序之一,QJVAJNI因为当我注释掉access函数调用时,QJVAJNI不会引用它.QJVAJNI服务程序的引用可能是多层深度,这意味着导入导入的导入.

2. 为什么粘合剂通过服务程序导入如此彻底地递归？绑定器看起来像遍历每个服务程序使用的每个导入,无论该程序是否使用该导入以及绑定的子过程.这有必要吗？是否可以递归检查每个级别使用的导入？有没有办法改变这种行为？

3. 如果对于上述两个问题没有什么可以做的,这是否意味着为了保证绑定始终有效(特别是对于"通用"函数,如错误处理),必须确保没有任何其他导出过程在同一台机器上的任何地方？我不知道任何像名称空间这样的设施可以缓解这个问题.据我所知,ILE编译器不使用其他平台在这种情况下可能使用的任何方法,如重载或名称修改.开始"非正式命名空间"是一种很好的做法,就像我可以看到一些C导出(例如_C_NEU_IFS_feof)以防止名称冲突一样？或者,有没有办法在发布服务程序之前搜索计算机上的所有导出过程以查找所需的名称？

4. IBM红皮书的作者是ILE编程领域的一些重量级人物.他们像我一样命名了他们推荐的出口之一"投掷"(尽管有不同的参数列表).他们遇到了类似的问题吗？他们有不同的方法来解决名称冲突吗？

我发现有*DUPPROC一个可以指定的选项CRTPGM,但我不确定这是个好主意.文档说"当允许多个重复过程时,与导入请求匹配的指定模块和服务程序列表中的第一个导出过程是所选的过程." 你能确定哪个符号将成为列表中的第一个吗？订单是否严格定义？

我知道重载使用静态绑定和覆盖使用动态绑定.但如果他们混在一起呢？根据本教程,要解析方法调用,静态绑定使用类型信息,而动态绑定使用实际的Object信息.

那么,在以下示例中是否发生了静态绑定以确定sort()要调用的方法？

public class TestStaticAndDynamicBinding {

    @SuppressWarnings("rawtypes")
    public static void main(String[] args) {
        Parent p = new Child();
        Collection c = new HashSet();

        p.sort(c);
    }
}

.

public class Parent {

    public void sort(Collection c) {
        System.out.println("Parent#sort(Collection c) is invoked");
    }

    public void sort(HashSet c) {
        System.out.println("Parent#sort(HashSet c) is invoked");
    }
}

.

public class Child extends Parent {

    public void sort(Collection c) {
        System.out.println("Child#sort(Collection c) is invoked");
    }

    public void sort(HashSet c) {
        System.out.println("Child#sort(HashSet c) …

我想弄清楚晶体中的c绑定是如何工作的.对于初学者,我想知道如何在水晶中加入一个简单的hello world c函数.总是很好从基础知识开始吧？这是我想要包含的功能:

#include <stdio.h>

void hello(const char * name){
  printf("Hello %s!\n", name);
}

我刚刚阅读了关于我现在在stackoverflow中询问的相同主题的所有搜索结果,并没有真正回答我的好奇心.但这就是事情.

问题

1.)据我所知,静态绑定意味着它在编译期间设置,并且它在运行时存在,而动态绑定意味着它在运行时设置.

2.)所以我读过的书介绍了动态数组,它提到动态数组大小可以在运行时设置.这是以这种方式完成的.

代码

int size;
cin >> size;
int * pz = new int [size]; // dynamic binding, size set at run time
delete [] pz; // free memory when finished

3.)在这段代码中,书中提到动态数组大小可以在运行期间设置.出于好奇,我试试这个.

代码

int size;
cin >> size;
int array[size];
//After the array declaraction i assign value to it to check whether it works or not.

4.)上面的代码也有效,所以我只是好奇动态数组有什么特别之处,因为普通静态数组可以做同样的工作.

5.)是因为动态数组可以在运行时释放它的内存而静态不能使它如此特殊吗？

感谢您花时间阅读我的问题,请指出我所犯的任何错误.

在PHP中编码和使用后期静态绑定时,我发现了一些奇怪的行为.static()在其父类中创建的子对象可以访问其父类的私有方法.

这是一个例子:

class Attachment
{
  public static function createFromFile($file)
  {
    $attachment = new static();
    echo get_class($attachment) . PHP_EOL;
    $attachment->loadFromFile($file);
  }

  private function loadFromFile($file)
  {
    echo 'attachment';
  }
}

class PictureAttachment extends Attachment
{
  //...
}

PictureAttachment::createFromFile('example.txt');

输出:

PictureAttachment
attachment

这是正确的行为吗？