Java 通过ArrayList<&燃气轮机；对象到扩展ArrayList的类

我试图创建一个扩展ArrayList的类，添加两个方法，如下所述。 但是，新的BetterArrayList类没有正确地从其构造函数方法中读入参数，从而从传递的ArrayList对象创建扩展对象。 将ArrayList对象传递给此类类并将该对象的内容分配给类成员变量的正确方法是什么

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class BetterArrayList<E> extends ArrayList<E> {
    private int size;
    private ArrayList<E> myArray = new ArrayList<>(size);

    public BetterArrayList(ArrayList<E> passArr){
        System.out.println("New BetterArrayList");
        this.size = passArr.toArray().length;
        this.myArray = passArr;
        myArray.addAll(passArr);    
    }
    public E pop() {
        return remove(this.size() - 1);
    }
    public void print() {
        myArray.forEach(elem ->{
            System.out.println(elem);
        });
    }
    /**
     * 
     */
    private static final long serialVersionUID = 1L;


    public static void main(String[] args) {
        // int[] ints = new int[] {1,2,3,4,5};
        Integer[] ints = new Integer[] {1,2,3,4,5};
        System.out.println(ints.length);
        ArrayList<Integer> arrs = new ArrayList<Integer>(Arrays.asList(ints));
        System.out.println(arrs.size());
        BetterArrayList<Integer> BetterArray = new BetterArrayList<Integer>(arrs);
        System.out.println(BetterArray.size());
        BetterArray.pop();
        BetterArray.print();
    }

}

import java.util.ArrayList；
导入java.util.array；
导入java.util.List；
公共类BetterArrayList扩展了ArrayList{
私有整数大小；
私有ArrayList myArray=新ArrayList（大小）；
公共BetterArrayList（ArrayList Passar）{
System.out.println（“新BetterArrayList”）；
this.size=passArr.toArray（）长度；
this.myArray=passArr；
myArray.addAll（passArr）；
}
公共E-pop（）{
返回移除（this.size（）-1）；
}
公开作废印刷品（）{
myArray.forEach（元素->{
系统输出打印项次（elem）；
});
}
/**
* 
*/
私有静态最终长serialVersionUID=1L；
公共静态void main（字符串[]args）{
//int[]ints=新的int[]{1,2,3,4,5}；
整数[]整数=新整数[]{1,2,3,4,5}；
系统输出打印长度（整数长度）；
ArrayList arrs=新的ArrayList（Arrays.asList（ints））；
System.out.println（arrs.size（））；
BetterArrayList BetterArray=新的BetterArrayList（arrs）；
System.out.println（BetterArray.size（））；
betterray.pop（）；
betterray.print（）；
}
}

尝试同时使用组合和继承会让您感到困惑

简单地说，组合就是您试图将

ArrayList

作为类字段放入其中，并通过访问该字段来使用它

继承是您试图使用

扩展的地方（在本例中）

我修改了您的代码以消除合成，只需使用
extends
（我稍微更改了test
print
语句以明确说明）：

旁注：

ArrayList: [1, 2, 3, 4, 5]
BetterArrayList: [1, 2, 3, 4, 5]
BetterArrayList After Pop: [1, 2, 3, 4]

我修改了您为
BetterArrayList
实例使用的名称，以使用适当的Java命名约定，
WithCasingLiketThis
作为变量名，而不是
CasingLiketThis

此外，组合也可以是一种非常有效的方法，但是不要在同一个类上同时使用这两种方法

区分它们的提示：

构图表示一个具有关系的

继承表示一种关系

在构造函数中添加了super方法，以自动创建新的BetterArrayList对象，该对象具有作为参数传递的ArrayList对象的所有属性。
这似乎是一个简单的修复方法，我试图手动继承父类的属性，而不仅仅是调用super

public class BetterArrayList<E> extends ArrayList<E> {

