A good University will teach you things you would almost never come into contact with on your own.
I will give you some random examples from my own degree. Some concepts are quite practical and others are theoretical, but all of the examples below taught me -- as someone who had started programming when he was 12, back in the DOS era -- something new.
- Data structures. I had played around with them myself before I went to university, but being formally introduced to the concept of data structures: lists (Queues, Linked Lists, Stacks); trees (Binary, B-Trees, Heaps, etc.) and the performance characteristics of each and how you would apply them. In my university it was first taught with mathematical notation followed by practical implementations in Pascal.
- Learning Prolog in my first year. An entirely procedural language that uses back tracking to 'solve' relations based on rules and facts. I loved this class. Prolog's not terribly practical but it taught me a lot about abstract data types and 'recursion'. The idea that a list is defined as a head (the item in a list) and the tail (the rest of the list) which can be iterated over recursively was a major eye-opener to me, an until then hobbyist coder.
- Haskell. A stark contrast to Prolog and Pascal, I learnt the power of composability and the ability to capture complex ideas with very powerful constructs and a very strong type system. The language is lazy so you can operate on infinite 'streams' of items which is another interesting way of thinking about the theory of computation.
- We were taught how to specify a PDP-11 (RAM banks, CPU, I/O) using an academic language that uses "rewriting logic". It was a very theoretical yet practical way of specifying a computer using only mathematical principles. The idea that the number 0 and the successor function is all you need to define the natural numbers and, combined with recursion, basic arithmetic was again the sort of thing you never ever do outside University.
- Compilers. I wrote compilers using lex and yacc. I have used that theory -- and the theory of regular languages -- to great effect since then to formally construct grammars and parsers for tasks I needed later on in life. And I could do it effectively and efficiently without reinventing the wheel or coding myself into a corner -- which is easy to do with compilers.
- Computer graphics. Basic convolution filters; image processing and the general theory of 3d graphics.
- Graph theory. When I first took it it seemed utterly "useless" but it has since then been one of the most useful things I know. I grasped the concept of Git right away thanks to that knowledge.
- Operating systems. Networking. Basic security. Complexity theory (the study of algorithm complexity) -- and the list goes on.
I remember maybe 30% of what I learnt but I can quickly jog my memory or pick up where I left off. I consider my degree invaluable from an academic sense...
... but it did nothing to make me a better developer. That, unfortunately, is something you have to work hard at. I got lucky: I had already been programming for 10 years by the time I graduated.