Java面试基础

这都是我师兄面试过程中会涉及到的，后面太多就没找。。。

一、软件开发流程

软件的需求定义与分析、设计、实现、测试、交付和维护

需求确认——概要设计——详细设计——编码——单元测试——集成测试——系统测试——维护

1. 瀑布式开发

       要求明确的需求，大家按照需求一步步做好规划，在项目运作过程中严格产出各种文档，按着流程一步步走下去。这种模式一般适用于需求比较明确、to B端项目。

2. 敏捷开发

       首先把客户最关注的软件原型先做出来，交付或者上线，在实际场景中去修改弥补需求中的不足，快速修改，再次发布版本。再次上线或者交付。通过一些敏捷实践方式，细化story，可以提供更小的迭代。如此循环，直到用户（客户）满意。适用于需求不明确的项目、创新性的项目或者需要抢占市场的项目。

       与其在两者之间做取舍，不如将敏捷融合到瀑布式开发环境中，这样可以提高项目的可预测性、提高成本效益，并促使项目最终获得成功。

        

3. DevOps

       DevOps被理解为公司在技术，组织和文化上的转变，以更有效，可靠和安全地运行软件。    DevOps是能够更快，更好地交付软件。

　　自动化 持续集成（CI） 持续交付（CD）

       持续集成的流程：

        

 

 

 

（1）开发人员每天提交代码提交到gitlab代码仓库；

（2）jenkins使用git工具到gitlab里面去拉取代码到集成服务器（jenkins），在配合JDK，maven等软件完成代码的编译，代码测试与审查，测试，打包等工作，如果在执行的过程中出错，将重新执行整个流程

（3）jenkins把生成的jar包或者war包分发到测试服务器或者生产服务器，用户就可以从网站访问应用。

 

二、Java基础

1. 面向过程 （C语言）

　　面向过程就是面向解决问题的过程进行编程。它首先分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，在使用时依次调用，是一种基础的顺序的思维方式。  自顶向下，逐步细化！

 

2. 面向对象（C++、Java语言）  

       在编程的时候尽可能的去模拟真实的现实世界，按照现实世界中的逻辑去处理一个问题，分析问题中参与其中的有哪些实体，这些实体应该有什么属性和方法，我们如何通过调用这些实体的属性和方法去解决问题。万物皆对象！面向对象是以功能划分问题。

面向对象四个特性：

抽象：抽象(Abstract)是将有关事物的共性归纳、集中的过程。抽象的作用表示同一类事物的本质，在抽象过程中，常常会忽略与当前主题目标无关的那些方面，以便更充分地注意到与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，忽略与主题无关的细节。

封装：就是把过程和数据包围起来，对数据的访问只能通过已定义的接口。封装(Encapsulation)性是面向对象程序设计方法的一个重要特性。封装包含两层含义，一是将抽象得到的有关数据和操作代码相结合，形成一个有机的整体，对象之间相对独立，互不干扰。二是封装将对象封闭保护起来，对象中某些部分对外隐蔽，隐藏内部的实现细节，只留下一些接口接收外界的消息，与外界联系，这种方法称为信息隐蔽(Information Hiding)。信息隐蔽有利于数据安全，防止无关的人了解和修改数据。

封装保证了类具有较好的独立性，防止外部程序破坏类的内部数据，使得程序维护修改比较容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。

继承：在面向对象程序设计中，如果已经建立一个类A，又需要建立另一个与A基本相同，但增加了一些属性和方法的类B，这时没有必要从头设计一个新类，只需在类A的基础上增加一些新的内容即可。即一个新类可以从现有的类中派生，这个过程称为类继承(Inheritance)。新类继承了原来类的特性，称为原来类的派生类(子类)，而原来类称为新类的基类(父类)。

       继承提供了一种明确表述共性的方法，允许和鼓励类的重用，不仅可以利用自己建立的类，还可以使用别人建立的或者存放在类库中的类。

多态：多态性(Polymorphism)是指允许不同的对象对同一消息做出不同的响应，执行不同的操作。例如，用同样的加法把两个时间加在一起和把两个整数加在一起的内涵肯定完全不同。

