并没有看懂是啥意思。。

你既然想传递一个已经附了值的对象进来，无非就是对这个对象里面的元素进行操作，这样直接在你调用的方法里操作这个传递过来的这个对象的引用就行，为什么还要给返回值，在你这个方法里修改了这个传递过来的对象的引用，实际上跟你当初的对象指向的是同一个地址，修改了就等同于修改了原来的对象，而不用想着再把这个对象引用再返回给他了，也就是不用给他返回值了。

2楼正解

最近写了个链表，你看看吧
public class Node<T> {
private T value;
private Node<T> next;
public Node() {
super();
}
public Node(T value) {
super();
this.value = value;
}
public Node(T value, Node<T> next) {
super();
this.value = value;
this.next = next;
}
public T getValue() {
return value;
}
public Node<T> getNext() {
return next;
}
public void setValue(T value) {
this.value = value;
}
public void setNext(Node<T> next) {
this.next = next;
}
}
public class MyLinkedList<T> implements MyListInterface<T> {
private Node<T> head;
private int size;
private void checkIndex(int index) {
if(index < 0 || index >= size) {
throw new ArrayIndexOutOfBoundsException("下标越界：" + index);
}
}
@Override
public boolean isEmpty() {
return head == null;
}
@Override
public int size() {
//int i = 0;
//Node<T> node = head;
//while (node != null) {
//i++;
//node = node.getNext();
//}
//return i;
return size;
}
@Override
public T get(int index) {
checkIndex(index);
Node<T> node = head;
int i = 0;
while(node.getNext() != null && i < index) {
i++;
node = node.getNext();
}
return node.getValue();
}
@Override
public void set(int index, T element) {
if(index < 0 || index > size) {
throw new ArrayIndexOutOfBoundsException("下标越界：" + index);
}
if(index == size) {
size++;
}
Node<T> node = head;
int i = 0;
while (node.getNext() != null && i < index) {
i++;
node = node.getNext();
}
node.setValue(element);
}
@Override
public boolean add(int index, T element) {
checkIndex(index);
size++;
if(head == null) {
head = new Node<T>(element);
}else{
Node<T> node = head;
if(index == 0) {
head = new Node<T>(element, node);
}else{
int i = 0;
while(node.getNext() != null && i < index - 1) {
i++;
node = node.getNext();
}
node.setNext(new Node<T>(element, node.getNext()));
}
}
return true;
}
@Override
public boolean add(T element) {
return add(Integer.MAX_VALUE, element);
}
@Override
public T remove(int index) {
checkIndex(index);
size--;
Node<T> node = head;
Node<T> reNode = head;
if(index != 0) {
int i = 0;
while(node.getNext() != null && i < index - 1) {
i++;
node = node.getNext();
}
reNode = node.getNext();
node.setNext(node.getNext().getNext());
node.getNext().setNext(null);
}else{
head = node.getNext();
node = null;
}
return reNode.getValue();
}
@Override
public void clear() {
head = null;
size = 0;
}
}

我觉得你还是把你想要做什么说清楚，从你的回复来看，并不一定适合泛型，你得知道泛型到底解决了什么问题

Filed[] fields = class.getDeclaredFields() ;
for(Field field : fields)
{
Object value = field.get() ;
String name = field.getName() ;
//然后串成sql语句
}
楼主是这个思路吗?