Java high-frequency basic interview questions——(2)

The content of the interview questions is as follows:

(Recommended related interview questions: java interview questions and answers)

1. String s = new String("xyz"); How many StringObjects are created? Is it possible to inherit the String class?

Both or one is possible. "xyz" corresponds to an object. This object is placed in the string constant buffer. The constant "xyz" will always appear no matter how many times it appears. is the one in the buffer. Each time NewString is written, a new object is created, which uses the contents of the constant "xyz" object to create a new String object.

If 'xyz' has been used before, then "xyz" will not be created here, and it will be taken directly from the buffer. At this time, a StringObject will be created; but if "xyz" has not been used before, then At this point an object is created and placed in the buffer, in which case it creates two objects. As for whether the String class is inherited, the answer is no, because String is final-modified by default and is not inheritable.

2. The difference between String and StringBuffer

The JAVA platform provides two classes: String and StringBuffer, which can store and operate strings, that is, contain multiple characters. character data. The String class provides numerically immutable strings. The string provided by this StringBuffer class can be modified. You can use StringBuffer when you know the character data is going to change. Typically, you use StringBuffers to dynamically construct character data.

3. How many objects are created in total by the following statement: String s="a" "b" "c" "d";

For the following code:

String s1 = "a";
String s2 = s1 + "b";
String s3 = "a" + "b";
System.out.println(s2 == "ab");
System.out.println(s3 == "ab");

The first statement prints a result of false, and the second statement prints a result of true. This shows that javac compilation can optimize expressions that directly add string constants. It is necessary to wait until runtime to perform the addition operation. Instead, remove the plus sign during compilation and directly compile it into a result of connecting these constants.

The first line of code in the question is optimized by the compiler at compile time, which is equivalent to directly defining a string of "abcd". Therefore, the above code should only create a String object. Write the following two lines of code,

String s ="a" + "b" +"c" + "d";
System.out.println(s== "abcd");

The final printed result should be true.

4. There is a return statement in try {}, so will the code in finally{} immediately following this try be executed? When will it be executed? Before or after return? ?

We know that the statement in finally{} will definitely be executed, so this may be blurted out normally before return, and this method may come out after return. Who knows where it went? But it is more accurate to execute it in the middle of return. Please see the running result of the following program code:

public classTest {
    public static void main(String[]args) {
       System.out.println(newTest().test());;
    }
    static int test()
    {
       intx = 1;
       try
       {
          returnx;
       }
       finally
       {
          ++x;
       }
    }
  
}
---------执行结果 ---------
1

The running result is 1. Why? The process of the main function calling the sub-function and getting the result is like the main function preparing an empty jar. When the sub-function wants to return the result, it first puts the result in the jar, and then returns the program logic to the main function. The so-called return means that the sub-function says, "I won't run it anymore. Let your main function continue to run. There is no result at all. The result is put into the jar before saying this."

(Video tutorial recommendation: java course)

5. The difference between final, finally, and finalize.

final is used to declare properties, methods and classes, which respectively means that properties are immutable, methods cannot be overridden, and classes cannot be inherited. For inner classes to access local variables, local variables must be defined as final type.

Finally is part of the exception handling statement structure, which means it is always executed.

Finalize is a method of the Object class. This method of the recycled object will be called when the garbage collector is executed. This method can be overridden to provide other resource recycling during garbage collection, such as closing files, etc. However, the JVM does not guarantee that this method will always be called

6. What are the similarities and differences between runtime exceptions and general exceptions?

Exceptions represent abnormal conditions that may occur during program running. Runtime exceptions represent exceptions that may be encountered in the normal operation of a virtual machine and are a common operating error. The Java compiler requires that methods must be declared to throw non-runtime exceptions that may occur, but it is not required to be declared to throw uncaught runtime exceptions.

7. What is the difference between error and exception?

error indicates a serious problem when recovery is not impossible but difficult. For example, memory overflow. It is impossible to expect a program to handle such a situation. exception represents a design or implementation problem. That is, it represents a situation that would never occur if the program were running normally.

8. Briefly talk about the simple principles and applications of the exception handling mechanism in Java.

Exceptions refer to abnormal situations or errors that occur when a Java program is running (not compiled). It is very similar to events in real life. Events in real life can include the time, place, character, plot, etc. of the event. Information can be represented by an object. Java uses an object-oriented approach to handle exceptions. It encapsulates each exception that occurs in the program into an object to represent it. The object contains the exception information.

Java classifies exceptions. Different types of exceptions are represented by different Java classes. The root class of all exceptions is java.lang.Throwable, and two subclasses are derived from Throwable:

Error and Exception, Error represents a serious problem that the application itself cannot overcome and recover. The program will only crash. For example, system problems such as memory overflow and thread deadlock.

Exception indicates a problem that the program can still overcome and recover, which is divided into system exceptions and ordinary exceptions:

System exceptions are problems caused by defects in the software itself, that is, software Problems caused by developers' poor consideration cannot be overcome and recovered by software users. However, under such problems, the software system can continue to run or the software hangs. For example, array script out-of-bounds (ArrayIndexOutOfBoundsException), empty Pointer exception (NullPointerException), class conversion exception (ClassCastException);

Common exceptions are problems caused by changes or exceptions in the operating environment, and are problems that users can overcome, such as network disconnection, insufficient hard disk space, After such an exception occurs, the program should not die.

Java provides different solutions for system exceptions and ordinary exceptions. The compiler forces ordinary exceptions to be processed by try..catch or continued to be thrown to the upper layer calling method with a throws statement, so ordinary exceptions are also called checked. Exceptions, and system exceptions can be processed or not. Therefore, the compiler does not force try..catch processing or throws declaration, so system exceptions are also called unchecked exceptions.

(Recommended tutorial: java introductory tutorial)

9. What is the difference between heap and stack in Java?

The heap and stack in JVM belong to different memory areas and are used for different purposes. The stack is often used to store method frames and local variables, while objects are always allocated on the heap. The stack is usually smaller than the heap and is not shared among multiple threads, whereas the heap is shared by all threads in the entire JVM.

Stack: Some basic types of variables and object reference variables defined in the function are allocated in the stack memory of the function. When a variable is defined in a block of code, Java will assign it to the stack on the stack. Variables allocate memory space. When the scope of the variable is exceeded, Java will automatically release the memory space allocated for the variable, and the memory space can be immediately used for other purposes.

Heap: Heap memory is used to store objects and arrays created by new. The memory allocated in the heap is managed by the automatic garbage collector of the Java virtual machine. After an array or object is generated in the heap, you can also define a special variable in the stack, so that the value of the variable in the stack is equal to the first address of the array or object in the heap memory. This variable in the stack becomes After obtaining the reference variable of the array or object, you can use the reference variable in the stack to access the array or object in the heap in the program. The reference variable is equivalent to giving a name to the array or object.

10. Can int be coerced into a byte type variable? What will happen if the value is larger than the range of the byte type?

We can do forced conversion, but int in Java is 32 bits, and byte is 8 bits. Therefore, if forced conversion, the high 24 bits of the int type will be discarded, because byte The range of types is from -128 to 127.

The above is the detailed content of Java high-frequency basic interview questions——(2). For more information, please follow other related articles on the PHP Chinese website!