I'm working on a Genetic Algorithm library and it occurs to me that I need the user to develop their own method for determining fitness.

I thought that I might do this by making the Chromosome abstract and leaving the fitness method abstract. Then they extend that class and write their own fitness method.

This of course leaves me in a tremendous pickle because the Chromosome in the model I'm working from is an inner class of GeneticAlgorithm. So I could make Chromosome an outside class. But although I can reserve objects in GeneticAlgorithm with the name ChromosomeTemplate, I then have the trouble of targeting the inherited class made by the user.

Or perhaps I could make GeneticAlgorithm abstract and put fitness scoring outside of the Chromosome, but I'm still a little unsure about that too because of dragging the user into the guts of something I shouldn't need them to understand.

Each path I take is a bit messy, an I haven't written abstract classes before for other people or even myself. I'm really interested to know what other peole think before I embark on making a really confusing library.

How I'd like to do things is (kind of pseudo code):
Code:

class Genetic Algorithm
  {
  // Global Variables
  GeneticAlgorithm(various variables)
  {
    // Init involving reference to Chromosome
  }
  // Methods
  class Chromosome
  {
    // Variables
    Chromosome(various variables)
    {
    // Init involving reference to
    // GeneticAlgorithm Global Variables
    }
    // Methods and also ideally I could do..

    abstract void scoreFitness();

    // But I'm pretty certain I can't
  }
}
 

So basically my issue was that I wanted this fleshed out class with one method that the user creates. So I'm pretty certain I need an abstract class of some sort.

But what would be the best way to do it? Because I don't think I can do it the way I've outlined above. (Unless there's actually some way of doing it?)

The Chromosome is going to be using a lot of variables from GeneticAlgorithm. Two separate classes would be a real pain in the arse. I think a way round it might be to do it this way:
Code:

class GeneticAlgorithm
{
  // yadda yadda and...
  
  abstract float parentScoreFitness();
  
  class Chromosome
  {
  // stuff and...
    void scoreFitness(){
	parentScoreFitness(Object target);
    }
  }
}
 

That way the user only has to extend GeneticAlgorithm and provide a fitness scoring method plus any other methods they may need. Would that be okay?

I'm thinking of parentScoreFitness() handling an Object because I've had the idea that the list of traits that represent the possible genetic traits could be like a Python list. I'd use a Vector to store them in. Then the user could get pretty creative.

Or should I just stick with a char[] for the traits and force them to use a simpler model?

What about using the power of interfaces? That way you could have inner classes and still utilise inheritance in a way ...

Code:

abstract class GeneticAlgorithm {
   // member variables and common GA methods ...

   // because of the interface definition, you can work with the Chromosome in any of the methods here ...
   abstract float scoreFitness(Chromosome o);
}

interface Chromosome {
   // define headers for common methods here ...
}

// then you can use
class SpecificGA extends GeneticAlgorithm {
   // some additional member variables and methods

   class SpecificChromosome implements Chromosome {
	// this is where you couple them ... the GA and the Chromosome are in the tight relation you probably need.
   }
}