In computer programming, binding time describes when an association is made in software between two data or code entities. This may occur either before or after execution starts. Early (a.k.a. static) binding occurs before the program starts running and cannot change during runtime. Late (a.k.a. dynamic or virtual) binding occurs as the program is running.^[1] Binding time applies to any type of binding including name, memory (i.e. via malloc), and type (i.e. for literals).

The following Java code demonstrates both binding times. The method foo is early-bound to the code block that follows the function declaration on line 3. The call to add is late-bound since List is an interface, so list must refer to a subtype of it. list may reference a LinkedList, an ArrayList, or some other subtype of List. The method referenced by add is not known until runtime.

import java.util.List;

public void foo(List<String> list) {
    list.add("bar");
}

Late static binding is a variant of binding somewhere between static and dynamic binding. Consider the following PHP example:

class A
{
    public static $word = "hello";
    public static function hello() { print self::$word; }
}

class B extends A
{
    public static $word = "bye";
}

B::hello();

In this example, the PHP interpreter binds the keyword self inside A::hello() to class A, and so the call to B::hello() produces the string "hello". If the semantics of self::$word had been based on late static binding, then the result would have been "bye".

Beginning with PHP version 5.3, late static binding is supported.^[2] Specifically, if self::$word in the above were changed to static::$word as shown in the following block, where the keyword static would only be bound at runtime, then the result of the call to B::hello() would be "bye":

class A
{
    public static $word = "hello";
    public static function hello() { print static::$word; }
}

class B extends A
{
    public static $word = "bye";
}

B::hello();

• Program lifecycle phase