1、HTTP和HTTPS区别

HTTPS是HTTP协议的安全版本，HTTP协议的数据传输是明文的，是不安全的，HTTPS使用了SSL/TLS协议进行了加密处理。SSL介于应用层和TCP层之间。应用层数据不再直接传递给传输层，而是传递给SSL层，SSL层对从应用层收到的数据进行加密后再传递给TCP保证了信息安全。http和https使用连接方式不同，默认端口也不一样，http是80，https是443。
请求方式有:

DNS解析过程:1、找缓存　2、找本机的hosts文件　3、找DNS服务器，保存在缓存中。

2、get和post区别

0、GET产生一个TCP数据包；POST产生两个TCP数据包,因为对于GET方式的请求，浏览器会把header和data一并发送出去，服务器响应200；而对于POST，浏览器先发送header，服务器响应100 ，浏览器再发送data，服务器响应200 （返回数据）。
1、url可见性和安全性：get，参数url可见；post，url参数不可见
2、数据传输上:get，通过拼接url进行传递参数；post，通过body体传输参数
3、缓存性：get请求是可以缓存的而post请求不可以缓存
4、后退页面的反应：get请求页面后退时，不产生影响
post请求页面后退时，会重新提交请求
5、传输数据的大小:get一般传输数据大小不超过2k-4k
post请求传输数据的大小无限制。
1xx：指示信息–表示请求已接收，继续处理
2xx：成功–表示请求已被成功接收、理解、接受
3xx：重定向–要完成请求必须进行更进一步的操作
4xx：客户端错误–请求有语法错误或请求无法实现
5xx：服务器端错误–服务器未能实现合法的请求

加密:

散列算法: MD5(转化成128位bit哈希值). SHA-256 256 位bit哈希值
对称加密:AES(加密：原文+密钥 解密：密文+密钥. 使用的是同一把钥匙)
非对称加密:RSA 公钥和私钥

Session是在服务端保存的一个数据结构，用来跟踪用户的状态，这个数据可以保存在集群、数据库、文件中。
Cookie是客户端保存用户信息的一种机制，用来记录用户的一些信息，也是实现Session的一种方式。

3、TCP的三次握手和四次挥手

三次握手：服务端处于监听状态等待客户端连接请求，第一次握手是客户端向服务端发送请求报文。第二次握手是服务端收到请求报文后同意建立连接，向客户端发送确认报文。第三次握手是客户端收到服务的确认信息后开始建立连接。
四次挥手:第一次挥手是客户端向服务端发送释放报文请求，第二次挥手是服务端收到请求后进入wait状态并且不再受到A的请求，第三次是服务端继续将还未发送完的报文传递给客户端并告诉客户端发送释放报文。第四次挥手是客户端收到释放报文后向服务端回应确认释放报文后等待一段时间才close，因为如果服务端没有收到回应可以请求客户端重新发送，服务端收到确认释放后立马进入close状态。
UDP区别 : TCP可靠，面向连接与面向不连接，面向字节流与报文，传输效率低准确率高。一对一与一对多，多对一，多对多。

tcp 协议是传输层内部建立通信需要经历三次握手和四次挥手,ip协议是网络层,用于用来查找地址的。http协议是应用层，在TCP/IP协议接收到数据之后需要通过HTTP协议来解析才可以使用,HTTP协议分为请求报文和响应报文。报文由首行、头部和主体构成。而socket只是一个API调用接口，对TCP/IP协议的封装，使得程序员不用关系内部通信细节而专注开发，根据数据传送方式socket分为面向连接的数据流通信和无连接的数据报通信。

4、进程通信方式

