contract-design – Can There Be Only One Instance of a Contract?

A public state variable will have an automatically generated accessor that other contracts can use to read the variable.

However, public state variables can only be changed by a function in a contract that changes the variable. If there are no such functions that are accessible to other contracts, the state variable cannot be changed by other contracts.

Functions can be specified as being external, public, internal or private, where the default is public.

external: External functions are part of the contract interface, which means they can be called from other contracts and via transactions. An external function f cannot be called internally (i.e. f() does not work, but this.f() works). External functions are sometimes more efficient when they receive large arrays of data.

public: Public functions are part of the contract interface and can be either called internally or via messages. For public state variables, an automatic accessor function (see below) is generated.

internal: Those functions and state variables can only be accessed internally (i.e. from within the current contract or contracts deriving from it), without using this.

private: Private functions and state variables are only visible for the contract they are defined in and not in derived contracts.

Yes it is possible, yes every contract has it's own address, but think about it like a memory reference rather than simply a direct call to an address. Here's an example:

pragma solidity ^0.4.0;

interface Letter {
    function f() 
        public 
        returns (uint);
}

contract A is Letter {
    function f() 
        public 
        returns (uint) {
        return 1;
    }
}

contract B is A {
}

contract C is Letter {
    function f() 
        public 
        returns (uint) {
        return 2;
    }
}

contract Alphabet {
    Letter[] letters;

    event printer(uint);

    // Add our own new contracts
    function Alphabet() 
        public {
        letters.push(new A());
        letters.push(new B());
        letters.push(new C());
    }

    // Include existing contracts
    function alphabetFromAddresses(address _addrA, address _addrB, 
                                   address _addrC)
        public{
        letters.push(A(_addrA));
        letters.push(B(_addrB));
        letters.push(C(_addrC));
    }

    function getLetters() 
        public {
        for(uint i = 0; i < letters.length; i++) {
            printer(letters[i].f());
        }
    }
}

You can add your own new instances which all get assigned their own contract addresses on creation, you can also reference existing contracts as long as they are implementations of your contracts or interfaces.