Uber JAR, in short, is a JAR containing everything.
Normally in Maven, we rely on dependency management. An artifact contains only the classes/resources of itself. Maven will be responsible to find out all artifacts (JARs etc) that the project depending on when the project is built.
An uber-jar is something that take all dependencies, and extract the content of the dependencies and put them with the classes/resources of the project itself, in one big JAR. By having such uber-jar, it is easy for execution, because you will need only one big JAR instead of tons of small JARs to run your app. It also ease distribution in some case.
Just a side-note. Avoid using uber-jar as Maven dependency, as it is ruining the dependency resolution feature of Maven. Normally we create uber-jar only for the final artifact for actual deployment or for manual distribution, but not for putting to Maven repository.
Update: I have just discovered I haven't answered one part of the question : "What's the point of renaming the packages of the dependencies?". Here is some brief updates and hopefully will help people having similar question.
Creating uber-jar for ease of deployment is one use case of shade plugin. There are also other common use cases which involve package renaming.
For example, I am developing
Foo library, which depends on a specific version (e.g. 1.0) of
Bar library. Assuming I cannot make use of other version of
Bar lib (because API change, or other technical issues, etc). If I simply declare
Foo's dependency in Maven, it is possible to fall into a problem: A
Qux project is depending on
Foo, and also
Bar:2.0 (and it cannot use
Qux needs to use new feature in
Bar:2.0). Here is the dilemma: should
Qux's code will not work) or
Foo's code will not work)?
In order to solve this problem, developer of
Foo can choose to use shade plugin to rename its usage of
Bar, so that all classes in
Bar:1.0 jar are embedded in
Foo jar, and the package of the embedded
Bar classes is changed from
com.foo.bar. By doing so,
Qux can safely depends on
Bar:2.0 because now
Foo is no longer depending on
Bar, and it is using is own copy of "altered"
Bar located in another package.