IPC的方式通常有管道（包括无名管道和命名管道）、消息队列、信号量、共享存储、Socket。
管道的实质是一个内核缓冲区，进程以先进先出的方式从缓冲区存取数据：管道一端的进程顺序地将进程数据写入缓冲区，另一端的进程则顺序地读取数据
消息队列，就是一个消息的链表，是一系列保存在内核中消息的列表。用户进程可以向消息队列添加消息，也可以向消息队列读取消息。消息队列与管道通信相比，其优势是对每个消息指定特定的消息类型，接收的时候不需要按照队列次序，而是可以根据自定义条件接收特定类型的消息。
共享内存允许两个或多个进程共享一个给定的存储区，这一段存储区可以被两个或两个以上的进程映射至自身的地址空间中，一个进程写入共享内存的信息，可以被其他使用这个共享内存的进程，通过一个简单的内存读取错做读出，从而实现了进程间的通信。
信号量：它是一个计数器。信号量用于实现进程间的互斥与同步，而不是用于存储进程间通信数据。
socket:

数据库

（1）原子性（Atomicity）
原子性是指事务包含的所有操作要么全部成功，要么全部失败回滚。
（2）一致性（Consistency）
一个事务执行之前和执行之后都必须处于一致性状态。
（3）隔离性（Isolation）
隔离性是当多个用户并发访问数据库时，比如操作同一张表时，数据库为每一个用户开启的事务，不能被其他事务的操作所干扰，多个并发事务之间要相互隔离。
（4）持久性（Durability）
持久性是指一个事务一旦被提交了，那么对数据库中的数据的改变就是永久性的。

5、算法

冒泡:数组中相邻的两个元素进行比较，将较大的放到后面，根据数去找位置。
选择：按顺序比较。按位置去找数
插入:前2个比然后小的排前面，插入第三个看插哪合适。
快速
希尔
归并
红黑树:是一种自平衡二叉查找树,每个节点要么是红色、要么是黑色
根节点永远是黑色（根）
所有叶节点（NIL）永远是黑色（子）
每个红色节点的两个子节点一定是黑色
对于每个节点，从节点到后代叶子（NIL）的所有简单路径，都包含相同数量的黑色节点
好处就是它的查找、插入和删除的最坏时间复杂度都为O(logn)

6、java代码执行顺序

父类静态代码块（包括静态初始化块，静态字段）
子类静态代码块（包括静态初始化块，静态字段）
父类非静态代码块（ 包括非静态初始化块，非静态字段 ）
父类构造函数
子类非静态代码块 （ 包括非静态初始化块，非静态字段 )
子类构造函数

7、基本数据类型有哪些？string转integer原理

byte,short,int,float,double,long,boolean,char。
Integer.parseInt方法，转int有Integer.valueOf(),int转string有+"",Integer.toString(),String.valueOf()。

8、String,StringBuffer与StringBuilder的区别

String 是不可变的常量对象,后2者可变变量。每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象。
速度比较：String < StringBuffer < StringBuilder
（1）如果要操作少量的数据用 String
（2）单线程操作字符串缓冲区 下操作大量数据 StringBuilder(线程不安全)
（3）多线程操作字符串缓冲区 下操作大量数据 StringBuffer（线程安全）

9、为什么string设计不可变

1. 字符串常量池的需要
当创建一个 String 对象时，如果此字符串已经存在于常量池中，则不会创建一个新的对象，而是引用已经存在的对象。如果允许改变，那么将导致各种逻辑错误，比如改变一个对象将会影响另一个独立对象，严格来说，这种常量池的思想是一种优化手段。
2. 允许 String 对象缓存 HashCode
Java 中 String 对象的哈希码会被频繁的使用，比如在 HashMap 中。字符串的不变形保证了 hash 码的唯一性，因此可以放放心的进行缓存。这也是一种优化手段，意味着不必没说都计算新的哈希码，在 String 类中有 private int hash 来缓存 hashcode
3. 安全性
String 被许多的类来当做参数，如网络 url，文件路径 path 等等，如果 String 不是固定的，将会引起各种安全隐患
4. 线程安全
String 不可变性天生具备线程安全，可以在多个线程中安全地使用。

String a = "a"+"b"+"c" 在内存中创建几个对象？通过编译器优化后，得到的效果是String a = "abc",此时，如果字符串常量池中存在 abc，则该语句并不会创建对象，只是讲字符串常量池中的引用返回而已。如果字符串常量池中不存在 abc，则会创建并放入字符串常量池，并返回引用，此时会有一个对象进行创建。

