BTW, another version of the DatabaseManagerObject.Save() function could
be:

public function Save(cmd as adodb.command) //save using a command
object

  Conn.begintrans
     cmd.activeconnection = Conn
     cmd.execute

   if err.count = 0 then Conn.commit else Conn.rollback

     //plus all the error handling to for this kind of transaction etc

end function

you get the idea.

"Edwinah63" wrote...

So why make them "DB-aware" at all... ;-)

[snipped code]

Well, there are a lot of options here, as well as opinions on what the best
design really should be, but I'll try to at least give you some quick
pointers. At least they will do about the same thing as you want to, even
though there might be even better designs if you would look at the "whole
picture"...

Anyway, here goes...

import java.sql.*;

// I prefer to separate the Person
// from how to "save" her...

class Person
{
   // I would use setters and getters instead
   // here, but for this example I skip it...
   public String hairColour;
   public int height;
}

// In OOP we use interfaces a lot... ;-)

interface DbObject
{
   void save(Connection conn);
}

// ...so we use that to encapsulate a "real" object
// and make the rest more polymorphic...

class DbPerson implements DbObject
{
   private Person p = null;

   public DbPerson(Person p)
   {
       this.p = p;
   }

   public void save(Connection myConnection)
   {
       CallableStatement cs = null;

       try
       {
           cs =
              myConnection.prepareCall
                ("{call UpdateEmp(?, ?)}");

           cs.setString(1, p.hairColour);
           cs.setInt(2, p.height);

           cs.execute();
           cs.close();
       }
       catch (SQLException sx)
       {
           // Perform error handling here...
       }
   }
}

// I'm not sure how DatabaseManagerObject fits
// into the rest, as this also can depend on other
// considerations, db-wise and others...

class DatabaseManagerObject
{
   private Connection getConnection()
   {
       Connection conn = null;

       // ToDo: Create a Connection...
       // ...or if there's another one
       // as an instance field somewhere...

       return conn;
   }

   // As you see, we only need to know that
   // the object has a method to "save", not
   // what it saves, or how...

   public void save(DbObject dbo)
   {
       try
       {
           Connection conn = getConnection();

           // Now we only have to let the object
           // "save itself"...

           dbo.save(conn);

           // Whether or not you'll close conn here,
           // is rather depending on how the
           // DatabaseManagerObject itself will be
           // constructed, but as this only
           // is an example, we go for that now...

           conn.close();
       }
       catch (SQLException sx)
       {
           // Perform error handling...
       }
   }

   public void save(String sql)
   {
       // Implement an "ordinary" statement
       // handling here...
   }
}

class WhatEver
{
   public void someOtherFunction()
   {
       // To actually know how to construct
       // the DatabaseManagerObject, there
       // are more things to consider,
       // db-wise and others...

       DatabaseManagerObject dbmo =
          new DatabaseManagerObject();

       // ...and possibly the Persons already
       // exist in a list of some sort, but
       // I follow what you did here...

       Person emp = new Person();

       // get values from user...

       emp.hairColour = "blonde";
       emp.height = 180;

       // save it to the database

       dbmo.save(new DbPerson(emp));
   }
}

I hope this helps...

// Bjorn A