Basic Java interview questions (3)

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.                              (Recommended study: java interview questions)

Every time NewString is written, a new object is created. It 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 is 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.

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 Character data for characters. The String class provides numerically immutable strings. The string provided by this StringBuffer class can be modified.

You can use StringBuffer when you know that the character data is going to change. Typically, you use StringBuffers to dynamically construct character data.

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 compiles expressions that can directly add string constants. To optimize, you do not need 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.

There is a return statement in try {}, so will the code in finally{} immediately following the 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 more To be precise, it should be executed in the middle of return. Please see the execution 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;
       }
    }
  
}

---------Execution result---------

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 will not run anymore, your main function can continue to run. There is no result at all. The result is put into the jar before saying this.

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.

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.

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.

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, and the object contains 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 overcome and recover from, which is divided into system exceptions and ordinary exceptions:

System exceptions are the software itself Problems caused by defects are problems caused by poor consideration by software developers. Software users cannot overcome and recover from this problem, but under such problems, they can still allow the software system to continue running or make the software hang.

For example, array script out-of-bounds (ArrayIndexOutOfBoundsException), null pointer exception (NullPointerException), class conversion exception (ClassCastException);

Ordinary exceptions are problems caused by changes or exceptions in the running environment, and are Problems that users can overcome, such as network disconnection and insufficient hard disk space, should not cause the program to die after such exceptions occur.

Java provides different solutions for system exceptions and ordinary exceptions. The compiler forces ordinary exceptions to be handled by try..catch or continued to be thrown to the upper layer calling method with a throws statement, so ordinary exceptions are also It is called a checked exception, 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.

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 Just allocate memory space for this variable on the stack. 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 generating an array or object in the heap, you can also define a special variable in the stack, so that the value of this variable in the stack is equal to the first address of the array or object in the heap memory. The stack This variable in becomes a reference variable of the array or object. In the future, 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.

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 type range is from -128 to 128.

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