I recon a `Thread` object could normally be created and kept track of in this fashion:

```
ArrayList<MyThreadClass> threads = new ArrayList<>();

MyThreadClass myThread = new Thread();
myThread.start();
threads.add(myThread);

```

But instead of doing all that *explicitly*, how about adding it to the constructor and make it happen *implicitly*?

I am creating a generalized server/client pair of programs to be implemented in my future network applications and I've taken a few shortcuts that I find practical.

I have created a "Connection" class to keep track of the clients that have connected to the server. It looks something like this:

```
class Connection{
    private static ArrayList<Connection> clients = new ArrayList<>();
    MyListener listener; //extends Thread

    Connection(Socket s){
        listener = new MyListener(s)
        listener.start();
        clients.add(this);
    }
}

```

This class has a static ArrayList to keep track of all the connections and the constructor implicitly adds each `new Connection` to this list and also starts my listener `Thread` to receive incoming network traffic.

I also have a `ConnectionListener` which the server is using to accept incoming connections and make `Connection` instances for each of them which looks something like this:

```
while(true){
    //try/catch blocks excluded here for the sake of simplicity
    new Connection(serverSocket.accept());
}

```

Perhaps I just haven't stumbled over the right code examples, but I very rarely (if at all) see this way of using a constructor to make objects and store their references. I'm wondering if it's unconventional and/or impractical to use either of the listed cases, and if any of them can cause errors.

**Is it unconventional/impractical to:**

* Use the `new MyClass()` without storing the returned reference?
* Add instance to a List using the `this` keyword from it's constructor?
* Start a `Thread` from within it's (child's) constructor?
* Can it cause problems to reference an instance before it's constructor has finished? (in this case within the constructor itself)