Java quick start
Java Basics
-
The biggest feature of Java is cross platform
-
Javase (Personal Edition), JavaEE (Enterprise Edition), javame (Micro Edition, for consumer electronics development)
-
Java is similar to Windows
Java running mechanism
-
Running process: source file (. Java) - [javac compiler] --- > bytecode (. Class) - [JVM virtual machine] --- > executable program
-
Relationship between JDK and JRE JVMs
JDK(Java Development Kit)
Debugger, compiler (javac)
JRE(Java Runtime Environment)
Library function
JVM(Java Virtual Mechine)
Java Procedure
Overloading of methods
Definition: same name, different parameters (similar functions are required)
int add(){...}; int add(int a){...}
object-oriented
- Object is similar to a table and consists of attributes and methods
- Object oriented is a kind of designer thinking, assembly
Memory mechanism
- Stack: responsible for function operation, and main starts
- Heap: the part responsible for storing objects
- Method area: responsible for storing the invariant parts of the class (methods, constants)
Garbage collection mechanism
Principle:
- Java's memory management is mostly the release of objects in the heap
- The heap is divided into three parts: young generation (Eden District + Survivor1 District + Survivor2 District), old generation and permanent generation (metadata space)
- There are three kinds of recyclers: Mini GC (responsible for the younger generation), major GC (responsible for the older generation) and full GC (all can be responsible)
- System.gc() can advise the system to perform garbage collection
Algorithm:
- Reference counting method
- Citation reachability method
Static and normal
Common attributes and methods have this pointer (implicit parameter), which distinguishes the same common attributes as local variables, such as this A=a, which is displayed in the constructor when it calls the overloaded constructor, such as
Test(int a, int b){ this.Test(a); ... }
Static attributes and static methods do not have this pointer, but have static construction methods, which are used for the initialization of static attributes, i.e
static{ ... }
package and import
The function of package is to classify and store classes, make them organized, and solve the problem of class homonymy to a certain extent.
There are two types of import
- Import class
import java.lang.Math; //Import Java Lang. math class import java.lang.*; //Import Java All classes under Lang package
- Import static variables or static methods
import java.lang.Math.PI; //Import PI static variables import java.lang.Math.random; //Import random() static method import java.lang.Math.*; //Import all static variables and methods under Math class
Override
requirement:
- ==: the method name and formal parameter list are the same
- < =: return value type, declaration exception type, subclass less than or equal to parent class
- >=: access permission. The subclass is greater than or equal to the parent class
combination
Object holds another object
encapsulation
objective
- High cohesion and low coupling: high cohesion refers to the completion of the internal data operation details of the class, and external interference is not allowed; Low coupling means that only a small number of methods are exposed for external use to facilitate external calls as much as possible. For example: the mobile phone is highly cohesive. All the internship details are encapsulated in the mobile phone shell and run independently. The mobile phone is also low coupling. There are only screens, charging ports, switches and volume adjustment buttons for the outside.
realization
-
private: class friendly
-
(default): in package friendly
-
protected: in bag friendly, father son friendly
-
public: Global friendly
get set method
The general method of encapsulation is to set all properties to private, and then access them externally through the set get function.
polymorphic
For the same method, different objects call different methods
Object type conversion
- Convert up (subclass to parent): automatic conversion
- Convert down (parent to child): force conversion of (subclass type) objects
abstract class
Abstract method: only the method name is not implemented, preceded by abstract.
A class containing abstract methods is an abstract class. An abstract class cannot produce objects, and subclasses must implement the abstract methods of the abstract parent class.
Interface
Basic format:
Control character interface Interface name [extends Interface 1, Interface 2, ...]{ //constant /*public abstract final*/Data type variable name = value; //Abstract method /*public abstract*/Return type method name(parameter list ); //Default method default Return type method name(parameter list ){...} }
An interface is a rule that needs to be implemented by a class
Inner class
Internal class is born for encapsulation and is a concept only available for compilation
There are four internal classes:
-
Member inner class
-
Non static inner class
-
Static inner class
-
-
Anonymous Inner Class
Use it only once, so you don't need a name
- Local inner class
Define classes in methods
array
Array creation
Initialization of array
- initiate static
- dynamic initialization
- Default initialization
Common operations of array
Array traversal
-
for(int i=0; i < array.length; ++i)
-
for(int i:array)
Array copy
Printing, sorting, searching and filling of arrays
Using methods in the Array class
-
Printing: array ToString (array object)
-
Sorting: array Sort (array object). This kind of array object needs to implement the comparable interface, and the compareTo() method in comparable needs to be implemented
-
Find: array Binarysearch (array object, find element)
-
Fill: array Fill (array object, start pos, end pos, fill element)
Two dimensional array
That is, the array of arrays
summary
-
Inclusion relationship of JDK, JRM and JVM
-
.java --javac-->. Class -- JVM -- > executable
-
Basic data classification and reference type (basic data types also have corresponding application types)
-
Classes and objects
-
pacakage Package name; import Package name.Class name(*); import static Package name.Class name.Static method; /* Class members include properties, methods, and inner classes Classes and members have modifiers: 1.public protected default private 2.static final abstract */ public class Class name(Consistent with file name) [extends Parent class name]{ //attribute //Construction method Modifier construction method(parameter list ){ } //method //Static inner class public static class A{ //Static member } //Non static inner class public class B{ } }
-
Storage of classes and objects (JVM memory model)
- Stack (storage method, starting from main method)
- Heap (object)
- Method area (method, static member, constant pool)
-
Interface
public interface Interface name [extends Interface 1, Interface 2, ...]{ [public static final] Type name property name = value; [public abstract] Return type name and method name(parameter list); //Supplementary default method default Return type name and method name(parameter list ); //Supplementary static method static Return type name and method name(parameter list ); }
-
encapsulation
Scope of public protected (default) private
-
inherit
- Class inheritance (single) interface inheritance (multiple)
- super
- Override @ override
-
polymorphic
Deepening and improving Java Foundation
Generics and generic classes
container
Basic structure
-
Collection interface
-
Set interface
- HashSet class
- LinkedHashSet class
- TreeSet class
-
List interface
- ArrayList class
- LinkedList class
- Vector class
-
-
Map interface
- HashMap class
- LinkedHashMap class
- TreeMap class
- Properties class
- HashTable class
Collections interface
//View basic information int size(); boolean isEmpty(); //Add / delete operation boolean add(Object element); boolean addAll(Collections c); boolean remove(Object element); boolean removeAll(Collections c); boolean retainAll(Collections c); //Only elements that intersect with container c are retained void clear(); //see boolean contains(Object element); //Whether to include an element boolean containsAll(Collections c); //iterator Iterator iterator(); //Returns an iterator for container traversal //conversion Object[] toArray();
List interface
Features: orderly + repeatable
//Add operation boolean add(int index, Object element); //Delete operation boolean remove(int index); //Modify operation boolean set(int index, Object element); //Find / view Object get(int index); int indexOf(Object element); int lastIndexOf(Object element);
ArrayList class
characteristic:
- It is realized through array, so the search efficiency is high and the operation efficiency of addition and deletion is low
- Thread unsafe
IO
Basic concepts
Input / output stream
- Input stream: program external -- > internal
- Output stream: program internal -- > external
data source
- Source device: the device that sends data
- Target device: the device that receives data
Node flow, processing flow (packaging flow): like a pipe, a flow can be nested
- Node flows: flows that directly link data sources
- Process flow: a flow that wraps other flows
4 IO abstract classes
byte
- InputStream
method:
int read(); //For byte reading, a decimal number of 0-255 is returned if the reading is successful, and - 1 is returned if the reading is failed void close(); //Close flow
·Subclass:
Node flow: FileInputStream; //Operation file ByteArrayInputStream; //Operation byte array Process flow: ObjectInputStream; //Operation object DataInputStream; //Operation basic data type and string type BufferdInputStream; //Increase cache function to provide efficiency
- OutputStream
method:
void write(int ); //Write a byte void close(); //Close flow
Subclass:
Node flow: FileOuputStream; ByteArrayOuputStream; Process flow: ObjectOutputStream; DataOutputStream; BufferedOutputStream; PrintStream;
character
- Reader
method:
int read(); //For character reading, a decimal number of 0-65535 is returned if the reading is successful, and - 1 is returned if the reading is failed void close(); //Close flow
Subclass:
Node flow: FileReader; Process flow: BufferedReader;
- Writer
method:
void write(int ); //Write a character void close(); //Close flow
method:
Node flow: FileWriter; Process flow: BufferedWriter;
File class
The File class is a wrapper class that handles disk files or directories
method:
//initialization File(String path); //Relative path acquisition method: system Property("user.dir"); //Create file / directory boolean createNewFile(); boolean mkdir(); boolean mkdirs(); //Delete file boolean delete(); //operation String getPath(); ...
Multithreading
Basic concepts
-
Program: executable file (static), which is usually placed on disk and run in memory when needed;
-
Process: a process is a run of a program in memory, which monopolizes a piece of memory space and is composed of several threads (at least one), code and data;
-
Thread: a thread is a linear execution unit running in a process. Data is shared between threads in the same process (sharing and mutual exclusion problem occurs)
-
Main thread: the thread that starts with the main method
-
Sub thread: a new thread created by the main method
Threads in java
Thread
Runnable
Thread control
- Thread end
- Thread pause
- sleep(long s); Enter the blocking state and return to the ready state after a certain time
- yeild(); Enter the ready state and give cpu resources to other threads of the same priority
Thread Union
join function. The added thread can run only after the added thread runs
thread priority
t.setPriority(5); t.start(); System.out.println(t.getPriority());
Daemon thread
Threads are divided into user threads and guard threads. Guard threads are used to serve user threads, such as garbage collection. If the user thread dies, the guard thread also dies.
Thread synchronization
Basic knowledge of thread synchronization
java implementation of thread synchronization
- Member variable
synchronized(Member variable object name){ //Code blocks that need to be synchronized }
- this
synchronized(this){ //Code blocks that need to be synchronized } synchronized public void func(){ }
- Class name class
synchronized(Class name.class){ //Code blocks that need to be synchronized } synchronized public static void func(){ //Code blocks that need to be synchronized }
Concurrent collaboration of threads
Model: Producer (thread) - > [buffer] -- > consumer (thread)
effect
- Logically realize the separation of survivor thread and consumer thread, and release the coupling between them
- The speed between producer thread and consumer thread is coordinated to improve efficiency
Communication between threads
- wait
- notify
- notifyAll
Communication + syn mechanism can realize the producer consumer model
Network programming
Basic concepts
computer network
A system that links computers in different places through communication lines and realizes computer resource sharing and information communication under the management and coordination of network operating system, network management software and network communication protocol
Network communication protocol
- Agreement: standards and rules. Similarly, the communication between humans needs a common language, and the information exchange between computers also needs the same set of rules.
- Computer communication is too complex, so it is layered, including IOS model (Theory) and TCP/IP model (industry). Each layer has a corresponding protocol.
- Under the guidance of the model, the communication between computers is a process of layer by layer packaging (sender) and then layer by layer splitting (receiver).
Encapsulation (splitting) and unpacking (merging) of data
why: the amount of data is too large to be transmitted at one time. It needs to be sent in order after segmentation;
what: the sender splits and encapsulates the data layer by layer until the physical media is transmitted, and the receiver splits the received data
how: because each layer of encapsulation and unpacking is a principle, we only discuss one layer here. The function of layer i is to transmit the data provided by layer i+1. The sender first splits the data PUD from the upper layer and then packages it, transmits it by using the service established at the lower layer, and then merges it after the receiver receives the data.
IP address and port number
- IP: identify computer
- Port number: identifies the service
URL
Composition: HTTPS (Protocol) 😕/ www.baidu. Com (domain name) [port number] / index HTML (file)
Role: identify computer resources (directories, files, references to complex objects)
Socket
Function: it creates a bridge between the application layer and the transport layer. It is the programming interface provided by the transport layer, so that the application can communicate with the network
TCP UDP
TCP
Located in the transport layer, reliable transmission mode, establish virtual link, disconnect virtual link, similar to making a phone call
3 handshakes and 4 waves
UDP
It is located in the transmission layer and is not reliable
Common classes in Java network programming
Socket programming sequence
-
The server creates a ServerSocket object and sets the listening interface;
-
The ServerSocket object calls the accept() method and keeps it in a blocking state, waiting for the link from the client;
-
The client creates a Socket object and sets the IP and Port to connect to the server;
-
The client sends a request, and the client establishes a link with the server;
-
Obtain the built InputStream and OutStream stream objects of the client and server through the Socket object;
-
Streaming data between client and server;
-
Close stream close Socket object
-
Information: the posts are limited and will disappear too late. Therefore, we should grasp the time. The two opportunities should be faster. It is expected to be cast before March 20
-
Is there any danger of interview or interview failure? No, it's beneficial. It's good to exercise your courage and learn interview experience! So don't be afraid and interview boldly