/*                  CSC 17 "Class" Exercise

         https://cs.hofstra.edu/~cscccl/csc17/stu1.java

Advanced object oriented programming requires three key components:

  1. Dynamic type information
  2. Dynamic memory allocation
  3. Dynamic dispatch

Advanced OOP requires a separation between the "abstract" view of
objects from their "concrete" view.  The abstract view is usually a
general superclass, an abstract superclass, or an interface.
Referring to the classic "shapes" example, the abstract view of
objects is that they're "shapes" and the concrete view is that they're
circles, rectangles, squares, etc.  For example, we may wish to place
different shapes into a data structure:

   shape[] S = new shape[3];  // array of abstract shapes
   S[0] = new circle(radius);
   S[1] = new rectangle(width,height);
   if (..) S[2] = new circle(..) else S[2] = new rectangle(..,..);
   double totalarea = 0;
   for(int i=0;i<S.length;i++) totalarea += S[i].area();
   
What is the type of S[i]?  Statically, as seen by the compiler, it has
type shape.  But at runtime (dynamically) the object created will be a
circle or rectangle or some other concrete shape.  The exact type 
is not determined until runtime. This is called *dynamic type information*. 

Because the compiler doesn't have exact type information, it cannot
calculate the exact amount of memory needed by a "shape": a rectangle
requires more memory than a circle.  Therefore, a "shape" cannot be
allocated on the stack.  In order for data to be allocated on the
stack the compiler has to be able to calculate the size of the data
(so it can generate code to add or subtract a constant from the stack
pointer register).  All we can allocate on the stack is a pointer
because we know how large a pointer is.  The actual object must be
allocated on the heap at runtime.  This is why Java allocates all
objects on the heap: OOP requires *dynamic memory allocation*.

Finally, circles and rectangles implement their own versions of the
area() function.  Which one is being called by S[i].area()?  The
compiler doesn't have enough information to determine which area()
should be called.  That is also determined at runtime.  At runtime,
the dynamic type information attached to each object is used to
determine which version of area() to call.  This is *dynamic dispatch*.

Dynamic dispatch allows an object to be *autonomous*. That is, when we call
S[i].area(), the object S[i] decides for itself what needs to happen.  We
do not need to write a bunch of if-else type of statements to define the
behavior of the objects.  This is a hallmark of object oriented abstraction.


         ==================== Your Assignment ====================

  Some programmers who thought they knew Java and object oriented programming
was asked to write a program to keep track of students at a university.
There are two kinds of students: grads and undergrads.  All students have a
name and a gpa and take a certain number of credit hours.  Graduate students
have a thesis topic while undergraduates have a major.  The algorithm
to compute the tuition for grads is also different from that for undergrads.
Our programmers created the following program.  Not only is it not really
object oriented (no meaningful use of dynamic dispatch), but because they 
relied on too many if and if-else statements, there is a mistake in the 
program (can you figure out where?)

Your task is to rewrite the program using an abstract class and inheritance
and take advantage of dynamic dispatch.

First, study the program to understand how it works and what it's supposed
to do.  Be sure to run it to see what happens.  Then follow the instructions 
in comments at the end.
*/

class student  {
    public final String name;
    protected boolean isgraduate = false; // is this student a grad student?
    protected double gpa;
    protected int credits; // number of credit hours taken
    protected String major; // used only for undergraduates
    protected String thesistopic; // used only for graduates
    public boolean isgraduate() { return isgraduate;}

    static String[] mjs= {"comp sci", "poly sci", "engineering", "math", "physics","biology","psychology", "history", "leisure studies"};
    static String[] topics = {"p equals np", "halting problem", "distributed os", "real time fault tolerance", "compiler design", "cryptography", "machine learning"};
    
    // constructor takes name and graduate/undergrad flag, randomizes rest
    public student(String n, boolean g) {
	name = n;
	isgraduate = g;
	gpa = ((int)(Math.random()*401))/100.0; // set random gpa
	credits = 3 + (int)(Math.random()*15); //number of credits being taken
	if (isgraduate) 
	    thesistopic = topics[(int)(Math.random()*topics.length)];
	else
	    major = mjs[(int)(Math.random()*mjs.length)];
    }//student constructor

    // compute tuition: undergrads pay $1500 per credit, grads pay $1800
    public double tuition() {
	if (isgraduate) return 1800*credits;  // these numbers are made up ...
	else return 1500*credits;
    }
}// student class

public class stu1 {
    public static void main(String[] argv) {
	String[] names = {"Kevin","Emilia","Artem","Brandon","Vivian","Manuel","Nicko","Christopher","Dale","Ryan","Joseph","Danny","Irene","Darren","William","Mary","Larz","Narx"};
	student[] roster = new student[names.length];
	// create random roster of students, alternating between grads and
	// undergrads
	for(int i=0;i<roster.length-1;i+=2)
	    {
		roster[i] = new student(names[i],true);  // grad
		roster[i+1] = new student(names[i+1],false); //undergrad
	    }
	//compute total tuition of all students
	double total = 0;
	for(student s:roster) total += s.tuition();
	System.out.println("total tution is "+total);

    // undergrad students with gpa < 2.0 are on academic probation,
    // while grad students with gpa < 3.0 are also on academic probation.
    // the following loop prints names of all students on probation, plus
    // some additional information about each student:
	for(student s:roster) {
		if (!s.isgraduate() && s.gpa<2.0)
		    System.out.println("Undergraduate student "+s.name+", majoring in "+s.major+", has an amazingly low gpa of "+s.gpa);
		else if (s.gpa < 3.0)
		    System.out.println("Graduate student "+s.name+", who is writing a thesis on "+s.thesistopic+", has a gpa of only " + s.gpa);
	    }
    }//main
}

/*
   There are many ways in which this program can be improved.  For example,
every student object contains both a major and a thesis topic.  Not only
does this waste memory but it would be possible for a programmer to 
accidentally refer to the thesis topic of an undergraduate, or the
major of a graduate student, which would be a *type error* that the 
compiler will not be able to catch.

The code to find students on academic probation in main should also
be *encapsulated* within the objects (objects should be autonomous).

======= ASSIGNMENT: =======

You need to restructure the program using a more advanced "object
oriented design."  You must use an abstract class in your design.  One
of the goals you should have in your new program is to **minimize**
the use of if and if-else statements (no more than a couple). You will
have to come up with your own object oriented design (i.e. what
methods to declare as abstract in the abstract class).

1. Rewrite the main from the sample program using your new oop design.

***YOU MAY USE AT MOST 2 IF STATEMENTS IN THE PROGRAM (only when you're 
testing if a numerical value is less than 2.0 or 3.0).

2. Add a new type of student to your design, without changing the design (i.e.
add only a subclass). Think of something like "nonmatriculated student"
or "student athlete" with unique attributes that distinguish them
from grads and undergrads.
*/