多态性是通过函数重载和虚函数等技术来实现的，利用多态性，可以在基类和派生类中使用同样的函数名，而定义不同的操作，从而实现"一个接口，多种方法“，这是一种在运行时出现的多态性，它通过派生类和虚函数来实现。

 

3. 8大数据类型 字节大小

 

 

 

4. 包装类型 int integer 为什么要有  ？转化类型 强转

　　在某些场合不能使用基本类型必须使用包装类，比如集合能接收的类型为Object,基本类型是无法添加进去的，还有范型也必须使用包装类。

包装类型是引用类型，说白了就是一个类，既然是类，里面可以有属性和方法，它里面有哪些属性和方法呢？每个包装类型和基本数据类型都是大同小异的，我们拿Integer 和 int来举例说明：

假设有这样一个场景，我接收到一个String型的数据想把它转换为整型，如果没有包装类这个操作是无法完成的，有了包装类我们可以这样做：

parseInt就是Integer包装类提供的一个将字符串转成int型的方法。

 

 

5. 字符串 string  stringbuffer  stringbuilder  区别

（1）运行速度

在这方面运行速度快慢为：StringBuilder > StringBuffer > String

String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。

Java中对String对象进行的操作实际上是一个不断创建新的对象并且将旧的对象回收的一个过程，所以执行速度很慢。而StringBuilder和StringBuffer的对象是变量，对变量进行操作就是直接对该对象进行更改，而不进行创建和回收的操作，所以速度要比String快很多。

（2）线程安全

在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的。

Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区，但不能修改。虽然在任意时间点上它都包含某种特定的字符序列，但通过某些方法调用可以改变该序列的长度和内容。

java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。

String：适用于少量的字符串操作的情况

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况

StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况

 

 6. string常用方法 比较大小 equals

String类常用的方法：

length（）：求字符串的长度

indexOf（）：求某个字符在字符串中的位置

charAt（）：求一个字符串中某个位置的值

equals（）：比较两个字符串是否相同

replace（）：将字符串中的某些字符用别的字符替换掉。形如 replace（“abc”,”ddd”）;

split（）:根据给定正则表达式的匹配拆分此字符串。形如 String s = “The time is going quickly！”;str1=s.split(" ");

substring（）：输出一个新的字符串，它是此字符串中的子串，形如 substring（3,7）；

它将字符串中的第四个 截取 第五个第六个输出。

trim（）：将字符串开头的空白（空格）和尾部的空白去掉。

format（）:使用指定的语言环境、格式字符串和参数返回一个格式化字符串。

toLowerCase（）:将字符串中所有的大写改变成小写

toUpperCase（）：将字符串中所有的小写改变为大写

getBytes():获取字符串字节数组

 

7. final finally try catch

       首先需要明白  final和finally是关键字，finalize是一个方法。

       1. final关键字        final可以修饰类、方法、变量，

（1）修饰类表示类不可以被继承

（2）修饰方法表示此方法不可以被重写(覆盖)但是可以被重载

（3）修饰变量表示变量不可变(引用不可变--也就是不可以重新指向另一个对象，但是引用内容可以变)，而且static final 经常用作常量处理。

       2. finally的使用:     通常用于try..catch..之后关闭一些IO流等操作

（1）try语句没有被执行，如在try语句之前就返回了，这样finally语句就不会执行；因此说明了finally语句被执行的必要而非充分条件是：相应的try语句一定被执行到。

（2）如果在try代码块中执行System.exit(0)语句;那么将终止Java虚拟机JVM，因此，finally语句也不会被执行到。

（3）finally块的语句在try或catch中的return语句执行之后返回之前执行且finally里的修改语句可能影响也可能不影响try或catch中return已经确定的返回值，如果返回值类型为传址类型，则影响；传值类型，则不影响。若finally里也有return语句则覆盖try或catch中的return语句直接返回。

　　3. finalize()析构方法的使用

　　　　finalize()在JVM回收对象的时候会调用该对象的此方法，用于垃圾回收的时候处理一些事情。

 

