java基础知识体系

1.1语法基础

面向对象特性？

• 封装
  利用抽象数据类型讲数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体。数据被保护在抽血数据类型的内部，尽可能地隐藏内部细节，只保留一些对外接口和外部产生联系。用户无需知道对象内部的细节，但可以通过对象对外提供的接口来访问该对象。
  优点：
  1.减少耦合，独立开发、测试、优化
  2.减轻维护的负担
  3.便于性能调优
  4.提高软件的可重用性
  5.降低构建大型系统的风险

• 继承
  继承只能继承一个父类。子类对象可以替换所有父类对象。
  继承不可以继承父类的构造方法，但是可以通过super调用。
  向上转型：Map<String, Object> result = new HashMap<>();子类转父类
  向下转型： String openid = (String) new object();需要强转

• 多态
  多态分为编译时多态和运行时多态
  编译时多态：方法重载 （不同函数相同方法名，但是入参个数或者类型不同）
  public MerchantDataPo selectByPrimaryKey(String onlyId);
  public MerchantDataPo selectByPrimaryKey(int onlyId);
  “重写”只发生在父类和子类之间，同名方法的不同实现

  运行时多态：程序中定义的对象引用所指向的具体类型运行时才确定
  1.继承
  2.方法重写
  3.向上转型

public class Instrument {
   
    public void play() {
   
        System.out.println("Instrument is playing...");
    }
}

public class Wind extends Instrument {
   
    public void play() {
   
        System.out.println("Wind is playing...");
    }
}

public class Percussion extends Instrument {
   
    public void play() {
   
        System.out.println("Percussion is playing...");
    }
}

public class Music {
   
    public static void main(String[] args) {
   
        List<Instrument> instruments = new ArrayList<>();
        instruments.add(new Wind());
        instruments.add(new Percussion());
        for(Instrument instrument : instruments) {
   
            instrument.play();
        }
    }
}

继承原则（两同两小一大）

父类与子类：

• 方法名相同 参数类型相同
• 子类返回类型小于等于父类的返回类型（父类object 子类可以任意，但是父类String 子类就不能object或者int）
• 子类抛出异常小于等于父类方法抛出异常
• 子类访问权限大于等于父类方法访问权限

继承原则（编译时看左边，运行时看右边）

继承原则 子类实例化时执行顺序

子类继承父类后，new 一个子类时，执行方法的顺序是：
1.父类的静态资源（静态变量，静态方法等）
2.子类的静态资源（静态变量，静态方法等）
3.父类的非静态代码
4.父类的无参构造方法
5.子类的非静态代码
6.子类的构造方法

对象创建过程？

对象创建过程可以分为下面几步：
首先判断当前对象是否以及被初始化加载过，如果说没有加载，那么就会调用类加载器进行加载，调用目标类的构造器完成初始化。这个时候主要是对目标类里的静态变量、成员变量、静态代码块进行初始化。
然后因为类加载时其实初始大小就定了，这个时候就在堆上面给目标对象分别空间。
再然后对目标对象的成员变量进行初始化，像int初始化为0，对象初始化为null。为了保证后续这些值可以使用。同时再对对象的方法头，hashcode，锁标记进行设置。
最后，由java执行加载器生成的init()方法它是一个实例构造器。把我们类的成员变量的值，构造函数，父类构造函数，代码块等方法集合。所以执行init()方法就可以最终完成对象创建。

a=a+b与a+=b的区别

+=会将加操作的结果类型强制转换为持有结果的类型。

byte a = 127;
byte b = 127;
b = a + b; // error : cannot convert from int to byte
b += a; // ok

3*01==0.3返回true还是false

false,因为有些浮点数计算机不能精确的表示出来
例如：0.1对应的二进制表示不出来
因此千万不要在代码中使用浮点数来表示金额等重要的指标，建议使用BigDecimal或者Long（单位为分）来表示金额。

为什么不建议使用浮点数表示金额，而是用bigdecimal或long？

