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

In this issue, the editor will bring you an introduction to how to achieve J2SE. The article is rich in content and analyzes and narrates it from a professional point of view. I hope you can get something after reading this article.

Getting started with J2SE:

1. Preliminary knowledge

two。 Storage mode and operation control

3. Object-oriented technology

4. Common data structure

5. Exception handling mechanism

6. Image processing and audio operation

7. Graphical interface (swing)

8. Multithreading technology

9. Icano operation

10. Basic network technology

Preliminary knowledge:

Needless to say, the historical background of ㈠ Java

Setting and principle of ㈡ Environment variable

The first step in developing Java programs is to set environment variables, which mainly include the settings of PATH and CLASSPATH. Understanding the role of PATH and CLASSPATH is beneficial to the operation of Java programs.

PATH: the operating system searches through PATH when executing a command; if the paths to some tools of Java, such as Java, Javac, Javadoc, etc., are also added to PATH, the system can search for these tools and perform operations when running Java's compiler or interpreter, all of which are in the bin directory under the jdk directory.

The settings of PATH are as follows (let jdk be installed in C:j2sdk1.4.2):

PATH=%PATH%;C:j2sdk1.4.2bin

Note:% PATH% means to retain the original PATH path, or you can add the jdk path directly to the original PATH path without setting this item. ; is the delimiter under Windows (under Linux:).

CLASSPATH: a list of paths to search for classes that are needed to compile or run Java. The virtual machine searches and loads all required classes in the following order:

Bootstrap classes: the classes that make up the java platform, including classes in rt.jar and i18n.jar.

Extension classes: classes that use the java extension mechanism are .jar archives located in the extension directory ($JAVA_HOME/jre/lib/ext).

User classes: developer-defined classes or third-party products that do not use the java extension mechanism.

The settings for CLASSPATH are as follows:

CLASSPATH=.;C:j2sdk1.4.2libtools.jar; C:j2sdk1.4.2_05jrelibrt.jar

Note:. Represents the current directory, if you think the directory name is too cumbersome, you can first set a JAVA_HOME, and make JAVA_HOME=C:j2sdk1.4.2, and then set the CLASSPATH format to:% JAVA_HOME%libtools.jar, etc. Dt.jar is a class library about the running environment, and tools.jar is a class library about some tools.

Note:

Programs and classes

There can be only one public class in the Java source program, but there can be any normal class, and the program file name must be the same as the class name of the public class.

Packet operation

Generally, in order to facilitate management, the classes of Java are made into a file, and then put into a Package, that is, a package contains several classes, including the main class and the general class. The format of running the compiled program is:

Java package name. Main class name

Coding habit

Java development process must develop good coding habits (from the doll to grab ^ _ ^), such as writing literal identifiers, code indentation format, standard and detailed comments, and so on.

Storage mode and operation control

The so-called storage mode and operation control are actually the choice of data structure and the design of algorithm. If the program is written too much, the ability in this aspect can be improved gradually.

㈠ storage mode refers to the data type of Java, the choice of variables is also very important in programming, and performance should be considered as far as possible if it meets the requirements.

Simple data types include:

Integer type (Integer): byte, short, int, long

Float type (Floating): float,double

Character type (Textual): char

Boolean type (Logical): boolean

Composite data types include:

String type: String

Array

Class

Interface

The operation method of ㈡ mainly refers to the control statements such as sequence, transfer, loop and so on which are often used in programming. No matter how complex the program is, it is inseparable from these control statements. Therefore, only by skillfully mastering the use of these sentences can we write beautiful and efficient code.

Sequential execution

Conditional transfer

Ⅰ if (exp) {

} else (exp) {

}

Ⅱ switch (exp) {

Case?: break

Case?: break

…… .

Default: break

}

Cycle operation

Ⅰ for (;;) {

}

Ⅱ while (exp) {

}

Jump instruction

Ⅰ break

Ⅱ continue

Ⅲ return

Note:

Some techniques can be used in the operation: for example, in the loop operation, the judgment end condition can be set to the type of dead loop (such as while (true)), and then set the condition break inside the program segment.

The difference between break and continue: the break statement jumps out of the block specified by it, no longer determines the termination condition, and executes from the first statement immediately following the block; the continue statement is used to end the loop, skip the following unexecuted statements in the body of the loop, and then judge the termination condition to determine whether to continue the cycle.

Object-oriented technology

OO is not only a profound thought, but also a common idea in modern software design. There are many principles summarized by predecessors in OO, which should be used for reference as far as possible. For example, giving priority to class aggregation over inheritance, programming against interfaces, striving for loose coupling and high cohesion, and so on. The first chapter of the book "detailed understanding of Design patterns" is very good at getting started with OO and design patterns. General OO and design patterns can produce unexpected results in software design, so it is highly recommended that OO and design patterns be studied together. Here we introduce a bible of design patterns, "Design patterns-the basis of reusable object-oriented software" (although it is implemented in C++, but the idea has nothing to do with language). The 23 patterns introduced in the book are refinement and extraction of some solutions in previous software development. It's refreshing and worth reading.

The basic idea of ㈠ OO is to use the basic concepts of class, object, inheritance, encapsulation, message and so on to program design.

