Как передать параметр класса как параметр и вернуть общую коллекцию в Java?

Ответ 1

Поскольку вы говорите, что не хотите, чтобы ваши методы доступа к данным в разных классах (в комментарии к ответу anish), я подумал, почему бы не попробовать что-то вроде этого.

public class Records {

public interface RecordFetcher<T>{
    public List<T> getRecords();
}
static RecordFetcher<Fruit> Fruit=new RecordFetcher<Fruit>(){
    public List<Fruit> getRecords() {
        ...
    }
};


static RecordFetcher<User> User=new RecordFetcher<User>(){
    public List<User> getRecords() {
        ...
    }   
};

public static void main(String[] args) {
    List<Fruit> fruitRecords=Records.Fruit.getRecords();
    List<User> userRecords=Records.User.getRecords();

}
}

EDIT:

Я хотел бы добавить еще одну мою реализацию.

public class Test 
{ 
    public static void main(String[] args) 
    { 
       Test dataAccess=new Test();
       List<Fruit> FruitList=dataAccess.getAllRecords(Fruit.myType);
       List<User> UserList=dataAccess.getAllRecords(User.myType);
    } 
    <T> List<T> getAllRecords(T cl)
    {
        List<T> list=new ArrayList<T>();
        if(cl instanceof Fruit)
        {
             // Use JDBC and SQL SELECT * FROM fruit
        }
        else if(cl instanceof User)
        {
            // Use JDBC and SQL SELECT * FROM user
        }
        return list;
    }
}
class Fruit
{
    static final Fruit myType;
    static {myType=new Fruit();}
}
class User
{
    static final User myType;
    static {myType=new User();}
}

ИЗМЕНИТЬ

Я думаю, что эта реализация так же, как вы спросили

public class Test 
{ 
    public static void main(String[] args) throws InstantiationException, IllegalAccessException 
    { 
       Test dataAccess=new Test();

       List<Fruit> FruitList=dataAccess.getAllRecords(Fruit.class);

       List<User> UserList=dataAccess.getAllRecords(User.class);

    } 
    <T> List<T> getAllRecords(Class<T> cl) throws InstantiationException, IllegalAccessException
    {
        T inst=cl.newInstance();
        List<T> list=new ArrayList<T>();
        if(inst instanceof Fruit)
        {
             // Use JDBC and SQL SELECT * FROM user
        }
        else if(inst instanceof User)
        {
            // Use JDBC and SQL SELECT * FROM fruit
        }
        return list;
    }
}

Ответ 2

Похоже, вы хотите приспособить то, что Джош Блох называет шаблоном гетеросексуальных контейнеров типовafeafe: вы передаете токен типа Class<T>, и вы хотите вернуть a List<T>.

Обычная старая THC может отображать Class<T> в T по типу, но поскольку вместо этого вы действительно хотите List<T>, тогда вы хотите использовать то, что Neal Gafter называет токенами супертекста.

Следующий фрагмент адаптирован из кода Crazy Bob Lee, размещенного в блоге Neal Gafter:

public abstract class TypeReference<T> {
    private final Type type;

    protected TypeReference() {
        Type superclass = getClass().getGenericSuperclass();
        if (superclass instanceof Class<?>) {
            throw new RuntimeException("Missing type parameter.");
        }
        this.type = ((ParameterizedType) superclass).getActualTypeArguments()[0];
    }
    public Type getType() {
        return this.type;
    }
}

Теперь вы можете создать маркер супер-типа, например:

    TypeReference<String> stringTypeRef =
            new TypeReference<String>(){};

    TypeReference<Integer> integerTypeRef =
            new TypeReference<Integer>(){};

    TypeReference<List<Boolean>> listBoolTypeRef =
            new TypeReference<List<Boolean>>(){};

По существу вы передаете TypeReference<T> вместо Class<T>. Разница в том, что нет List<String>.class, но вы можете сделать TypeReference<List<String>>.

Итак, теперь мы можем сделать наш контейнер следующим образом (следующее из оригинального кода Джоша Блоха):

public class Favorites {
    private Map<Type, Object> favorites =
        new HashMap<Type, Object>();

    public <T> void setFavorite(TypeReference<T> ref, T thing) {
        favorites.put(ref.getType(), thing);
    }
    public <T> T getFavorite(TypeReference<T> ref) {
        @SuppressWarnings("unchecked")
        T ret = (T) favorites.get(ref.getType());
        return ret;
    }
}

