Question: So here is the code, and there are few lines I don't understand. 

```
account acct = new account(); // making a new object named acct, type:account

ConsoleAccountEvents c1 = new ConsoleAccountEvents(acct); // new object created with parameters.

acct.addObserver(c1); // also not sure. 

acct.addTransaction(100.00); // not sure.... 

```

This is Java. I'm not sure how parameters are passed to the constructor.

Answer: 
In java, the constructor is invoked when the object of the class is created using the `new` keyword. So to call the constructor with a certain parameter you just have to create an object with parameter as per your requirement example in your case.

```
class ConsoleAccountEvents {

    Account account;

    public ConsoleAccountEvents(Account account) {
        this.account = account;
    }
}

class Account {

}

```

So when you create object with 

```
Account acct = new Account(); 
ConsoleAccountEvents c1 = new ConsoleAccountEvents(acct);

```

So here parameterized constructor will be called and this object will be assigned in instance variable of `ConsoleAccountEvents` class
I think what you may be looking for is how the `new` keyword works, but let me be thorough:

Some things to note about constructing objects in Java:

1. A constructor will be called every time you "request" a `new Account()`.
2. A constructor can be defined to use parameters (and thus require arguments) of any type - both class types and primitive types (int, float, char, etc..)
3. If the constructor is called like `new SomeClass(someObject)`, `someObject` is the argument passed to the constructor of SomeClass.

In the constructor of a class, parameters are defined with a type and a name as such:

```
class ConsoleAccountEvents{
    Account account;

    ConsoleAccountEvents(Account a){
        account = a;
    }
}

```

Here the *parameter* "`a`" is defined to be of the `Account` "type" - the *argument* sent to the constructor must be an instance of the `Account` class, in other words the constructor requires an `Account` object. So in order to construct a `ConsoleAccountEvents` object we must pass it an `Account` object as the *argument* as such:

```
Account acct = new Account();
ConsoleAccountEvents c1 = new ConsoleAccountEvents(acct)

```

Using "new" calls the constructor of the following class. For the Account class, we need no arguments to create an object - it has a *default constructor*, but we need to *use* an Account object - `acct` - as the argument to allow `ConsoleAccountEvents` to be constructed since it's constructor has an Account type parameter in it's definition.

In other languages there are more ways to construct objects. In C++ for example, the programmer can choose which objects should be saved on the "heap" and the "stack" by switching between using the `new` keyword vs calling the constructor directly as if it was any other function. In Java this is not possible. Almost all objects are created using the new keyword or by copying another object in some way. I believe even *serializing* and *deserializing* had to start with `new` at some point to create the first object.