Array Overflow Check

I'm trying to check whether or not an array is overflowing.
This is the logic that I'm using:

/*
store the length of the stackArray[] into a temp. int.
compare the size of the temp int to the stackArray[] via 3 tests.
If the stackArray[]'s size is greater than the int's size,
then say that the array is overflowing, and that it doesn't have any more space to enter elements into.
If the stackArray[]'s size is less than the int's size,
then say that the stackArray[] is underflowing and that it still has space to enter some elements into it.
If the stackArray[]'s size is equal to the int's size,
then say that the array is full.
*/

To implement this logic, here's the method I'm using:

public void overflowCheck(int temp)
{
if(stackArraySize/stackArray.length > 100)
{
System.out.println("stack is overflowing");
}
else if(stackArraySize/stackArray.length < 100)
{
System.out.println("stack is not full");
}
else
{
System.out.println("stack is full");
}
}

But when I run this on my array, I keep getting "stack is not full. Here's my array:

Data stackTest = new Data(10, false); //create a new stack & confirm it's not a queue
int stackSize = stackTest.size;
stackTest.push(10); //push 10 into the stack
stackTest.push(20); //push 20 into the stack
stackTest.push(30); //push 30 into the stack
stackTest.push(40); //push 40 into the stack
stackTest.push(50); //push 50 into the stack
stackTest.push(60); //push 60 into the stack
stackTest.push(70); //push 70 into the stack
stackTest.push(80); //push 80 into the stack
stackTest.push(90); //push 90 into the stack
stackTest.push(100); //push 100 into the stack
stackTest.push(110); //push 110 into the stack
stackTest.push(120); //push 120 into the stack
stackTest.overflowCheck(stackSize);

I should be getting an output of "stack is overflowing", but I keep getting "stack is not full".

Is this because my logic is flawed or my execution is flawed?
How do I fix this?

full class

    int size; //initialize size
int stackArray[]; //initialize array
int top; //initialize top
int stackArraySize;
public Data(int size, boolean isArrayQueue) //constructor
{
if(isArrayQueue)
{
len = 0;
Queue = new int[size];
front = -1;
rear = -1;
}
else
{
this.size = size;
this.stackArray = new int[size];
this.top = -1;
}
}
public boolean isFull() //check if it's full
{
return(size-1 == top);
}
public boolean isEmpty() //check if it's empty
{
return(top == -1);
}
public void push(int pushedElement) //push an element into the stack, as long as isFull is false
{
if(!isFull()) //check if the stack is already full
{
top++; //increment top
stackArray[top] = pushedElement; //set array[top] to the pushedElement
System.out.println("The pushed element is: " + pushedElement);
}
else //if the stack is full, tell the user.
{
System.out.println("The stack is full.");
}
}
public int pop() //pop an element from the stack, as long as isEmpty is false
{
if(!isEmpty()) //check is the stack is already empty.
{
int originalTop = top; //store original top value into originalTop
top--;//decrement top
System.out.println("The popped element is: " + stackArray[originalTop]);
return stackArray[originalTop]; //return the originalTop again
}
else //if the stack is empty, tell the user.
{
System.out.println("The stack is empty.");
return -1;
}
}
public int top() //peek into the stack & return the element on the top
{
if(!this.isEmpty()) //if the stack has values, return the top element.
{
return stackArray[top];
}
else //if the stack is empty, tell the user.
{
System.out.println("The stack is empty");
return -1;
}
}

you have to modified your logic and update the value of stackArraySize in push and pop method you are not updating this value anywhere

