Compilation of common Java interview questions

What are the characteristics of object-oriented?

The so-called encapsulation is to encapsulate objective things into abstract objects Class, and the class can allow its own data and methods to be operated only by trusted classes or objects, and hide information from untrusted ones. Encapsulation is one of the characteristics of object-oriented and the main characteristic of the concepts of objects and classes. (Recommended study: java common interview questions)

Inheritance means that the subclass obtains the attributes and methods of the parent class. For example, if a dog is a type of animal, it can also be said that it inherits the characteristics of the animal, or that the dog is a subclass of the animal.

Polymorphism means that a method can only have one name, but it can have many forms. That is, multiple methods with the same name can be defined in the program, which is described by "one interface, multiple methods". You can pass Method parameters and type references

Five principles: Single Responsibility Principle SRP Open and Closed Principle OCP Replacement Principle LSP Dependency Principle DIP Interface Separation Principle ISP

Member variables and local variables The difference

* A: Different positions in the class

* Member variables: outside the methods in the class

* Local variables : In the method definition or method declaration

* B: Different locations in the memory

* Member variables: In the heap memory (member variables belong to objects, objects into heap memory)

* Local variables: in stack memory (local variables belong to methods, methods are pushed into stack memory)

* C: different life cycles

* Member variables: exist when the object is created and disappear when the object disappears

* Local variables: exist when the method is called and disappear when the method is called

* D: Different initialization values

* Member variables: have default initialization values

* Local variables: no default initialization values, must be defined, assigned, and then can be used.

The difference between static variables and member variables

* Static variables are also called class variables. Member variables are also called object variables

* A: Different ownership

* Static variables belong to classes, so they are also called class variables

* Member variables belong to objects, so they are also called instance variables (object variables)

* B: Different locations in memory

* Static variables are stored in the static area of ​​the method area

* Member variables are stored in the heap memory

* C: Memory appearance time is different

* Static variables are loaded as the class is loaded, and disappear as the class disappears

* Member variables follow the object's It exists when it is created and disappears when the object disappears

* D: Different calls

* Static variables can be called through class names or through objects

* Member variables can only be called through the object name

The difference and application of this and super

* A: What do this and super stand for

* this: represents the reference of the current object, whoever calls me, I will represent that person

* super: represents the reference of the parent class of the current object

* B: The difference between the use of this and super

* a: Calling member variables

* this. Member variables call member variables of this class or of the parent class Member variable

* super. Member variable calls the member variable of the parent class

* b: Calls the constructor method

* this(...) calls the constructor method of this class

* super(...) calls the constructor method of the parent class

* c: calls the member method

* this. The member method calls the member method of this class, also You can call the method of the parent class

*super.Member method calls the member method of the parent class

What are the methods of sorting? Please list the

sorting methods: insertion sort (direct insertion sort, Hill sort), exchange sort (bubble sort, quick sort), selection sort (direct selection sort, heap sort), Merge sort, distribution sort (box sort, radix sort)

Pseudo code of quick sort.

The difference between String, StringBuffer and StringBuilder.

The length of String is immutable;

The length of StringBuffer is variable. If you frequently operate on the content in the string, especially if the content is When modifying, use StringBuffer. If String is needed in the end, use StringBuffer's toString() method; thread safety;

StringBuilder is starting from JDK 5 and adds an equivalent method for single thread use to the StringBuffer class. class; you should generally use the StringBuilder class in preference because it supports all the same operations, but is faster because it does not perform synchronization.

The difference between Overload and Override. Can an Overloaded method change the type of return value?

Answer: Method overriding Overriding and overloading Overloading are different manifestations of Java polymorphism.

Overriding is a manifestation of polymorphism between parent classes and subclasses, and overloading is a manifestation of polymorphism in a class. If a method defined in a subclass has the same name and parameters as its parent class, we say the method is overriding.

