$O(n^2)$ running time vs $O(n^2)$ worst case
Suppose that you have an arbitrary array of $n$ numbers, and you give it to  Quicksort to sort.
The expected running time of the algorithm is $O(n \log n)$.  However, if the array is sorted, but in the wrong direction, and you pick the first element as pivot, then the algorithm might actually run in time $O(n^2)$.
That means that if you look at how Quicksort behaves with increasingly larger arrays of reversely sorted data, the time it uses grows as $n^2$.
However, if you spend $O(n)$ time to shuffle the array before sorting it, the expected running time is $O(n \log n)$; i.e. very few time will the algorithm spend close to $O(n^2)$ many operations.

A different example is with respect to amortized complexity.  For example, adding a single element to an ArrayList in Java takes $O(1)$ time, most of the time.  However, on a rare occasion, Java needs to create a new array and copy all the elements over to this new one.  That takes $O(n)$ time.
This means that the worst case complexity for ArrayList.add is $O(n)$, but if you do this operation $n$ times, the total complexity is also $O(n)$, so we say that the amortized complexity is $O(1)$.