/*		CSC15 Midterm Exam Review Guide

                Solutions to Practice Problems



                       Practice Problems:

YOU SHOULD WRITE OUT ON PAPER ALL FUNCTIONS FIRST. Remember, you'll be
asked to write code on paper during the exam!  Do not fool yourself.
Write the program by looking at your notes and other programs first.
Then, try to write it again, WITHOUT looking at your notes.

1. complete the following program, following instructions in comments:

Write the following simple statements

   a.  Declare integer variables x and y, 

     int x;  int y;

   b.  Assign 2*x to y

     y = 2*x;
  
   b2. swap the values of x and y

     int temp;
     temp = x;
     x = y;
     y = temp;

   d.  Write an if-else statement that determines which one of three
       integer variables (x,y,z) contains the smallest value.

     I'll write the solution as a function:

    public int least3(int x, int y, int z)
    {
     int answer;
     if (x<y)
       { if (x<z) answer = x;
           else answer = z;
       }
     else 
       {
         if (y<z) answer = y;
           else answer = z;
       }
     return answer;
    }

   e.  Assume integer variables x, y and double variable z has been
       declared.  You want to divide x by y, but you want the result to
       be a floating point (double) value, so you can assign it to z.
       Write one or more statements to do so.

   z = ((double)x)/y;


2.  In the following class does not contain any variables.  Write the
following functions in this class, then complete the main function in
the second class below.  Remember: determine what parameters and what
return value these functions need to have first.  Since there are no
variables in the class, these functions(methods) don't share variables
with any other functions (all their variables are local).
*/

class theClass
{

// write a function f that takes an integer x and return an integer
// representing 3*x + 1.

   public int f(int x)
    { return 3*x+1; }

// write a function s that takes an integer x and returns no value.
// the function's code should first change the value of x to x+1, then
// print out the new value of x. e.g., s(3) should print 4.

    public void s(int x)
    { x = x+1;
      System.out.println(x);
    }


// Write a function that takes a double between 0 and 1 and return the
// corresponding integer between 0 and 100 (think if it as a percentage
// value).  For example, f(0.5) should return 50, assuming f is the
// name of the function.  Hint: multiply by 100.0, then type cast to int. 

    public int percent(double p)
    {
	int answer;  double temp;
	temp = p* 100;
	answer = (int) p;  
        // if the question asked you to round off, the above line
	// would be answer = (int) (p+0.5) - be careful about the parentheses
        return answer;
    }  
   
} // the class

/*
// complete the following main function:
public class whatever
{
 public static void main(String[] args)
 {
  // declare variables x, and y, and assign them 3 and 4 respectively

  int x;  x = 3;
  int y = 4;   // convenient form of above

  // declare a boolean variable b;

  boolean b;

  // create an instance of the class theClass so you can call functions
  // on it.  Remember this is a two-step process.

  theClass obj = new theClass();

  // call function s on x;  -- note this is a statement, since s returns void
  // print out the value of x.  Why did it print 3?  Wasn't it changed to
  // 4 inside the function s?!  You need to understand what's happening 
  // here (local variables).

  obj.s(x);
  
  // Print out the final values of x, y, indicating which is which.

  System.out.println("x is"+x+" and y is "+y);

 }
}


3. Review the object-orientation examples.

Assume you build PCs for people.  Write a class to represent a PC.

The class should encapsulate the followoing information (variables).

String cputype - such as "pentium4" or "athlon"
double ghz  - e.g, 2.4 gigahertz
int RAM     - e.g, 512 megabytes
int drivespace - e.g, 80 gigs
String gpu  - such as "Nvidia" or "ATI"
   
   class PC
   {

     String cputype; 
...

3a. Write a constructor function for the class.  By default, 
all PC's will have 256 megs of RAM and a 60 gig hard drive.  However,
the constructor should accept parameters to determine the type and
speed of the CPU and the graphics card.

   public PC(...


4.  Write "accessor methods" that return the values of each of the
variables in the class.

5.  Write a function called 'changegpu' that changes the graphics card.

   public void changegpu(String newgpu)

    Sometimes I'll give you the first line, like above, but sometimes I won't


6. Write a function called 'upgrade' that doubles the ammount of RAM in
   the PC, and triples the disk space.


7. Write a function called 'betterthan' that takes another PC object
as a parameter and determines if 'this' PC is better than the other
PC.  One PC is better than another if it has more memory AND a faster
processor.  Otherwise, it's not better.  Your function should return a
boolean.  (look in other programs (e.g., footballteam) for similar
examples).


8.  Write a public class with a main method that creates two PC objects
and demonstrate how each of the methods can be called.

*/

class PC
{
    private String cputype; // - such as "pentium4" or "athlon"
    private double ghz;     //  - e.g, 2.4 gigahertz
    private int RAM;        //     - e.g, 512 megabytes
    private int drivespace; //- e.g, 80 gigs
    private String gpu;     // - such as "Nvidia" or "ATI"

    // 3a. (constructor)
    public PC(String c0, double g0, String gpu0)
    {
	cputype = c0;
	ghz = g0;
	gpu = gpu0;
	RAM = 256;
	drivespace = 60;
    } 

    // 4. accessors
    public String getcputype() { return cputype; }
    public double getspeed() { return ghz; }
    public int getram() { return RAM; }
    public int getdisk() { return drivespace; }
    public String getgpu() { return gpu; }    
 
    // 5.
    public void changegpu(String newgpu)
    {  gpu = newgpu; }

    // 6.
    public void upgrade()
    { RAM = RAM * 2;
      drivespace = drivespace * 2;
    }

    // 7. 
    public boolean betterthan(PC other)
    {
	double speed2;  // speed of other pc
	int ram2;       // ram of other pc
	speed2 = other.getspeed();
	ram2 = other.getram();
        if ((ghz > speed2) && (RAM > ram2))
	    return true;
	else 
	    return false;
    }
} // class PC


public class revsol
{
    public static void main(String[] args)
    {
	PC mypc;
        PC yourpc;
	mypc = new PC("pentium 4", 2.4, "Matrox");
        yourpc = new PC("athlon", 2.0, "Radeon 8500");
        mypc.upgrade();
	yourpc.changegpu("Radeon 9500");
        System.out.println("my pc has "+mypc.getram()+"megs of memory");
        System.out.println("your pc has a "+yourpc.getdisk()+"gig drive");
        if (mypc.betterthan(yourpc))
	    System.out.println("my pc is better than your pc");
        else
	    System.out.println("my pc is not better than your pc");
    }
}