The basic characteristics are encapsulation, inheritance, polymorphism:

Encapsulation: combine the attributes and operations of the object into an entity, hide the internal details as much as possible, and provide interfaces only to class users. The basic principle is not to provide public member variables, but to make use of the characteristics of bean to provide set and get methods to access member variables.

Inheritance: it can be inaccurately attributed to the generality of the parent class and the characteristics of the subclass, such as the passenger ship is a special class of ships and passenger transport tools, the ship is the parent class, and the passenger ship is the subclass that realizes the passenger transport function.

Polymorphism: the polymorphism of an object means that attributes or services defined in a general class can have different data types or behave differently after they are inherited by a special class. For example, the "drawing" method of "geometry", "ellipse" and "polygon" are all subclasses of "geometry", and their "drawing" methods have different functions.

Key technologies of ㈡:

Class, object

The relationship between classes and objects is like the relationship between moulds and castings.

Class declaration:

[public] [abstract | final] class className [extends superclassName]

[implements interfaceNameList] {

Member variable

Member method

}

Member variables:

[public | protected | private] [static]

[final] [transient] [volatile] type variableName;

The meaning of qualifiers in variable declarations:

Static: static variable (class variable); relative to instance variable

Final: constant

Transient: temporary variable for object archiving

Volatile: contribution variable for sharing of concurrent threads

Member method:

[public | protected | private] [static]

[final | abstract] [native] [synchronized]

ReturnType methodName ([paramList]) [throws exceptionList] {statements}

The meaning of the qualifier in the method declaration:

Static: class method, which can be called directly through the class name

Abstract: abstract methods, no method body, implemented by subclasses

Final: methods cannot be overridden

Native: integrate code from other languages

Synchronized: controls access to multiple concurrent threads

Qualifier in class:

Private

Members of a class that are qualified as private can only be accessed by the class itself. If the constructor of one class is declared as private, other classes cannot generate an instance of the class.

Default

Members of a class without any access restrictions are in the default (default) access state and can be accessed by the class itself and by classes in the same package.

Protected

Members of a class that are qualified as protected can be accessed by the class itself, its subclasses (including subclasses in the same package and in different packages), and all other classes in the same package.

Public

A member of a class that is qualified as public and can be accessed by all classes

Construction method:

The construction method is a special method. Each class in Java has a constructor that initializes an object of that class. The constructor has the same name as the class name and does not return any data types.

Overloading is often used for constructors. Constructors can only be called by the new operator.

Method overloading and method rewriting:

Method overloading means that multiple methods have the same name, but the parameters of these methods must be different, or the number of parameters is different, or the parameter types are different. The return type cannot be used to distinguish between overloaded methods.

Method rewriting means that the method of the parent-child class with inheritance relationship has the same name, the method rewritten in the subclass and the method overwritten in the parent class should have the same name, the same parameter table and the same return type, but the function body is different. The java runtime system decides which method to call based on the instance that calls the method. For an instance of a subclass, if the subclass overrides the method of the parent class, the runtime system calls the method of the subclass; if the subclass inherits the method of the parent class (not overridden), the runtime system calls the method of the parent class.

Principles to follow when rewriting a method:

1) the rewritten method cannot have more stringent access rights than the overridden method (can be the same).

2) the rewritten method can not produce more exceptions than the written method.

Note: overload methods with the same name in the same class and override methods with the same name for parent-child classes with inherited relationships.

Explanation of commonly used keywords

1) static

Static variable: all such instances share this static variable, that is, only one piece of storage is allocated when the class is loaded, and all objects of this class can manipulate this block of storage.

Static method: this method can be called without an object of this class, and a static method is called "class name. method name".

Static class: usually a normal class is not allowed to be declared as static, only an inner class can. At this point, the inner class, which is declared static, can be used directly as a normal class without instantiating an external class.

2) final

Final member: its value is immutable for the base type and its reference is immutable for the object variable. Initialization can be done in two places, one at its definition, that is, assigning a value to the final variable directly when it is defined, and in the constructor. You can only choose one of these two places, either at the time of definition or in the constructor, not both at the time of definition and another value in the constructor at the same time.

Final method: declare the method as final, which means you already know that the function provided by this method meets your requirements, does not need to be extended, and does not allow any classes inheriting from this class to override the method, but inheritance can still inherit the method, that is, it can be used directly.

Final class: the use of the final class is almost no different from that of a normal class, except that it loses its inherited features.

3) super, this (commonly used in construction methods)

The usage of super:

Access member variables of the parent class that are hidden, such as:

Super.variable

Call the overridden method in the parent class, such as:

Super.Method ([paramlist])

Call the constructor of the parent class, such as:

Super ([paramlist])

This usually refers to the current object, and super usually refers to the parent class. In the constructor, super is used to call the constructor of the same form in the parent class, while this is used to call the current constructor with the same parameter.

Operation control of object

Generation of objects:

Declaration: the declaration does not allocate memory space to the object, but only allocates a reference space; the reference to the object is a 32-bit address space similar to a pointer, and its value points to an intermediate data structure. it stores information about the data type and the address of the heap where the current object resides, while the actual memory address where the object is located is inoperable, which ensures security. Instantiation: the operator new allocates memory space for the object, which calls the object's constructor and returns a reference; different objects of a class occupy different memory space.