有些浮点数计算机不能精确表示出来，如0.1
因此使用bigdecimal或者long来便是金额，避免数据丢失

equals和==区别

“==”对于基本类型就是比较值，对于引用对象就是比较内存地址

3==3//true

equals如果未被重写就是比较内存地址，如果重写了就是比较值

try catch finally的执行顺序

如果try中有return值，那么会先将这个需要返回的值存起来。再执行finally中的代码，如果finally也有retrun那么，finally中的return会将前面代码块的暂存的值覆盖掉。否则就是执行完finally后的代码，再正常返回前面的返回。
如果出现了异常，catch执行后，还是会执行finally中的代码，但是执行完程序就停止运行了

能在 Switch 中使用 String 吗?

Java7 以后就可以在swtich case中使用字符串。
但其内部仍然使用的是字符串的hashcode

对equals()和hashCode()的理解?

• 为什么在重写 equals 方法的时候需要重写 hashCode 方法?
  现在有强制规范需要同时重写equals和hashcode方法。如果只是重写equals不重写hashcode就会出现冲突：一个set 中存在两个值相同的对象（实际内存地址不同，code不同）不能正确去重

• 有没有可能两个不相等的对象有相同的 hashcode?
  有可能，hashcode是2的32次方，理论上足够多的对象就会重复相同的code

• 两个相同的对象会有不同的 hash code 吗?
  不会，相同的对象code一定相同

final、finalize 和 finally 的不同之处?

• final 一个修饰符号，用来修饰变量、方法和类。被final修饰的变量值初始化后不能被改变
• finalize 是java技术中jvm使用finailze()方法在垃圾收集器中从内存清除时的必要清理工作。这个方法是垃圾清理器确定对象没有被引用时调用的，但是什么时候调用没有保证
• finally 是一个关键字，与try和catch一起用于异常的处理。finnally中的语句一定会执行，如果finally中有return，会覆盖前面try中的return。另外，catch捕捉到异常后，程序结束！
  （两种情况finally语句不会被执行：
  1.当程序还没有进入try{}catch{}代码块的时候就抛出异常终止了。这个一般是由于对于异常捕获的范围不够
  2.在try或者catch语块中执行了system.exit(0)语句，导致jVM直接退出）

String、StringBuffer与StringBuilder的区别？StringJioner?

1.可变和适用范围
String对象不可变，StringBuffer和StringBuilder是可变字符序列。每次对String对象的操作实际是生成了新的String对象，而对StringBuffer和StringBuilder的操作是对对象本身的操作，而不会生成新的对象。所以改变频繁的字符串避免使用String，减少性能损耗。
2.线程安全
String有final修饰是一定安全的。
StringBuffer保证线程同步是安全的
StringBuilder线程不同步，不安全，效率更高
3.性能方面
对字符串的修改，String的性能最低，因为它是不可变，每次操作都是new一个对象
其次是stringbuffer，因为它加了同步锁，所以效率要低于StringBuilder
4.存储位置
String是存在常量池里面
StringBuffer StringBuild都是在堆里面

ps:StirngJioner其实底层是StringBuilder，所以也是线程不安全

new String(“abc”)是创建了几个对象？

我觉得创建了几个对象时是分两种情况的。
首先这个new String里面有一个new关键字，那么创建时肯定会在堆里面分配一个区域来保存创建的new String这个对象。
其次，“abc”这个是一个字符串常量，相当于在new String这个对象时把这个字符串常量对象传入其中。所以这个时候就要从常量池中去找是否存在“abc”字符串常量。如果说以及有了，那么只需要直接引用就可以。如果说没有那么就需要先创建一个“abc”的字符串常量对象。
所以，这个new String(“abc”)到底创建了几个对象，取决于常量池中是否以及存在“abc”字符串常量，如果存在，那么就只有一个new String对象，如果不存在，那么就是两个对象。

StringBuffer线程安全实现

