🚀 go-pugleaf

Solution Technology wrote:
> 
> Nelson Yu (nelson@scapa.cs.ualberta.ca) wrote:
> [...]
> : Java has
> [...]
> : 4) A nice class hierarchy(i.e everything is derived from object)
> 
> Very argumentative!  Deep trees result in almost monolithic systems
> that are hard to change.

In C++ you would do(every good class has these)

class __rtti MyClass
{
public:
	MyClass();

	// Virtual destructor
	virtual ~MyClass();

	// Copy constructor	
	MyClass(MyClass c);

	// Assignment operator
	MyClass& operator=(MyClass& myClass)
};

This is totally unnecesary under Java, since copy(), class() and 
clone() are ALL located in Object. Object _encapsulates_ the 
basics such as object's identity and copy construction. Since
everything is derived from Object, the power of polymorphism can 
be exploited. Of course C++ templates are faster, but then we get 
the problem of code bloat.

I know very well that once an hierarchy has been set it's 
extremely difficult to change. AWT lacks protected 
methods/variables for extendiblity and is fairly rigid(although 
its 'interfaces' help loosen it up). IMHO Java(excluding the 
ever-changing AWT) has a nice hierarchy because 

1) Has a well designed parent class.
2) Well designed and fairly shallow class structure(using single
inheritance) compared to C++ libraries. Take a good look at how 
complex iostream(with multiple inheritance) is! 

Albeit you can't compare OWL with AWT, which has fairly 
complicated hierarchy that uses multiple inheritance extensively, 
'cause they are suited for different purposes.