10、封装继承多态

类的三大特性：
封装：很好的诠释了单一职责原则、迪米特法则，将类的状态信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问，外部不需要关系内部细节，也避免了外部错误使用对该类的改动。比如数据结构的一些类，可以封装一些数据和对数据的操作。
继承：字段方法复用，解决编程中代码冗余的问题，同时继承也是实现多态的基础
多态：多态体现在编译期多态与运行时多态，编译期多态是指方法重载，运行时多态是方法重写父类的引用指向子类的对象。依赖倒置原则（我们要面向抽象，面向接口编程）

11、接口和抽象类区别

抽象类是一个可同时包含具体方法和抽象方法(方法未被实现)的类。抽象方法必须被该抽象类的子类实现。抽象类是可以继承的。
接口像是描述类的一张蓝图或者说是类的一种契约，它包含了许多空方法，这代表着它的所有的子类都应该拥有共同点。它的子类应该提供这些空方法的具体实现。一 个类需要用 implements 来实现接口，接口可以用 extends 来继承其他接口。
应用上区别：接口是表现在系统架构设计方法发挥作用，主要用于定义模块之间的通信契约。而抽象类在代码实现方面发挥作用，可以实现代码的重用。

12、重写重载区别

覆盖是子类与父类之间的关系，是一种垂直关系；重载是同一个类中方法之间的关系，是水平关系
覆盖只能由一个方法或者只能由一对方法产生关系；重载是多个方法之间的关系
覆盖要求参数列表要相同；重载要求参数列表不同
覆盖关系中，调用方法体是根据对象的类型（对象对应存储空间类型）决定，重载是根据调用的时候实参表和形参表来选择方法

13、静态属性和静态方法是否可以被继承？是否可以被重写？为什么？

静态属性和方法可以被继承，但是不可以被重写，一般静态属性和方法属于一个类，而非对象，在内存中一般只保存一份。

14、内部类、静态内部类、局部内部类和匿名内部类的区别及作用？

    内部类概述:
        把类定义在其他类的内部，这个类就被称为内部类。
        举例：在类A中定义了一个类B，类B就是内部类。
    内部的访问特点：
        A:内部类可以直接访问外部类的成员，包括私有。
        B:外部类要访问内部类的成员，必须创建对象。
作为外部类的一个成员存在，与外部类的属性、方法并列
成员内部类持有外部类的引用
成员内部类中不能定义static变量和方法.
1、内部类如果使用static声明，则此内部类就称为静态内部类。（其实也相当于外部类）可以通过外部类 . 内部类来访问。
2、静态内部类使用场合：内部类不需要外部类的实例（注意区分成员内部类），静态内部类存在仅仅为外部类提供服务或者逻辑上属于外部类，且逻辑上可以单独存在。
3、静态内部类的特征：
静态内部类不会持有外部类的引用
静态内部类可以访问外部的静态变量，如果访问外部类的成员变量必须通过外部类的实例访问

1、局部内部类也叫区域内嵌类，局部内部类与成员内部类类似，不过，区域内嵌类是定义在一个方法中的内嵌类。
2、使用场合：如果内部类对象仅仅为外部类的某个方法使用，使用局部内部类
3、特征：
用在方法内部，作用范围仅限于该方法中
根据情况决定持有外部类对象引用
不能使用private，protected，public修饰符
不能包含静态成员

如果一个内部类在整个操作中只使用一次的话，就可以定义为匿名内部类。匿名内部类也就是没有名字的内部类，这是java为了方便我们编写程序而设计的一个机制，因为有时候有的内部类只需要创建一个它的对象就可以了，以后再不会用到这个类，这时候使用匿名内部类就比较合适。
2、使用场合：简化内部类的使用

15、单例模式有哪些？

饿汉式 在静态成员变量初始化时就实例对象,以空间换时间，故不存在线程安全问题。

public class SingleTon{
   private static SingleTon INSTANCE = new SingleTon();
 private SingleTon(){}
public static SingleTon getInstance(){ return INSTANCE; }}

懒汉式 在方法中检查非空初始化实例,以时间换空间，在多线程环境下存在风险。