主要是通过关键字synchronized关键字保证的。它确保在同一时刻内只有一个线程可以访问stringBuffer区域。从而避免多线程并发情况下数据同步，达到线程安全。

StringBuffer与StringBuilder实现字符串的反转

StringBuffer和StringBuilder中都有一个reverse()可以直接实现字符串反转。
或者就是笨方法for循环+toCharArray();

        String b = "33s13s13f13sfsf";
        char[] charArray = b.toCharArray();
        int length = charArray.length;
        for (int i = 0; i <length/2 ; i++) {
   
            char temp =charArray[i];
            charArray[i]=charArray[length-1-i];
            charArray[length-1-i]= temp;
        }
        String s = new String(charArray);
        System.out.println(s);

integer和int的区别？

integer和int的区别有很多：

• integer是对象，里面有很多方法和属性，int是基本数据类型
• integer的存储位置是堆内存里面，int类型存储栈或者堆里
• integer初始值是null，int初始值是0
  之所以要设计基本数据的包装类，其实是因为java语言是面向对象的语言，所以对象时java操作的基础。因此将基本数据类型包装为对象类型，可以更加方便灵活的操作。比如集合里面存储的也是object对象，不能方基本数据类型。

integer使用不当的问题？integer不能用==去判断？

首先integer是int的包装类，它作为对象如果判断值，应该使用equals去判断，否则就可能会出问题。
因为integer是包装类，本质是一个对象，而在java为了避免integer对象频繁的创建，其实是对-128——127间的数据做了缓存，意思是如果创建的integer数值在这个区间，那么会直接从缓存中读取这个数。所以此时用==判断，那当然是没问题，因为他们就是一个内存位置。
但是当超过这个区间，那么就会创建integer对象。不同的对象的内存地址当然不一样，用 = = 去对比那返回一定是FALSE了。

接口与抽象类的区别？

• 一个子类只能继承一个抽象类，但是可以实现多个接口

• 抽象类有构造方法，接口没有构造方法

• 抽象类有普通成员变量+静态成员变量，接口只有静态成员变量。

• 抽象类的静态成员变量访问类型任意，接口只能用public static final（默认）

• 抽象可以没有抽象方法，抽象类可以有普通方法；接口在JDK8之前都是抽象方法，JDK8中有default方法，在JDK9中允许有私有普通方法

• 抽象类可以有静态方法；接口在JDK8之前不能有静态方法，JDK8中可以有静态方法，且只能被接口类直接调用（不能被实现类的对象调用）

staic

● 静态变量、静态方法、静态常量统称为类的静态成员；

● 静态成员归整个类所有，不属于某个单一的对象，是类中的“公共财产”；

● 要弄清楚静态变量和实例变量的区别；

● 静态方法中不能使用this和super关键字；

● 静态方法中不能访问非静态的成员。

abstic

• 不能修饰变量，只可以修饰类和方法
• 修饰的类是抽象类，修饰的方法是抽象方法

abstract和final

1、abstract类不能用来创建abstract类的对象；
2、final类不能用来派生子类，因为用final修饰的类不能被继承；
3、如2所述，final不能与abstract同时修饰一个类，abstract类就是被用来继承的；
4、类中有abstract方法必须用abstract修饰，但abstract类中可以没有抽象方法，接口中也可以有abstract方法。

this() & super()在构造方法中的区别？

• 调用super()必须写在子类构造方法的第一行, 否则编译不通过
• super从子类调用父类构造, this在同一类中调用其他构造均需要放在第一行
• this可以调用一个构造器, 却不能调用2个
• this和super不能出现在同一个构造器中, 否则编译不通过
• this()、super()都指的对象,不可以在static环境中使用
• 本质this指向本对象的指针。super是一个关键字

枚举类？

枚举类如果有构造函数，那么当前枚举类有几个实例，就会调用几次构造函数。

Java移位运算符？

java中有三种移位运算符

<< :左移运算符,x << 1,相当于x乘以2(