Stack with "getMiddle" and "deleteMiddle" operation
Implementing "correctly":

Your Classname says, you have implemented a Stack with additional operations. Why do I not see implements or extends in your code then?


public class FindMiddleStack&lt;T&gt; {



should have been:

public class FindMiddleStack&lt;T&gt; extends Stack&lt;T&gt; {


scratch that, Stack&lt;T&gt; has been deprecated for so long, that there should be some annotation @Antique. Even the official oracle documentation recommends the use of Deque&lt;T&gt;!
Mind that Deque can also be used as a FIFO Queue

That said, your class could start with the following:

public class FindMiddleDeque&lt;T&gt; implements Deque&lt;T&gt; {


Design:

Your node class design is "flawed". You make it way to complicated, if you only want a LIFO (last in first out) behavior. Usually a Node in a stack knows about it's value and has a reference to the next Node.

private static class Node&lt;T&gt; {
    Node&lt;T&gt; next;
    T value;

    Node(T value, Node&lt;T&gt; next) {
        this.value = value;
        this.next = next;
    }
}


This also simplifies your pop and push methods:

@Override
public T pop() {
    if(size == 0 || top == null){
       throw new EmptyStackException();
    }

    size--;
    Node&lt;T&gt; destroy = top;
    top = destroy.next;

    return destroy.value;
    //destroy should be destroyed by falling out of scope
}

@Override
public void push(T value) {
    top = new Node(value, top);
    size++;
}

@Override
public T peek() {
    if(size == 0 || top == null){
       throw new EmptyStackException();
    }

    return top.value;
}


Finding the middle.

Your code is a little complicated concerning finding the middle of the stack. In fact we can assume, that the middle element is that at "index" size / 2. 

How can we use that to our advantage?

public void deleteMiddle() {
    if(size == 0 || top == null){
        throw new EmptyStackException();
    }
    int middleIndex = size / 2;

    Node&lt;T&gt; current = top;
    Node&lt;T&gt; previous = null;
    for (int i = 0; i &lt; middleIndex; i++){
        previous = current;
        current = current.next;
    }
    // we can assume we are in the middle now.
    previous.next = current.next; //current is lost
    size--;
}


We can also get the middle element in a similar fashion:

public T getMiddle() {
    if(size == 0 || top == null){
        throw new EmptyStackException();
    }

    int middleIndex = size / 2;

    Node&lt;T&gt; current = top;
    for (int i = 0; i &lt; middleIndex; i++){
        current = current.next;
    }
    return current.value;
}