Big generic problem

Question

I'm having a big problem. Look at this:
public class Person {
public class Employee extends Person {
public class Bank {
private List<Person> people = new ArrayList<Person>();
public List<Person> people() {
return people;
Now the problem:
public class Test {
public static void main(String args[]) {
Bank b = new Bank();
b.people().add(new Employee()); // This was to be forbidden, but
// the compiler doesn't complain
In the class Bank I declared a list to contain only Person objects:
private List<Person> people = new ArrayList<Person>();
and a method to return it, with the same generic type:
public List<Person> people()
so, how could the compiler let me add a person of type Employee in the class
Test? No matter if I change the declaration of the people() method to accept
only objects of class Person and above, like this:
public List<? super Person> people()
it still compiles and I still can add Employee objects to the list that were
supposed to hold just Person objects.
So, the question is:
HOW COULD I RETURN A LIST IN A METHOD WITH A GENERIC TYPE THAT HAS SUBCLASSES AND THAT I CAN MAKE THE LIST TO ACCEPT OBJECTS JUST OF THAT TYPE, NOT OF ITS SUBCLASSES? So, this is type safe. I don't want the list of the example above to accept objects of type Employee, just Person.

Answer 1

so, why can I add Employees to a list declaredthis
way
public List<Person> get() {
return people; // <--- list of Person
}I don't see how it can be said any more clearly -
BECAUSE AN Employee IS A Person!
wouldn't it be to behave the same way as you
said?
Is
the proplem related to a param and a return
type.
With params with works, but not with returntypes?
I don't understand your point!Look if I'm really understanding this thing:
public void add(List<Person> p)
private List<Employee> e = new
ArrayList<Employee>();
obj.add(e) // Error. It's not exactly a PersonNow:
public List<Person> people();
private List<Employee> e = new
ArrayList<Employee>();
obj.people().add(new Employee()); // Ok. But why?An Employee is a Person. But in the first code it
didn't let me add an Employee to a method acception a
Person. That's what I want. But why the second code
worked. Isn't it the same thing. The param type in
both examples is a list of Person.To be more clear in the first code:
public class Obj {
    public void people(List<Person> p)
private List<Employee> e = new ArrayList<Employee>();
Obj obj = new Obj();
obj.people(e) // Error. It's not exactly a Person