Java基础

一、 Java中的IO流的分类：(40多个类，从四个抽象类中派生出的：InputStream(字节流)/Reader(字符流)，OutputStream/Writer)

1. 输入输出流
2. 字节流、字符流
3. 节点流，处理流

二、为什么有了字节流还需要字符流？
不管文件读写，还是网络传输，信息的最小存储单位都是字节，那为什么IO流操作还要分为字节流操作和字符流操作呢？
答：字符流是由Java虚拟机将字节转换得到的，但是这个转换的过程还是比较耗时的，而且在不知道编码类型就会很容易出现乱码问题。所以，IO流直接提供了一个对字符操作的接口，方便我们对字符文件进行操作。如果处理音频图片等数据时，采用字节流操作比较好，但是如果只是操作字符的话，还是应该采用字符流比较好。

三、 NIO、BIO、AIO的区别

1. 何为阻塞I/O？
   在服务器端接收客户端输入时，服务器端就陷入了阻塞，性能就会比较差
   在服务端和客户端编程中， accept()、connect()、read()、write()方法都是阻塞的
2. BIO劣势：
   每当有一个新客户端请求接入，服务端都会创建一个新的线程，无法满足高性能、高并发场景
3. NIO API主要集中在java.nio和它的subpackages中
   四、 深拷贝与浅拷贝
4. 浅拷贝：Object.clone()
   对于基本数据类型进行值传递，对引用数据类型进行引用传递般的拷贝。改变其中一个，会对另外一个也产生影响。
5. 代码

• 对象赋值
  student：

public class Student {
    int id;
    String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }

test:

public class Test {
    public static void main(String[] args) {
        //对象直接赋值
        Student st1 = new Student(1,"tony");
        Student st2 = st1;
        st2.setName("asi");
        System.out.println("st1:"+st1);
        System.out.println("st2:"+st2);
        System.out.println("st1 hashcode:"+st1.hashCode());
        System.out.println("st2 hashcode:"+st2.hashCode());
    }
}

result：

st1:Student{id=1, name='asi'}
st2:Student{id=1, name='asi'}
st1 hashcode:460141958
st2 hashcode:460141958

可知对象直接赋值未产生新对象，st1与st2实际指向的是同一片内存区域
重写Object.clone方法：

@Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

test：

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        //对象直接赋值
        Student st1 = new Student(1,"tony",new FamilyName("tim"));
        //clone原对象
        Student st2 = (Student) st1.clone();
        //修改基本数据类型
        st2.setName("asi");
        //修改类内引用数据类型
        FamilyName fn = st1.getFamilyName();
        fn.setFname("peter");
        //打印
        System.out.println("st1:"+st1);
        System.out.println("st2:"+st2);
        System.out.println("st1 hashcode:"+st1.hashCode());
        System.out.println("st2 hashcode:"+st2.hashCode());
    }
}

result：

st1:Student{id=1, name='tony', familyName=FamilyName{fname='peter'}, familyName HashCode=460141958}
st2:Student{id=1, name='asi', familyName=FamilyName{fname='peter'}, familyName HashCode=460141958}
st1 hashcode:460141958
st2 hashcode:1163157884

可知，clone方法对于类内引用对象的拷贝是浅拷贝，对一般数据类型进行值传递；对于引用数据类型引用传递，实际上新对象与原对象指向的是同一片内存区域。改变一个会影响原对象。

2. 深拷贝：
   对于基本数据类型进行值传递，对引用数据类型，新建一个对象，并复制其内容。
   实现深拷贝我这里收集到两种方式：第一种是给需要拷贝的引用类型也实现Cloneable接口并覆写clone方法；第二种则是利用序列化。接下来分别对两种方式进行演示。

五、 StringBuffer StringBuilder String
当对字符串进行修改的时候，特别是字符串对象经常改变的情况下，需要使用 StringBuffer 和 StringBuilder 类。

1. 都继承自AbstractStringBuilder类，也都是用char存字符串，但是没有加final，所以是可变的。
2. 线程安全：String对象不可变，可以理解为常量，所以为线程安全；SBuffer对父类提供的方法(expandCapacity、indexOf、append、insert)或对调用的方法都加了同步锁，所以是线程安全的；StringBuilder没有加同步锁，所以是非线程安全的。
3. 性能：StringBuffer每次对StringBuffer对象本身操作，而不是生成新的对象并改变对象引用；相同情况下使用StringBuilder相比StringBuffer仅能获得10-15%的提升。
4. String

• 不可变，因为String类内部是用final关键字修饰的字符数组来保存字符串，private final char value[]，所以是不可变的
• java9之后，String内部使用final byte[]保存字符串

• 每次对String进行操作之后，都会产生一个新的String对象，然后将指针指向新的String对象；

  
  
  image.png

六、 接口与抽象类的区别

1. 接口的默认方法为public，所有方法中不能有实现（JAVA8可以有默认实现），而抽象类可以有非抽象的方法
2. 接口中除了有ststic、final ，不能有其他变量；而抽象类中不一定。
3. 一个类能实现多个接口，但只能实现一个一个抽象类；接口本身可以通过extends扩展多个接口
4. 接口方法默认修饰符为public，抽象方法可以有static、protected、和default关键字。
5. 接口、抽象类不能实例化类。
   Interface:

public interface Car {
    public void start();
}

实现类：

public class Truck implements Car {
    @Override
    public void start() {
        System.out.println("Truck Starting...");
    }
}

测试类：

public class Test {
    public static void main(String[] args) {
        Car car = new Truck();
        car.start();
    }
}
//或者可以如下实现
public class Test {
    public static void main(String[] args) {
        Car car = new Car() {  //接口不能实例化对象，因此实例化对象时要实现接口方法
            @Override
            public void start() {
            }
        };
        car.start();
    }
}