The use of objects:

Since the basic principle of encapsulation is to provide interfaces but not public member variables, we can only use "." To reference member methods in the class. The use of an object is actually passing a message to change certain properties or perform certain operations.

Cleanup of objects:

Java's garbage collector automatically scans the dynamic memory area of objects, collecting and releasing objects that are not referenced as garbage. System.gc (); when the system runs out of memory or calls System.gc () for garbage collection, the garbage collection thread runs synchronously with the system.

Inheritance (abstract class), interface

Abstract classes:

Abstract class abstractClass {... } / / Abstract class

Abstract returnType abstractMethod ([paramlist]) / / Abstract method

Abstract classes must be inherited and abstract methods must be overridden. Abstract methods only need to be declared, not implemented; abstract classes cannot be instantiated, and abstract classes do not have to contain abstract methods. If a class contains abstract methods, the class must be defined as an abstract class.

Interface:

[public] interface interfaceName [extends listOfSuperInterface] {… }

Interface is a kind of abstract class, which only contains the definition of constants and methods, but has no implementation of variables and methods, and its methods are all abstract methods.

Note:

A class can only use inheritance relationships once, but it can have multiple interfaces.

Abstract classes represent "is a" relationships, and interfaces represent "like a" relationships. (involving design patterns)

Inner class

An inner class is a class that is nested within a class. It can be a member of another class, it can be defined inside a statement block, or it can be defined anonymously within an expression.

An anonymous class is a special inner class that contains a complete class definition (message response class, etc.) inside an expression.

Comparison of advantages and disadvantages of internal classes:

◇ advantage: save the size of the compiled bytecode file

◇ disadvantage: make the program structure unclear

Common data structure

Vector

ArrayList

List

Queue

Map

Tree

Stack

Hashtable

Enumeration

Wait, wait.

Note: generally, the data access in these data structures is based on Oject, so the data extracted from it needs type conversion, and int, etc., cannot be directly stored in these data structures, and must be repackaged with overlay classes (such as Integer, etc.) before they can be stored.

One aspect that Java is easier to use than C++ should be that Java provides rich data structures for users without having to let users design their own data structures for a long time, only to find that they are still full of mistakes and frustration. Because Sun encapsulates these data structures well, you can use them as long as you understand the characteristics of these data structures and their interface methods.

Generally speaking, in learning and development, you can check the help documents when needed, but only by deeply understanding the characteristics of these data structures can you choose the best data structure to develop excellent code.

Exception handling mechanism

An exception is actually an event in a program that causes an error to interrupt the normal flow of instructions.

All exception classes inherit directly or indirectly from the Throwable class. Throwable is divided into two subcategories: Error and Exception, in which Error is directly processed by virtual machines and part of Exception is handled by users.

A general framework for catching exceptions:

Try {

.

} catch (ExceptionName1 e) {

.

System.out.println ("message:" + e.getMessage ()); / / e.getMessage () is a method provided by the class Throwable to get information about abnormal events.

} catch (ExceptionName2 e) {

.

E.printStackTrace (System.out); / / e.printStackTrace () is used to trace the contents of the execution stack when an exception event occurs.

}

.

} finally {

. / / this section needs to be executed regardless of whether an exception is generated, unless System.exit (0)

}

When the Java runtime system gets an exception object, it will trace back layer by layer along the method's call stack, looking for code to handle the exception. After finding a way to handle this type of exception, the runtime system hands over the current exception object to this method, a process called catch exception.

Note: the order in which exceptions are caught is related to the order of catch statements, and when an exception is caught, the remaining catch statements are no longer matched. Therefore, when arranging the order of catch statements, you should first catch the most special exceptions, and then gradually generalize. That is, the subclass is generally arranged first, and then the parent class is arranged.

Throws and throw

Throw is the statement that throws an exception, and throws is the method that throws an exception.

Throw:throw

Throws: [] ([]) [throws]

Declare to abandon the exception

If an exception is generated in a method, but the method does not know exactly how to handle the exception, the method should declare to discard the exception so that the exception object can propagate backward from the call stack until the appropriate method catches it. The declaration discarding exception is specified in the throws clause of a method declaration. For example:

Public int read () throws IOException {

.

}

Throw an exception

Throwing an exception is the process of generating an exception object, first of all, the exception object is generated either by a virtual machine or by an instance of some class, or in a program. In the method, the exception object is thrown through the throw statement.

For example:

IOException e = new IOException ()

Throw e; / / throw an exception artificially

Note: throw explicitly throws an exception to the upper layer; throws indicates the various exceptions that a method may throw.

Throws can be used alone, but throw cannot.

Custom exception

An exception is a class, and a user-defined exception must inherit from the Throwable or Exception class, and the Exception class is recommended.

Common anomalies

ArithmeticException

ArrayIndexOutOfBandsException

ArrayStoreException

IOException

FileNotFoundException

NullPointerException

MalformedURLException

NumberFormatException

OutOfMemoryException

Image processing and audio operation

Image processing.

