Java is an object-oriented programming language that can write cross-platform application software. Java technology has excellent versatility, efficiency, platform portability and security, widely used in PCs, data centers, game consoles, scientific supercomputers, mobile phones and the Internet, and has the world's largest professional developer community.
1. Java operation (basic essential)
This may seem very simple, who can't run java programs? But many times, we simply execute java programs through IDE. How does the underlying IDE execute java programs? Many people do not understand.
This knowledge point is the most basic Java developers need to master. For beginners, the first thing to do is to teach you how to execute java programs on the command line. However, many people once they have finished learning java and used the IDE, they will put Forgot all this. Why do you emphasize that you need to know this? After you know the purest way to start java, you can analyze how many directories are started at that time, how are the execution names, how are the parameters, and whether there are any missing, etc. This will help you solve those weird and environment-related problems in real development.
The knowledge that needs to be mastered here is:
javac compiles java files into class files;
The use of the java command, how to start the java class with package on the command line;
The various paths involved in the java program (classpath, java, library, path, the main directory where java runs, etc.).
2. Data Type
There is not much to say in this article, it is nothing more than the mastery of basic types and object types in Java. You can learn more about how JDK automatically converts, including boxing and unboxing, and pay attention to avoid the type equality judgment after boxing
Main knowledge points:
basic types: int, long, float, double, boolean;
Corresponding object types: conversion of types such as Integer to primitive types, boxing and unboxing
Object type: features of equals, hashcode, and String types.
3. Access Control
This is also a foundation of the java encapsulation feature, which needs to be mastered:
public protected default private Modification of class, method and field.
4. Process Control
The basics of Java flow control, although some syntaxes are not necessarily very common, but they all need to be understood and used where appropriate.
What you need to master are: if, switch, loop, for, while and other flow control syntax.
5. Concepts of Object Oriented Programming
This is a core concept of java that any java developer needs to master. Many features or knowledge points in Java are related to the concept of Java object-oriented programming. In my understanding, a good developer not only needs to understand these features (knowledge points) themselves, but also needs to know how these objects are reflected in the concept of object-oriented programming in java, which is more conducive to developers to master java This development language, as well as other object-oriented programming languages.
The main knowledge points include:
The three major characteristics of object-oriented: encapsulation, inheritance, polymorphism; their respective definition concepts, which characteristics are reflected, their respective usage scenarios, the concept of static multi-dispatch, dynamic single-dispatch, the concept and use of overloading
Inheritance: multiple implementations of interfaces, single inheritance of base classes, abstract classes, interfaces
Polymorphism: The Concept of Method Overriding and Using Interface Callbacks
6. Objects and Instances, Object Creation
In this regard, developers need to understand the concept of class and instance and the difference between them, which is a foundation of Java's object-oriented features. The main knowledge points are:
The concepts of Class and Instance;
The process of Instance creation:
1. No inheritance: allocate memory space, initialize variables, and call constructors;
2. There is inheritance: processing static actions, allocating memory space, defining variables as initial values, starting from base class -> subclass, processing initialization at the definition, and executing constructors;
Points to note: static properties, etc. are initialized from the base class -> subclass; features related to the default no-argument constructor.
7. Static
Static properties are often used in the daily development of java. It is necessary to understand the usage related to the static keyword, as well as the use of other keywords, such as whether it can be used in conjunction with keywords such as abstract and final.
The main things you need to know are:
Definition, use, and initialization of static properties when classes are loaded
Definition and use of static methods
Definition and use of static classes
Definition and initialization timing of static code blocks
8. Basic knowledge points
Here are some scattered, unsystematically categorized java knowledge points. It is also used a lot in daily development. There is actually a lot more to this piece, but for now, these are just briefly summarized here:
Including: equals, hashcode, string/stringbuffer, final, finally, finalize
9. Collection Framework
This is a part that needs to be mastered more. When doing java development, it can be said that there is no need to use the collection framework, which is very important. But the knowledge points here are not difficult, but it is best to understand the internal implementation of collections, because this will help you choose a suitable framework to solve problems in different scenarios, such as collections with 1W elements, often Performing the contains judgment operation, knowing the characteristics or internal implementation of the collection, it is easy to make the correct choice.
This includes the following (concurrency related is not included):
The system of the collection framework: basic Collection, Map
The content of the specific collection implementation, the specific implementation of List, Set, Map, the internal structure, the special method, the usage of the collection-related tool class Collections, etc. java internal learning group: 725633148.
10. Exception Framework
Exceptions may not be taken so seriously in Java development. Generally, if you encounter an exception, throw it directly, or just catch it and handle it, and it will not have a big impact on the overall operation of the program. However, in enterprise-level design and development, the quality of abnormal design and handling is often related to the overall robustness of the system. For developers, the handling of exceptions in a good system should be unified to avoid a lot of exception handling logic scattered everywhere; for the system, exceptions should be controllable and easy to operate and maintain. There should be a way to deal with it and know how to operate and maintain it, so although the exception framework is very simple, exception handling is very important for the development of the entire enterprise-level application. To handle exceptions well, you need to understand the exception system in Java.
There are not many knowledge points that need to be mastered in this part, mainly:
Unusual system:
Throwable
Exception
RuntimeException
Error
The difference between RuntimeException and general Exception, the specific processing method, etc.
11. Java I.
IO in java is not only as simple as file reading and writing, but also includes all input and output operations such as socket network reading and writing. For example, reading the content of Post in a standard HTTP request is also an output process, etc...
For IO, Java not only provides APIs related to basic Input and Output, but also provides some APIs such as Reader and Writer that simplify operations, which are also very important in some development (projects involving a large number of IO operations). Generally, in daily development Also involved (logging, reading and writing of temporary files, etc.).
The main points of knowledge in this are:
Basic IO system: including InputStream, OutputStream, Reader/Writer, file reading, various stream reading and other NIO concepts, specific usage and usage scenarios
12. Multi-threaded concurrency
Multithreading is generally considered a difficult part of Java. Multi-threading can effectively improve the CPU usage and improve the overall system efficiency, especially in the case of a large number of IO operations blocked; but it is also a double-edged sword. There is no improvement, and it will also bring problems such as debugging between multiple threads.
There is a lot of content in multi-threading, just briefly explain the knowledge points that need to be mastered for the initial use of multi-threading in Java, and then have the opportunity to introduce the usage scenarios of some advanced features in detail separately.
Implementation and startup of multithreading
Difference between callable and runable
syncrhoized, reentrantLock features and comparison
Thread Pool
future asynchronously obtains the execution result
concurrent package
lock
..
13. Network
Java also provides APIs that can directly operate the TCP protocol and the UDP protocol. When it is necessary to emphasize network performance, you can directly use Socket to communicate through TCP/UDP. In viewing the source code of Tomcat, etc., you can see the usage of these related APIs. However, in general, TCP is rarely used directly, and frameworks such as MINA and Netty are used for processing. Because the development of this aspect does not involve much, it will not be listed in detail.
14. Time and date processing
For almost every application, the processing of time and date cannot be bypassed, but the usage of time-related APIs before JDK8 is not friendly. In that era, timeframes like Joda could be chosen. After the release of JDK8, the new time API basically integrates the advantages of other frameworks and can be used directly.
For Java developers, it is necessary to be proficient in using the API to deal with time and date.
The specific knowledge points are no longer listed, and a special article will be written in the future to summarize the usage of the time and date API in JDK8.
15. XML parsing / JSON parsing
In fact, these two pieces of content are not the content in J2SE, but in daily development, interaction with other programs and configuration files is more and more inseparable from the analysis of these two formats.
However, for a developer, being able to understand some principles and methods of XML/JSON specific parsing will help you to better choose the appropriate method in each specific scenario to make your program more efficient and more robust. .
XML: Need to understand the basic principles of DOM parsing and SAX parsing and their respective applicable scenarios
JSON: You need to understand the usage of some common JSON frameworks, such as Jackson, FastJson, Gson, etc.
16. Reflective technology
Provides an artifact for dynamically creating instances and calling methods dynamically, which is loved by major frameworks.
17. Use of Maven or gradle
Maven is not the content in Java, but maven is revolutionary and brings great convenience to java development. From the introduction and management of dependencies, the update of the development process and the release output, and even the update of the version, the use of maven can greatly simplify the complexity of the development process, thereby saving a lot of time. It can be said that maven has become the standard for java developers. So I also regard maven as a basic knowledge point necessary for a java developer. I will put some of my experience and skills in using maven in the future, so I won't go into details here. As for gradle, it is a rising star.
18. Generics
This is a new concept introduced by JDK5. In fact, it is a syntactic sugar. It will be a little convenient when writing java code. For general applications or business development, it only needs to be used simply, and operations such as defining generics may not be used. However, the development of some basic public components will be used. You can look at this part when you need it. In general, you only need to use it simply.
19. Callout
It was also introduced after jdk5. Spring is an excellent framework, with xml as the standard configuration file from the very beginning. However, after Spring 3, especially after the rise of spring-boot, the use of annotations to simplify xml configuration files has become more and more popular. For developers, it can save a lot of xml configuration time. But the disadvantage is that the annotations are scattered in various classes, unlike xml, which can have a global understanding and management of all configurations, so there is no way to completely replace all xml. For ordinary developers, it is enough to use annotations. Some developers of public components may need to understand the definition and implementation of annotations, and they can take a closer look when they need it.
20. JVM related (including features of each version)
For those who have just come into contact with Java, JVM-related knowledge does not necessarily require a deep understanding, and it is enough to have some simple understanding of the concepts in it. But for a senior developer with 3+ years of Java experience, not knowing the JVM is almost unacceptable.
The JVM is the basis for running java. It is hard to believe that people who don't know anything about the JVM can fully understand the java language. When I interview developers with over 3 years of Java experience, the JVM is almost a must-ask question. Of course, JVM is not the only interview question that determines the technical ability, but it can prove the level of java development ability.
In the big category of JVM, I think the knowledge that needs to be mastered are:
JVM memory model and structure
GC principle, performance tuning
Tuning: Thread Dump, analyze memory structure
class binary bytecode structure, class loader system, class loading process, instance creation process
Method execution process: new features provided by each major version of Java (need to understand briefly)
Summarize:
Humans can't do too many things in one lifetime, so everything must be done wonderfully.
Your time is limited, so don't live for others. Don't be trapped by dogma, don't live in other people's ideas. Don't let the opinions of others dictate your inner voice.
The most important thing is to have the courage to follow your heart and intuition, only your heart and intuition know what you really think, everything else is secondary.