Question

您好我有非常相似的课程（汽车，客户，预订）。在这些类中，我具有相同的功能，如（add，delete，getItem，getAll和sort）。

public class Clients {  
    List<Client> persons = new ArrayList<Client>(); 

    public void add (Client k) {
        persons.add(k);
    }

    public void delete (Client k) {
        persons.remove(k);
    }

    public Client getKlienet(int id) {
       for ( Client k: persons) {
           if ( k.getId() == id)
               return k;
       }            

       return null;
    }

    public List<Client> getAllClients() {
        List<Client> temp = new ArrayList<Client>();                
        temp.addAll(persons);   

        return temp;
    }

    public List<Client> sortujKontakty() {
        Collections.sort(persons);          

        return persons;
    }

我想在这些类中使用一个泛型类。但是我有很多问题.. 首先使用函数getId()（此函数只返回Id的值），并使用sort()方法。其他类的Compareto()方法不同。

所以，我完成了界面：

public interface ManagerInterface <T> { 
    public void    add (T t );
    public void    delete ( T t);
    public T       getRecord(int id);
    public List<T> getAll();
    public List<T> sort();  
}

上课：

public class RecordManager<T> implements RecordManagerInterface <T> {
    private T id;

    public T getId() {
        return id;
    }

    public ArrayList<T> record = new ArrayList<T>();

    @Override
    public void add(T t) {
        record.add(t);  
    }

    @Override
    public void delete(T t) {
        record.remove(t);
    }

    @Override
    public T getRecord(int id) {
        for ( T k: record) {
            if ( ((Client) k).getId() == id)
                return k;
            else if ( ((Person) k).getId() == id)
                return k;
            else if ( ((Reservation) k).getId() == id)
                return k;               
        }

        return null;
    }

    @Override
    public List<T> getAll() {
        List<T> temp = new ArrayList<T>();              

        temp.addAll( record);   

        return temp;        
    }

    @Override
    public  List<T> sort() {
        Collections.sort(record);           

        return record;      

    }

请求任何帮助。

Answer 1

如果您有类似的类，请尝试为它们创建通用接口，

即

interface  HasId { 
int getId();
}

然后您需要的所有内容都是让您的课程实现它，并将您的RecordManager更改为

public class RecordManager<T extends HasId> implements RecordManagerInterface <T> {
...
}

这意味着你的T必须实现你的界面，所以你的get getRecord方法会更简单

 public T getRecord(int id) {
        for ( T k: record) {
           if (k.getId() == id)
               return k;
        }

        return null;
    }

修改让我们说你的通用界面将是

interface CommonInterface<T> extends Comparable<T> { public int getId(); }

然后定义你的班级，即

Person implements CommonInterface<Person> { ... }

您的RecordManager

class RecordManager<T extends CommonInterface<T>> implements RecordManagerInterface<T>{ }

这应该用sort
解决你所有的问题

Answer 2

这就是所谓的＆＃34;编码到接口＆＃34;。然后，当您实例化对象时，请将对接口和对象的引用引用到要实例化的特定类。

例如：

Interface example = new Class();

然后使用example.getMethod（），example.setMethod（）。根据继承，这实际上会调用Class.getMethod（）（如果有的话）。

泛型类用Java编写

2 个答案: