第一部分-自我介绍

第二部分-Java的基础知识

1、接口和抽象类的区别

抽象类（abstract）

• abstract 修饰的类就是抽象类，修饰的方法就是抽象方法。
• 抽象类中可以没有抽象方法，但有抽象方法的类一定要声明为抽象类。
• 抽象类不能使用new来创建对象，它是用来让子类继承的。
• 抽象方法只有方法的声明，没有实现，让其子类实现。
• 子类继承抽象类，必须实现抽象类的所有方法，否则该子类也要声明为抽象类。

 //abstract 抽象类：类 extends: 单继承（接口可以多继承）
public abstract class Action {
    //约束~有人帮我们实现~
    //abstract,抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();

    //1.不能new抽象类，只能靠子类去实现它，仅作为一个约束
    //2.抽象方法只能出现在抽象类中，抽象类可以有普通方法
    //抽象的抽象：约束
    //3.抽象类有 构造器 ，可以派生子类
    //4.抽象类的意义：约束，提高开发效率。但是类只能单继承，所以有局限 用的不多
    
}  

 //抽象类的所有方法，继承了它的子类，都必须要实现它的方法

public class A extends Action{
    @ Override 
    public void doSomething() {
    }
}  

接口(interface)

• 普通类：只有具体实现
• 抽象类：具体实现和规范(抽象方法)都有
• 接口：只有规范，没有方法实现，专业的约束！约束与实现分离：面向接口编程~
• 接口就是规范，定义的是一组规则，”你是什么…必须做什么…”的思想。
• 接口的本质是约束，就像人间法律一样，制定好大家都遵守。

 //interface 定义的关键字,接口都需要有实现类
public interface UserService {
    //接口中的所有定义其实都是抽象的 public abstract
     void add(String name);
     void delete(String name);
     void update(String name);
     void query(String name);
}  

 //类 可以实现接口 implements 接口
//实现接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService{

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }
}  

作用：
1、约束
2、定义一些不同的方法，让不同人的实现
3、public abstact
4、public static final
5、接口没有构造方法，不能被实例化
6、实现类必须要重写接口中的方法
7、实现类（implements） 可以实现多个接口

2、 Java 1.8之后的新特性

lambda表达式

 package com.kuang.lambda;
//lambda表达式
public class TestLambda1 {
    //3、静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
        like = new Like2();
        like.lambda();

        //4、局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        like = new Like3();
        like.lambda();
        //5.匿名内部类，没有类的名称，必须借助接口或者父类
        like = new ILike() {
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        like.lambda();

        //6.用lambda简化，接口和方法都不要了
        like = ()->{
            System.out.println("I like lambda5");
        };
        like.lambda();

    }

}
//1、定义一个函数式接口
//任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口
//接口里默认是抽象方法
interface ILike{
    void lambda();
}
//2、实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}  

多个参数

 package com.kuang.lambda;

public class TestLambda2 {
    public static void main(String[] args) {
        ILove love = new Love();
        love.love("bl");

        love = new ILove() {
            @Override
            public void love(String a) {
                System.out.println("I love you-->"+a);
            }
        };
        love.love("bdf");
        //lambda表达式
        love = (String a)->{
            System.out.println("I love you-->"+a);
        };
        love.love("yiyeri");
        //简化1.去掉参数类型
        love = (a)->{
            System.out.println("I love you-->"+a);
        };
        love.love("520");
        //简化2.简化括号
        love = a ->{
            System.out.println("I love you-->"+a);
        };
        love.love("521");
        //简化3.简化花括号
        love = a ->
            System.out.println("I love you-->"+a);
        love.love("aaaaaaa");

        //总结：
        /*
        1.lambda表达式只能有一行代码的情况下才能简化成为一行，如果有多行，那么就用代码块包裹
        2.前提是接口为函数式接口
        3.多个参数也可以去掉参数类型，要去掉就都去掉了，必须加上括号
         */    }
    
}
interface ILove{
    void love(String a);
}
class Love implements ILove{
    @Override
    public void love(String a) {
        System.out.println("I love you-->"+a);
    }
}  

2、Java1.8之后的新特性- hashmap

在 jdk 1.8中对hashMap等map集合的数据结构优化。
hashMap 数据结构的优化
原来的hashMap

• 采用的数据结构是 哈希表 （数组+链表），

hashMap默认大小是16，一个0-15索引的数组，

3.如何往里面存储元素，

（1)首先调用元素的 hashcode 方法，计算出哈希码值，

(2)经过哈希算法算成数组的索引值，

