//********************************************************************
//  ParamPassTest.java
//  To test passing primitive data as parameters
//********************************************************************
public class ParamPassTest {
	public static void main (String args[])	{
		int param = 3;
		addOne(param);
		System.out.println("main param is " + param);
	}
	public static void addOne(int p) {
		p = p + 1;
		System.out.println("addOne param is " + p);
	}
}

//********************************************************************
//  Cat.java
//  Used in PassByValue.java
//********************************************************************

public class Cat
{
   private float weight;
   private int age;
   private boolean isFriendly;

   public Cat()
   {
   	  weight = 3.8f;
   	  age = 2;
   	  moodSwing();
   }
   
   public void moodSwing()
   {
      isFriendly = ((int)(Math.random()*2) == 0);
   }
   
   public String toString()
   {	
   	  String sWeight = "I weight " + weight + " kg.\n";
   	  String sAge = "I'm " + age + " years old.\n";
   	  String sFriendly = (isFriendly)? "I'm the nicest cat in the world." 
   	  				: "One more step and I'll attack.";
   	  return (sWeight+sAge+sFriendly);
   }

   public float eat(float food)
   {
   	  weight += food;
   	  System.out.println("it wasn't Fancy Feast's seafood fillet...");
   	  wail();
   	  return weight;
   }
   
   public void wail()
   {
      System.out.println("Miiiiaaawwwwwww!");
      moodSwing();
   }
   
   public int getAge()
   {
   	return age;
   }

   public void birthday()
   {
	age++;
	for (int i=0; i<age; i++)
		wail();
   }
}


//********************************************************************
//  PassByValue.java
//  Demonstrates that Java parameters are always passed by value
//********************************************************************

public class PassByValue
{
  public static void main(String[] args)
  {
    System.out.println("--In main--");

    //the reference to an object is passed by value 
    Cat curly = new Cat();
    System.out.println("The value of curly's age is " + curly.getAge());

    goCelebrateBirthdayAtFriskys(curly);

    System.out.println("\n--Back in main--");
    System.out.println("The value of curly's age is " + curly.getAge());
    System.out.println();

    //primitives are passed by value as well
    int age = 5;
    System.out.println("The value of age is " + age);

    goAddOneToThisVariableAtJavas(age);

    System.out.println("\n--Back in main--");
    System.out.println("The value of age is " + age);
  }

  //the reference to an object is passed by value
  public static void goCelebrateBirthdayAtFriskys(Cat theCat)
  {
    System.out.println("\n--In GoCelebrateBirthdayAtFriskys--");
    System.out.println("The value of theCat's age is " + theCat.getAge());

    //update the cat object that both theCat and curly refer to
    theCat.birthday();
    System.out.println("The value of theCat's age is " + theCat.getAge());

    //make theCat reference a different object - doesn't affect variable curly
    theCat = new Cat();
    System.out.println("The value of theCat's age is " + theCat.getAge());

    //updating theCat now, has no effect on the Cat referenced by curly
    theCat.birthday();
    theCat.birthday();

    System.out.println("The value of theCat's age is " + theCat.getAge());
  }

  //primitives are passed by value as well
  public static void goAddOneToThisVariableAtJavas(int anAge)
  {
    System.out.println("\n--In goAddOneToThisVariableAtJavas--");
    System.out.println("The value of anAge is " + anAge);

    //change value of anAge - doesn't affect variable age within main
    anAge = anAge+1;

    System.out.println("The value of anAge is " + anAge);
  }

}

//********************************************************************
//  ParameterPassing.java       Author: Lewis and Loftus
//
//  Demonstrates the effects of passing various types of parameters.
//********************************************************************

class ParameterPassing
{
   //-----------------------------------------------------------------
   //  Sets up three variables (one primitive and two objects) to
   //  serve as actual parameters to the changeValues method. Prints
   //  their values before and after calling the method.
   //-----------------------------------------------------------------
   public static void main (String[] args)
   {
      ParameterTester tester = new ParameterTester();

      int a1 = 111;
      Num a2 = new Num (222);
      Num a3 = new Num (333);

      System.out.println ("Before calling changeValues:");
      System.out.println ("a1\ta2\ta3");
      System.out.println (a1 + "\t" + a2 + "\t" + a3 + "\n");

      tester.changeValues (a1, a2, a3);

      System.out.println ("After calling changeValues:");
      System.out.println ("a1\ta2\ta3");
      System.out.println (a1 + "\t" + a2 + "\t" + a3 + "\n");
   }
}


