I need help with this java problem$($TODO parts$)$:

package ps$1$;

$/**$ Cons is a simple cons cell record type. $*/$

class Cons $\{$

RatPoly head;

Cons tail;

Cons$($RatPoly h$,$ Cons t$)\{$ head $=$ h; tail $=$ t; $\}$

$\}$

$/**$ RatPolyStack is a mutable finite sequence of RatPoly objects.

Each RatPolyStack can be described by $[$p$1,$ p$2,...],$ where $[]$ is

an empty stack, $[$p$1]$ is a one element stack containing the Poly

$\text{'}$p$1\text{'},$ and so on$.$ RatPolyStacks can also be described

constructively, with the append operation, $\text{'}$:$\text{'}.$ such that $[$p$1]$:S

is the result of putting p$1$ at the front of the RatPolyStack S$.$

A finite sequence has an associated size, corresponding to the

number of elements in the sequence. Thus the size of $[]$ is $0,$ the

size of $[$p$1]$ is $1,$ the size of $[$p$1,$ p$1]$ is $2,$ and so on$.$

Note that RatPolyStack is similar to lists like $\{$@link

java.util.ArrayList$\}$ with respect to its abstract state $($a finite

sequence$),$ but is quite different in terms of intended usage. A

stack typically only needs to support operations around its top

efficiently, while a vector is expected to be able to retrieve

objects at any index in amortized constant time. Thus it is

acceptable for a stack to require O$($n$)$ time to retrieve an element

at some arbitrary depth, but pushing and popping elements should

be O$(1)$ time.

$*/$

public class RatPolyStack $\{$

private Cons polys; $//$ head of list

private int size; $//$ redundantly$-$stored list length

public void div$()\{$

$//$TODO: Fill in this method, then remove the RuntimeException

throw new RuntimeException$("$RatPolyStack$->$div$()$ unimplemented!

$")$;

$\}$

$/**$ Integrates the top element of this, placing the result on top

of the stack.

@requires this.size$()>=1$

@modifies this

@effects If this $=[$p$1]$:S

then this$\_$post $=[$p$2]$:S

where p$2=$ indefinite integral of p$1$ with integration constant $0$

$*/$

public void integrate$()\{$

$//$TODO: Fill in this method, then remove the RuntimeException

throw new RuntimeException$("$RatPolyStack$->$integrate$()$ unimplemented!

$")$;

$\}$

$/**$ Differentiates the top element of this, placing the result on top

of the stack.

@requires this.size$()>=1$

@modifies this

@effects If this $=[$p$1]$:S

then this$\_$post $=[$p$2]$:S

where p$2=$ derivative of p$1$

$*/$

public void differentiate$()\{$

$//$TODO: Fill in this method, then remove the RuntimeException

throw new RuntimeException$("$RatPolyStack$->$differentiate$()$ unimplemented!

$")$;

$\}$

$/**$ Returns the number of RayPolys in this RatPolyStack.

@return the size of this sequence.

$*/$

public int size$()\{$

$//$TODO: Fill in this method, then remove the RuntimeException

throw new RuntimeException$("$RatPolyStack$->$size$()$ unimplemented!

$")$;

$\}$

$/**$ Checks to see if the representation invariant is being violated and if so$,$ throws RuntimeException

@throws RuntimeException if representation invariant is violated

$*/$

private void checkRep$()$ throws RuntimeException $\{$

if$($polys $==$ null$)\{$

if$($size $!=0)$

throw new RuntimeException$("$size field should be equal to zero when polys is null sine stack is empty"$)$;

$\}$ else $\{$

int countResult $=0$;

RatPoly headPoly $=$ polys.head;

Cons nextCons $=$ polys;

if$($headPoly $!=$ null$)\{$

for $($int i $=1$;; i$++)\{$

if$($nextCons $!=$ null$)\{$

countResult $=$ i;

nextCons $=$ nextCons.tail;

$\}$ else

break;

$\}$

$\}$

if$($countResult $!=$ size$)$

throw new RuntimeException$("$size field is not equal to Count$($s$.$polys$).$ Size constant is $"+$size$+"$ Cons cells have length $"+$countResult$)$;

$\}$

$\}$

$\}$