面试题答案

昨天把面试题分享出来，不知道大家感觉难度怎么样？今天我把大概的答案写出来，作为总结吧。

1、表的级联是什么意思？数据库里的内连接和外连接是什么意思？

级联：级联是用来设计一对多关系的。例如一个表存放老师的信息:表A（姓名，性别，年龄），姓名为主键。还有一张表存放老师所教的班级信息:表B（姓名，班级）。他们通过姓名来级联。级联的操作有级联更新，级联删除。 在启用一个级联更新选项后，就可在存在相匹配的外键值的前提下更改一个主键值。系统会相应地更新所有匹配的外键值。如果在表A中将姓名为张三的记录改为李四，那么表B中的姓名为张三的所有记录也会随着改为李四。级联删除与更新相类似。如果在表A中将姓名为张三的记录删除，那么表B中的姓名为张三的所有记录也将删除。

内连接（JOIN或INNER JOIN）：指使用INNER JOIN关键字将多个数据表连接起来，同时列出这些表中与连接条件相匹配的数据行。（返回的源数据行必须满足ON子句中的搜索条件）

示例：
SELECT a.xh,a.xm,a.lldh,a.jtdz,b.xf.b.bz
FROM t_stud as a
INNER JOIN t_credit as b
on a.xh = b.xh
ORDER BY a.xh

外连接：分为左外连接（LEFT OUTER JOIN），右外连接（RIGHT OUTER JOIN）和完全外连接（FULL OUTER JOIN）

左外连接：指将左表的所有数据分别和右表中的每条数据进行连接组合，返回的结果包括左表中不符合条件的数据，并在右表的相应列中添加NULL值。

示例：
SELECT a.xh,a.xm,a.lldh,a.jtdz,.b.xf,b.bz
FROM t_stud as a
LEFT_OUTER JOIN t_credit as b
on a.xh = b.xh
ORDER BY a.xh

右外连接：指将右表的所有数据分别和左表中的每条数据进行连接组合，返回的结果包括右表中不符合条件的数据，并在左表的相应列中添加NULL值。

示例：
SELECT a.xh,a.xm,a.lldh,a.jtdz,.b.xf,b.bz
FROM t_stud as a
RIGHT_OUTER JOIN t_credit as b
on a.xh = b.xh
ORDER BY a.xh

完全外连接：指将左表的所有数据分别和左表中的每条数据都进行连接组合，返回的结果集除了内连接的数据外，还有两个表中不符合条件的数据，并在左或右表的相应列中添加NULL值。

示例：
SELECT a.xh,a.xm,a.lldh,a.jtdz,.b.xf,b.bz
FROM t_stud as a
RIGHT_OUTER JOIN t_credit as b
on a.xh = b.xh
ORDER BY a.xh

2、设计一个表结构，如何做到多个用户对应多个角色及多个权限。

这个问题我在51CTO博客上找到了比较好的解答，我把原文链接发出来，大家可以去看看http://blog.51cto.com/11156310/2058134

3、Java中的public,private,default,protected修饰权限的区别。

修饰类的权限：

普通类：public、default、abstract、final

内部类：public、protected、static、private、abstract、final；访问权限的控制和方法是一样的。

Public：可以在整个项目中使用
Protected：只能在本包中和继承关系中使用
default：只能在本包中使用
Private：只能在本类中使用
Abstract：抽象类，需要继承关系实现
Final：最终的类，不能被继承的类
Native：本地的，不是Java语言书写的

修饰成员变量的权限：public、protected、default、private、static、final

Public：可以在整个项目中使用
Protected：只能在本包中和继承关系中使用
default：只能在本包中使用
Private：只能在本类中使用
Static：不用创建实例就可以使用的类的变量
Final：最终成员变量，不可以改变的常量

修饰成员方法的权限：public、static、private、protected、abstract、final、synchronized、native

Public：可以被其他任何类访问
Static：不用创建实例就可以使用，通过类名.就可以调用
Private：在该类中可以访问该方法
Protected：子类可以访问，同包中也可以访问
Abstract：抽象的方法，无方法体
Final：最终方法，可以被继承，但不能被改写
Synchronized：基于线程安全机制，加锁执行
Native：集成其他语言的代码，在java中没有代码体
default：系统默认只能在同一个包中访问该方法

4、接口和抽象类的区别，有哪些应用场景，抽象类是否可以多继承，抽象类是否可以实现具体方法。

抽象类：用关键字abstract修饰的类叫抽象类，同样，用abstract修饰的方法叫抽象方法。

重点：
1、抽象类不能直接被实例化，必须由子类创建对象。
2、抽象类必须被继承，抽象方法必须被重写。
3、抽象类的子类也可以是抽象类。
4、继承抽象类的非抽象类，必须实现超类中的全部抽象方法。

