>2021-03-04 19:19:34 星期四
>追随javaGuide哥，把基础过一遍

#java面试篇4-java基础

## 1.Java基本功
### 1.1 java基本类型
![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/03/04/kuangstudy01c5af58-66d1-4800-9d35-5768c61d1084.png)
short-int-long :16-32-64
float-double : 32-64
byte : 8
char:16
> 为什么char是16位两个字节？Unicode和UTF-8的关系是什么？
Unicode是一种字符集（charset），用两个字节就能囊括世界上多有的文字集合。
当时java诞生时，unicode码点上限还是0xFFFF。java也使用了这个unicode，可以包含汉字。
Unicode是字符集，utf-8是编码方式。比如三个汉字，在unicode里占了三个码点，六字节。三个英文字母，也是6字节但是第一个字节都是浪费的。
UTF-8是对不同长度编码采用了不同的格式。
英文就0开头，和ASCII保持一致。
其他的多于一个字节的编码，汉字两字节，就用11（两个1）开头，后面10开头，这样原本16位，需要三个字节编码完成。
如果是三个字节的unicode。就用111（三个1）开头，后面也用10，原本24位，需要用四个字节编码完成。
当然上面是不对的，其实是按照编码后有多少字节，第一个字节就用几个1。因此汉字开头都是三个1。

```java
0xxxxxxx
110xxxxx 10xxxxxx
1110xxxx 10xxxxxx10xxxxxx
11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
----------
//unicode编码
I 00000000 01001001
t 00000000 01110100
' 00000000 00100111
s 00000000 01110011
  00000000 00100000
知 01110111 11100101
乎 01001110 01001110
日 01100101 11100101
报 01100010 10100101
//utf-8
I 01001001
t 01110100
' 00100111
s 01110011
  00100000
知 11100111 10011111 10100101 //都是第一字节111开头，后面10开头
乎 11100100 10111001 10001110
日 11100110 10010111 10100101
报 11100110 10001010 10100101
```
### 1.2.==和equals的区别
== 判断引用类型地址是不是同一个，基本类型判断的是值。
equals 不重写的情况下也是比较值，继承Object的方法。
```java
    public boolean equals(Object obj) {
        return (this == obj);
    }
```
一般都会重写这个方法，来比较两个对象内容是否相等。
比如String中的equals方法
```java
    public boolean equals(Object anObject) {
		//地址都相同了，那还有什么话说
        if (this == anObject) {
            return true;
        }
		//比较类型，比较长度，比较值
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;
    }
```
### 1.3. 为什么重写 equals 时必须重写 hashCode 方法？
hashcode很重要，比如在集合领域中,那么多的数据，通过内容比较太费时了，一般都要先通过hashcode比较落到某一个位置，再在这个位置进行具体的内容比较，也就是equals。如果重写了equals没有重写hashcode,很容易造成equals相等了而hashcode不相等的情况，这样会让人迷惑，程序也就不清不楚。
所以规定equals相等，hashcode必须相等，但是反过来，hashcode相等，equals不一定需要相等。因为hash运算是通过hash函数进行散列，将无限的可能映射在有限的空间中（hashcode总要有长度限制的对吧）。势必会有hash冲突的可能。
两个毫不相干的对象，hashcode的值却有可能相等。但是也无大的影响，因为比如集合，set在判断时都是先判断hashcode再去判断equals,过的了第一关过不了第二关，两关都过那就只能说本来就是一个对象。

### 1.4. 自动装箱和拆箱
Java 基本类型的包装类的大部分都实现了常量池技术，即 Byte,Short,Integer,Long,Character,Boolean；前面 4 种包装类默认创建了数值[-128，127] 的相应类型的缓存数据，Character 创建了数值在[0,127]范围的缓存数据，Boolean 直接返回 True Or False。如果超出对应范围仍然会去创建新的对象。

```java
    public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
	//Interger a = 100;实际执行的是Interger a = Integer.valueOf(100)；
	Integer i1 = 33;
	Integer i2 = 33;
	System.out.println(i1 == i2);// 输出 true
	Integer i1 = 333;
	Integer i2 = 333;
	System.out.println(i1 == i2);// 输出 false，重新new Integer
	Integer i1 = new Integer(3);
	Integer i2 = new Integer(3);
	System.out.println(i1 == i2);// 输出 false，都是新建对象
```
>如果比较过程中有 运算，那就拆箱为基本类型。数值相等就相等。