Java is not very powerful in desktop programs, so it is rarely used to develop desktop programs, but you still need to know about it. General image processing is divided into application program and Applet:

Images in applications are generally encapsulated as ImageIcon, which are posted on Button and Label, such as:

JButton btn = new JButton ()

ImageIcon img = new ImageIcon (path)

Btn.setIcon (img)

In Applet, it is generally used directly from files and images, such as:

Image img = new Image ()

Img = getImage (getDocumentBase (), imageFile)

…… ..

2D drawing is generally implemented in Applet, which is realized by copying paint method. In the application, you can also new a Graphics to get the drawing handle. Specific translation, flipping and other algorithms are no longer described.

Note: paintComponent is commonly used in paint,swing in awt.

Double buffering, sometimes the image will flicker when refreshed, which can be improved with double buffering. Double buffering is to create a drawing handle to draw when the image is update.

Audio operation

Audio operations and image processing are also similar, and are generally used in Applet, such as:

AudioClip first = getAudioClip (getDocumentBase (), "first.au")

First.play ()

If you want to implement audio operations in your application, you can use Applet conversion, such as:

Audio audio = Applet.newAudioClip (audio_path)

Audio.play ()

Note: the audio operation implemented by Java is very weak, and it is generally only used to play audio files in midi, au and other formats, while for mp3 and other formats, there must be a decoder, but it is not cost-effective to implement.

Graphical interface (swing)

Introduction to Swing

Swing is implemented by 100% pure Java, Swing components are lightweight (light-weight) components implemented in Java, no native code, do not rely on the support of the operating system, this is the biggest difference between it and AWT components.

Swing adopts a design paradigm of MVC, namely "Model-View-Control" (Model-View-Controller), in which the model is used to store the content, the view is used to display the content, and the controller is used to control user input.

Class hierarchy of Swing

In the javax.swing package, two types of components are defined: top-level containers (JFrame,JApplet,JDialog and JWindow) and lightweight components. Swing components are both direct and indirect subclasses of the Container class of AWT.

Java.awt.Component

-java.awt.Container

-java.awt.Window

-java.awt.Frame-javax.swing.JFrame

-javax.Dialog-javax.swing.JDialog

-javax.swing.JWindow

-java.awt.Applet-javax.swing.JApplet

-javax.swing.Box

-javax.swing.Jcomponet

MVC (Model-View-Control) architecture

In a MVC user interface, three communication objects are stored: models, views, and controls. The model is the specified logical representation, the view is the visual representation of the model, and the control specifies how to handle user input. When the model changes, it notifies all views that depend on it, and the view uses controls to specify its corresponding mechanism. MVC is a general idea of making graphical user interface in existing programming languages. its idea is to separate the content of data from the mode of display, which makes the display of data more flexible and diverse.

In the Swing component, using the registerKeyboardAction () method of the JComponent class enables the user to use the keyboard operation to replace the corresponding action of the mouse driving the Swing component on the GUI.

Brief introduction of Swing Program structure

The programming of Swing can generally be done according to the following process:

1. Introduce Swing package

2. Select "look and feel"

3. Set the top-level container

4. Set buttons and labels

5. Add components to the container

6. Add boundaries around the component

7. Perform event handling

Classification of components:

Functionally, components can be divided into:

① top-level container: 4 JFrame,JApplet,JDialog,JWindow

② intermediate container: JPanel,JScrollPane,JSplitPane,JToolBar

③ special container: middle tier that plays a special role on GUI, such as JInternalFrame,JLayeredPane,JRootPane. ④ basic controls: components that implement interpersonal interaction, such as Jbutton, JComboBox, JList, JMenu, JSlider, JtextField.

Display of ⑤ non-editable information: components that display non-editable information to the user, such as JLabel, JProgressBar, ToolTip.

Display of ⑥ editable information: a component that displays formatted information that can be edited to the user, such as JColorChooser, JFileChoose, JFileChooser,Jtable, JtextArea.

The special functions of the JComponent class are as follows:

1) Border setting: use the setBorder () method to set the border around the component, and use an EmptyBorder object to leave white space around the component.

2) double buffers: the use of double buffering technology can improve the display effect of frequently changing components. Unlike the AWT component, the JComponent component defaults to double buffers and does not have to rewrite the code itself. If you want to close the double buffers, you can impose the setDoubleBuffered (false) method on the component.

3) Tips: use the setTooltipText () method to set helpful prompts for the component.

4) Keyboard navigation: using the registerKeyboardAction () method, users can use the keyboard instead of the mouse to drive the components. AbstractButton, a subclass of the JComponent class, also provides a convenient way to indicate a character with the setMnemonic () method, which activates the button action together with a special modifier of the current Lobf.

5) can be inserted: each Jcomponent object has a corresponding ComponentUI object, for it to complete all the painting, event handling, determine the size and other work. The ComponentUI object depends on the currently used lumped F, which can be set with the UIManager.setLookAndFeel () method.

6) support layout: by setting the maximum, minimum and recommended size of components and setting X and Y alignment parameter values, you can specify the constraints of the layout manager to provide support for layout.

Basic rules for using Swing