接口：使用interface声明，是抽象类的一种。

重点:
1、接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。
2、在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。

接口和抽象类的区别：

1. 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3. 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
4. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

5、排序算法有哪些？请用java实现冒泡排序的算法。

常见的排序算法有冒泡排序、快速排序、选择排序、插入排序、希尔排序。

1、冒泡排序

public class BubbleSort {
　　public static void main(String[] args) {
　　　　int[] arr={6,3,8,2,9,1};
　　　　System.out.println("排序前数组为：");
　　　　for(int num:arr){
　　　　　　System.out.print(num+" ");
　　　　}
　　　　for(int i=0;i<arr.length-1;i++){//外层循环控制排序趟数
　　　　　　for(int j=0;j<arr.length-1-i;j++){//内层循环控制每一趟排序多少次
　　　　　　　　if(arr[j]>arr[j+1]){
　　　　　　　　　　int temp=arr[j];
　　　　　　　　　　arr[j]=arr[j+1];
　　　　　　　　　　arr[j+1]=temp;
　　　　　　　　}
　　　　　　}
　　　　} 
　　　　System.out.println();
　　　　System.out.println("排序后的数组为：");
 　　　　for(int num:arr){
 　　　　　　System.out.print(num+" ");
 　　　　} 
　　}
 }

2、快速排序算法

public class FastSort{
 public static void main(String []args){
    System.out.println("Hello World");
    int[] a = {12,20,5,16,15,1,30,45,23,9};
    int start = 0;
    int end = a.length-1;
    sort(a,start,end);
    for(int i = 0; i<a.length; i++){
         System.out.println(a[i]);
     }       
 }
 public void sort(int[] a,int low,int high){
     int start = low;
     int end = high;
     int key = a[low];
          
     while(end>start){
         //从后往前比较
         while(end>start&&a[end]>=key)  //如果没有比关键值小的，比较下一个，直到有比关键值小的交换位置，然后又从前往后比较
             end--;
         if(a[end]<=key){
             int temp = a[end];
             a[end] = a[start];
             a[start] = temp;
         }
         //从前往后比较
         while(end>start&&a[start]<=key)//如果没有比关键值大的，比较下一个，直到有比关键值大的交换位置
            start++;
         if(a[start]>=key){
             int temp = a[start];
             a[start] = a[end];
             a[end] = temp;
         }
     //此时第一次循环比较结束，关键值的位置已经确定了。左边的值都比关键值小，右边的值都比关键值大，但是两边的顺序还有可能是不一样的，进行下面的递归调用
     }
     //递归
     if(start>low) sort(a,low,start-1);//左边序列。第一个索引位置到关键值索引-1
     if(end<high) sort(a,end+1,high);//右边序列。从关键值索引+1到最后一个
 }
 
}

3、选择排序

	public class SelectionSort {	 
    public static void selectionSort(int[] a) {
        int n = a.length;
        for (int i = 0; i < n; i++) {
            int k = i;
            // 找出最小值的下标
            for (int j = i + 1; j < n; j++) {
                if (a[j] < a[k]) {
                    k = j;
                }
            }
            // 将最小值放到未排序记录的第一个位置
            if (k > i) {
                int tmp = a[i];
                a[i] = a[k];
                a[k] = tmp;
            }
        }
    }
 
    public static void main(String[] args) {
        int[] b = { 49, 38, 65, 97, 76, 13, 27, 50 };
        selectionSort(b);
        for (int i : b)
            System.out.print(i + " ");
    }
}

6、Android里如何实现用户退到后台，还能继续收到消息（即消息栏的实现）

详解请看https://blog.csdn.net/qq_34908107/article/details/75105971

7、Android如何实现应用自动启动？

详解请看https://blog.csdn.net/a872822645/article/details/74740544

8、session和cookie的区别，请说明如何实现用户10天内可以免登录及自动登录。

1、cookie数据存放在客户的浏览器上，session数据放在服务器上。
2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗，考虑到安全应当使用session。
3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能，考虑到减轻服务器性能方面，应当使用COOKIE。
4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。
5、所以个人建议：
将登陆信息等重要信息存放为SESSION
其他信息如果需要保留，可以放在COOKIE中

来自于https://www.cnblogs.com/shiyangxt/articles/1305506.html

实现用户N天内免登录

详解请看https://blog.csdn.net/a997208868/article/details/47787305

用户自动登录

详解请看https://blog.csdn.net/qq_28292937/article/details/51967292?locationNum=10

9、前后端分离，前端如何拿到后端数据？

请移步到https://www.cnblogs.com/feipengting/p/8371680.html

10、介绍下你做的android应用所用到的框架。

这个问题比较主观了，大家根据自己的实际项目来回答吧，没有固定答案。