¿Hay una manera de lanzar un objeto que no ocupará espacio de memoria en Java?

sndmnn:

Estoy codificación de un generador de SQL basada en Java reflexión (que está destinado a ser utilizado con los genéricos en el futuro). Recibo un objeto como un parámetro para generar el nombre de tabla, campos y valores de campo (para las operaciones de inserción y actualización), pero en mis clases DAO estoy instanciar un nuevo objeto vacío, que no se utiliza en ningún otro lugar en el código , acaba de obtener esta información. ¿Hay una manera de emitir algún tipo de objeto "fantasma", que no ocupará espacio en la memoria, para servir a este propósito?

Esta es la clase responsable de generar el código SQL:

public abstract class DynamicSQL
{
    public static final boolean NO_ID = false;
    public static final boolean WITH_ID = true;

    private Vector<Field> get_class_fields(Object obj, id_wanted)
    {
        Class<?> cls = obj.getClass();
        Vector<Field> fields = new Vector<>();

        while(cls != Object.class)
        {
            Field[] cls_flds = cls.getDeclaredFields();
            fields.addAll(Arrays.asList(cls_flds));

            cls = cls.getSuperclass();
        }
        // If the id is not wanted, it is removed here
        if(!id_wanted)
        {
            for(int i = 0; i < fields.size(); i += 1)
            {
                Field f = fields.get(i);
                if(f.getName().equals("id")) 
                                fields.remove(f);
            }
        }
        return fields;
    }

    private Vector<String> get_fields_names(Object obj, boolean id)
    {
        Vector<Field> fields = get_class_fields(obj, id);
        Vector<String> field_names = new Vector<>();

        for(Field f : fields)
        {
            field_names.add(f.getName());
        }
        return field_names;
    }

    private String get_table_name(Object obj) 
    {
        String[] class_name = obj.getClass().getName().toLowerCase().split("\\.");
        String table_name = class_name[class_name.length - 1];

        return table_name;
    }

    protected String select_sql(Object obj)
    {
        String table_name = get_table_name(obj);
        Vector<String> fields = get_fields_names(obj, WITH_ID);

        String sql = "SELECT ";
        for(int i = 0; i < fields.size(); i += 1)
        {
            sql += fields.get(i);
            if(i < fields.size()-1) sql += ", ";
        }
        sql += " FROM " + table_name;
        return sql;
    }

        //work in progress...
}

Esta es mi clase DAO:

public class CustomerDAO extends DynamicSQL implements IDAO<Customer>
{
    @Override
    public Vector<Customer> list_all() 
    {
        Vector<Customer> customers = new Vector<>();

        //Here I instantiate the object I'm willing to get rid of
        String sql = select_sql(new Customer.Builder().build(), DynamicSQL.WITH_ID);
        try
        {
            ResultSet rs = ConnectionFactory.get_instance().execute_query(sql);

            while(rs.next())
            {
                customers.add(new Cliente.Builder().
                        id(rs.getLong("id")).
                        nome(rs.getString("nome")).
                        endereco(rs.getString("endereco")).
                        telefone(rs.getString("telefone")).
                        build()
                        );
            }
        }
        catch(SQLException e)
        {
            e.printStackTrace();
        }
        return customers;
    }

    //other method overrides and implementation...
}

Todo funciona bien, pero estoy molesto con que la instanciación de objetos innecesarios. ¿Hay otra manera de hacerlo, o tengo que crear una instancia de ese objeto de todos modos?

Raedwald:

En Java, nunca se puede acceder directamente a los objetos. Lo que tenemos es referencias a objetos (como punteros en C o C ++) que pueden referirse a un objeto. Por lo tanto diferentes clases y métodos pueden compartir objetos mediante el uso de diferentes referencias de objetos que se refieren a (punto a) del mismo objeto. Si varias clases (o métodos) objetos comparten, en lugar de cada creación de un nuevo objeto para su uso exclusivo, no hay espacio adicional se utiliza para los usos segunda y subsiguientes. Así que aunque no se puede crear un objeto fantasma , se puede hacer algo equivalente al compartir objetos. Esto funciona mejor si los objetos son inmutables .

Si un método utiliza un objeto inmutable equivalente cada vez (lo que parece ser el caso para el método), se puede ahorrar el costo de la creación de objetos cambiando el objeto a ser un staticobjeto, por lo que se crea el objeto cuando se carga la clase y compartida para todas las ejecuciones posteriores del método.

Esto es lo que la Collections.emptyList()hace método:

Las implementaciones de este método no es necesario crear un objeto de lista separada para cada llamada.