Typy Generyczne i dodawanie typów Prostych

Witam
Mam do stworzenia Program(Dokładniej prosty Model Neuron, ale to mniej istotne) Użytkownik w tym programie może pracować na typach całkowitych bądź zmiennoprzecinkowych i założenie rozwiązania tego problemu ma być Klasa Generyczna, która tworzy obiekt takiego typu jakiego użytkownik wybierze. Mój problem polega na dodaniu Do Elementu Tablicy typu "T" wylosowanej wartości zmiennoprzecinkowej bądź cał.

 
public class NeuronGeneric<T>
{
 private T weights[]; 
 private int output;
    
    
    public T[] getWeights() {
        return weights;
    }
    public void setWeights(T[] weights) {
        this.weights = weights;
    }
    public int getOutput() {
        return output;
    }
    public void setOutput(int output) {
        this.output = output;
    }
   
    
    public NeuronGeneric(int n )
    {
        weights = (T[])new Object[n];
    }
    
    
    public void randomWeights(T a , T b )
  {
    Random r = new Random();    
    
    
         for(int i = 0; i<weights.length;i++)
         {               
             weights[i]=r.nextDouble()*(b-a+1) +a ;
             if (weights[i]>b)
             {
                 i--;
             }
         }
     }
}//

Dziekuje z góry za podpowiedz :)

Pamiętaj, że w Javie wszystkie typy prymitywne mają swoje obiektowe odpowiedniki tzn. jeżeli chciałbyś użyć NeuronGeneric<int> to należy użyć NeuronGeneric<Integer>. Mechanizm autoboxingu typów już sobie z tym poradzi.

////
Jestem po kawusi zatem działam...

Po pierwsze

 weights[i]=r.nextDouble()*(b-a+1) +a ;

To się nawet nie skompiluje, bo w Javie typem generycznym może być tylko Obiekt, a ten nie posiada operatorów + i -. Zabawa z <T extends Number> też nie da zbyt wiele. Skoro klasa ma być generyczna, ale ma wpierać tylko int i double to można zastosować pewien trik. O tym za chwilę.

NeuronGeneric(int n) {
        weights = (T[]) new Object[n];
    }

To znowuż wywali się w runtime z ClassCastException, bo rzutujesz w dół typ bardziej ogólny.

Moje rozwiązanie to ukrycie implementacji dla konkretnych typów w klasach wewnętrznych:

abstract class NeuronGeneric<T extends Number> {
    protected T weights[];
    private int output;


    protected NeuronGeneric(int n) {
        // do nothing need to override
    }

    public T[] getWeights() {
        return weights;
    }

    public void setWeights(T[] weights) {
        this.weights = weights;
    }

    public int getOutput() {
        return output;
    }

    public void setOutput(int output) {
        this.output = output;
    }

    public static NeuronGeneric<?> forInt(int i ){
        return new Int(i);
    }

    public abstract void randomWeights(T a, T b);


    private static class Int extends  NeuronGeneric<Integer>{

        protected Int(int n) {
            super(n)   ;
            weights = new Integer[n];
        }

        @Override
        public void randomWeights(Integer a, Integer b) {
            //...
        }
    }
}

i dodanie metod tworzących "dla typu".