How to generify classes when they have more than one differing fields?

Question

Given:

class PhysicsClass {
    private PhysicsInstructor instructor;
    private Set<PhysicsStudent> students;
}

class ChemistryClass {
    private ChemistryInstructor instructor;
    private Set<ChemistryStudent> students;
}

class MathemeticsClass {
    private MathemeticsInstructor instructor;
    private Set<MathemeticsStudent> students;
}

Is it possible to collect all of these classes in one generic class like:

class ScienceClass<T> {
    // What to write here?
    // What to write here?
}

If this is not possible, then how can I prevent the code duplication here?

I thought of making it like:

class ScienceClass<T extends Instructor, S extends Student> {
    private T instructor;
    private Set<S> students;
}

but this would allow me to make something like:

ScienceClass<PhysicsInstructor, ChemistryStudent> scienceClass;

which would be incorrect.

Answer 1

Start with Interfaces for the subjects

public interface Subject {}

public interface Physics extends Subject {}
public interface Chemistry extends Subject {}
public interface Mathematics extends Subject {}

Next

public class Instructor<T extends Subject> {
  ...
}

Then, you could create just one class for your "class"

public class SchoolClass<T extends Subject> {
  Instructor<T> prof;
  ArrayList<Student<T>> students;
}

Answer 2

Given your example, the most natural thing to do would be to start with something like:

public interface Subject

public interface Instructor<S extends Subject> { ...

public interface Student<S extends Subject> { ...

The above would for example allow to do things like:

public class Whatever<S extends Subject> {
  private T<S> instructor;
  List<S> students;

The other point here: always remember the good old "prefer composition over inheritance". Meaning: be really careful about creating various different classes here and complicated inheritance settings.

Finally: of course one has to understand what the programming language offers; but: the core part of your object/class model is: to be a helpful abstraction of reality. Meaning: don't focus too much on how to use generics in the first place. First you should carefully look at the aspects of real world that your application has to deal with. Then build your solution around that!

Answer 3

Assuming that you want the two types to "match up", you can do something like this:

interface Subject {}

interface Instructor<T extends Subject> {}

interface Student<T extends Subject> {}

With our basic interfaces set up, we can now create implementations of the subjects:

class Physics implements Subject {}

class Chemistry implements Subject {}

What you put in these classes is up to you, technically you can even leave them empty. Next thing, define the generic class representing a school class.

class SchoolClass<T extends Subject> {
    private Instructor<T> instructor;
    private Set<Student<T>> students;
}

And there's your link between the two fields, as they both refer to the same T type parameter.

---

As you can see from this, the design still isn't very clean, particularly the pointless Subject implementations stick out.

At this point it is a tempting, but obviously bad idea to do something like this:

//PLEASE DON'T DO THIS!
interface Instructor {}
interface Student<T extends Instructor> {}

Hooray, we've avoided that ugly Subject interface, but we've created what looks like a false relationship between student and instructor.

The moral of the story is (and this really depends on your actual use case) that inheritance&generics probably isn't the best tool to tackle this problem.