Best practice OOP - good design

Question

I started to write a chat application [server + client]
and I wanted to optimise it [good OOP + reuse of classes,objects].
So, I have a class that handles the interface, a class that handles the socket [reading, writing], a class that handles the events, etc...
As Iwanted to write it the best way possible, I looked a little in patterns and OOP design books in order to make it better.
After reading, digging ..., an idea came to me.
A problem I came across many times, in my past projects also was the fact that, when I was in the interface class, and i needed the socket class I couldn't find a way to get it and instantiate it when I needed it. I always had to pass it as an argument to the constructor of the interface class [just for this example] or in the class where i instantiate the interface class, i had to appeal a method on the object=interface in order to put the socket object in the interface class , for future manipulation.
It could get more complicated if i wanted to use the socket object only when a certain event appear, and i wanted it in who-knows what class.
So i trid this implementation of noname pattern [with influences from all the books I read] :
I create an instatiator of objects [say class ObjectManager] with the following methods:
void addObject(Object o,String nameObj)
Object getObject(String nameObj)
Now I instantiate [in the meanwhile i present to the user a pretty JWindow with loading...] all the objects I will use in the application and the objects-resource > [Colors, Fonts,etc...] and also add them to the ObjectManager.Also, all the objects will have a reference to this ObjectManager.
and when I need a specific Object, I will get it with [specyfing its name]
ObjectManager.getObject(nameObj).
What I want from the guys from this forum:
1) comments on this [is it good, i just go crazy, all of this is garbage, i am wrong(specify why)]...
2) Is this a well-known pattern, or a version of a well-known pattern and I can't recognize it?
3) If anybody understood my problem, is this the best way to achieve it[getting objects already instantiated whenever and wherever I want], and if not, which is it
4) The problem is put wrong, an application should be thought differently - please guide me to some URLs, tutorials...
Thanx in advance
Gabi

Answer 1

In some ways, this is similar to a Factory pattern: a place that you go to get objects.
The difference is that a typical Factory creates (or returns from somewhere!) objects of a limited number of related types, based on some configuration input (a FooFactory, for example, doesn't typically return a Bar object, unless Bar is a subclass of or implements Foo).
For an atypical factory, consider the java.rmi.Naming class. On the one side, a server registers the objects that it serves; on the other, a client requests those objects. As far as the client is concerned, this fits the Factory pattern exactly; on the server side, it doesn't.
Personally, I like having a singleton "Manager" object for various semi-related objects within an application. For example, a DialogManager that holds onto all the application's dialogs. Someone has to know about them, and it could be the application's main class, but that tends to more clutter than I like.