看看
project lombok,因为龙目岛做了类似你想要的事情.
龙目岛将采取这个来源,
public class GetterSetterExample {
@Getter @Setter private int age = 10;
@Setter(AccessLevel.PROTECTED) private String name;
@Override public String toString() {
return String.format("%s (age: %d)", name, age);
}
并生成一个类,
public class GetterSetterExample {
private int age = 10;
private String name;
@Override public String toString() {
return String.format("%s (age: %d)", name, age);
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
protected void setName(String name) {
this.name = name;
}
}
有一篇文章描述了lombok如何工作here,以及如何添加自己的转换.

     java代码中经常要实现一些接口，这个也是java代码独有的地方。实现接口，就意味着要实现这个接口中定义的方法，如果一个个去码出方法就需要记得方法名称等等，就算有内容辅助快捷键帮助，也是很麻烦的。这里有个小技巧，可以快速在当前类中实现接口定义的所有方法，当然都是空实现。:-D
        步骤一：先码出需要实现的接口
        
       步骤二：光标放到声明类的那一行，按住神键：Ctrl+1，即可看到实现所有方法的提示
       
      步骤三：选择实现所有方法，该类中即生成了接口中的方法空实现，接下来就根据需要自己重新实现，方便多了
 
 
     上一篇文章，Eclipse用法和技巧十四：自动生成的TODO注释2：
                             http://blog.csdn.net/ts1122/article/details/9009217
     下一篇文章，Eclipse用法和技巧十六：自动添加未实现方法2：
                             http://blog.csdn.net/ts1122/article/details/9116291
    

版权声明：本文为博主原创文章，未经博主允许不得转载。


转载于:https://www.cnblogs.com/wvqusrtg/p/4977939.html

类和类之间只能继承(extends)

接口和接口之间只能继承(extends)
只有接口才可以被实现(implements)
抽象类实现接口时可以不实现接口中的方法

接口继承接口同样不需要写额外的东西
普通类继承抽象类需要添加未实现的方法

普通类实现接口同样需要实现未实现的方法

本次实现的ArrayList并未使用泛型,以后添加。 

在自己实现ArrayList之前强烈建议先看一遍JDK的源码，有助于理解。 

附上一个链接深入Java集合学习系列：ArrayList的实现原理 

我自己实现了ArrayList中的add,get，set,remove方法 

MyArrayList:



import java.util.Arrays;
/*
 * ArrayList的底层实现为数组
 * MyArrayList暂时不考虑泛型
 */
public class MyArrayList {
    private Object[] elementData;//存放Object的数组
    private int size;//ArrayList大小

    public MyArrayList() {
        this(10);//如果不指定大小，默认大小为10
    }
    public MyArrayList(int initSize) {
        if(initSize<0){
            throw new IllegalArgumentException("IllegalArgument:"+initSize);//参数不合法，抛出异常
        }
        elementData = new Object[initSize];
    }
    public void add(Object obj) {//在末尾条件元素
        checkCapacity(size+1);//插入一个元素，至少需要size+1大小的空间
        elementData[this.size++] = obj;
    }
    public void add(int index,Object obj) {//在index处插入元素obj
        RangeCheck(index);
        checkCapacity(size+1);//插入一个元素，至少需要size+1大小的空间
        System.arraycopy(elementData, index, elementData, index+1, size-index);//将index后的元素都后移一个位置
        elementData[index] = obj;
        size++;
    }
    private void checkCapacity(int needCapacity) {//检查ArrayList开辟的空间是否足够，如果不足则进行扩容
        if(needCapacity>elementData.length){//空间不足，扩容
            Object oldelementData[] = elementData;
            int newSize = this.size*2+1;//扩容的空间
            elementData = new Object[newSize];
            elementData = Arrays.copyOf(oldelementData, newSize);
        }
    } 
    private void RangeCheck(int index) {//检查索引是否合法
        if(index<0||index>=size){
            throw new IndexOutOfBoundsException("IllegalArgument"+index);//出界，抛出异常
        }
    }
    public Object get(int index) {//根据索引返回对象
        RangeCheck(index);
        return elementData[index];
    }
    public Object set(int index,Object obj) {//将index位置置为obj
        RangeCheck(index);
        Object oldvalue = elementData[index];
        elementData[index] = obj;//设置新值
        return oldvalue;//返回旧值
    }
    public Object remove(int index) {//删除index处的元素
        RangeCheck(index);
        Object oldValue = elementData[index];
        int moveNum = size-index-1;
        if(moveNum>0){
            System.arraycopy(elementData, index+1, elementData, index, moveNum);
        }   
        elementData[--size] = null;//让垃圾回收器回收
        return oldValue;//返回旧值
    }
    public boolean remove(Object obj) {//删除等于obj的元素，成功返回true，失败返回false
        if(obj == null){
            for(int i=0;i<size;i++){
                if(elementData[i]==null){
                    fastremove(i);
                    return true;
                }
            }
        }else {
            for(int i=0;i<size;i++){
                if(obj.equals(elementData[i])){//obj不为null,一定要在前，否则使用elementData[i]调用equals()可能导致控制在异常
                    fastremove(i);
                    return true;
                }
            }
        }

        return false;
    }
    public void fastremove(int index) {
        int moveNum = size-index-1;
        if(moveNum>0){
            System.arraycopy(elementData, index+1, elementData, index, moveNum);
        }   
        elementData[--size] = null;//让垃圾回收器回收
    }
    public int size(){
        return this.size;
    }
    public int length() {
        return elementData.length;
    }
}


测试：



public class TestMyArrayList {
    public static void main(String[] args) {
        MyArrayList List = new MyArrayList(5);
        //末尾插入
        List.add(new A("张三"));
        List.add(new A("李四"));
        List.add(new A("王五"));
        List.add(new A("JACK"));
        List.add(new A("张三"));
        List.add(new A("李四"));
        List.add(new A("王五"));
        List.add(new A("JACK"));
        //自选位置插入
        List.add(2,new A("TOM"));
        System.out.println(List.size());
        System.out.println(((A)List.get(8)).name);
        //将index处置为新值
        A oldA = (A)List.set(3, new A("Lucy"));
        System.out.println(oldA.name);//打印旧值
        System.out.println(((A)List.get(3)).name);//打印新值
        System.out.println(List.size());
        //将index处的元素删除
        oldA = (A)List.remove(3);
        System.out.println(oldA.name);//打印删除的元素
        System.out.println(List.size());
        //删除和指定对象匹配的元素
        A temp = new A("Lily");
        List.add(temp);
        System.out.println(List.remove(temp));
    }
}
class A{
    String name;
    public A(String name) {
        super();
        this.name = name;
    }
}