8. 类 内部类 外部类 匿名类   https://www.jianshu.com/p/f0fdea957792

我们所说的内部类，官方的叫法是嵌套类(Nested Classes)。嵌套类包括静态内部类(Static Nested Classes)和内部类(Inner Classes)。而内部类分为成员内部类，局部内部类(Local Classes)和匿名内部类(Anonymous Classes)。

外部类：最普通的，我们平时见到的那种类，就是在一个后缀为.java的文件中，直接定义的类，比如

public class Student {
    private String name;
    private int age; 
}

内部类：内部类，顾名思义，就是包含在外部类中的类，就叫做内部类。内部类有两种，一种是静态内部类，一种是非静态内部类（成员内部类、局部内部类）。

静态内部类：

public class School {
    private static School instance = null;
    static class Teacher {}
}

创建静态内部类：以Class.Iner的形式 School.Teacher teacher = new School.Teacher();

成员内部类：

public class OuterCls {
        private String name;
        public String getName(){
            return name;
        }
        class InerCls{
            private String name;
            public String getName(){
                   return name;
            }
        }
}

创建内部类对象方法，以object.new Iner的形式：OuterCls outerCls = new OuterCls();

OuterCls.InerCls inerCls = outerCls.new InerCls(); 

局部内部类：

public class OuterCls {
        private String name;
        public String getName(){
            return name;
        }
        public void getInerCls(){
            class InerCls{
                    private String name;
                    public String getName(){
                    return name;
                    }
                }
        }
}
    

作为非静态内部类的一种特殊形式, 非静态内部类的所有限制对局部类同样成立。局部类不仅可以访问外部类的所有成员，还可以访问方法体的局部变量，但必须是final修饰的局部变量。局部类访问局部变量，变量必须加上final

匿名内部类：为了免去给内部类命名，或者只想使用一次，就可以选择使用匿名内部类。

public void countDown(){
        new Thread(){
            @Override
            public void run() {

            }
        }.start();
}

 

9. 静态方法 构造方法   https://blog.csdn.net/ForeverNagisa/article/details/79017439

 

 

用static 修饰的方法就是静态方法。静态方法是不能向对象施加操作的方法。

静态方法：是使用公共内存空间的，所有对象都可以直接引用，不需要创建对象再使用该方法。

构造方法：一个类 可以有多个构造函数。构造函数的主要作用 一是用来实例化该类。二是 让该类实例化的时候执行哪些方法，初始化哪些属性。

 

10. 栈区 堆区 方法区 https://blog.csdn.net/weixin_44135991/article/details/91351656?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~aggregatepage~first_rank_ecpm_v1~rank_v31_ecpm-2-91351656.pc_agg_new_rank&utm_term=%E5%A0%86%E3%80%81%E6%A0%88%E3%80%81%E6%96%B9%E6%B3%95%E5%8C%BA&spm=1000.2123.3001.4430

https://blog.csdn.net/qq_33591903/article/details/102741487?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2~aggregatepage~first_rank_ecpm_v1~rank_v31_ecpm-3-102741487.pc_agg_new_rank&utm_term=%E5%A0%86%E3%80%81%E6%A0%88%E3%80%81%E6%96%B9%E6%B3%95%E5%8C%BA&spm=1000.2123.3001.4430

首先来看一道题 :

单选题 : 方法通常存储在进程中的哪个区 ?

A. 堆区

B. 栈区

C. 全局区

D. 方法区

这个题我们要注意的是题干的问题,是问"进程"中的哪个区,而不是JVM中的哪个区.答案是D。

（1）堆区：存储的是一切new出来的对象。

（2）栈区：存储基本数据类型的值和对象引用。

每个栈中的数据(基础数据类型和对象引用)都是私有的,其他栈不可以访问。

栈分为三个部分：基本类型变量区,执行环境上下文,操作指令区(存放操作指令)。

（3）方法区：保存所有的class文件和static变量与方法。

举例 :String str = new String(“hello”);

堆 存储的是new出来的对象, jvm中只有一个堆区, 被所有的线程共享

栈 是变量str, 每个栈中的数据私有的, 其他栈不可以访问