    public BetterArrayList(ArrayList<E> passArr){
        super(passArr);
        System.out.println("New BetterArrayList");
    }
    public E pop() {
        return remove(this.size() - 1);
    }
    public void print() {
        System.out.println(this);
    }
    /**
     * 
     */
    private static final long serialVersionUID = 1L;


    public static void main(String[] args) {
        // int[] ints = new int[] {1,2,3,4,5};
        Integer[] ints = new Integer[] {1,2,3,4,5};
        System.out.println(ints.length);
        ArrayList<Integer> arrs = new ArrayList<Integer>(Arrays.asList(ints));
        System.out.println(arrs.size());
        BetterArrayList<Integer> BetterArray = new BetterArrayList<Integer>(arrs);
        System.out.println(BetterArray.size());
        BetterArray.print();
        BetterArray.pop();
        BetterArray.print();
    }

}

公共类BetterArrayList扩展了ArrayList{
公共BetterArrayList（ArrayList Passar）{
超级（帕萨尔）；
System.out.println（“新BetterArrayList”）；
}
公共E-pop（）{
返回移除（this.size（）-1）；
}
公开作废印刷品（）{
System.out.println（本文件）；
}
/**
* 
*/
私有静态最终长serialVersionUID=1L；
公共静态void main（字符串[]args）{
//int[]ints=新的int[]{1,2,3,4,5}；
整数[]整数=新整数[]{1,2,3,4,5}；
系统输出打印长度（整数长度）；
ArrayList arrs=新的ArrayList（Arrays.asList（ints））；
System.out.println（arrs.size（））；
BetterArrayList BetterArray=新的BetterArrayList（arrs）；
System.out.println（BetterArray.size（））；
betterray.print（）；
betterray.pop（）；
betterray.print（）；
}
}
我不明白为什么要获取arraylist并将其添加到构造函数中。你想在这里完成什么？你的类中不需要myArray。只需在构造器中调用super（passArr）并使用“此”上的其他方法即可“。详细说明一下，我认为您的想法是尝试在同一个类中同时使用组合和继承。谢谢！全部清楚。简单继承是目标，但我没有调用父类的构造函数方法。我听说组合“更好”因为它允许更大的灵活性，而不需要严格的层次结构。我知道这可能是一个广泛的概括，但是，对于常见的应用程序，这种说法有多准确？@Darnoc Eloc我不知道我是否会说“更好”，但可能更有用。根据我的经验，更常见的情况是需要在另一个自定义类中包含多个其他自定义类，而不是将一个类的功能扩展到另一个自定义类。例如，银行应用程序可能有一个
Customer
类，其中包含一个
SavingsAccount
类，但有一个
SavingsAccount
不是
客户，所以你不会扩展，你会使用合成。@Darnoc Eloc一个有用的继承示例可能是制作一个视频游戏，其中所有敌人都有默认功能，即
敌人
类，而一个特定的敌人会扩展该类，例如
地精扩展我的
，因为
地精
是一个
敌人
。你也可以深入到多个层次-
敌人
职业，
怪物扩展敌人
，
地精扩展怪物
等等。
public class BetterArrayList<E> extends ArrayList<E> {

    public BetterArrayList(ArrayList<E> passArr){
        super(passArr);
        System.out.println("New BetterArrayList");
    }
    public E pop() {
        return remove(this.size() - 1);
    }
    public void print() {
        System.out.println(this);
    }
    /**
     * 
     */
    private static final long serialVersionUID = 1L;


    public static void main(String[] args) {
        // int[] ints = new int[] {1,2,3,4,5};
        Integer[] ints = new Integer[] {1,2,3,4,5};
        System.out.println(ints.length);
        ArrayList<Integer> arrs = new ArrayList<Integer>(Arrays.asList(ints));
        System.out.println(arrs.size());
        BetterArrayList<Integer> BetterArray = new BetterArrayList<Integer>(arrs);
        System.out.println(BetterArray.size());
        BetterArray.print();
        BetterArray.pop();
        BetterArray.print();
    }

}