面试面经

一.海康威视笔试

1.Mysql

主键重新从1开始的指令：truncate [table] 表名
数据库的连接方式：

1、内连接(inner join)使用比较运算符进行表间某(些)列数据的比较操作，并列出这些表中与连接条件相匹配的数据行。根据所使用的比较方式不同，内连接又分为等值连接、自然连接和不等连接三种。

2、外连接分为左外连接(left out join或left join)、右外连接(right out join或right join)和全外连接(full out join或full join)三种。

3、交叉连接：返回到结果集合中的数据行数等于第一个表中符合查询条件的数据行数乘以第二个表中符合查询条件的数据行数。

2.算法

冒泡法的时间复杂度（O(n^2)）
单链表法添加和删除头结点、尾节点的时间复杂度为O(1)，查找操作以及向链表中间位置插入节点的时间复杂度则为O(n)-----需要遍历。

3.MVC

MVC（Model View Controller）是软件工程中的一种软件架构模式，它把软件系统分为模型、视图和控制器三个基本部分。用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。

MVC每层之间的逻辑关系：

M：Model，模型。 JavaBean

完成具体的业务操作，如：查询数据库，封装对象
V：view视图。JSP、HTML等来进行数据展示

C：Controller控制器。 Servlet

获取View的请求

调用模型将数据交给视图进行展示

4.线程

终止/停止线程的方法

使用标志位退出线程：定义一个boolean型的标志位，在线程的run方法中根据这个标志位是true还是false来判断是否退出
使用stop方法强制终止线程：stop方法是很危险的，就象突然关闭计算机电源，而不是按正常程序关机一样，可能会产生不可预料的结果，因此，并不推荐使用stop方法来终止线程。
使用interrupt方法终止线程
- （1）线程处于阻塞状态，如使用了sleep方法（处于暂停线程的状态）。
- （2）使用while（！isInterrupted（））{……}来判断线程是否被中断。
  在第一种情况下使用interrupt方法，sleep方法将抛出一个InterruptedException例外，而在第二种情况下线程将直接退出。

5.java基础

接口和抽象类的区别
- 1.默认的实现方法：
  （1）抽象类可以有默认的方法实现，但也可以有不能有方法实现的抽象方法。
  - 抽象类中可以有已经实现了的方法，也可以有被abstract修饰的方法（抽象方法）
  - 如果存在一个类存在抽象方法，那么该类必须是抽象类。
  （2）接口根本不存在方法的实现。
  - 但是接口要求只能包含抽象方法，抽象方法是指没有实现的方法。接口就根本不能存在方法的实现。
  2.子类使用的关键词不一样：
  （1）实现抽象类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。
  
  抽象类虽然不能实例化来使用，但是可以被继承，让子类来具体实现父类的所有抽象方法。但是如果子类将抽象方法没有全部实现，就必须把自己也修饰成抽象类，交于继承它的子类来完成实现。以此类推，直到没有抽象函数。
  
  （2）子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现。
  
  接口的实现，通过implements关键字。实现该接口的类，必须把接口中的所有方法给实现。不能再推给下一代。
  
  3.是否有构造器：
  （1）抽象类可以有构造器
  
  抽象类是属于类，享有类的所有特性（但是不能实例化），当然包括类的构造方法，也就是构造器。
  
  （2）接口不能有构造器
  
  接口是所有抽象方法的集合，注意，是集合，不是类。当然没有构造方法一说，更别提什么构造器了。
  
  4.可使用的修饰符：
  （1）抽象方法可以有public、protected和default这些修饰符
  
  抽象类的目的就是被继承，抽象方法就是为了被重写，所以肯定不能用private修饰符，肯定是可以用public的。但是protected和default也是可以的。
  
  （2）接口方法默认修饰符是public。你不可以使用其它修饰符。
  
  接口就有且只有一个public修饰。接口的方法隐藏了“public abstract”，所以接口的方法是抽象方法
  
  接口的属性都隐藏了“public static final”,所以接口的属性都是常量

5.增加新方法对子类的影响：
（1）如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。

抽象类可以有一些非抽象方法的存在，这些方法被称为默认实现。如果添加一个默认实现方法（不能是抽象方法），就不需要在子类中去实现，所以继承这个抽象类的子类无须改动。

如果你往接口中添加方法，那么你必须改变实现该接口的类。

（2）接口中只能添加抽象方法，当你添加了抽象方法，实现该接口的类就必须实现这个新添加的方法。

因为，定义中说的很清楚，接口的实现必须实现所有的方法。所有，当然包括新添加的方法。

**6.子类能继承的数量：**

- java中抽象类只有单继承，接口就可以实现多继承。
- 一个类只能继承一个父类，但是能实现多个接口

6.HTTPS

cookie
会话秘钥

7.代码实现一个简单的工厂模式

就是建立一个工厂类，对实现了同一接口的或者是存在继承关系的一些类进行实例的创建！！！

二.京东笔试

1.变量

访问控制修饰符Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java支持4种不同的访问权限。
默认的，也称为default，在同一包内可见，不使用任何修饰符

2.抽象类和接口

见上！！！！！！！

3.反射

获取反射的方式：

1.通过new对象实现反射机制

2.通过路径实现反射机制

