Question

I have read a parent Class called MyClass
code like this,

 public class MyClass extends CompositeObject{
    protected Map<String,MyAttibute> attributes = new       

    HashMap<String,MyAttribute>
    .....

 }

In MyAttribute Class,
Code like this

public class MyAttibute extends MyObject 
{
   private MyClass definedOnClass;//point to its parentClass

}

This actually is a circular reference.Which makes trouble when you do deep serlization and equals. And it may not be a good design.How to avoid it? And after fixing it, we can still easily find the parentClass from its attribute.

P.S. I see another two classes design

public class Transaction{
   private ChangeManager parentManager;
   ....
   public Transaction(ChangeManager parentManager)
} 

public class ChangeManager {
  //record transaction when commit
  private List<Transaction> transactions = new ArrayList<Transaction>();
  Transaction currentTransaction;
  ....  
}

Do you think this kind of design is good? Why?
As you can see the domains these classes are defining on are quite common.
So can anyone share some insight about it? Is it harmful to let Transaction know its ChangeManager and let MyAttributes know its MyClass in their properties? Any comments are welcome. Cons and pros.

Answer 1

put the MyAttibute as a child logically independent of the parent so attr1.equals(attr2) doesn’t involve the respective parents (same with serialization; don’t include it in the stream) and you can keep the definedOnClass property

or you can use a different equals method when testing from MyClass

public class MyAttibute extends MyObject 
{
   private NgcClass definedOnClass;//point to its parentClass

   public boolean equals(Object o){
       if(o instanceof MyAttibute){
           MyAttibute other = (MyAttibute)o;

           if(!this.definedOnClass.equals(other.definedOnClass))
                return false;//when not from the same parent they are never the same

           return this.equals2(other);
       }
       return false;
   }

   //this one should then be called from MyClass
   public boolean equals2(MyAttibute o){
       //check equality without worrying about definedOnClass
   }
}

note that the default serialization of java’s objectstreams can handle circular references