Shulou(Shulou.com)06/02 Report--

This article mainly introduces the basis that Java programmers need to master, has a certain reference value, interested friends can refer to, I hope you can learn a lot after reading this article, the following let the editor take you to know about it.

1 Anonymous class

Java anonymous classes are much like local classes or inline classes, except that they don't have a name. We can use anonymous classes to define and instantiate a class at the same time. This should be done only if the local class is used only once.

Anonymous classes cannot have explicitly defined constructors. Instead, each anonymous class implicitly defines an anonymous constructor.

There are two ways to create an anonymous class:

Extend existing classes (either abstract or concrete)

Create an interface

The best way to understand the code is to read it first, so let's look at the code first.

Anonymous classes can be created in class and function code blocks. As you may know, anonymous classes can be created using interfaces or by extending abstract or concrete classes. In the above example, I first created an interface Football, and then implemented an anonymous class within the scope of the class and the main () method. Football can also be an abstract class or a top-level class juxtaposed with interface.

Football can be an abstract class, see the following code.

Public abstract class Football

{

Abstract void kick ()

}

Anonymous classes can be not only abstract classes, but also concrete classes.

/ / normal or concrete class

Public class Football

{public void kick () {}

} / / end of class scope.

What if the Football class does not have a constructor without arguments? Can we access class variables in anonymous classes? Do we need to overload all methods in anonymous classes?

You can use any constructor when creating anonymous classes. Note that the parameters of the constructor are also used here. Anonymous classes can extend top-level classes and implement abstract classes or interfaces. Therefore, the rules of access control still apply. We can access the protected variable, but if we change it to private, we can't. Because the Football class is extended in the above code, we don't need to overload all the methods. However, if it is an interface or abstract class, then you must provide an implementation for all unimplemented methods. Static initialization methods or member interfaces cannot be defined in anonymous classes. Anonymous classes can have static member variables, but they must be constant.

The purpose of anonymous classes:

Clearer project structure: usually we use anonymous classes when we need to change the implementation of some methods of a class at any time. This eliminates the need to add a new * .java file to the project to define the top-level class. This method is very useful, especially when the top-level class is only used once.

UI event listeners: the most common use of anonymous classes in graphical applications is to create various event handlers. For example, the following code:

Button.setOnClickListener (new View.OnClickListener () {

Public void onClick (View v) {

/ / your handler code here

}

});

We created an anonymous class that implemented the setOnClickListener interface. Its onClick method is triggered when the user clicks the button.

2 Multithreading

Multiple threads in Java can execute multiple threads at the same time. Threads are lightweight child processes and the smallest unit of processing. The main purpose of using multithreading is to maximize CPU utilization. We use multithreading instead of multiple processes because threads are lighter and can share memory space within the same process. Multithreading is used to implement multitasking.

Life cycle of a thread

As shown in the figure above, the life cycle of a thread has five main states. Let's explain each state in turn.

New: after creating an instance of a thread, it enters the new state, which is the first state, but the thread is not ready to run.

Runanble: call the start () method of the thread class, and the state changes from new to Runnable, meaning that the thread can run, but when it actually starts running depends on the Java thread scheduler, because the scheduler may be busy executing other threads. The thread scheduler picks a thread from the thread pool in a FIFO (first-in, first-out) fashion.

Blocked: there are many situations that can cause a thread to become in a blocked state, such as waiting for an Icano operation, waiting for a network connection, and so on. In addition, a higher priority thread can change the currently running thread into a blocked state.

Waiting: a thread can call wait () to enter the waiting state. When another thread calls notify (), it returns to the runnable state.

When the Terminated:start () method exits, the thread enters the terminated state.

Why use multithreading?

Using threads allows Java applications to do more than one thing at the same time, thus speeding up the execution. In technical terms, threads can help you implement parallel operations in Java programs. Because modern CPU is very fast and may contain multiple cores, it is impossible for a single thread to use all cores.

Key points to keep in mind

Multithreading can make better use of CPU.

Improve responsiveness and user experience

Reduce response time

Provide services to multiple clients at the same time

There are two main ways to create threads:

Extend the Thread class

Implement the Runnable interface

Create threads by extending the Thread class

Create a class that extends the Thread class. This class should overload the run () method in the Thread class. The thread begins its life cycle in the run () method. We create an object of the new class, and then call the start () method to start executing the thread. In the Thread object, start () calls run ().

You can also create classes through interfaces.

The following code creates a class that implements the java.lang.Runnable interface and overloads the run () method. Then we instantiate a Thread object and call the object's start () method.

Interface between Thread class and Runnable

By extending the Thread class, you cannot extend more classes because Java does not allow multiple inheritance. Multiple inheritance can be implemented through interfaces. So it's best to use the interface instead of the Thread class.

If you extend the Thread class, it also includes some methods, such as yield (), interrupt (), and so on, which may not be needed by our program. There are no such useless methods in the Runnable interface.

3 synchronization

Synchronization refers to the synchronization of multiple threads. The code block of synchronized can only be executed by one thread at a time. Synchronization in Java is an important concept because Java is a multithreaded language and multiple threads can execute in parallel. In a multithreaded environment, the synchronization of Java objects, or Java classes, is very important.

Why synchronize?

If the code is executed in a multithreaded environment, it is in multiple threads. Shared objects need to be synchronized to avoid breaking the state or causing any unpredictable behavior.

Before delving into the concept of synchronization, let's understand this problem.

Class Table {

Void printTable (int n) {/ / method not synchronized

For (int I = 1; I

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.