//********************************************************************
//  ParameterTester.java       Author: Lewis and Loftus
//
//  Demonstrates the effects of passing various types of parameters.
//********************************************************************

class ParameterTester
{
   //-----------------------------------------------------------------
   //  Modifies the parameters, printing their values before and
   //  after making the changes.
   //-----------------------------------------------------------------
   public void changeValues (int f1, Num f2, Num f3)
   {
      System.out.println ("Before changing the values:");
      System.out.println ("f1\tf2\tf3");
      System.out.println (f1 + "\t" + f2 + "\t" + f3 + "\n");

      f1 = 999;
      f2.setValue(888);
      f3 = new Num (777);

      System.out.println ("After changing the values:");
      System.out.println ("f1\tf2\tf3");
      System.out.println (f1 + "\t" + f2 + "\t" + f3 + "\n");
   }
}


//********************************************************************
//  Num.java       Author: Lewis and Loftus
//
//  Represents a single integer as an object.
//********************************************************************

class Num
{
   private int value;

   //-----------------------------------------------------------------
   //  Sets up the new Num object, storing an initial value.
   //-----------------------------------------------------------------
   public Num (int update)
   {
      value = update;
   }

   //-----------------------------------------------------------------
   //  Sets the stored value to the newly specified value.
   //-----------------------------------------------------------------
   public void setValue (int update)
   {
      value = update;
   }

   //-----------------------------------------------------------------
   //  Returns the stored integer value as a string.
   //-----------------------------------------------------------------
   public String toString ()
   {
      return value + "";
   }
}

//********************************************************************
//  Predator.java
//
//  Demonstrates the declaration of an interface.
//********************************************************************

interface Predator
{
   public void preys ();
   public boolean groupHunt ();
   public void validateWeight (int kilos);
}


//********************************************************************
//  Lion.java
//
//  Demonstrates the implementation of an interface.
//********************************************************************
class Lion implements Predator
{
	public void preys ()
	{
		System.out.println("Wildebeests, zebras, buffaloes, young elephants, rhinos, hippos,");
		System.out.println("giraffes, warthogs, antelopes, hyenas, humans and even crocodiles ");
	}
	
	public boolean groupHunt ()
	{
		return true;
	}
	
	public void validateWeight (int kilos)
	{
		if (kilos<220)
			System.out.println("Weight: " + kilos + " kg");
		else
			System.out.println("Max weight: 220 kg");
	}

	public void roar()
	{
		System.out.println("\nRRRRRAAAAAAWWWWWWWWWRRRRRRRR...");
	}
}

//********************************************************************
//  Hyena.java
//
//  Demonstrates the implementation of an interface.
//********************************************************************
class Hyena implements Predator
{
	public void preys ()
	{
		System.out.println("Wildebeests, humans, zebras, buffaloes, warthogs, antelopes, cheetahs, hyenas and almost anything");
	}
	
	public boolean groupHunt ()
	{
		return true;
	}
	
	public void validateWeight (int kilos)
	{
		if (kilos<85)
			System.out.println("Weight: " + kilos + " kg");
		else
			System.out.println("Max weight: 85 kg");
	}
	
	public void foundFood()
	{
		System.out.println("\nHeeaaHeeaaHeeeHeee...");
	}
}

//********************************************************************
//  Leopard.java
//
//  Demonstrates the implementation of an interface.
//********************************************************************
class Leopard implements Predator
{
	public void preys ()
	{
		System.out.println("Baboons, zebras, hares, warthogs, antelopes and humans");
	}
	
	public boolean groupHunt ()
	{
		return false;
	}
	
	public void validateWeight (int kilos)
	{
		if (kilos<60)
			System.out.println("Weight: " + kilos+ " kg");
		else
			System.out.println("Max weight: 60 kg");
	}
	
	public void purr()
	{
		System.out.println("\nGggggggppppppprrrrrr...");
	}
}

//********************************************************************
//  Hunting.java
//
//  Demonstrates the use of an interface for polymorphic references.
//********************************************************************

public class Hunting
{
	public static void main (String[] args)
	{
		Predator hunter;
		
		hunter = new Lion();
		System.out.println("***The lion's \"a la carte\" menu***");
		hunter.preys();
		
		hunter = new Leopard();	
		System.out.println("\n***The leopard's \"a la carte\" menu***");
		hunter.preys();
		
		hunter = new Hyena();
		System.out.println("\n***The hyena's \"a la carte\" menu***");
		hunter.preys();
		
		((Hyena)hunter).foundFood();
	}
}