Han pasado dos años desde la última vez que codifiqué algo en Java, por lo que mis habilidades de codificación están un poco oxidadas.

Necesito guardar datos (un perfil de usuario) en diferentes estructuras de datos,ArrayList yLinkedList, y ambos vienen deList. Quiero evitar la duplicación de código donde pueda y también quiero seguir las buenas prácticas de Java.

Para eso, estoy tratando de crear una clase abstracta donde las variables privadas sean de tipoList<E> y luego crea 2 subclases dependiendo del tipo de variable.

La cosa es que no sé si estoy haciendo esto correctamente, puedes echar un vistazo a mi código:

Clase: DBList

import java.util.List;

public abstract class DBList {

    private List<UserProfile> listName;
    private List<UserProfile> listSSN;

    public List<UserProfile> getListName() {
    return this.listName;
    }

    public List<UserProfile> getListSSN() {
    return this.listSSN;
    }

    public void setListName(List<UserProfile> listName) {
    this.listName = listName;
    }

    public void setListSSN(List<UserProfile> listSSN) {
    this.listSSN = listSSN;
    }

}

Clase: DBListArray

import java.util.ArrayList;

public class DBListArray extends DBList {

    public DBListArray() {
    super.setListName(new ArrayList<UserProfile>());
    super.setListSSN(new ArrayList<UserProfile>());
    }

    public DBListArray(ArrayList<UserProfile> listName, ArrayList<UserProfile> listSSN) {
    super.setListName(listName);
    super.setListSSN(listSSN);
    }

    public DBListArray(DBListArray dbListArray) {
    super.setListName(dbListArray.getListName());
    super.setListSSN(dbListArray.getListSSN());
    }

}

Clase: DBListLinked

import java.util.LinkedList;

public class DBListLinked extends DBList {

    public DBListLinked() {
    super.setListName(new LinkedList<UserProfile>());
    super.setListSSN(new LinkedList<UserProfile>());
    }

    public DBListLinked(LinkedList<UserProfile> listName, LinkedList<UserProfile> listSSN) {
    super.setListName(listName);
    super.setListSSN(listSSN);
    }

    public DBListLinked(DBListLinked dbListLinked) {
    super.setListName(dbListLinked.getListName());
    super.setListSSN(dbListLinked.getListSSN());
    }

}

1) ¿Algo de esto tiene sentido? ¿Qué estoy haciendo mal? Tiene alguna recomendación?

2) Tendría más sentido para mí tener a los constructores enDBList y llamándolos (consuper()) en las subclases, pero no puedo hacerlo porque no puedo inicializar una variable connew List<E>().

3) Se pensaba que hacía copias profundas siempre que era posible y para eso siempre anulo elclone() método de mis clases y codificarlo en consecuencia. Pero esas clases nunca tenían listas, conjuntos o mapas en ellas, solo tenían cadenas, ints, flotadores. ¿Cómo hago copias profundas en esta situación?