How to implement a PriorityQueue without using the Java class?

Your PriorityQueue constructor has to initialize the array and set the current number of items. That is:

public PriorityQueue() {
    data = /* initialize array */
    len = 0;
}

You really don't need to keep the elements in the queue in order. Just make your put method add the item as the next element in the array:

public put(Element e) {
    if (len == SIZE) {
        return false;
    }
    data[len++] = e;
    return true;
}

And then your get method searches the array for the highest-priority item, saves it, replaces that with the item at the end of the array, and returns:

Element get() {
    if (len == 0) {
        return null;
    }
    int p = 0;
    for (int i = 1; i < len; ++i) {
        if (data[i].getPriority() < data[p].getPriority()]) {
            p = i;
        }
    }
    Element e = data[p];
    // replace with the last item
    data[p] = data[len-1];
    --len;
    return e;
}

So put is an O(1) operation and get is O(n). In your code, both are O(n).

The constructor just needs to initialise the Element[]:

public PriorityQueue() {
    data = new Element[SIZE];
}

Now to put(). This method will throw an ArrayOutOfBoundsException in the while loop since you start with i = len - 1 which is the last field of data. Then you access data[i+1] which does not exist, and the exception will be thrown (unless, of course, you initialise it with data = new Element[SIZE + 1]).

Solution: just use i and i-1 instead:

boolean put(Element element) {
    if (len == SIZE) {
        return false;
    } else {
        // EDIT: I changed i = len - 1 to i = len since, otherwise,
        // the last element would always be overwritten. Now, the
        // last element gets copied to the first "free" element and
        // so on.
        i = len;
        while (i > 0 && element.getPriority() > data[i-1].getPriority()) {
            data[i] = data[i - 1];
            i--;
        }
        data[i] = element;
        len++;
        return true;
    }
}

EDIT: I said before that the element with the smallest priority would be returned. Actually, it is the greatest.

The get() method behaves as expected (except it should say Element x = data[0] instead of q[0] at the beginning). It returns the first element of the array (the one with the greatest getPriority() value) and moves the rest one index down. If, however, you want the element with the smallest value to be returned, just switch the > to < in the while loop of the put() method:

while (i > 0 && element.getPriority() < data[i-1].getPriority()) {
    ...
}

Last but not least, the toString() method. It looks mostly right, except for the for-each loop. This one always iterates over the whole array where it should only iterate up to data[len - 1]. So, just use an index instead and you should be fine:

public String toString() {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < len; i++) {
        sb.append(data[i]).append(",");
    }
    if (sb.length() > 0) {
        sb.deleteCharAt(sb.length() - 1);
    }

    return sb.toString();
}

Alternatively, if you have at least Java 8 installed, you can use streams for this method:

public String toString() {
    return Arrays.asList(data).stream()
        .limit(len)
        .map(Element::toString)
        .collect(Collectors.joining(","));
}