Java basic interview questions (1)

1. Can a ".java" source file include multiple classes (not internal classes)? What are the restrictions?

There can be multiple classes, but there can only be one public class, and the public class name must be consistent with the file name.

(More interview question recommendations: java interview questions and answers)

2. Does Java have goto?

Reserved words in java are not used in java now.

3. Talk about the difference between & and &&.

& and && can be used as logical AND operators, indicating logical AND (and). When the results of the expressions on both sides of the operator are true, the entire operation result is true. Otherwise, as long as If one of the parties is false, the result is false.

&& also has the function of short-circuiting, that is, if the first expression is false, the second expression will no longer be evaluated, for example, for if(str!= null&& !str.equals(s)) Expression, when str is null, the following expression will not be executed, so NullPointerException will not occur. If && is changed to &, NullPointerException will be thrown. If(x==33 & y>0) y will grow, If(x==33 && y>0) will not grow

& can also be used as a bit operator, when the & operator on both sides When the expression is not of boolean type, & represents a bitwise AND operation. We usually use 0x0f to perform the & operation with an integer to obtain the lowest 4 bits of the integer. For example, the result of 0x31 & 0x0f is 0x01.

4. How to get out of the current multiple nested loops in JAVA?

In Java, if you want to jump out of multiple loops, you can define a label before the outer loop statement, and then use the break statement with the label in the code of the inner loop body to jump out of the outer loop. .

For example:

for(int i=0;i<10;i++){
   for(intj=0;j<10;j++){
       System.out.println(“i=” + i + “,j=” + j);
       if(j == 5) break ok;
   }
}

In addition, I personally don’t usually use labels. Instead, I allow the results of the outer loop conditional expression to be controlled by the inner loop body code. For example, you want to find a number in a two-dimensional array.

int arr[][] ={{1,2,3},{4,5,6,7},{9}};
boolean found = false;
for(int i=0;i<arr.length&&!found;i++)       {
        for(intj=0;j<arr[i].length;j++){
              System.out.println(“i=” + i + “,j=” + j);
              if(arr[i][j] ==5) {
                      found =true;
                      break;
              }
        }
}

(Recommended study: java introductory tutorial)

5. Can the switch statement act on byte, can it act on long, and can it act on String Above?

In switch(e), e can only be an integer expression or enumeration constant (larger font). The integer expression can be the int basic type or the Integer wrapper type. Due to byte, short , char can be implicitly converted to int, so these types and packaging types of these types are also possible. Obviously, neither long nor String types conform to the syntax of switch and cannot be implicitly converted to int type, so they cannot be used in switch statements.

It is wrong to say whether the switch statement can be used on String. This writing method is already supported after Java 1.7!

6. short s1= 1; s1 = (s1 1 is int type, and the left side of the equal sign is short type, so it needs to be forced) 1 1; What’s wrong? short s1 = 1; s1 = 1;What's wrong? (Nothing wrong)

For short s1= 1; s1 = s1 1;Since s1 1 will automatically promote the type of expression during operation, the result is int type, and then assigned to short When type s1, the compiler will report an error requiring a type cast.

For short s1= 1; s1 = 1; since = is an operator specified in the java language, the java compiler will perform special processing on it, so it can be compiled correctly.

7. Can a Chinese character be stored in a char variable? Why?

The char variable is used to store Unicode-encoded characters. The Unicode-encoded character set contains Chinese characters, so , of course Chinese characters can be stored in char type variables. However, if a special Chinese character is not included in the unicode encoding character set, then the special Chinese character cannot be stored in this char variable. Additional explanation: Unicode encoding occupies two bytes, so variables of type char also occupy two bytes.

8. Use the most efficient method to calculate what is 2 multiplied by 8?

2<< 3, (left shift by three places) Because shifting a number to the left by n places, It is equivalent to multiplying 2 to the nth power. Then, when multiplying a number by 8, you only need to shift it to the left by 3 bits. Bit operations directly supported by the CPU are the most efficient. Therefore, what is the most efficient number of 2 multiplied by 8? The method is 2<<3.

9. When using the final keyword to modify a variable, does the reference cannot be changed or the referenced object cannot be changed?

When using the final keyword to modify a variable, it means that the reference variable cannot be changed, but the content of the object pointed to by the reference variable can still be changed. For example, for the following statement:

finalStringBuffer a=new StringBuffer("immutable");

Executing the following statement will report a compile-time error:

a=new StringBuffer("");

However, executing the following statement will compile:

a.append(" broken!");

When someone defines the parameters of a method, they may want to use the following form to prevent the method from modifying the parameter object passed in:

public void method(final  StringBuffer param){
}

Actually, this is not possible, and it can still be added inside the method. Use the following code to modify the parameter object:

param.append("a");

(Learning video recommendation: java course)

10. What is the difference between static variables and instance variables?

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，永远都只分配了一个staticVar变量，并且每创建一个实例对象，这个staticVar就会加1；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。

public class VariantTest{
        publicstatic int staticVar = 0;
        publicint instanceVar = 0;
        publicVariantTest(){
              staticVar++;
              instanceVar++;
              System.out.println(staticVar +instanceVar);
        }
}

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