Java - Passing generic lists into class via constructor

You have to change this: private List<Animal> myAnimalList to private List<? extedns Animal> myAnimalList

and

public List<Animal> getAnimalList() {
        return myAnimalList;
    } to
 public List<?extends Animal> getAnimalList() {
            return myAnimalList;
        }

Main reason is Cat extends Animal but List<Cat> do not extends List<Animal>. java generics will not allow to List<Cat> to List<Animal>. example: You can not do this: List<Animal> animalList= new ArrayList<Cat>(); java will not allow this. Cause otherwise Snake can be added animalList which ambiguous. But you can cast like this: List<? extends Animal> animalList= new ArrayList<Cat>(); In this casting you can only call the function of Animal class. As a result you can add any type of animal in animalList.

There is really just the one line of code in the body of the constructor of MyAbstractClass that needs to be changed. Basically you have two options: casting the incoming list or making a (defensive) copy of the list.

If you simply keep a reference to the incoming list, all changes made to that list outside of your code will be reflected in MyAbstractClass. This may or may not be what you want. Conversely, any change you make to the list in MyAbstractClass will also affect the caller of your code. This is usually rather unexpected. If you intend to add to the list, the solution of casting the incoming list is dangerous since you do not know the actual type of the elements of the list passed to the constructor (the caller might have cast the list to List<Cat>even if it was really a List<BigCat>) - which is not a type safe operation but not forbidden. Casting inside your constructor is not type safe either, so it should probably be avoided. Nonetheless, here is the constructor with casting:

public MyAbstractClass(List<? extends Animal> animalList) {
    this.myAnimalList = (List)animalList;
}

If MyAbstractClass wants to take control of the list of Animals, a copy of the list needs to be made. Note that copying a list does not automatically clone the elements of a list, so changes to an animal would still show up in MyAbstractClass. Here are two ways to copy the list which incidentally also solve the compilation problem (as every list of Cat or Snake is also a list of Animal, creating a copy of type List<Animal is fine - the copy only promises that all its elements are of type Animal, nothing more, nothing less):

public MyAbstractClass(Collection<? extends Animal> animalList) {
    this.myAnimalList = new ArrayList<>(animalList);
}

You should also change the accessor to the animals list unless it is ok that every caller can modify the animal list:

public List<Animal> getAnimalList() 
    return Collections.unmodifiableList(myAnimalList);
}

If the list of animals never changes, there is an alternative solution that uses ImmutableList from Google's guava library:

public abstract class MyAbstractClass {
   private List<Animal> myAnimalList;

    public MyAbstractClass(){
        this(ImmutableList.of());
    }

    public MyAbstractClass(Collection<? extends Animal> animalList) {
        this.myAnimalList = ImmutableList.copyOf(animalList);
    }

    public List<Animal> getAnimalList() {
        return myAnimalList;
    }

    //Stuff which DOES NOT add to the list
}

What makes this solution nice is that (a) the list is indeed immutable (compared to Collections.unmodifiableList which simply wraps a mutable list) and (b) ImmutableList.copyOf()is clever enough to know that when the list it receives is an ImmutableListit does not need to be copied. Because of (a), getAnimalList() can simply return the list.

BTW: the Java convention for method names is to start in lower case, for example shedSkin() rather than ShedSkin() - which is the C# convention.

To make that work, you must change the field in MyAbstractClass from:

private List<Animal> myAnimalList;

to

private List<? extends Animal> myAnimalList;

or change the constructor to

public MyAbstractClass(List<Animal> animalList){
    // stuff
}

Add a generic parameter to MyAbstractClass, this way you will know type of items in the list.

I just create a project with your code. please rectify below errors.

1) Import the java.util.List package.

2)  another error I find is this.. How don't know your requirement Cannot suggest the solution.

public MyAbstractClass(List<? extends Animal> animalList) {
        this.myAnimalList = animalList; <==== problem you cannot assign List<? extends Animal> to List<Animal> .. Subtyping is not allowed in generic class.
    }

One of the Solution :

public MyAbstractClass(List<? extends Animal> animalList) {

   myAnimalList= new ArrayList<Animal>();   

   for(Animal c: animalList){
        this.myAnimalList.add(c);
   }
}