public class SingleTon{
   private static SingleTon  INSTANCE = null;
   private SingleTon(){}
   public static SingleTon getInstance() {  
   if(INSTANCE == null){
      INSTANCE = new SingleTon(); 
    } 
    return INSTANCE；
  }
}

双重检查锁需要判断两次非空，第一次是instance为null才加锁，防止多线程同时执行加锁操作。第二次是避免instance加锁实例化后，其他阻塞线程被唤醒后仍然进行实例化。时间和空间问题都解决了，但是有一个问题，jvm在创建对象会执行三部操作：
1，在堆内存开辟内存空间，2在堆内存实例化singleTon，3把instance指向堆内存空间。因为jvm会有指令重排序可能会先执行132在执行13的时候B线程获取的instance是null就会发生bug。所以加了volatile。由此引出锁机制。

public class SingleTon{
  private static  volatile SingleTon  INSTANCE = null;
  private SingleTon(){}
  public static SingleTon getInstance(){if(INSTANCE == null){
   synchronized(SingleTon.class){
     if(INSTANCE == null){ 
        INSTANCE = new SingleTon();
       } 
     } 
        return INSTANCE; 
    } 
  }
}

静态内部类外部类加载时并不需要立即加载内部类，内部类不被加载则不去初始化INSTANCE，故而不占内存。为什么线程安全呢？因为虚拟机会保证一个类的<clinit>()方法在多线程环境中只会初始化一次。实际开发用的最多。

