JAVA技术面试

内部类和匿名内部类

public class MyOuterClass {
    int i=10;
   class MyInnerClass{
       int i=20;
       public void myMethod(){
           int i=30;
           System.out.println(i); // 30
           System.out.println(this.i); //20
           System.out.println(MyOuterClass.this.i); //10  外部类.this. 成员变量（仅适用于非 static 修饰的内部类）}
   }

    public static void main(String[] args) {//        MyInnerClass innerClass=new MyInnerClass();
        MyOuterClass.MyInnerClass innerClass=new MyOuterClass().new MyInnerClass();
        innerClass.myMethod();}
}

输出如下图所示：

此处的内部类主要注意几点：
1、非静态关键字修饰的内部类，需要通过外部类的调用进行实例化，不能直接实例化，否则再编译时会报错。（被静态关键字修饰的则可以。）
2、这里主要注意调用该变量的对象是谁，即 this 这个对象是属于哪个类即是哪个类的变量被调用了。

匿名内部类：隐藏的继承了一个类（可以是普通类、抽象类，不能是被 final 修饰的类），或者实现了一个接口。

首先请看下面这一段代码：

public class Demo01 {

    //String str =“zs”public static boolean empty(String str){return str.isEmpty() ;
    }

    public static long empty2(Date date){return date.getTime();   //2020 - 09-19 12:22:55   -  1970.-1-1 0:0:0.000
    }

    public static void main(String[] args) {System.out.println(empty(     new String()  )) ;
        System.out.println(empty(     new String(){})) ;  // 这里提示 final 修饰的类不能被继承


        System.out.println(empty2(new Date()) );
         empty2(new Date(){});



    }

}

当我们给 new String()后加一个 {} 时会提示这里的 final 修饰的类不能被继承。其实这里加上一个 {} 后就变成了继承 String 类的子类，只不过这个子类是没有名字的，而 String 类是被 final 修饰的所以不能够被继承。

关于内部类的使用：

常常使用一个方法，使其返回值为某个类或接口的对象。而这个类或接口在方法内部创建

// 常常使用一个方法，使其返回值为某个类或接口的对象。而这个类或接口在方法内部创建
    // 方式一、不使用匿名内部类
    public Comparable getComparable(){
        //1、创建一个实现 Comparable 接口的类：局部内部类
        class MyComparable implements Comparable{

            @Override
            public int compareTo(Object o) {return 0;}
        }
        return new MyComparable();}

    // 常常使用一个方法，使其返回值为某个类或接口的对象。而这个类或接口在方法内部创建
    // 方式二、使用匿名内部类
    public Comparable getComparable01(){
        //1、创建一个实现 Comparable 接口的类：局部内部类
      return   new Comparable(){

            @Override
            public int compareTo(Object o) {return 0;}
        };
        
    }

包装类的自动拆箱和装箱

int  Integer

byte Byte

short Short

long Long

float Float

double Double

boolean Boolean

这个知识点涉及到的面试主要有两个地方：

1、自动拆箱和装箱时什么意思。如下所示: 装箱就是可以实现将普通类型到变量自动转换成与它对应的引用类型的变量，拆箱则相反.
   Integer i = 10 ; // 自动装箱：包装类  = 基本类型

   int j = i ;// 自动拆箱：基本类型 = 包装类 
2、在自动装箱时当 int 类型的变量超过它的范围时装箱时会发生什么情况。默认范围: 以 Integer 为例，在自动装箱时，如果判断 整数值的范围在 [-128,127] 之间，则直接使用 整形常量池中的值；如果不在此范围，则会 new 一个新的 Integer();
  
这里面试时主要会考如下代码：Integer n1 =  100 ; //Integer = int   ;int ->Integer,  自动装箱
        Integer n2 =  100 ;
        Integer n3 =  1000 ; //Integer n3 = new Integer(1000) ;
        Integer n4 =  1000 ; //Integer n4 = new Integer(1000) ;
        System.out.println(n1 == n2);
        System.out.println(n3 == n4);
 第一个输出为 true ,  第二个输出为 false。

泛型

List<Object> objs = new ArrayList<Object> (); 对

List<Object> objs = new ArrayList<String> (); 错

List<?> objs = new ArrayList<String> (); 对

List<?  extends Object> objs = new ArrayList<String> (); 对

List<?  extends String> objs = new ArrayList<String> (); 对, 在考虑泛型时，不用考虑 final