计算机复习

面试

1. java

1. 基础

1. 基础

1. 特性

​ 一处编译，多处运行

2. 数据类型

1. 基本数据类型

​ 1. 整数型（byte,short,int,long）
​ 2. 浮点数型（float,double）
​ 3. 字符型(char)
​ 4. 布尔型（boolean）

2. 引用数据类型

​ 1. 类和接口
​ 2. String
​ 3. 数组

2. 面向对象

1. 定义

​ 面向过程注重事情的每个步骤及顺序，面向对象注重参与事情的对象有哪些，以及他们各自需要做什么

2. 三大特性

1. 封装

​ 将类的某些信息隐藏在内部（private），对外通过方法调用，不用关心具体实现。减少耦合

2. 继承

​ 从已有的类中派生出新的类，能继承并扩充已有类的属性和方法（父类private不能继承）

3. 多态

​ 父类或接口定义的引用变量可以指向不同子类的实例对象，实现对同一个方法调用，执行不同的逻辑。让代码更好的维护和扩展。

3. 类

1. 变量类型

​ 1. 类变量/静态变量（存在方法区）
​ 2. 实例变量/成员变量（方法外，有默认值，存在堆中）
​ 3. 局部变量（方法内，无默认值，存在栈中）

2. 修饰符

• 1. 作用域
     ​ 1. private(同类)
     ​ 2. default（同包）
     ​ 3. protected（同包和子类）
     ​ 4. public（所有）
• 2. static
     ​ static修饰的变量内存只有一份，static修饰的变量和方法可以直接通过类名访问。static修饰的代码块只会执行一次
• 3. final
     ​ final修饰的变量成为常量，final修饰的方法不能被覆盖，final修饰的类不能被继承
• 4. super
     ​ 可以调用父类的方法和属性

3. 抽象类（abstract）

​ 抽象类跟普通类不同在于：1.不能创建对象；2.可以定义抽象方法（“是不是”的概念）

4. 接口（interface）

​ 1. 特殊的抽象类，所有方法都是抽象的，变量都是静态的。（有不有的概率）
​ 2. 1.不能创建对象，不能定义实例字段
​ 3. 2.可以定义抽象方法和default方法 ；（default方法不用所有实现接口的类都去实现这个方法）
​ 4. 3.接口能继承接口，但不能实现接口
​ 5. 4.变量都是final static，方法都是public abstract

5. 内部类

• 1. 作用
     ​ 内部类可以更方便访问外部类成员（否则只能通过外部类对象访问），并且每个内部类都能独立的继承一个接口的实现，使多继承变得更加完善
• 2. 注意
     ​ 内部类和外部类可相互访问private属性，非静态的内部类不能定义静态方法和变量。
• 3. 调用内部类变量或方法
     ​ 1. 间接调用：在外部类方法常规调用，再通过外部类对象调用
     ​ 2. 直接调用：定义内部类对象：Outer.Inter inter=new Outer.new Inter();

3. IO

​ 1. 字节流：以字节为单位，可处理任意类型数据
​ 2. 字符流：以字符为单位，根据码表映射关系，一次性可读多个字节，处理字符类型数据

4. 异常

​ Throwable
​ ​ 1. Error（错误）：程序无法处理
​ ​ ​ 1. 栈/内存溢出
​ ​ ​ 2. 虚拟机运行错误
​ ​ 2. Exception（异常）：程序可以处理
​ ​ ​ 1. RuntimeException及其子类:如空指针，下标越界
​ ​ ​ 2. 非RuntimeException异常：可查异常，需要try catch 或throws

5. 高阶

1. 泛型

1. 含义

​ 给类型指定一个参数，然后在使用时再指定此参数具体的值。优点：代码重用、保护类型的安全以及提高性能。

2. 泛型通配符

​ 1. class A{}：可以定义任意类型
​ 2. class A{}：只能定义B或B的子类
​ 3. class A{}：只能定义B或B的父类

2. 反射

​ 1. 机制：反编译（Class->java）
​ 2. 作用：通过对象也能获取类的信息。可以动态获取类的信息， 运行期类型的判断，动态加载类，提高代码灵活度，框架中比较常见

3. 动态代理

​ 作用：类似Spring的aop，可以动态的，不修改源代码的情况下为某个类增加功能，如在一个方法的前后添加一下功能。

2. 集合

1. collection（单列集合）

1. list(可重复，有序:元素存取顺序一样)

1. 查快：ArrayList

​ 1. 底层数组，查快，增删慢，线程不安全，效率高
​ 2. Vector：线程安全，结构跟ArrayList类似。内部实现直接使用synchronized 关键字对 每个方法加锁。性能很慢。现在淘汰（synchronizedList跟Vector类似，区别是使用synchronized 关键字对 每个方法内部加锁）
​ 3. copyOnWriteArrayList：线程安全，在写的时候加锁（reentrantlock锁），读的时候不加锁，写操作是在副本进行，所以写入也不会阻塞读取操作，大大提升了读的速度。缺点：写操作是在副本上进行的，数组的复制比较耗时，且有一定的延迟。

2. 删快：LinkedList

​ 底层双向链表(所以可以作为栈和队列)，查慢，增删快，线程不安全，效率高

2. set(唯一，无序:元素存取顺序不同)

1. 未排序：HashSet

​ 1. 底层哈希表，哈希表依赖hashcode()和equals()保证唯一性。
​ 2. 有一个子类LinkedHashSet,底层为链表和哈希表，依赖链表保证有序

2. 排好序：TreeSet

​ 底层红黑树（Compareable保证唯一）

2. map（双列集合，无序）

1. 未排序：HashMap

​ 1. 线程不安全，底层哈希表+红黑树（1.7之前为哈希表），效率高,各操作接近O(1)（补充：1.7之前哈希冲突后通过单向链表保存,查找时间n，1.8将单向链表换成了红黑树（链表长度超过8。1.8后链表插入从头插法改为了尾插法，因为头插法在多线程中可能导致死循环），查找时间为logn——n为链表长度）
​ 2. 线程安全的concurrentHashMap ，底层跟1.8后的hashMap差不多，通过synchronized加锁保证线程安全（1.8之前底层是segment数组和哈希表，通过segment加锁保证线程安全）
​ 3. 线程安全的HashTable，跟HashMap类似，通过Synchronized保证安全，现已淘汰（被concurrentHashMap替代，因为HashTable锁住整个map，效率低。而concurrentHashMap锁住一部分map）

2. 根据key排好序：TreeMap

​ 底层红黑树，各操作O(logn）

3. 并发

1. 开启线程三种方式

​ 1. 继承Thread类，重写run方法。(代码：Thread t=new MyThread()