### 1.5. 方法的重写与重载
重载是同一个方法名，根据不同的输入，做出不同的处理
重写是子类继承的父类的方法，但是想改写父类的计算逻辑

重载要求方法名相同，参数列表不同(个数或者类型)，返回值无所谓。
重写要求方法名相同，参数也相同，内部计算逻辑不同。抛出异常要小于父类抛出异常。访问修饰符要更宽泛，返回类型要小于父类的返回类型。
####为什么异常、访问修饰符、返回类型有这些不同的考量?
一般引用的时候，按照多态的思路，很可能是父类引用，引用着子类对象。那么子类如果抛出的异常大于父类，父类不能接受。肯定会报错。返回类型也是一样的道理。如果访问修饰符很小，本来程序在调用父类的时候觉得这个访问修饰符它有权访问，但是真正进入子类却不能。还是会报错。
>需要宽泛的都是进入时的考虑（访问修饰符），需要严格的（范围更小的）都是出来的考虑（抛出异常和返回）。

### 1.6.深拷贝&浅拷贝
浅拷贝：对于数据就是数据值的拷贝，对于对象就是地址值的拷贝，实际上堆中还是只有一份对象。
深拷贝：对于数据就是数据值的拷贝，对于对象，重新创建一个对象，并复制其内容。
### 1.7.Object对象
```java
public class Object {
	//本地方法执行需要
	//1.通过System.loadLibrary()将包含本地方法实现的动态文件加载进内存；
	//2.当Java程序需要调用本地方法时，虚拟机在加载的动态文件中定位并链接该本地方法，从而得以执行本地方法。
	//使用了registerNatives之后，让程序主动将本地方法链接到调用方，当Java程序需要调用本地方法时就可以直接调用，而不需要虚拟机再去定位并链接。
    private static native void registerNatives();
	//类被加载的时候，调用该方法完成对该类中其他本地方法的注册
    static {
        registerNatives();
    }
	//获取实例对象的类对象
    public final native Class<?> getClass();、
	//本地方法，hashcode
    public native int hashCode();
	//相等
    public boolean equals(Object obj) {
        return (this == obj);
    }
	//拷贝
    protected native Object clone() throws CloneNotSupportedException;
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
	//线程相关，唤醒
    public final native void notify();
	//线程相关，唤醒所有
    public final native void notifyAll();
	//线程相关，阻塞
    public final native void wait(long timeout) throws InterruptedException;
    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }
        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                               "nanosecond timeout value out of range");
        }
        if (nanos > 0) {
            timeout++;
        }
        wait(timeout);
    }
    public final void wait() throws InterruptedException {
        wait(0);
    }
	//jvm相关，回收时用来逃逸？
    protected void finalize() throws Throwable { }
}

```

# 2.JAVA核心技术
## 2.1 反射机制
JAVA 反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为 java 语言的反射机制。
### 动态编译和静态编译
静态编译：在编译时确定类型，绑定对象
动态编译：在运行时确定类型，绑定对象
### 反射的优缺点
优点是更灵活，缺点是慢。反射相当于一系列解释操作，告诉JVM要做什么，性能要比直接的java代码要慢很多。
而且有安全隐患，因为可以突破访问修饰符的限制。
```java
//Person类具有私有成员变量name,和age.
//Person类具有私有方法，setName
public class Main {
    public static void main(String[] args) throws Exception {
        int a = 100;
        Person p = new Person();
        p.setAge(20);
        System.out.println(p);
		//Person{name='null', age=20}
        Method setName = p.getClass().getDeclaredMethod("setName",String.class);
        setName.setAccessible(true);
        setName.invoke(p,"hhh");
        System.out.println(p);//Person{name='hhh', age=20}
        Field name = p.getClass().getDeclaredField("name");
        name.setAccessible(true);
        name.set(p,"dffd");
        System.out.println(p);//Person{name='dffd', age=20}
    }
}
```
### 反射应用场景
反射式框架设计的灵魂。
场景举例：
1. JDBC创建数据库连接时需要Class.forName()通过反射加载数据库的驱动程序。
2. Spring 框架的 IOC（动态加载管理 Bean）创建对象以及 AOP（动态代理）功能都和反射有联系；