3.通过类名实现反射机制

        //方式一(通过建立对象)
		Student stu = new Student();
		Class classobj1 = stu.getClass();
		System.out.println(classobj1.getName());
		
		//方式二（所在通过路径-相对路径）
		Class classobj2 = Class.forName("fanshe.Student");
		System.out.println(classobj2.getName());
		
		//方式三（通过类名）
		Class classobj3 = Student.class;
		System.out.println(classobj3.getName());

4.异常

5.JVM

常见的类加载器有

[：
垃圾回收自动调用的方法是：finalize()

6.mysql

索引失效的情况！！！！

7.算法分析

三.腾讯理财一面

1.算法题

链表删除数字相同的元素

2.mysql的隔离级别有哪些？有什么特点

3.mysql的索引是什么，有哪些运用了B+树，有哪些运用了B树？

四. 字节飞书客户端一面

1.手写代码深拷贝，浅拷贝

1.1 浅拷贝

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。即对象的浅拷贝会对“主”对象进行拷贝，但不会复制主对象里面的对象。”里面的对象“会在原来的对象和它的副本之间共享。

简而言之，浅拷贝仅仅复制所考虑的对象，而不复制它所引用的对象。

1.2 深拷贝

深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

public class testCopy {
   public static void main(String[] args) throws CloneNotSupportedException {
       Student s1=new Student();
       s1.setAge(10);
       s1.setName("zxh");

        Teacher t1=new Teacher(s1);
        t1.setAge(30);
        t1.setName("lyj");
        Teacher t2=(Teacher) t1.clone();

       System.out.println("=====================拷贝后老师的情况，以及老师学生的情况================");
        System.out.println("t1=t2:"+(t1==t2));
        System.out.println("t1名字+年龄:"+t1.getName()+t1.getAge());
       System.out.println( "t1老师的学生名字+年龄:"+t1.student.getName()+t1.student.getAge());
        System.out.println("t2老师的学生名字+年龄:"+t2.student.getName()+t2.student.getAge());

       System.out.println("=====================修改数据后老师的情况，以及老师学生的情况================");
       t2.setName("linyujun");
       t2.student.setAge(18);
       t2.student.setName("zyx");
       System.out.println("t1老师他的名字"+t1.getName());
       System.out.println("t2老师他的名字"+t2.getName());
       System.out.println( "t1老师的学生名字+年龄:"+t1.student.getName()+t1.student.getAge());
       System.out.println("t2老师的学生名字+年龄:"+t2.student.getName()+t2.student.getAge());
    }

}

//浅拷贝时，Teacher类和Student类
/*class Teacher implements Cloneable{
    public Teacher(){

    }
    public Teacher(Student student){
        this.student=student;
    }
    private int age;
    private String name;
    public Student student;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    @Override
        public Object clone() throws CloneNotSupportedException {
        Object object = super.clone();
        return object;
    }
}

 class Student{
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
    */


//深拷贝时，Teacher类和Student类
class Teacher implements Cloneable{
    public Teacher(){

    }
    public Teacher(Student student){
        this.student=student;
    }
    private int age;
    private String name;
    public Student student;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    @Override
    public Teacher  clone() throws CloneNotSupportedException {
        Teacher teacher  = (Teacher) super.clone();
        teacher.student=(Student)  student.clone();
        return teacher;
    }
}

class Student implements Cloneable{
    private int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
/*
浅拷贝结果：
=====================拷贝后老师的情况，以及老师学生的情况================
t1=t2:false
t1名字+年龄:lyj30
t1老师的学生名字+年龄:zxh10
t2老师的学生名字+年龄:zxh10
=====================修改数据后老师的情况，以及老师学生的情况================
t1老师他的名字lyj
t2老师他的名字linyujun
t1老师的学生名字+年龄:zyx18
t2老师的学生名字+年龄:zyx18

深拷贝结果：
=====================拷贝后老师的情况，以及老师学生的情况================
t1=t2:false
t1名字+年龄:lyj30
t1老师的学生名字+年龄:zxh10
t2老师的学生名字+年龄:zxh10
=====================修改数据后老师的情况，以及老师学生的情况================
t1老师他的名字lyj
t2老师他的名字linyujun
t1老师的学生名字+年龄:zxh10
t2老师的学生名字+年龄:zyx18
*/

2. 手写代码多态

写了很久，对代码不熟

父类的引用指向子类的对象
多态是对方法的多态，属性是没有多态的
多态存在的条件：继承关系，方法需要重写，父类引用子类的对象！！！
多态的好处及弊端：
好处：隐藏了子类类型，提高了代码的可扩展性。
弊端：只能使用父类的功能，无法使用子类的特有的功能，功能有限制。

public class Main {
    public static void main(String[] args) {
        //Scanner in = new Scanner(System.in);
        //int a = in.nextInt();
        //System.out.println(a);
        People p1= new Student();
        p1.say();
    }
}
 class People{
       public int id;
       public String name;
        public void say(){
             System.out.print("I'm a teacher!");
    }
 }
 class Student extends People{
       public int id;
       public String name;
        @Override
        public void say(){
             System.out.print("I'm a student!");
}
    }

作者太懒，持续更新中。。。。

posted @ 2021-05-08 19:43 维他命D片阅读(44) 评论(0) 编辑收藏举报

刷新页面返回顶部

维他命D片