Unlike the AWT component, the Swing component cannot be added directly to the top-level container; it must be added to a content panel (content pane) associated with the Swing top-level container. The content panel is a common container contained in the top-level container, which is a lightweight component. The basic rules are as follows:

(1) place the Swing component on the content panel of a top-level Swing container

(2) avoid non-Swing heavyweight components.

There are two ways to add components to JFrame:

1) use the getContentPane () method to obtain the content panel of JFrame, and then add a component to it: frame.getContentPane (). Add (childComponent)

2) create an intermediate container such as Jpanel or JDesktopPane, add components to the container, and use the setContentPane () method to set the container as the content panel of JFrame:

Jpanel contentPane=new Jpanel ()

. / / add other components to Jpanel

Frame.setContentPane (contentPane)

/ / set the contentPane object to the content panel of frame

Various container panels and components

Root panel

The root panel consists of a glass panel (glassPane), a content panel (contentPane), and an optional menu bar (JMenuBar), while the content panel and the selectable menu bar are placed in the same layer. The glass panel is completely transparent and the default value is invisible, making it easy to receive mouse events and draw on all components.

The methods provided by the root panel:

Container getContentPane (); / / get the content panel

SetContentPane (Container); / / set the content side

JMenuBar getMenuBar (); / / active menu bar

SetMenuBar (JMenuBar); / / set the menu bar

JLayeredPane getLayeredPane (); / / get the layered panel

SetLayeredPane (JLayeredPane); / / set the layered panel

Component getGlassPane (); / / get the glass panel

SetGlassPane (Component); / / set the glass panel

Layered panel

Swing provides two hierarchical panels: JlayeredPane and JDesktopPane. JDesktopPane is a subclass of JLayeredPane and is specifically set up to accommodate the internal framework (JInternalFrame). To add a component to a hierarchical panel, you need to indicate which layer to add it to, and indicate the location of the component in that layer:

Add (Component c, Integer Layer, int position).

Scroll window (JScrollPane)

Divider (JSplitPane)

Palettes (JTabbedPane)

Toolbar (JToolBar)

Internal Framework (JInternalFrame)

The internal framework JInternalFrame is like a window inside another window with the following characteristics:

1) the internal frame must be added to a container (usually JDesktopPane), otherwise it will not be displayed

2) there is no need to call the show () or setVisible () method. The internal frame is displayed with the container in which it is located.

3) the frame size must be set with setSize () or pack () or setBounds method, otherwise the size is zero and the frame cannot be displayed

4) you can use the setLocation () or setBounds () method to set the position of the internal frame in the container. The default value is 0 ~ 0, that is, the upper left corner of the container.

5) like the top-level JFrame, adding components to the internal framework should also be added to its content panel

6) create a dialog box in the internal frame. You can't use JDialog as the top-level window. You must use JOptionPane or JInternalFrame.

7) the internal framework cannot listen for window events, and you can handle the operation of the internal frame window by listening to the internal frame (JInternalFrameEvent) similar to the window event.

Button (JButton)

Check box (JCheckBox)

Radio checkbox (JRadioButton)

Select box (JComboBox)

File selector (JFileChooser)

Label (JLabel)

List (List)

Menu (JMenu)

Process bar (JProgressBar)

Slide bar (JSlider)

Form (JTable)

Tree (JTree)

Layout Manager

Although Swing has a top-level container, we can not add components directly to the top-level container. Swing forms contain a container called the content panel (ContentPane), put the content panel on the top-level container, and then add components to the content panel. BoxLayout layout Manager adds components in order from top to bottom (y-axis) or left-to-right (x-axis). To create a BoxLayout object, you must specify two parameters: the container being laid out and the principal axis of the BoxLayout. By default, the component is centered on the vertical axis.

The layout manager is set up as follows:

Pane.setLayout (new BoxLayout (pane,BoxLayout.Y-AXIS))

The graphical interface needs to be understood, but it doesn't take much effort, because the knowledge is updated too fast, and it's not the mainstream technology. Recently, SWT is popular again. I don't know if it will replace Swing to become the new love of developers. And with the development of development tools, the graphical interface will become very easy to use (not only will not do the same as Delphi), JBuider will do a good job, so it is best to spend energy on other technologies, for graphical interface beautification in the need to learn and use again, personal point of view.

Multithreading technology

Implementation of ㈠ Thread

Thread class

Define a thread class that inherits the thread class Thread and overrides the method run (). When initializing an instance of this class, the target target can be null, indicating that the thread body is executed by this instance. Because Java only supports single inheritance, classes defined in this method can no longer inherit from other parent classes.

Directly inherit the Thread class:

1) can no longer inherit from other classes

2) it is easy to write, and you can manipulate threads directly without using Thread.currentThread ().

Runnable interface:

Provide a class that implements the interface Runnable as the target object of a thread. When initializing a thread object of a Thread class or Thread subclass, pass the target object to the thread instance, and the target object provides the thread body run (). At this point, the class that implements the interface Runnable can still inherit other parent classes.

Use the Runnable interface:

1) CPU, code and data can be separated to form a clear model

2) you can also inherit from other classes

3) keep the consistency of program style.

Example:

Thread T1 = new MyThread ("T1"); / / extends

ClockThread = new Thread (this, "Clock"); / / Runnable