## 2.2 文件与IO流
按照流的流向分，可以分为输入流和输出流
按照操作单元划分，可以划分为字节流和字符流。
按照流的角色划分，可以分为节点流和处理流。
InputStream/Reader: 所有的输入流的基类，前者是字节输入流，后者是字符输入流。
OutputStream/Writer: 所有输出流的基类，前者是字节输出流，后者是字符输出流。
![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/03/05/kuangstudy5f1b8d09-ea57-4630-8e4f-200a83d68fe7.jpg)
![](https://kuangstudy.oss-cn-beijing.aliyuncs.com/bbs/2021/03/05/kuangstudye8a3fa89-878f-4f6a-b323-8dd181b805ec.jpg)

## 2.3 代理模式
使用代理对象代替对真实对象的访问，在不修改原对象的情况下，提供额外的操作。
### 静态代理

**1.定义接口**
```java
public interface MsgService{
	public void sendMessage(String message);
}
```

**2.定义实现类**
```java
public class MegServiceImpl implements MsgService{
	public void sendMessage(String message){
		System.out.println(message);
	}
}
```

**3.定义代理对象**
```java
public class MsgServiceProxy implements MsgService{
	private final MsgService msgService;
	public MsgServiceProxy(MsgService msgService){
		this.msgService = msgService;
	}
	public void sendMessage(String message){
		System.out.println("sendMessage before");
		msgService.sendMessage(message);
		System.out.println("sendMessage after");
	}
}
```

**4.实际使用**
```java
public static void main(String[] args){
	MsgService msgService = new MsgServiceImpl();
	MsgServiceProxy msgProxy = new MsgServiceProxy(msgService);
	msgProxy.sendMessage("hello world");
}
//result:
/*
	sendMessage before
	hello world
	sendMessage after
*/
```
>以上可以看出：
	静态代理条理清晰，但是每个目标对象都要有一个代理类，而且每次对原对象的改动，代理对象也要改。很是麻烦。
	因此接下来介绍动态代理

### JDK动态代理
jvm在运行时生成类的字节码文件，然后加载到jvm，效率其实不高。
有JDK动态代理和CGLIB动态代理两种，前者要有接口，相当于实现目标对象的接口，增强方法。后者是继承目标对象，不需要接口。

**1.定义接口**
```java
public interface MsgService{
	public void sendMessage(String message);
}
```

**2.定义实现类**
```java
public class MegServiceImpl implements MsgService{
	public void sendMessage(String message){
		System.out.println(message);
	}
}
```

**3.定义动态代理类**
```java
//需要实现InvocationHandler接口
public class MyDynamicInvocationHandler implements InvocationHandler{
	private final Object target;
	public MyDynamicInvocationHandler(Object target){
		this.target = target;
	}

public Object invoke(Object proxy,Method method,Object[] args) throws InvocationTargetException, IllegalAccessException{
		//增强
		System.out.println(" before");
		Object result = method.invoke(target,args);
		//增强
		System.out.println(" after");
		return target;
	}
}
```

**4.实际使用**
```java
public static void main(String[] args){
	MsgService msgService = new MsgServiceImpl();
	Object proxyIntance = Proxy.newProxyInstance(
		msgService.getClass().getClassLoader(),
		msgService.getClass().getInterfaces(),
		new MyDynamicInvocationHandler(msgService);
	);
	MsgService msgServiceProxy = (MsgService)proxyIntance;
	//执行代理对象的方法，实际上会走MyDynamicInvocationHandler的invoke方法
	msgServiceProxy.sendMessage("hello world");
}
//result:
/*
	before
	hello world
	after
*/
```

>参考自：
Unicode与UTF-8: https://www.zhihu.com/question/23374078/answer/65352538

Java面试篇4-java基础

总共已有 0 条评论