When an object of a subclass uses this method, the definition in the subclass will be called. For it, the definition in the parent class seems to be "shielded". If multiple methods with the same name are defined in a class, and they have different number of parameters or different parameter types, it is called method overloading. Overloaded method can change the type of return value.

What is the difference between final and finally?

Answer: final: modifier (keyword); if a class is declared final, it means that it cannot Derived new subclasses cannot be inherited as parent classes, so a class cannot be declared both abstract and final; declaring variables or methods as final ensures that they will not be changed during use. ; Variables declared as final must be given an initial value when declared, and can only be read in subsequent references and cannot be modified; methods declared as final can also only be used and cannot be overloaded.

finally: Provide a finally block to perform any cleanup operations during exception handling; if an exception is thrown, the matching catch clause will be executed, and then control will enter the finally block (if any ).

Several common operating abnormalities.

java.lang.nullpointerexception (null pointer exception)

java.lang.classnotfoundexception (the specified class does not exist)

java.lang.arithmeticexception (mathematical Operation exception)

java.lang.arrayindexoutofboundsexception (array subscript out-of-bounds exception)

IOException (input and output exception)

Two common problems with array operations are out-of-bounds and empty Pointer

* A:Case demonstration

* a:ArrayIndexOutOfBoundsException: Array index out of bounds exception

* Reason: You accessed a non-existent index.

* b: NullPointerException: Null pointer exception

* Reason: The array no longer points to the heap memory. And you also use array names to access elements.

* int[] arr = {1,2,3};
* arr = null;
* System.out.println(arr[0]);

How does JAVA language handle exceptions? What do the keywords: throws, throw, try, catch, and finally mean? Can exception be thrown in try block?

Answer: Java handles exceptions through object-oriented methods, classifies various exceptions, and provides a good interface.

In Java, each exception is an object, which is an instance of the Throwable class or other subclasses. When an exception occurs in a method, an exception object is thrown. The object contains exception information. The method of calling this object can catch the exception and handle it.

Java's exception handling is implemented through 5 keywords: try, catch, throw, throws and finally. Generally, try is used to execute a program. If an exception occurs, the system will throw an exception. At this time, you can catch it by its type, or finally by the default handler. to handle.

Use try to specify a program that prevents all "exceptions". Immediately after the try program, a catch clause should be included to specify the type of "exception" you want to catch.

Thethrow statement is used to explicitly throw an "exception".

throws is used to indicate various "exceptions" that a member function may throw.

Finally ensures that a piece of code is executed no matter what "exception" occurs.

You can write a try statement outside a member function call, and write another try statement inside the member function to protect other code. Whenever a try statement is encountered, the "exception" frame is placed on the stack until all try statements are completed.

If the next level try statement does not handle a certain "exception", the stack will expand until it encounters a try statement that handles this "exception".

When the server receives the form data submitted by the user, does it call the Servlet's doGet() or doPost() method?

Answer: The

element of HTML has a method attribute, which is used to specify the method of submitting the form. Its value can be get or post.

Our custom Servlet will generally override one or both of the doGet() or doPost() methods. If it is a GET request, it will call the doGet() method. If it is a POST request, it will call doPost. () method, then why is this happening?

Our custom Servlet usually inherits from HttpServlet, HttpServlet inherits from GenericServlet and overrides the service() method, which is defined in the Servlet interface.