方法区 是"hello" , 被所有的线程共享, 方法区包含所有的class static变量

栈和堆的区别就像 :

使用栈就像是去饭馆里吃饭, 只管点菜, 付钱和吃, 吃饱了就走, 不必理会切菜, 洗菜等准备工作和洗碗刷锅等, 他的好处是快捷, 但是自由度小

使用堆就像是自己动手做饭, 比较麻烦, 但是比较符合自己的口味, 而且自由度大.

 

 

11. 重载 重写 区别 https://www.cnblogs.com/upcwanghaibo/p/6527354.html

方法重载是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同。

方法重写是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型。

注:(1)子类中不能重写父类中的final方法

(2)子类中必须重写父类中的abstract方法

总结：多态性是面向对象编程的一种特性，和方法无关，简单说，就是同样的一个方法能够根据输入数据的不同，做出不同的处理，即方法的重载——有不同的参数列表（静态多态性）

而当子类继承自父类的相同方法，输入数据一样，但要做出有别于父类的响应时，你就要覆盖父类方法，即在子类中重写该方法——相同参数，不同实现（动态多态性）

 

12. 集合 collection：list map set 区别  https://www.cnblogs.com/chenglc/p/8073049.html

https://zhuanlan.zhihu.com/p/165914686

 

集合的主要三种类型

List：一种有序列表的集合，例如，按索引排列的Student的List；

Set：一种保证没有重复元素的集合，例如，所有无重复名称的Student的Set；

Map：一种通过键值（key-value）查找的映射表集合，例如，根据Student的name查找对应Student的Map。

 

 

常见面试笔试题:Arraylist，LinkedList，Vector的区别

 

 

13. 线程安全 有序集合 无序

14. hashmap底层实现原理红黑树

15. 线程 进程 含义 区别 线程的调用方法（4种） 线程池核心参数 线程同步

16. 设计模式 解决方案 单例模式 饿汉懒汉区别（线程安全） 工厂模式 代理模式

17. IO

18. 文件

19. JVM 垃圾回收算法 新生代 老年代

20. Java8新特性 流

 

框架

1. SSM spring springmvc mybatis  spring(ioc控制反转 aop面向切片编程 bean事务) 、MVC（执行流程）（模型视图控制器 dao层 controler层 service层）、mybatis（JDBC数据库驱动）
2. Springboot（常见注解）（简化spring自动装配原理 autowired）、springcloud （微服务）

 

前端

1. HTML CSS JS
2. Vue react

 

机器学习

1. 十大算法

 

Linux

1. 常见命令

 

计算机网络

1. Tcp ip
2. Tcp udp
3. 七层 四层 五层协议
4. 网页跳转
5. Tcp 安全传输 三次握手四次挥手
6. 塞包
7. Cookie session 区别
8. https dns

 

数据库

1. 常见数据库 mysql oracle
2. 索引 哪些索引 索引的数据结构（B+树） 红黑树 B树
3. 引擎 innodb myIasm 区别
4. 事务 acid、隔离级别、
5. Sql优化
6. 编写常见命令
7. 乐观锁 悲观锁

 

操作系统

1. 死锁 并行 并发
2. 锁 ….

 

数据结构

1. 排序算法
2. 栈 队列 先进先出
3. 二叉树遍历 先序后序
4. 平衡二叉树 概念
5. B+树 B树 存储过程
6. 图 广度优先 深度优先
7. 哈夫曼树
8. 最小生成树 prim krustral 贪婪算法

 

Radis（键值对 key value）缓存数据库

1. 使用场景（缓存 排行榜 数据库 计数器 发布订阅）
2. 数据类型（8大 string hash zset 3地图 graph）

 

Mongodb 数据库 文字方面

 

工具类

　　Idea  java8 jdk8

　　数据库连接 navicate

　　代码管理工具 git （push pop）

 

消息队列

　　微服务 kafka（工作原理） rabbitmq rocketmq 区别 应用场合

 

测试

1. 黑盒 白盒 灰盒 单元测试 集成测试 系统测试 验收测试 压力测试
2. 校验规则  用户登录