Scheduling of ㈡ threads

The thread scheduler selects high-priority threads (entering the running state) to execute according to the priority of the thread. The priority of the thread is expressed as a number from 1 to 10, that is, Thread.MIN_PRIORITY to Thread.MAX_PRIORITY. The default priority for a thread is 5, or Thread.NORM_PRIORITY.

Example: void setPriority (int newPriority)

Control of threads

Terminating thread

Stop () to terminate the thread

Test thread status

Get whether the thread is active through the isAlive () method in Thread

Pause and resumption of threads

1) sleep () method

2) join ()

Mutual exclusion and synchronization of threads

In order to solve the problem of incompleteness of operation, the concept of object mutex is introduced in Java language to ensure the integrity of shared data operation. Each object corresponds to a tag that can be called a mutex, which is used to ensure that only one thread can access the object at any one time. Keyword synchronized to contact the mutex of the object.

Example:

Public void push (char c) {

Synchronized (this) {/ / this represents the current object of Stack

Data [idx] = c

Idx++

}

}

Public char pop () {

Synchronized (this) {

Idx--

Return data [idx]

}

}

Synchronized can also modify methods and classes

Note:

Wait, nofity, and notifyAll must be executed when the lock is already held, so they can only appear within the scope of synchronized, that is, in methods or classes decorated with synchronized.

Thread group

Threads are created individually, but they can be grouped into thread groups for debugging and monitoring. A thread can only be associated with a thread group while it is created. In programs that use a large number of threads, it can be helpful to use thread groups to organize threads.

Inter-thread communication

When a thread needs to wait for a condition before continuing execution, the synchronized keyword is not enough. Although the synchronized keyword prevents concurrent updates of an object, it does not implement inter-thread messaging. The Object class provides three functions for this: wait (), notify (), and notifyAll ().

Ipaw O operation

Two base classes: InputStream and OutputStream, Reader and Writer

Ⅰ byte stream:

A series of classes derived from InputStream and OutputStream. Such streams are processed in bytes (byte).

◇ InputStream 、 OutputStream

◇ FileInputStream 、 FileOutputStream

◇ PipedInputStream 、 PipedOutputStream

◇ ByteArrayInputStream 、 ByteArrayOutputStream

◇ FilterInputStream 、 FilterOutputStream

◇ DataInputStream 、 DataOutputStream

◇ BufferedInputStream 、 BufferedOutputStream

Ⅱ character stream:

A series of classes derived from Reader and Writer that use characters represented by 16-bit Unicode codes as the basic processing unit.

◇ Reader, Writer / / Abstract Base Class

◇ InputStreamReader 、 OutputStreamWriter

◇ FileReader 、 FileWriter

◇ CharArrayReader 、 CharArrayWriter

◇ PipedReader 、 PipedWriter

◇ FilterReader 、 FilterWriter

◇ BufferedReader 、 BufferedWriter

◇ StringReader 、 StringWriter

Ⅲ object stream

◇ ObjectInputStream 、 ObjectOutputStream

Ⅳ other

◇ file processing:

File 、 RandomAccessFile

◇ interface

DataInput 、 DataOutput 、 ObjectInput 、 ObjectOutput

The class File provides a machine-independent way to describe the properties of a file object.

Classes FileInputStream and FileOutputStream are used for file I / O processing, and the methods provided by them can open files on the local host and read / write sequentially.

Random access to the file allows random read / write of the contents of the file. In java, the class RandomAccessFile provides a method to randomly access files.

The filter stream can process the data while reading / writing the data, and it provides a synchronization mechanism so that only one thread can access an IUnip O stream at a time, in order to prevent the unexpected results of multiple threads operating on an Imax O stream at the same time. The classes FilterInputStream and FilterOutputStream are the parents of all filtered input streams and output streams, respectively.

Several common filter flows

◇ BufferedInputStream and BufferedOutputStream

The buffer stream is used to improve the efficiency of input / output processing.

◇ DataInputStream and DataOutputStream

Not only can read / write data streams, but also can read / write a variety of java language basic types.

◇ LineNumberInputStream

In addition to providing support for input processing, LineNumberInputStream can record the current line number.

◇ PushbackInputStream

Provides a way to return newly read bytes to the input stream so that you can read them again.

◇ PrintStream

The function of the print stream is to send the built-in type of the Java language to the corresponding output stream in its character representation.

Processing of character stream

Java provides classes that handle character streams represented by 16-bit Unicode codes, that is, a series of classes derived from the base classes Reader and Writer.

The Ⅰ Reader class is the parent class that handles all character stream input classes.

The Ⅱ Writer class is the parent class that handles all character stream output classes.

These two classes are abstract classes that only provide a series of interfaces for character flow processing, cannot generate instances of these two classes, and can only deal with character streams by using subclass objects derived from them. Such as InputStreamReader and OutputStreamWriter;BufferedReader and BufferedWriter.

Object serialization

The life of an object usually ends with the termination of the program that generated the object. Sometimes, you may need to save the state of the object and restore the object when needed. We call the ability of an object to record its own state for future regeneration, called object persistence. Objects record themselves by writing values that describe their state, a process called Serialization of objects. Serialization needs to inherit the Serializable interface. In the java.io package, ObjectInputStream and ObjectOutputStream are provided to extend the data flow function to read-write objects.