public class Data {
int size; // initialize size
int stackArray[]; // initialize array
int top; // initialize top
int stackArraySize;
int len;
int[] Queue;
int front;
int rear;
public Data(int size, boolean isArrayQueue) // constructor
{
if (isArrayQueue) {
len = 0;
Queue = new int[size];
front = -1;
rear = -1;
} else {
this.size = size;
this.stackArray = new int[size];
this.top = -1;
}
}
public boolean isFull() // check if it's full
{
return (size - 1 == top);
}
public boolean isEmpty() // check if it's empty
{
return (top == -1);
}
public void push(int pushedElement) // push an element into the stack, as
// long as isFull is false
{
if (!isFull()) // check if the stack is already full
{
top++; // increment top
stackArray[top] = pushedElement; // set array[top] to the
stackArraySize=top;					// pushedElement
System.out.println("The pushed element is: " + pushedElement);
} else // if the stack is full, tell the user.
{
stackArraySize++;
System.out.println("The stack is full.");
}
}
public int pop() // pop an element from the stack, as long as isEmpty is
// false
{
if (!isEmpty()) // check is the stack is already empty.
{
int originalTop = top; // store original top value into originalTop
top--;// decrement top
System.out.println("The popped element is: " + stackArray[originalTop]);
stackArraySize=top;	
return stackArray[originalTop]; // return the originalTop again
} else // if the stack is empty, tell the user.
{
System.out.println("The stack is empty.");
return -1;
}
}
public int top() // peek into the stack & return the element on the top
{
if (!this.isEmpty()) // if the stack has values, return the top element.
{
return stackArray[top];
} else // if the stack is empty, tell the user.
{
System.out.println("The stack is empty");
return -1;
}
}
public void overflowCheck(int temp) {
if (stackArraySize>= temp) {
System.out.println("stack is overflowing");
} else if (stackArraySize<temp) {
System.out.println("stack is not full");
} else {
System.out.println("stack is full");
}
}
public static void main(String args[]) {
Data stackTest = new Data(10, false); // create a new stack & confirm
// it's not a queue
int stackSize = stackTest.size;
stackTest.push(10); // push 10 into the stack
stackTest.push(20); // push 20 into the stack
stackTest.push(30); // push 30 into the stack
stackTest.push(40); // push 40 into the stack
stackTest.push(50); // push 50 into the stack
stackTest.push(60); // push 60 into the stack
stackTest.push(70); // push 70 into the stack
stackTest.push(80); // push 80 into the stack
stackTest.push(90); // push 90 into the stack
stackTest.push(100); // push 100 into the stack
stackTest.push(110); // push 110 into the stack
stackTest.push(120); // push 120 into the stack
stackTest.overflowCheck(stackSize);
stackTest.pop(); 
stackTest.pop(); 
stackTest.pop(); 
stackTest.pop(); 
stackTest.pop(); 
stackTest.pop(); 
stackTest.pop(); 
stackTest.pop(); 
stackTest.pop();
stackTest.pop(); 
stackTest.pop(); 
stackTest.overflowCheck(stackSize);
}
}

Using a ratio to check needs it to be a double, otherwise typecast would keep it as default integer.

Having said that, your push method does not currently allow for elements to be pushed after length defined, which you would need for the below overflowCheck to work.

class StackCheck {
Data stackTest = new Data(10, false); //create a new stack & confirm it's not a queue
public static void main() {
stackTest.push(10); //push 10 into the stack
stackTest.push(20); //push 20 into the stack
stackTest.push(30); //push 30 into the stack
stackTest.push(40); //push 40 into the stack
stackTest.push(50); //push 50 into the stack
stackTest.push(60); //push 60 into the stack
stackTest.push(70); //push 70 into the stack
stackTest.push(80); //push 80 into the stack
stackTest.push(90); //push 90 into the stack
stackTest.push(100); //push 100 into the stack
stackTest.push(110); //push 110 into the stack
stackTest.push(120); //push 120 into the stack
stackTest.overflowCheck();
}
public void overflowCheck() {   
double ratio = stackArray.length/stackTest.size;
if(ratio > 1){
System.out.println("stack is overflowing");
}
else if(ratio == 1){
System.out.println("stack is full");
}
else{
System.out.println("stack is not full");
}
}
}