• (3)如果对应的索引处没有元素，直接存放，如果有对象在，那么比较它们的equals方法比较内容
• 如果内容一样，后一个value会将前一个value的值覆盖，如果不一样，
• 在1.7的时候，后加的放在前面，形成一个 链表 ，形成了碰撞，在某些情况下如果链表无限下去，那么效率极低，碰撞是避免不了的
• 加载因子：0.75，数组扩容，达到总容量的75%，就进行扩容，但是无法避免碰撞的情况发生
• 在1.8之后，在数组+链表+红黑树来实现hashmap，当碰撞的元素个数大于8时 & 总容量大于64，会有 红黑树 的引入
• 除了添加之后，效率都比链表高，1.8之后链表新进元素加到末尾 ConcurrentHashMap (锁分段机制)，concurrentLevel,jdk1.8采用CAS算法(无锁算法，不再使用锁分段)，数组+链表中也引入了红黑树的使用

哈希冲突: 存储地址发生冲突
当我们对某个元素进行哈希运算，得到一个存储地址，然后进行插入的时发现已经被其他元素占用了

3、 死锁

指两个或两个以上的 线程 在执行的过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞现象，若无外力作用，他们都将无法推进下去。此时系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程成为死锁进程。

举例来说：有两个进程A和B,A持有资源a等待b资源，B持有资源b等待a资源，两个进程都在等待另一个资源的同时不释放资源，就形成死锁。

产生死锁的原因，主要包括：

• 系统资源不足；
• 程序执行的顺序有问题；
• 资源分配不当等。

形成死锁的四个必要条件：

（1） 互斥条件：一个资源每次只能被一个进程使用。

（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。

（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

如何处理死锁？

• 预防死锁：破坏四个必要条件中的一个或多个来预防死锁
• 避免死锁：在资源动态分配的过程中，用某种方式防止系统进入不安全的状态。
• 检测死锁：运行时产生死锁，及时发现思索，将程序解脱出来。
• 解除死锁：发生死锁后，撤销进程，回收资源，分配给正在阻塞状态的进程。

预防死锁的办法：

• 破坏请求和保持条件：

• 破坏不可抢占条件：

当一个进程获得某种不可抢占资源，提出新的资源申请，若不能满足，则释放所有资源，以后需要，再次重新申请。

• 破坏循环等待条件：

死锁的解除办法：

1、抢占资源。从一个或多个进程中抢占足够数量的资源，分配给死锁进程，以解除死锁状态。

2、终止（撤销）进程：将一个或多个死锁进程终止（撤销），直至打破循环环路，使系统从死锁状态解脱。

4、get和post的区别

两种 HTTP 请求方法：GET 和 POST
在客户机和服务器之间进行请求-响应时，两种最常被用到的方法是：GET 和 POST。

GET – 从指定的资源请求数据。
POST – 向指定的资源提交要被处理的数据

5、 HTTPS

• HTTPS：是以安全为目标的 HTTP 通道，是 HTTP 的安全版。
• HTTPS 的安全基础是 SSL。
• SSL 协议位于 TCP/IP 协议与各种应用层协议之间，为数据通讯提供安全支持。
• SSL 协议可分为两层：
• SSL 记录协议（SSL Record Protocol），它建立在可靠的传输协议（如TCP）之上，为高层协议提供数据封装、压缩、加密等基本功能的支持。
• SSL 握手协议（SSL Handshake Protocol），它建立在 SSL 记录协议之上，
• 用于在实际的数据传输开始前，通讯双方进行身份认证、协商加密算法、=交换加密密钥等。

二、HTTP 与 HTTPS 的区别

• 1、HTTPS 协议需要到== CA （ Certificate Authority，证书颁发机构）申请证书，一般免费证书较少，因而需要一定费用==。(以前的网易官网是http，而 网易邮箱 是 https 。)
• 2、HTTP 是超文本传输协议，信息是明文传输，HTTPS 则是具有安全性的 SSL 加密传输协议。
• 3、HTTP 和 HTTPS 使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。
• 4、HTTP 的连接很简单，是无状态的。HTTPS 协议是由 SSL+HTTP 协议构建的可进行加密传输、身份认证的网络协议，比 HTTP 协议安全。
• (无状态的意思是其数据包的发送、传输和接收都是相互独立的。无连接的意思是指通信双方都不长久的维持对方的任何信息。)

SSL 的功能实现主要依赖于三类基本算法：
散列函数 Hash、对称加密和非对称加密，
其利用 非对称加密 实现 身份认证 和 密钥协商 ，
对称加密 算法采用 协商的密钥 对数据加密，
基于 散列函数 验证 信息 的 完整性

对称加密

常见的有 AES-CBC、DES、3DES、AES-GCM 等，信息的加密和解密用相同的密钥，掌握密钥才能获取信息。在对称加密中，信息安全的基础是保证密钥的安全。