public class SingleTon{
  private static SingleTon  INSTANCE = null;
  private SingleTon(){}
  public static SingleTon getInstance(){if(INSTANCE == null){
   synchronized(SingleTon.class){
     if(INSTANCE == null){ 
        INSTANCE = new SingleTon();
       } 
     } 
        return INSTANCE; 
    } 
  }

枚举也可以用，实际开发用的不多

public enum SingleTon{
  INSTANCE;
        public void method(){
        //TODO
     }
}

16、== 和 equals() 和 hashCode() 的区别？

对于== 如果是基本数据类型 byte,short,char,int,long,float,double,boolean ,比较的是他们的值。引用类型(类、接口、数组) 比较的是引用地址。对象是放在堆中的，栈中存放的是对象的引用（地址）。
equals是Object类的方法，默认情况下比较两个对象是否是同一个对象，内部实现是通过“==”来实现的。如果想比较两个对象的其他内容，则可以通过重写equals方法。比如string源码中就重写了equals,比较了字符串长度和每个字符是否相等。
hashCoed也是Object类里面的方法，返回值是一个对象的哈希码，同一个对象哈希码一定相等，但不同对象哈希码也有可能相等。如果两个对象通过equals方法比较相等，那么他的hashCode一定相等；如果两个对象通过equals方法比较不相等，那么他的hashCode有可能相等；

17、 final、finally 和 finalize 的区别？

final可以修饰类、变量、方法，修饰类表示该类不能被继承、修饰方法表示该方法不能被重写、修饰变量表示该变量是一个常量不能被重新赋值。
finally一般作用在try-catch代码块中，在处理异常的时候，通常我们将一定要执行的代码方法finally代码块中，表示不管是否出现异常，该代码块都会执行，一般用来存放一些关闭资源的代码。
finalize是一个方法，属于Object类的一个方法，而Object类是所有类的父类，该方法一般由垃圾回收器来调用，当我们调用System的gc()方法的时候，由垃圾回收器调用finalize(),回收垃圾。

18、static 关键字有什么作用？

static 是 Java 里的非访问修饰符，它可以用来创建类方法和类变量。当修饰一个变量的时候，此变量就成了独立于对象的静态变量，无论一个类实例化了多少个对象，这个类只有一份这个静态变量的拷贝，所以 static 修饰的变量，即静态变量，也被叫做类变量。一个局部变量不能被声明为 static 变量。
当修饰一个方法的时候，此方法就成了独立于对象的静态方法，静态方法不能使用类的非静态变量，因为静态方法和静态变量先于非静态的其他成员初始化，静态方法先出来，然后才是非静态的，所以明白这个顺序很重要。静态方法从参数列表得到数据，然后计算这些数据。

19、静态代理和动态代理的区别？有什么场景使用？

静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类
静态代理事先要知道代理的是什么 ，而动态代理不知道要代理什么东西，只有在运行时才知道。
动态代理是实现JDK里面的InvocationHandler接口里面的invoke方法，但注意的是代理的是接口，也就是说你的业务类必须要实现接口，通过Proxy里的newProxyInstance得到代理对象。AOP编程就是基于动态代理实现的，比如著名的Spring框架、Hibernate框架等等都是动态代理的使用例子.

20、hashmap原理与HashTable，ConcurrentHashMap区别

HashMap基于Map接口实现，元素以键值对的方式存储，并且允许使用一个null 键和多个null值，而hashtable不允许空键空值，这是因为hashtable为了线程安全使用了安全失败机制，这种机制会需要调用key.comtain()方法来判断一些操作，会抛出空指针。hashmap是非线程安全，效率高，hashtable将所有get和put操作都加synchronized，而concurrentHashmap则是每一段数据进行分段加锁。hashmap初始长度是16，hashtable是11，负载因子都是0.75，原理就是
第一步： 先把将key,value存放到Node（节点）对象中。
第二步：通过底层key的hashcode（）方法计算出key的hash值。
第三步：通过hash算法，将hash值转化为数组的下标，下表位置上如果没有任何元素，那么将Node添加到这个位置上。如果下标位置已经存在链表，此时，将会拿着key和链表上的每个节点的key进行比较（equals方法）。如果所有的equlas方法返回的都是false，那么这个新的节点将被添加到链表的末尾，如果有一个equals返回true，那么这个节点的value将会被覆盖。
当size超过阈值（数组长度的负载因子）时，负载因子就是0.75，就开始扩容，变为原来的二倍。提前扩容就是为了减少hash碰撞。1.8以前是数组+链表，1.8后如果链表长度超过8，就变为红黑树结构，防止链表过长。

21、集合汇总

2020110820521788.png

22、泛型

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为【泛型类】、【泛型接口】、【泛型方法】而且参数类型不能是简单类型。 它带来的好处是提高java程序类型安全，编译时就会强检，消除强制类型转换，代码复用性更好。<? extends T>上界通配符、<? super T> 的区别，下界通配符？上界set方法会失效，get有效。下界set方法有效，get方法失效，所以读取适合用上界 Extends，插入适合用下界 Super。

23、反射

反射机制是在运行时，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意个对象，都能够调用它的任意一个方法。在java中，只要给定类的名字，就可以通过反射机制来获得类的所有信息。这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。获取Class对象，有4种方法：(1)Class.forName(“类的路径”)；(2)类名.class；(3)对象名.getClass()；(4)基本类型的包装类，可以调用包装类的Type属性来获得该包装类的Class对象。通过反射可以使程序代码访问装载到JVM 中的类的内部信息，成员变量信息，类的方法，构造方法信息。缺点是带来性能问题，需要对内存中的对象进行一系列检查和解析一系列字节码，模糊程序内部逻辑，使用要求较高。

24、对注解的了解？依赖注入了解？

在运行期，由外部容器动态地将依赖对象注入到组件中。依赖注入方式有：构造器注入，接口注入，setter注入。参考dagger

25、对象创建过程

1，类加载：先在常量池看有无该类的引用并检查是否加载解析和初始化。如果有就分配内存，没有就执行类加载机制。
2，分配内存 根据对象所需内存大小在堆内存中分配内存。
3, 初始化 jvm初始化分配好的内存，将值设为0。这一步骤操作保证了对象实例过字段，别的程序能访问到这些字段，都是零值。
4,设置对象头:包含2部分信息，自身运行时数据和类型指针指向它对应的类元数据。
5,执行init方法 对属性赋值，执行构造函数

26、类加载机制

一个程序写好后都会生成.class文件，类加载机制就是把.class文件加载到内存中，并对数据进行校验，准备，解析和初始化，最终形成虚拟机直接可用的java类型。类的加载可分为
启动类加载器(bootstrapClassLoader)：加载核心库。
扩展类加载器（extensionClassLoader）：加载扩展库。
应用程序类加载器(AppClassLoad)：加载应用程序的jar和class文件。
自定义加载器(customClassLoader):因为java默认ClassLoader只加载指定目录的jar和class文件，如果家在其他位置的比如网络上的class文件，就需要自定义，一般是继续classLoader重写findClaa方法。
它的原理是使用了双亲委托模型，如果一个classLoader实例需要加载某个类，它会由上至下依次检查，先给顶层的bootStrap加载，如果没有就转交给extentionClassLoader，如果也没有就转交APPClassLoader，如果也没有就返回给委托的发起者自己去加载。如果最终都没搜索到就抛出classNotFoundException异常。这样的好处是避免重复加载而且保证安全性，防止被用户自定义修改。

27、jvm回收机制

垃圾判断算法包含：
1、引用计数算法：每有一个对象实例的引用就+1,生命周期结束或被重置为新值，实例对象的引用计数就-1.但是缺点是对象循环引用，这样引用计数一直不能释放。
2、可达性分析算法
把GC Roots的对象作为根节点向下搜索，搜索所走的路径称为引用链，如果一个对象没有任何引用链就被判断可回收对象。可作为gc ROOT的对象包含:虚拟机中引用的对象，方法区中类静态属性引用的对象，方法区中常量引用的对象，本地方法栈中引用的对象。
垃圾回收算法包含：
标记-清除算法:扫描空间2次，第一次标记存活对象，第二次清除没有标记的对象，容易产生内存碎片化，不是连续的内存区域。
复制算法：将内存按容量划分2块，每次在内存用完后复制存活的对象到另一块上上，把之前的一块全部清理。解决了内存碎片，但每次可用内存仅有一半。
标记-整理算法：将所有存活对象移到一端，再清理边界以外的区域，需要整理所有存活对象的引用地址，所以内存变动很频繁效率低。
分代收集算法：堆区划分为老年代，新生代，永久代。不同年代使用以上最合适的算法。新生代每次都有大部分对象死去，只有少量存活，适合标记复制算法。老年代中，对象存活率高、没有额外空间对它进行分配担保，就必须使用标记-清理算法或者标记-整理算法来进行回收。

垃圾回收机制与调用 System.gc() 的区别？System.gc()只是通知要垃圾回收了，但是并没有即刻进行垃圾回收

29、jmm（java内存模型）

定义程序中各个变量的访问规则,解决多线程同步访问共享变量的规则也就是并发性，模型分为主内存和本地内存,作用于主内存的变量要通过加锁和解锁。而本地内存必须通过先store在write顺序执行存入主内存，读取必须通过read在load顺序操作。所以涉及并发三大特性，原子性，可见性，有序性解决。

30、引用类型

强引用：Object o = new Object(); 只要引用对象还在垃圾回收机制就不会回收，可通过赋值null被回收器回收。
软引用：内存够回收期不回收，不足就回收。图片缓存框架经常用
弱引用：回收器扫描到时，不管当前内存空间是否足够都会回收内存。用于静态内部类中
虚引用：任何时候都可能被回收，主要用于监测对象是否已经从内存中删除

31、

Serializable 和Parcelable 的区别

Serializable的作用是为了保存对象的属性到本地文件、数据库、网络流、以方便数据传输，当然这种传输可以是程序内的也可以是两个程序间的。Serializable的实现是采用ObjectInputStream和ObjectOutputStream实现的，并且期间产生临时对象。
Android的Parcelable的设计初衷是因为Serializable效率过慢，为了在程序内不同组件间以及不同Android程序间(AIDL)高效的传输数据而设计，这些数据仅在内存中存在，Parcelable是通过IBinder通信的消息的载体。2、效率及选择。Parcelable的性能比Serializable好，在内存开销方面较小，所以在内存间数据传输时推荐使用Parcelable，如activity间传输数据，而Serializable可将数据持久化方便保存，所以在需要保存或网络传输数据时选择Serializable。