Теперь мы можем поместить их вместе:

    Favorites f = new Favorites();
    f.setFavorite(stringTypeRef, "Java");
    f.setFavorite(integerTypeRef, 42);
    f.setFavorite(listBoolTypeRef, Arrays.asList(true, true));

    String s = f.getFavorite(stringTypeRef);
    int i = f.getFavorite(integerTypeRef);
    List<Boolean> list = f.getFavorite(listBoolTypeRef);

    System.out.println(s);    // "Java"
    System.out.println(i);    // "42"
    System.out.println(list); // "[true, true]"

Нил Гафтер утверждал в своем блоге, что с еще несколькими колокольчиками TypeReference для токенов супертипа сделает достойное включение в JDK.

Приложения

• Полный исходный код на ideone.com

Ссылки

• Neal Gafter Blog - супертекстовые тики

Ответ 3

Вы довольно близки.

public <T> LinkedList<T> getAllRecords(List<T> list) {
 ...
}

Это называется Общий метод.

Вам нужно указать такой параметр, как List<T>. Затем, основываясь на типе списка, который вы проходите, Java выведет возвращаемый родовой тип.

Edit:

Ответ Poly очень хорош. Вам должно быть достаточно легко сделать следующее и не создавать класс TypeReference.

List<Fruit> fruit = myDataAccessObject.getAllRecrods(new LinkedList<Fruit>());
List<User> users = myDataAccessObject.getAllRecords(new LinkedList<User>());

Ответ 4

Ну, я действительно не знаю, нужен ли вам этот способ. Но вот полиморфный подход. Это может где-то помочь.

Создавайте разные объекты для разных таблиц, реализуя общий интерфейс. Это означает, что вы представляете каждую таблицу как объект.

import java.util.LinkedList;

public class DataAccessTest 
{

    /**
     * @param args
     */
    public static void main(String[] args) 
    {
        DataAccess myDataAccessObject = new DataAccess();
        Type type1 = new Fruit();
        Type type2 = new User();
        LinkedList<Type> list1 = myDataAccessObject.getAllRecords(type1);
        LinkedList<Type> list2 = myDataAccessObject.getAllRecords(type2);
        LinkedList<Type> list3 = myDataAccessObject.getAllRecords(new Fruit());
        LinkedList<Type> list4 = myDataAccessObject.getAllRecords(new User());
    }
}

class DataAccess
{
    public LinkedList<Type> getAllRecords(Type type)
    {
        return type.getAllRecords();
    }
}

interface Type
{
    public LinkedList<Type> getAllRecords();
}

class Fruit implements Type
{
    public LinkedList<Type> getAllRecords()
    {
        LinkedList<Type> list = new LinkedList<Type>();
        list.add(new Fruit());
        return list;
    }
}

class User implements Type
{
    public LinkedList<Type> getAllRecords() 
    {
        LinkedList<Type> list = new LinkedList<Type>();
        list.add(new User());
        return list;
    }
}

Ответ 5

В зависимости от того, как вы действительно извлекаете данные, вы можете сделать что-то вроде этого:

private static <T> List<T> getAll(Class<T> cls){
  List<T> fromSql = (List<T>) sql.query("SELECT * FROM objects WHERE type="+cls.getName());
  return fromSql;
}

Это требует, чтобы ваш объект sql возвращал правильный тип списка, который O/R отображает как iBatis.

Если вам нужно различать пройденные типы, вы все равно можете сделать переключатель/регистр на cls.

Ответ 6

Я считаю, что то, что вы пытаетесь сделать, возможно с небольшим количеством магии дженериков. Я должен был решить ту же проблему только сейчас, и это то, что я сделал:

public class ListArrayUtils{
   @SuppressWarnings("unchecked") // It is checked. 
   public static <T,E> List<T> filterByType(List<E> aList, Class<T> aClass){
      List<T> ans = new ArrayList<>();
      for(E e: aList){
         if(aClass.isAssignableFrom(e.getClass())){
            ans.add((T)e);
         }
      }
      return ans;
   }       
}

И модульные тесты:

public class ListArrayUtilsTest{
   interface IfA{/*nothing*/}
   interface IfB{/*nothing*/}
   class A implements IfA{/*nothing*/}
   class B implements IfB{/*nothing*/}
   class C extends A implements IfB{/*nothing*/}

   @Test
   public void testFilterByType(){
      List<Object> data = new ArrayList<>();
      A a = new A();
      B b = new B();
      C c = new C();
      data.add(a);
      data.add(b);
      data.add(c);

      List<IfB> ans = ListArrayUtils.filterByType(data, IfB.class);

      assertEquals(2, ans.size());
      assertSame(b, ans.get(0));
      assertSame(c, ans.get(1));
   }
}

Ответ 7

Я действительно сделал это в общей библиотеке доступа к данным. См. Norm. Полный исходный код на Github.