I realized there could be a lot of bad code in a system while writing Java.
I wonder why schools don't teach what programming practices are bad. For example, in Java, using a big try/catch block that catches Exception is bad, but no one told me. And we see the typical "String + String" concatenation appear in every corner of a program.
Isn't it the job of schools, assuming most programmers are taught at a school and not self-taught, to warn students away from the pitfalls in a programming?
If you are talking about CS degree at a university the answer is simple: programming is just a means to an end. The degree is more about the science of computing and not programming. Now, it may be a valid question for a community college/technical college program whose sole purpose is to create programmers.
To build on what S.Lott said in the comments, that there are an infinite amount of bad things but only a small amount of good, so why focus on the infinite bad. That is just for one language. So the university would spend all this time teaching the students how not to do something (and if they had time they may teach them how to do it right) for language X. So lets say that is 2 classes (the intro and then the "how to do it right class"). That is a full year of studies learning that one language, language X. The next year you want to take an embedded systems class which uses Y. So now you have to burn another year block of classes to learn Y and learn it properly. It just isn't realistic nor is it desirable because often what is good or bad can change. It is just something that can easily be learned once in the real world.
Two fundamental reasons:
First, I think it is a mistake to assume that there aren't a lot of self-taught programmers.
Second, there is a lot of room for debate about what is good code and what isn't. Some people are focused on readability, some on maintainability, some on efficiency, some on testability - and so forth.
Third, there is a big problem with how programming is taught - in the secondary and post secondary schools I've attended, at least. There isn't a good, cohesive, multi-year curriculum that can build year over year. Just about every course has to assume that there may be novices and veterans in the same class, so the course content ends up dumbed down so as not to leave too many people behind.
I'm sure that there are many university CS programmes that do have cohesive mulit-year curriculums, but there are many, many professional programmers with science, math, business and even arts degrees, not CS degrees.
There is a massive general perception that school knowledge (specifically about programming) is useless or weak. This is actually not true.
In fact, ask an average fresher from school to write about code -she/he will right a bad code. But it will at least compile and run. Ask an average fresh electronics engineer (i was one of them!) to build an FM radio - he won't even be halfway through the job.
The problem is the classic difference between - knowing and realizing. Usually, there is enough of theory of you know from the college but you don't quite develop a judgment of where and how to use that knowledge.
For example Schools do teach you that violating encapsulation is bad. But many people don't quite realize that their code had done it - till long things become a problem.
The reason why development of judgment doesn't come by the time you leave school because you have only spent few months on real problems to solve. When you spent another 10 years in industry you repeat the same thing you learn't in your first year.
If a school puts too much emphasis on avoiding bad code they could be guilty of "premature optimization". For many projects in school only a portion of the code is used to demonstrate the understanding of the new material. Because there is a need to cover a lot of material in a semester, asking the students to go back and improve the code to save a few seconds of run time, will mean that less material can be covered.
At work you can say take a couple of hours to find the parts of the code that are a bottleneck and fix them. In school asking them to do that extends the due date for the project by a few days or a week.
There is no need to focus on what is strictly bad style, because every company does it differently.
I agree with the comment about the mixture of students in a class, especially in high school. Some members of the class have never seen an If statement, others are on their third language.
Exceptionis usually not the best solution, but I wouldn't call it categorically bad. And the typical "String + String" concatenation makes the code easy to read, so most of the time it is best practice. Except when called many many times in a tight loop, where it may indeed degrade performance. Similarly, all idioms / techniques have their benefits and drawbacks, and they are applicable for some problems but bad for others. These details can only reliably be learnt during practice, as and when you actually need them.