Serialize elements that can be saved

Only non-static member variables of the object can be saved, no member methods and static member variables can be saved, and serialization saves only the value of the variable, not any modifier of the variable.

Transient keyword

For some types of objects whose state is transient, such objects cannot save their state, such as a Thread object or a FileInputStream object. For these fields, we must indicate them with the transient keyword.

Custom serialization

In the default serialization mechanism, object serialization first writes information about class data and class fields, and then writes its values in the ascending order of names. If you want to explicitly control the order and type of writing of these values, you must define your own way to read the data stream. Is to override the writeObject () and readObject () methods in the definition of the class.

Note: after using the stream (or file), you must remember that the stream (or file) is closed: in.close (); out.close (); f.close ()

Several common cases of flow class processing (inter-stream combinations):

Ⅰ BufferedInputStream bis = new BufferedInputStream (System.in)

BufferedOutputStream bos = new BufferedOutputStream (new File ("filename"))

Ⅱ InputStreamReader in = new InputStreamReader (System.in)

OutputStreamWriter out = new OutputStreamWriter (new

FileOutputStream ("filename.txt"))

Ⅲ BufferedReader in = new BufferedReader (new InputStreamReader (System.in))

BufferedWriter out = new BufferedWriter (new OutputStreamWriter (new)

FileOutputStream ("filename.txt"))

PrintWriter out = new PrintWriter (new FileWriter ("filename.txt"))

Ⅳ FileInputStream fin = new FileInputStream (filename); /

FileOutputStream fos = new FileOutputStream (new File ("filename"))

