Hjälp med Java tack.

import java.util.HashMap;

public class Model {
	
	 HashMap<Integer,Long> memory = new HashMap<Integer,Long>();
	 
	 Integer value;
	 Long result;
	 
	
	 
	 
	
	 public long computePower(int value){
		 if(value <= 0 )
			 return 1;
		 else{
			 return 2 * computePower(value-1);
		 }
	 }
	 
	private void addValueToMemory(Integer value, Long result){
		 memory.put(value, result);
	 }
	 private Long getValueFromMemory(Integer value){
		 return memory.get(value);
	 }
	 public long compute2Power(int value){
		 if(value < 0)
			 throw new  IllegalArgumentException();
		 else if(value >= 0){
			return getValueFromMemory(value);
		 }
		 else{
				
			  return computePower(value);
		 }

			 
	 }
	 public void clearMemory(){
		 memory.clear();
	 }
	 
}

import java.util.Scanner;

public class Program {

	public static void main(String[] args) {
		
		Model m = new Model();
		
		Scanner s = new Scanner(System.in);
		
		System.out.println("Add a positive number, -1 to clear or -2 to quit");
		
		int input = 0;
		
		
		
		while(input != -2){
		
		input = s.nextInt();
		
		if(input == -1){
			m.clearMemory();
			System.out.println("Memory cleared");
		}
			else if(input == -2){
			m.clearMemory();
			System.out.println("Memory cleared");
			System.out.println("Program quits");
		}
		else if(input >= 0){
			System.out.println("2^n = " + m.compute2Power(input));
		}
		else{
			try{
				System.out.println("Invalid input");
			}catch(IllegalArgumentException e){
			}
		
		}		
	}
		System.exit(0);
	}
}

compute2Power()/getValueFromMemory() kollar aldrig om resultatet för det efterfrågade värdet tidigare har sparats. getValueFromMemory() returnerar med andra ord alltid ett null för alla värden större eller likamed 0. Detta null blir till ett exception i compute2Power när den unboxar Long till long.

Ang. att raden är understruken: det är bara en hjälpande varningseffekt från din utvecklingsmiljö. Du borde få samma varning på rad 6 och 7 i Model.java

En stor del i att lära sig programmera är att själv lösa problem man får. Nu vet du exakt vad problemet är, att säga exakt vad du ska ändra är en björntjänst.

Börja med att förklara hur du tänkte här:

public long compute2Power(int value)
{
    if(value < 0)
        throw new  IllegalArgumentException();
    else if(value >= 0){
        return getValueFromMemory(value);
    }
    else{
        return computePower(value);
    }		 
}

Om value är mindre än noll så är det en IllegalArgumentException, om value är noll eller högre hämtar du det från minnet. I vilken situation kommer "return computePower(value)" hända?

Vad är ens poängen med HashMap:en?
Sedan bör du nog fundera lite över hur du beräknar upphöjt:

 return 2 * computePower(value-1);

Som jag ser det bör du fokusera på själva logiken snarare än hur koden skall se ut. Din kod vill hämta värdet som det finns i minnet, annars räkna ut det. Utöver detta vill funktionen också reagera om värdet inte är valid. Nu är det bara att bygga koden runt den logiken:

public long compute2Power(int value)
{
    if (value < 0)
        throw new  IllegalArgumentException();

    Long ret = getValueFromMemory(value);
    if (ret != null)
        return (long)ret;
    else
        return computePower(value);		 
}

Varning, jag har inte jobbat med Java på länge och är inte superinsatt i hur boxing och nullables fungerar. Jag antar att Long är som en nullable long och kan castas till long, i så fall borde koden ovan fungera. Det är snarare logiken som är det viktiga dock, inte exakt hur det är skrivet.

Dela upp det i två delar, en som alltid tar resultatet ur minnet och som därmed måste lägga till de resultat som saknas. Den andra delen är att räkna ut resultat utan hänsyn taget till eventuell cache.

Det första steget blir då något i linje med detta

	static public Long memoize(Integer arg)
	{
		if (!cache.containsKey(arg)) {
			cache.put(arg, compute(arg));
		}
		return cache.get(arg);
	}

där "cache" är en instans av din HashMap<Integer, Long> och "compute" är det som alltid räknar ut resultatet.