How does BGE inheritance work Following the documentation at: https://docs.blender.org/api/blender_python_api_2_76_2/bge.types.KX_GameObject.html I can extend a game object with:

class Mine( types.KX_GameObject ):

    def __init__( self, old_owner): #Note: where has my argument gone?

         #stuff

def activate( controller ): # Called from Controller

    Mine( controller.owner ) # Note: Object is stored nowhere


But I'm missing what's doing the magic here. Somehow the controller not gets passed as second argument to __init__ but as first and the game object is internally (?) exchanged (?) with mine. 

So how is this working exactly? Is there some blender-foo or is this something Python can do for me which I'm not aware of?

EDIT:
To make it more clearly: If I do "normal" inheritance in Python this is how it works:

class Parent:

    def __init__( self ):
        self.a = "FOO"

    def talk():
        return a

class Child( Parent ):

    def __init__( self, b ):
        Parent.__init__( self )
        self.b = b

    def talk( self ):
        return self.a + self.b


child = Child( "BAR" )
print( child.talk() )

someglobal[ 'child' ] = child


so the parameter "BAR" gets passed as second argument b to the constructor of class A. The constructor calls the other one from class A and I end up with an instance which I have to store somewhere globally in order to access it from somewhere else.

Compare this to blender's version: The already instantiated object is passed as an argument to the constructor. But it doesn't end up as second argument to __init__ but gets somehow mangled in while the second argument is something else (in fact it seems to be nothing. trying to access it yields in an error). The finally constructed instance is then somehow stored in the global dictionary for objects and replaces the old one.

These somehows and somethings are which I'm interested in. What's happening here?

EDIT2: Taken from the linked documentation:

def __init__(self, old_owner):

# "old_owner" can just be ignored. At this point, "self" is
# already the object in the scene, and "old_owner" has been
# destroyed.


If I only read the python code in this module (my first example) this is not what is supposed to happen python-wise. So what makes self the object and what destroys the old owner? Is this some c-code magic patched into the python interpreter? Or is this some python magic somewhere in KX_GameObject? Or something else?
When inherit an object you will "merge" the attributes, properties, functions:

class Mine( types.KX_GameObject ):

    def __init__( self, old_owner):
        self.life = 100

def activate( controller ): # Called from Controller

    object = Mine( controller.owner )
    print(object.worldPosition) # [0,0,0] KX_GameObject.worldPosition
    print(object.life) # 100


While no inherit:

class Mine():

    def __init__( self):
        self.life = 100

def activate( controller ): # Called from Controller

    object = Mine()
    print(object.worldPosition) # ERROR
    print(object.life) # 100


About, is this something Python can do for me which I'm not aware of? PY classes class-objects