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)$.