1.Java running (Basic requirements)
This one may seem simple, but who doesn’t run Java programs? But most of the time, we just use the IDE to execute Java programs. How does the underlying IDE execute Java programs? Many people don’t.
This is one of the most basic things Java developers need to know. The first thing you learn is how to execute Java programs on the command line, but many people forget this once they learn Java and use the IDE. Why do you want to know this? Knowing the purest way to start Java allows you to analyze how many directories you started, how the execution was named, what the parameters were, and whether there were any missing files when something went wrong. This allows you to really develop solutions to all the weird and potentially environment-related problems
The knowledge to master here includes:
Javac compiles Java files to class files.
The use of Java commands, where Java classes with package are launched on the command line;
The various paths involved in Java programs (classpath, Java, Library, Path, home directory where Java runs, etc.).
- The data type
There’s not much to say about this, but it’s all about basic types and object types in Java. Learn more about automatic conversion in the JDK, including boxing and unboxing, etc., but also pay attention to avoid boxing type equality judgment
Key points:
Basic types: int, long, float, double, Boolean;
Corresponding object types: Integer and other types of conversion to basic types, boxing and unboxing
Object: Equals, Hashcode, String.
- Access control
This is also a foundation of Java encapsulation features, to master:
Public protected default private Class, method, field.
- Process control
The basics of Java process control, although some of the syntax may not be very common, need to be understood and used where appropriate.
Need to master: if, switch, loop, for, while and other flow control syntax.
- The concept of object-oriented programming
This is a core Java concept that should be mastered by any Java developer. Many of the features or knowledge points in Java are related to Java object-oriented programming concepts. In my opinion, a good developer not only needs to understand the features themselves, but also needs to know how these objects are reflected in the concept of Java object-oriented programming, which is more conducive to the developer to master the Java development language, as well as other object-oriented programming languages.
Key knowledge points include:
Object-oriented three features: encapsulation, inheritance, polymorphism;
Definition of each concept, what features are represented, their use scenarios, static multiple dispatch, dynamic single dispatch concept, overload concept and use
Inheritance: interface multiple implementation, base class single inheritance abstraction, abstract class, interface
Polymorphism: the concept of method override and the use of interface callbacks
- Objects and instances, object creation
In this regard, developers need to understand the concepts and differences between class and Instance, which is a foundation of Java’s object-oriented nature. The main points are:
The concepts of Class and Instance;
Instance creation process:
1. No inheritance: allocate memory space, initialize variables, call constructors;
2. There is inheritance: handle static actions, allocate memory space, define variables as initializers, from base class -> subclass, handle initialization at definitions, execute constructors; Points to note: static attributes and so on are initialized from base -> subclasses; Properties associated with the default no-argument constructor. 7. Static
Static properties are also frequently used in Java daily development. You need to understand the usage of the static keyword, as well as the use of other keywords, such as whether it can be used together with the keywords such as abstract and final.
The main things to master are:
How static attributes are defined, used, and initialized during class loading
Definition and use of static methods
Definition and use of static classes
Static code block definition and initialization timing
- Basic knowledge points here mainly lists some scattered, no system classification of some Java knowledge points. It is also used in daily development.
In fact, there are a lot of this content, just temporarily summarized these several here:
These include equals, HashCode, String/StringBuffer, Final, finally, finalize
9. Collection framework this is a need to master the part, do Java development, can say that there is no collection framework, this is very important. But the knowledge is not difficult, but to set the best to understand the internal implementation approach, because it can help you in each different scenario to choose a suitable framework to solve the problem, such as the 1 w a collection of elements, often should undertake the contains operation, know the characteristics of the collection or internal implementation, it is easy to make the right choice.
This includes the following (concurrency is not included) :
Collection framework system: basic Collection, Map
The content of the concrete collection implementation, the concrete implementation of List, Set, Map, internal structure, special methods, applicable scenarios, and the usage of Collections related utility class.
10. Exception framework
Anomalies may not be as important in Java development. In general, there is no great impact on the overall operation of the program after directly throwing or catching exceptions. But in enterprise design development,
The design and handling of exceptions are often related to the robustness of the system as a whole. A good system exception handling for the developer should be uniform, avoid scattered exception handling logic; For the system, exceptions should be controllable, and is easy to operate and maintain, some exceptions appear, there should be coping methods, know how to operate and maintain processing, so although the exception framework is very simple, but for the whole enterprise application development
For example, exception handling is very important. To handle exceptions well, you need to understand the exception system in Java.
There are not many knowledge points to master in this part, mainly including:
Abnormal system:
Throwable
Exception
RuntimeException
Error
A RuntimeException is a common Exception.
11.Java IO
IO in Java is not only file read and write so simple, but also includes socket network read and write and so on all input and output operations. For instance
Reading the content of a Post in a standard HTTP request is also an output process, etc…
For IO, Java not only provides basic Input and Output related apis, but also provides some simplified operation apis such as Reader and Writer. It is also important in some development projects (involving a large number of I/O operations), and is also involved in daily development (logging, reading and writing temporary files, etc.).
The main knowledge points in this are:
Basic IO system: including InputStream, OutputStream, Reader/Writer, file reading, various streams reading NIO concepts, specific use methods and use scenarios
Multithreading concurrency Multithreading is generally considered a difficult part of Java. Multithreading can effectively improve the CPU utilization rate, improve the overall system efficiency,
Especially if there are a lot of I/O operations blocking; But it’s also a double-edged sword,
If not used well, the system will not only improve little, or no improvement, but also bring debugging problems between multiple threads.
There are a lot of content in multi-threading, just a brief description of the initial use of multi-threading in Java to master the knowledge, later have the opportunity to separate and detailed some advanced features of the use of the scenario.
Multithreading implementation and startup
Callable is different from runable
Syncrhoized and reentrantLock respectively feature and compare thread pools
Future gets the execution result asynchronously
Concurrent package
lock ..
13 network Java also provides you can directly operate THE TCP protocol, UDP protocol API. In the case that network performance needs to be emphasized, Socket can be directly used to communicate through TCP/UDP. You can see the usage of these apis in the source code of Tomcat, etc. However, TCP is seldom used directly, and frameworks such as MINA and Netty are used for processing. As there is not much development involved in this area, I will not list in detail.
14. Time and date processing
Time and date handling is also tricky for almost every application, but the time related apis prior to JDK8 were not user-friendly. In that era, time frames such as Joda were available. By the time JDK8 was released, the new time-based API basically incorporated the benefits of the other frameworks and was ready to be used directly. For Java developers, you need to be proficient in using the API to manipulate times and dates.
I will write a later article summarizing the use of the date and time API in JDK8. XML parsing/JSON parsing
In fact, these two contents are not J2SE inside the content, but in daily development, and other programs interaction, and configuration file interaction, more and more inseparable from these two formats of parsing. However, as a developer, understanding the principles and methods of XML/JSON parsing can help you choose the right way to make your application more efficient and robust in each specific scenario.
XML: You need to understand the basic principles of DOM parsing and SAX parsing and their applicable scenarios
JSON: You need to understand some common JSON frameworks such as Jackson, FastJson, Gson, etc.
16. Reflection technology
Provide dynamic creation instance, dynamic call method artifact, each big frame zhong love.
17. Using Maven or Gradle
Maven is not in Java either, but Maven is revolutionary and brings great convenience to Java development. From the introduction and management of dependencies, to the updating and release outputs of development processes, and even newer versions, using Maven can save a lot of time by simplifying the complexity of the development process. Maven has become standard for Java developers. So I use Maven as a basic knowledge base for Java developers. In the future, I will cover some of my experiences and tips on using Maven, but I won’t go into details here. Gradle is an up-and-comer.
18. Generics
This is a new concept that JDK5 is starting to introduce, and it’s actually a syntactic sugar that makes it a little easier to write Java code,
General application or business development, only simple use, do not necessarily need to define generics such operations,
However, developing some basic common components will be used, so you can look at this section as needed, generally as long as you know how to use it.
19. Mark
Also introduced after JDK5. Spring is an excellent framework that starts with XML as the standard configuration file. However, with Spring3, and especially with the advent of Spring-Boot, annotations are becoming increasingly popular to simplify XML configuration files, which can save developers a lot of time in XML configuration. But the disadvantage is that annotations are scattered across classes, unlike XML, which has a global understanding and management of all configurations, so there is no way to completely replace XML. For the average developer, it’s ok to use annotations, but some publicly built developers may need to understand the definition and implementation of annotations, so they can review them as needed.
- JVMS (including features of each version)
For those new to Java, knowledge of the JVM does not have to be deep, but a brief understanding of the concepts involved. However, for an experienced developer with more than 3 years of Java experience, not knowing the JVM is almost unacceptable.
The JVM is the foundation on which Java runs, and it’s hard to believe that someone who doesn’t know anything about the JVM can know everything about the Java language. When I interview developers with more than 3 years of Java experience, the JVM is almost a must-ask question. Of course, the JVM is not the only interview question that determines technical competence, but it is a good example of Java development competence.
In the JVM category, I think the things to know are:
JVM memory model and structure
GC principle, performance tuning
Tuning: Thread Dump, analyzing memory structure
Class binary bytecode structure, class loader system, class loading process, instance creation process
Method Execution: New features provided by major Java releases (need a brief introduction)
Conclusion: People can’t do too many things in this life, so do everything wonderful. Your time is limited, so don’t waste it living someone else’s life. Don’t be trapped by dogma, which is living with the results of other people’s thinking. Don’t let the noise of others’ opinions drown out your own inner voice. And most important, have the courage to follow your heart and intuition. They already know what you truly want to become. Everything else is secondary.