The service() method rewritten by HttpServlet will first obtain the method requested by the user, and then call doGet(), doPost(), doPut(), doDelete() and other methods according to the request method. If you are customizing the Servlet If these methods are overridden in , then the overwritten (customized) methods will obviously be called, which is obviously an application of the template method pattern (if you don't understand, please refer to Chapter 37 of the book "Java and Patterns") .

Of course, the service() method can also be directly rewritten in a custom Servlet, so no matter what kind of request it is, it can be processed through your own code, which is more suitable for scenarios where the request method is not distinguished.

What is the difference between abstract class and interface?

Interface is a variant of abstract class, and all methods in the interface are abstract. An abstract class is a class that declares the existence of a method without implementing it.

Interfaces can have multiple inheritance, but abstract classes cannot.

Interfaces define methods but cannot implement them, while abstract classes can implement some methods.

The basic data type in the interface is static but the abstract image is not.

Memory leak and memory overflow?

Memory leak: It means that after the application applies for memory, it cannot release the memory space it has applied for. The harm of a memory leak can be ignored, but if it is allowed to develop, it will lead to memory overflow.

For example: after reading the file, the stream must be closed in time and the database connection must be released.

Memory overflow: It means that when the application applies for memory, there is no final memory space for it to use.

For example: We import large batches of data in the project using segmented batch submission.

What is thread synchronization?

1. The purpose of thread synchronization is to protect resources from being damaged when multiple threads query a resource.

2. The thread synchronization method is implemented through locks. Each object has only one lock. This lock is associated with a specific object. Once a thread acquires the object lock, other threads accessing the object You can no longer access other non-synchronized methods of the object.

3. For static synchronization methods, the lock is for this class, and the lock object is the Class object of this class. The locks of static and non-static methods do not interfere with each other. When a thread acquires a lock and accesses a synchronized method on another object in a synchronized method, it will acquire the two object locks.

4. For synchronization, it is key to always be aware of which object to synchronize on.

5. When writing thread-safe classes, you need to always pay attention to making correct judgments on the logic and safety of multiple threads competing to access resources, analyze "atomic" operations, and ensure that other operations during atomic operations are The thread cannot access the competing resource.

6. When multiple threads are waiting for an object lock, the thread that has not acquired the lock will be blocked.

7. Deadlock is caused by threads waiting for each other to lock. The probability of occurrence in practice is very small. If I really ask you to write a deadlock program, it may not work, haha. However, once a deadlock occurs in the program, the program will die.

Understanding of multi-threading?

The same thing, done by different people, is multi-threading.

When cooking in the cafeteria, one person is single-threaded. Opening N windows and N people eating at the same time is multi-threading.

The basic concept of threads, the basic status of threads, and the relationship between states Relationship:

Thread refers to an execution unit that can execute program code during program execution. Each program has at least one thread, which is the program itself. Threads in Java have four states: running, ready, suspended, and ended.

What collections are there?

List features: elements are put in order, elements can be repeated

Map features: elements are stored in key-value pairs, no putting order

Set features: elements There is no putting order, and elements cannot be repeated (note: although there is no putting order for elements, the position of the element in the set is determined by the HashCode of the element, and its position is actually fixed)

The List interface has three Implementation classes: LinkedList, ArrayList, Vector

LinkedList: The bottom layer is implemented based on a linked list. The linked list memory is scattered. Each element stores its own memory address and also stores the address of the next element. Linked lists are fast to add and delete, but slow to search.

The difference between ArrayList and Vector: ArrayList is non-thread-safe and has high efficiency; Vector is based on thread-safety and has low efficiency

The Set interface has two implementation classes: HashSet (the bottom layer is implemented by HashMap), LinkedHashSet

SortedSet interface has an implementation class: TreeSet (the bottom layer is implemented by balanced binary tree)

The Query interface has an implementation class: LinkList

The Map interface has three implementation classes: HashMap, HashTable, LinkeHashMap

HashMap is not thread-safe, efficient, and supports null; HashTable is thread-safe, inefficient, and does not support null

SortedMap has an implementation class: TreeMap

In fact, the most important thing is that list is used to process sequences, while set is used to process sets. Map is the basic class that stores key-value pairs

File reading and writing:

File Reader class and FileWriter class inherit from Reader class and Writer class respectively. The FileReader class is used to read files, and the File Writer class is used to write data to files. Before using these two types, you must call their construction methods to create the corresponding objects, and then call the corresponding read() or write() method.

The above is the detailed content of Compilation of common Java interview questions. For more information, please follow other related articles on the PHP Chinese website!