（一）常问基础小点

1、&与&&，｜与｜｜

&与&&：只有两边都是true时，结果才是true；

不同之处：&两边都要运算，&&先算左侧，左侧false则右侧不计算；

 

｜与｜｜与上述类似，当两边计算结果至少有一个是true时，结果才是true；

不同之处：｜两边都要运算，｜｜先算左侧，左侧true则右侧不计算；

2、最有效计算2乘以8

原理：位运算时CPU直接支持的，效率高

8是2的3次方，2*8 == 2<<3

1 //常见的JDK源码⾥⾯HashMap的默认容量16
2 //1<<4，就相当于 1 * 2的4次方，1*16
3 int DEFAULT_INITIAL_CAPACITY = 1 << 4; 

3、两个int值互换

面试官考察：+-和异或

方法一：加减法，求和后相互做差；

     System.out.printf("a=%d, b=%d",a,b);
     a = a + b;
     b = a - b ;
     a = a - b;
     System.out.printf("\na=%d, b=%d",a,b);
 }

方法二：异或，⼀个数 与另一数 异或两次 是本身，与本身异或是0；

     System.out.printf("a=%d, b=%d",a,b);
     a = a^b; //a1 = a^b
     b = b^a; //b = b^a^b 是a
     a = a^b; //a = a1^b = a^b^a
     System.out.printf("\na=%d, b=%d",a,b);
 }

4、java语言的基础类型（1 个字节 8 位）

基础数据类型：byte、short、int、long、float、double、char、boolean

除上述，其他均是引用类型（String，Enum）

数据类型	名称	字节	默认值	位数	取值范围
byte	位	1	0	8	-2^7 - 2^7-1
short	短整型	2	0	16	-2^15 - 2^15-1
int	整型	4	0	32	-2^31 - 2^31-1
long	长整型	8	0	64	-2^63 - 2^63-1
float	单精度	4	0.0	32	-2^31 - 2^31-1
double	双精度	8	0.0	64	-2^63 - 2^63-1
char	字符	2	空	16	-2^15 - 2^15-1
boolean	布尔	1	false	8	true/false

 

5、自增/自减运算符

int i = 5;
return i++; 
// 先返回，再操作 5

return ++i;
// 先操作，再返回 6

6、try-catch-finally 

try {
     //...
 } catch (ArithmeticException e) {
     a = 3;
     return a;
 } finally {
     a = 4;
 }
//返回结果是3

try {
     //...
 } catch (ArithmeticException e) {
     a = 3;
     return a;
 } finally {
     a = 4;
    return a;
 }
//返回结果是4

如果存在finally代码，先执行finally中的代码 后执行catch中代码；

如果finally有return，则会执行finally中的return，如果finally中无但之前有，则会先确定返回值，而后再执行finally中的代码；

即：finally代码是必执行，finally语句比catch语句先执行，finally的return优先级更高，但若执行catch中的return则会先确定返回值；

7、try-witch-resource

try()中定义的资源，在try-catch结束后会自动关闭，JDK1.7后实现了java.lang.AutoCloseable；

 1 // txt文件拷贝代码
 2 try (
 3     FileInputStream fis = new FileInputStream("/Users/xdclass/Desktop/test.txt");
 4     BufferedInputStream bis = new BufferedInputStream(fis);
 5     FileOutputStream fos = new FileOutputStream("/Users/xdclass/Desktop/copy.txt");
 7     BufferedOutputStream bos = new BufferedOutputStream(fos);
 8  ) {
 9      int size;
10      byte[] buf = new byte[1024];
11      while ((size = bis.read(buf)) != -1) {
12          bos.write(buf, 0, size);
13      }
14  } catch (Exception e) {
15      e.printStackTrace();
16  }    

 

8、文件与目录

//找出某⽬录下的所有⼦⽬录以及⼦⽂件并打印到控制台上
public static void main(String[] args) {
    List<String> paths = new ArrayList<>();
    getAllFilePaths(new File("/Users/xdclass/Desktop/demo"),paths);
     for(String path : paths){
         System.out.println(path);
     }
 }
 
private static void getAllFilePaths(File filePath, List<String> paths) {
    File[] files = filePath.listFiles();
    if(files == null){
        return;
    }
    for(File f : files){
        if(f.isDirectory()){
            paths.add(f.getPath());
            getAllFilePaths(f,paths);
        }else{
           paths.add(f.getPath());
        }
    }
}

