The purpose of writing this article is to summarize my experience in using Java for so many years, mainly related to some Basic Knowledge points of Java, so I also hope to share it with the Java programmers who have just started and the would-be novices who plan to enter the Java development industry, hoping to give you some experience. Make it easier for you to learn and use Java.

The main content of this presentation is j2SE-related, in addition, some J2Ee-related and Java frameworks will be introduced in the future.

After so many years of Java development, combined with the usual interview Java developers experience, I think J2SE is mainly to master some of the following content.

1. Jvm-related (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 would like to know: JVM memory model and architecture GC principles, performance tuning tuning: Class binary bytecode structure, class loader system, class loading process, instance creation process, method execution process

2. 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, whether there were any missing files, etc. 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 as class files for the use of Java commands, Java classes with package such as the various paths involved in starting Java programs from the command line (classpath, Java). The library. Path, home directory where Java runs, etc.)

3. Data types

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 type: equals, hashCode String characteristics

4. 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:

Class and Instance concepts

Instance creation process:

1, no inheritance: allocate memory space, initialize variables, call constructors 2, inheritance: handle static actions, allocate memory space, define variables as initial values, from base class -> subclass, handle initialization at definition, execute constructors

Points to note: static properties, etc., are initialized from base -> subclasses with default no-argument constructor related features

5. Access control

Public protected Default Private decorates classes, methods, and fields

6. 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

7. 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. Here is just a simple list, the main knowledge points include: object-oriented three features: encapsulation, inheritance, polymorphism; Concept of static multiple dispatch, concept of dynamic single dispatch, concept of overloading and use inheritance: interface multiple implementation, base class single inheritance abstraction, abstract class, interface polymorphism: concept of method override and use interface callback

8. 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 you need to know are: how to define static properties, how to use them, and how to initialize static method definitions and how to use static class definitions and how to use static code blocks and when to initialize them

9. Basics

Here mainly lists some scattered, no system classification of some Java knowledge points. It is also used in daily development. Equals, HashCode, String/StringBuffer, Final, finally, Finalize

10. Collection framework

This is an area that needs to be mastered. It is important to do Java development without using a collection framework. 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) : Basic Collection, Map concrete Collection implementation content, List, Set, Map concrete implementation, internal structure, special methods, applicable scenarios and other Collections related tool class usage

11. Exception framework

Exceptions 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. However, in enterprise design and 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 system, the anomaly should be controlled, and is easy to operations, some abnormal, there should be a response to approach, know how to operational process, so although exception framework is very simple, but for the entire enterprise application development, exception handling is important to deal with abnormal you need to understand the exception system of Java.

Exception system: Throwable Exception RuntimeException Error RuntimeException is different from common exceptions and how to handle exceptions

12. 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 example, reading the content of a Post in a standard HTTP request is 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.). Basic IO system: including InputStream, OutputStream, Reader/Writer, file reading, all kinds of stream reading NIO concepts, specific use methods and use scenarios

13. Multi-threaded concurrency

Multithreading is generally considered a difficult part of Java. Multithreading can effectively improve THE CPU utilization rate, improve the overall system efficiency, especially in the case of a large number of IO operation blocking; But it is also a double-edged sword, if the use is not good, the system 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. Concurrent package lock, concurrent package lock, concurrent package lock, concurrent package lock, concurrent package lock.

14. The network

Java also provides apis for directly operating TCP and UDP protocols. In cases where network performance needs to be emphasized, TCP/UDP can be directly used for communication. 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.

15. 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: Need to understand the basic principles of DOM parsing and SAX parsing and their applicable scenarios JSON: Need to understand the usage of some common JSON frameworks, such as Jackson, FastJson, and Gson.

17. The use of Maven

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 of development processes and release outputs, to the updating of versions, using Maven can greatly simplify the complexity of the development process, resulting in significant time savings. 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.

18. Generics

This is JDK5 started to introduce new concept, is actually a syntactic sugar, there’s a convenience when writing Java code, general application or the development of the business, only need a simple to use, does not necessarily need to define a generic such operations, but the development, some basic common components will have access to this part can be in need of looking closer, In general, as long as you can use it simply.

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.

20.RMI

The Remote Invocation of the Java language is simple to use. However, in the case of cross-language support, other means such as WebService are needed. In general, applications do not need to use RMI, but they can be used in certain situations, such as in one project where I used RMI to remotely start and stop applications.

21.JNI

Java Native Interface allows you to call Native Interface methods in Java. It is generally used to call C/C++ code. One thing to note is the path to load so/ DLL files in Java. Calling the interface itself is not complicated, but it often takes a lot of time to determine whether or not the required local interface library is loaded.

The above is just a brief introduction of my views and introduction to the basic Knowledge and technical points of Java. These contents are derived from my summary of using Java over the years. I hope to give some experience to those who are new to Java, or who are planning to develop from Java, and hope to learn and use Java more efficiently. Avoid detours and waste valuable time. There are still some incomplete parts, which will be added in future articles. Due to my limited personal ability, of course, there will be some mistakes and omissions, welcome to correct, discuss together, and improve this article together, hoping that it can really help people in need.

Author: Engineer – Stranded


Website: Home of Scripts