Ⅴ DataInputStream din = new DataInputStream (new FileInputStream ("filename.dat")

DataInputStream din = new DataInputStream (newBufferedInputStream (new)

FileInputStream ("filename.dat")

Ⅵ ObjectInputStream s = new ObjectInputStream (new FileInputStream ("filename.ser"))

ObjectOutputStream s = new ObjectOutputStream (new

FileOutputStream ("filename.ser"))

Ⅶ RandomAccessFile inOut = new RandomAccessFile ("filename.dat", "rw")

Basic network technology

Principle:

In the TCP/IP protocol, the IP layer is mainly responsible for the location of the network host and the routing of data transmission. A host on the Internet can be uniquely determined by the IP address. The TCP layer provides application-oriented reliable or unreliable data transmission mechanism, which is the main object of network programming, generally do not need to care about how the IP layer deals with data. At present, the more popular network programming model is the client / server (Cplink S) structure. That is, both sides of the communication wait for the client to make a request and respond as a server. The customer applies to the server when the service is needed. The server generally runs as a daemon all the time, listening to the network port, and once there is a customer request, it will start a service process to respond to the customer, and at the same time, it will continue to monitor the service port, so that the later customers can also get the service in time.

Basic concepts of network

IP address: a network address that identifies a network device, such as a computer, consisting of four 8-bit binary numbers separated by a decimal point.

Hostname (hostname): the mnemonic name of a network address, which is managed according to the domain name.

Port number (port number): identification of different processes on the same machine when communicating on a network.

Type of service (service): various services of the network.

Note: usually there are many processes on a host that require network resources for network communication. The object of network communication is not exactly the host, but the process running in the host. It is obviously not enough to have hostnames or IP addresses to identify so many processes at this point. Port number is a means to provide more network resources on a host, and it is also a mechanism provided by the TCP layer. Only through the combination of hostname or IP address and port number can the object in network communication be uniquely determined: process.

Two types of transport protocols: TCP;UDP

TCP, the abbreviation of Tranfer Control Protocol, is a connection-oriented protocol to ensure reliable transmission. Through the TCP protocol transmission, the result is a sequential error-free data stream. A connection must be established between the two pairs of socket of the sender and receiver in order to communicate on the basis of the TCP protocol. When one socket (usually the server socket) is waiting to establish a connection, the other socket can request a connection. Once the two socket are connected, they can carry out two-way data transmission, and both sides can send or receive operations.

UDP is the abbreviation of User Datagram Protocol and is a connectionless protocol. Each Datagram is an independent information, including a complete source address or destination address, which is transmitted to the destination by any possible path on the network, so whether it can reach the destination, the time of arrival and the correctness of the content can not be guaranteed.

Note: since there is a TCP protocol that ensures reliable transmission, why should there be an unreliable transport UDP protocol? There are two main reasons. First, reliable transmission comes at a price, and the verification of the correctness of data content will inevitably occupy the processing time of the computer and the bandwidth of the network, so the efficiency of TCP transmission is not as high as UDP. Second, it is not necessary to guarantee strict transmission reliability in many applications, such as video conference system, which does not require the absolute correctness of audio and video data, as long as it is consistent. In this case, it is obviously more reasonable to use UDP.

Create a URL

Constructors like URL declare that a non-runtime exception (MalformedURLException) is discarded, so when generating a URL object, we have to handle this exception, usually with a try-catch statement. The format is as follows:

Try {

URL myURL = new URL (...)

} catch (MalformedURLException e) {

....

}

Read WWW network resources from URL

When we get a URL object, we can read the specified WWW resource through it. At this point, we will use URL's method openStream (), which is defined as:

InputStream openStream ()

The method openSteam () establishes a connection with the specified URL and returns an object of the InputStream class to read data from this connection.

Ex: BufferedReader in = new BufferedReader (new InputStreamReader ((new URL (...)) .openStream ()

Connect to WWW through URLConnetction

Class URLConnection provides many methods to set or get connection parameters. GetInputStream () and getOurputStream () are most commonly used in programming, which are defined as:

InputSteram getInputSteram ()

OutputSteram getOutputStream ()

We can communicate with the remote object through the returned input / output stream. Look at the following example:

URL url = new URL ("http://www.javasoft.com/cgi-bin/backwards");

/ / create a URL object

URLConnectin con=url.openConnection ()

/ / get the URLConnection object from the URL object

DataInputStream dis=new DataInputStream (con.getInputSteam ())

/ / URLConnection gets the input stream and constructs the DataInputStream object

PrintStream ps=new PrintSteam (con.getOutupSteam ())

/ / URLConnection gets the output stream and constructs the PrintStream object

String line=dis.readLine (); / / read a line from the server

Ps.println ("client...") ; / / write the string "client..." to the server

Low-level Java Network programming based on Socket (socket)

Two programs on the network exchange data through a two-way communication connection, and one end of this two-way link is called a Socket. Socket is usually used to achieve the connection between the client and the server. Socket is a very popular programming interface of the TCP/IP protocol, and a Socket is uniquely determined by an IP address and a port number.

The general process of Socket communication:

The general connection process of Client/Server programming with Socket is as follows: the server side Listen (listens) whether there is a connection request on a port, the client side sends a Connect (connection) request to the Server side, and the server sends back an Accept (accept) message to the Client side. A connection is established. Both Server and client can communicate with each other through Send,Write and other methods.

For a fully functional Socket, it should include the following basic structure, and its working process includes the following four basic steps:

(1) create a Socket

(2) Open the input / outflow connected to the Socket

(3) read / write Socket according to certain protocols

(4) close Socket.

Note that care must be taken when selecting ports. Each port provides a specific service, and only when the correct port is given can the corresponding service be obtained. The port number of 0room1023 is reserved by the system.

Socket of the client

Try {

Socket socket = new Socket ("127.0.0.1", 8080)

} catch (IOException e) {

System.out.println ("Error:" + e)

}

Server-side ServerSocket

ServerSocket server = null

Try {

Server = new ServerSocket (8080)

} catch (IOException e) {

System.out.println ("can not listener to:" + e)

}

Socket socket = null

Try {

/ / accept () is a blocking method that returns a Socket object to interact with the customer whenever a customer requests it

Socket = server.accept ()

} catch (IOException e) {

System.out.println ("Error:" + e)

}

Opening the input / output class Socket provides methods getInputStream () and getOutStream () to get the corresponding input / output streams for read / write operations, which return InputStream and OutputSteam class objects, respectively. In order to facilitate reading / writing data, we can set up a filter stream on the returned input / output stream object, such as DataInputStream, DataOutputStream or PrintStream class object. For text stream object, we can use InputStreamReader, OutputStreamWriter, PrintWirter and so on.

Close Socket

When each Socket exists, it will take up a certain amount of resources, and when the Socket object is finished, it will be closed. Turn off Socket to call the Close () method of Socket. Before closing Socket, all input / output streams associated with Socket should be closed to free all resources. And pay attention to the order in which you close. All inputs / outputs related to Socket should be closed first, and then Socket.

Datagram (Datagram)

The so-called Datagram, just like the mail system in daily life, cannot guarantee reliable delivery, while the link-oriented TCP is like a phone call, where both parties can be sure that the other has received the message.

The representation of Datagram communication: DatagramSocket;DatagramPacket

Principle:

Two classes, DatagramSocket and DatagramPacket, are provided in the package java.net to support Datagram communication, DatagramSocket is used to establish a communication connection between programs to transmit datagrams, and DatagramPacket is used to represent a Datagram. When writing a client/server program with Datagram, both the client side and the service side must first establish a DatagramSocket object to receive or send datagrams, and then use DatagramPacket class objects as the carrier of data transmission. Before receiving the data, you should use the first method above to generate a DatagramPacket object that gives the buffer and its length of the received data. Then call DatagramSocket's method receive () to wait for the Datagram to arrive, and receive () will wait until a Datagram is received.

DatagramPacket packet=new DatagramPacket (buf, 256)

Socket.receive (packet)

Before sending the data, you also need to make a new DatagramPacket object, so use the second construction method above to give the complete destination address, including the IP address and port number, as well as the buffer area where the data is sent. Sending data is achieved through DatagramSocket's method send (), which finds its path according to the destination address of the Datagram to deliver the Datagram.

DatagramPacket packet=new DatagramPacket (buf, length, address, port)

Socket.send (packet)

The above is the introduction to how to achieve J2SE shared by the editor. If you happen to have similar doubts, you might as well refer to the above analysis to understand. If you want to know more about it, you are welcome to follow the industry information channel.

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.