非递归方式：把目录放到list中，while集合不是空时 是文件就打印删除，是目录就打印获取下级放入集合；但是就无序了； 

 

9、字符串

String str = new String("test123"); 创建了1/2个对象

str保存在栈中；

如果常量池中存在字符串“test123”，则只在堆中创建一个对象；--1个

如果常量池中不存在字符串“test123”，则常量池和堆中会分别各创建一个对象；--2个

String s1 = "sclass";//常量，常量池地址
String s2 = s1 + ".net"; //变量 + 常量 = 来⾃堆地址
String s3 = "sclass" + ".net"; //常量 + 常量 = 来⾃常量池地址
final String s4 = "sclass";//常量，常量池地址
String s5 = s4 + ".net"; //常量 + 常量 = 来⾃常量池地址

System.out.println(s2 == "sclass.net");//false
System.out.println(s3 == "sclass.net");//true
System.out.println(s5 == "sclass.net");//true

常量地址 取自 常量池，变量地址 取自 堆；final修饰的变量也是常量；

 

String方法：
substring截取字符，start位置开始包含，end位置结束，不含end；0开始计数；
indexOf 字符出现第一个位置，0开始计数；从某位置开始第一次出现位置，包含这个位置，且从头计数；

 

10、字符串相关构建类

String、StringBuffer与StringBuilder

三者都是：char[]字符数组实现，都是final class 不允许被继承；

不同之处：String是定长，其他两个是可变长度；其中StringBuffer的append/length/setlength/charat方法等都加了synchronized，线程安全；

少量操作使用String；单线程下使用StringBuilder效率更快，因为它不需要加锁，不具备多线程安全；

 

11、面向对象的思想

⾯向对象思想OOP，⾯向对象的四⼤特性：抽象、封装、继承、多态

抽象：关键词abstract声明的类叫作抽象类；抽象类中至少有一个抽象方法；抽象方法只声明，无方法体；把一类事物的共同特征抽取出来，组装成一个类；

封装：把数据属性封装到一个类中，通过接口方法实现对属性的访问；隐藏数据属性，控制对数据的修改和访问；

继承：子类继承父类/基类的属性和方法；

多态：继承+重写

 

12、Overload和Override

重载Overload：同一个类中，有 多个方法 名称相同 但是 入参参数类型或者个数不同 的方法； 

重写Override：子类中定义了和父类 名称相同且参数完全相同 的方法；

 

13、接口与类

 一个类只能继承一个类 ⽤extends关键字，可以实行多个接口 用implements关键字；

接口可以继承多个接口 ⽤extends关键字，接口中只能有抽象方法；

JDK8新特性：

接口可以有static⽅法且必须有实现体，方法仅属于接口，且通过接口名.方法名 调用；新增加了default关键字修饰的⽅法，可以被子类继承和重写；

 

14、异常类

Error与Exception都是继承Throwable；异常可以处理 规避，错误无法处理必须修改或调整；

Error：编译错误或系统错误，虚拟机自身或虚拟机试图执行程序时；

runtime异常：无法预知，运行时发生的；NPE空指针；

IO异常：可以预测的，可以合理解决的；

 

15、int与Integer区别

int：基础数据类型；　　Integer：包装类；

int：不需要实例化，默认是0；　　Integer：需要实例化，默认是null；

取值范围相同 4字节32位  -(2^31)   2^31-1 :有一位是代表正负数，首位0剩余全1为(0111111* = 2^31-1 )故而如此，-128--127是已初始化好的常量，效率高；

 

16、==与equals区别

==：判断两个变量或实例是否是指向同一个内存空间，引用是否相同，对内存地址比较；

equals：判断两个变量或实例对应的内存空间的值是否相同，内容是否相同，对值比较；

 

17、静态代码块、构造函数、父类等加载执行顺序

无继承关系：静态代码块 > 普通构造代码块 > 构造函数 > 方法代码块，且多次创建对象 静态代码块仅执行一次

存在继承关系：父类静态块 > 子类静态块 > 父类普通构造代码块 > 父类构造函数 > 子类普通构造代码块 > 子类构造函数 > 正常方法代码块

 

18、内部类

内部类好处：封装隐藏内部类，外部类提供获取内部类对象接口；封装内部类，相当于外部类实现了多继承；

内部类：需使用外部类对象来实现实例化；

静态内部类：无指向外部对象的引用，仅外部类类名来实现实例化；

匿名内部类：仅使用一次，无法使用外部除final的变量；