Java面试题【1】

Java面试题——选择题部分

• Java面试题——编程题部分
• Java面试题——简答题部分

1.下面sum的值是（ D ）

int sum = 1;
for (int i = 0; i <10; i++){
    i++;  //1 3 5 7 9
    sum += i;  //1+1+3+5+7+9
}
System.out.println(sum);
A.46  B.24  C.45  D.26

2.下面程序的运行结果（ A ）

Integer a = 300;	//自动装箱 a = new Integer(300)
Integer b = 300;	//自动装箱 b = new Integer(300)
int c = 300 ;
System.out.println(a == b);	// false
System.out.println(a == c);	// true  == 两侧为引用类型和基本数据类型，将自动拆箱，进行数值比较  
A.false ; true
B.false ; false
C.true ; false
D.true ; true

自动拆装箱操作：从JDK1.5开始提供，自动拆箱是在编译期完成，自动拆装箱底层都是通过调用方法来完成

• xx.java： Integer a = 100; int x = a;
• xx.class： Integer a = Integer.valueOf(100); int x = a.intValue();

valueOf()：Integer底层实现是：判断整数的值，是否处于-128~127之间，若处于该区间，则返回常量池中的Integer对象，不会新建，若整数不处于该区间，此时底层 new Integer(i)，为新创建的对象

基本数据类型的包包装类中 所有的整数都有常量池，小数（浮点型）、布尔是没有常量池的

3.若x是float类型变量，x=10/4; 则x的值是（ B ）

A. 2   B. 2.0   C. 2.5   D. 编译错误      

4.以下程序的输出结果是（x= 99 , x= 201）

public class HasStatic() {
    private int x = 100;
    public static void main(String[] args) {
        HasStatic has1 = new HasStatic();
        has1.x++;
        HasStatic has2 = new HasStatic();
        has2.x += has1.x;
        has1 = new HasStatic();
        has1.x--;
        System.out.println("x=" + has1.x);	//99
        System.out.println("x=" + has2.x);	//201
    }
}

//考点: 实例变量是属于实例的，会随着实例的重新创建而重新初始化

5.以下程序的输出结果是（x= 200）

public class HasStatic() {
    private static int x = 100;
    public static void main(String[] args) {
        HasStatic has1 = new HasStatic();
        has1.x++;
        HasStatic has2 = new HasStatic();
        has2.x += has1.x;
        has1 = new HasStatic();
        has1.x--;
        HasStatic.x--;
        System.out.println("x=" + has1.x);	//200
    }
}

//考点: static变量是属于类的，在类加载时期完成初始化，且只初始化一次

6.以下程序的输出结果是（200 300 400 500）

public class Test{
    static{
        System.out.println("200");
    }
    public Test(){
        System.out.println("500");
    }
    {
        System.out.println("300");
    }
    public static void main(String[] args) {
        new Test();
    }
    {
        System.out.println("400");
    }
}

// static代码块 ->  代码块（构造块） ->  构造方法

7.以下程序的输出结果是（x= 200）

String s1 = "abc", s2 = "def", s3 = "abcdef";
String s4 = s1 + s2;
String s5 = "abc" + "def";
String s6 = new String("abc");

System.out.println(s1 == s6);	//false
System.out.println(s3 == s4);	//false
System.out.println(s3 == s5);	//true

//1.字符串变量之间的拼接在运行期完成，通过StringBuilder进行拼接，StringBuilder的toString()方法底层是new String
//2.字符串字面量之间的拼接在编译期完成

8.String str = new String(“abc”)创建了几个StringObject

//2个  一个是 new String, 另一个是 字面量 “abc”

9.String str = new String(“ab” +“c” + “d”)创建了几个String对象

//2个  一个是 new String, 另一个是 字面量 “abcd” 是因为字符串字面量之间的拼接是在编译期完成的
//在 .class文件中代码为 String str = new String("abcd")

10.下面程序的运行结果（ C ）

abstract class MineBase {
    abstract void amethod();
    static int i;
}

public class Mine extends MineBase {
    public static void main(String[] args) {
        int[] ar = new int[5];
        for (i = 0; i < ar.length; i++) {
            System.out.println(ar[i]);
        }
    }
}

A. 打印5个0
B. 编译出错，数组ar[]必须初始化
C. 编译出错，Mine应声明为abstract
D. 出现IndexOutOfBoundsException异常

11.下面哪个关键字，使类不能再被其他类继承（C）

A.static  B.finally  C.final  D.instance

• final：是一个修饰符

  1. 类：类不能被继承
  2. 方法：方法不能被重写
  3. 变量：可以是成员变量也可以是局部变量，变量值一旦初始化不可改变
     • 修饰成员变量：必须在声明同时初始化
     • 修饰局部变量：可以先声明再初始化

• static：是一个修饰符

  1. 成员变量：在类加载时期完成初始化，且只初始化一次，通过类名调用，也可通过对象调用不过不推荐
  2. 方法：通过类名调用静态方法，static方法内部不能使用this、super关键字（静态方法中是通过类名来调用方法的，不存在通过实例来调用，this是引用，指向调用当前方法的对象，super指向的是父类对象，所以都不存在，而非静态方法默认存在this、super关键字）
  3. 代码块：在类加载时期执行结束，且只执行一次

  注：static可以修饰类，但必须是内部类，如LinkedList的内部类Node，其本质是修饰类中的成员，内部类就是类中的成员

• finally：和try...catch配合使用，finally块中的代码不论之前是否有异常出现，都会执行，通常在finally块中保存释放资源的代码

• instanceof：判断某个实例是否属于某种类型

  eg：if(per instanceof Person)

12.下面程序的运行结果（ C ）

public class Ppvg{
    public static void main(String[] args) {
        Ppvg p = new Ppvg();
        int x = p.flition();
        System.out.println(x);
    }
    public int flition(){
        try{
            FileInputStream din = new FileInputStream("Ppvg.java");
            din.read();
        }catch(IOException e){
            System.out.println("flytwick");
            return 99;
        }finally{
            System.out.println("flition");
        }
        return -1;
    }
}

A. 程序正常运行并输出: "flition" 和 99
B. 程序正常运行并输出: "flytwick"、"flition" 和 -1
C. 程序正常运行并输出: "flytwick"、"flition" 和 99
D. 在编译时产生错误，因为flition方法要求返回两个值

//以上代码执行流程

/*
9行 执行时会报异常，若通过输入流直接写入文件名称，可能出现找不到，因为直接找的是当前项目下，而类存在于src下

抛出异常后被 11行 捕获异常 进入 catch块 输出 12行内容   "flytwick"

如果 try...catch块中有 finally ，finally必执行，则会在 catch块返回时 先进入 finally块 输出 15行内容   "flition"

最后返回 catch块 执行 13行 返回 99 程序结束

所以最终输出   "flytwick"、"flition" 和 99
*/

13.下面程序的运行结果（ C ）

public class Ppvg{
    public static void main(String[] args) {
        Ppvg p = new Ppvg();
        int x = p.flition();
        System.out.println(x);
    }
    public int flition(){
        int i = 99;
        try{
            FileInputStream din = new FileInputStream("Ppvg.java");
            din.read();
        }catch(IOException e){
            System.out.println("flytwick");
            return i;
        }finally{
            i++;
            System.out.println("flition");
        }
        return -1;
    }
}

A. 程序正常运行并输出: "flition" 和 99
B. 程序正常运行并输出: "flytwick"、"flition" 和 100
C. 程序正常运行并输出: "flytwick"、"flition" 和 99
D. 在编译时产生错误，因为flition方法要求返回两个值

//以上代码执行流程

/*
10行 执行时会报异常，若通过输入流直接写入文件名称，可能出现找不到，因为直接找的是当前项目下，而类存在于src下

抛出异常后被 12行 捕获异常 进入 catch块 输出 13行内容   "flytwick" ,此时 14行 返回时 i=99

如果 try...catch块中有 finally ，finally必执行，则会在 catch块返回时 先进入 finally块 执行 16行 i=100 ,输出 17行内容   "flition"

最后返回 catch块 执行 14行,此时到底 返回100还是99 答案是返回 99 程序结束
其涉及内部操作，当catch一开始要返回时，因为finally中的代码必须执行，此时catch中的return就会暂停，但其实是知道要返回的值是多少，相当于在这里会拍一个快照，在之后执行任何操作都不会影响这个快照，之后返回的值还是这个快照中的值，而finally修改的是方法里的值，返回的是之前记录的值，所以finally中的操作属于附带操作


所以最终输出   "flytwick"、"flition" 和 99
*/

14.下面哪些是合法标识符（ A 、B、E）

A. $persons
B. TwoUsers 
C. *point
D. this
E. _ending
F. 2_4dis

//所以 标识符 是由 数字、字母、_、$ 组成,且数字不能开头，且不能使用Java已经定义好的关键字

15.已知如下的命令执行 java MyTest a b c，请问哪个选项是正确的（C ）

A. args[0]="MyTest a b c"
B. args[0]="MyTest" 
C. args[0]="a"
D. args[1]="b c"

关于 java命令：在jdk目录下bin文件夹下的可执行文件 就是一条条命令
搭建Java环境：安装JDK和配置JDK环境变量

• JAVA_HOME： JDK的安装路径

• path： bin目录的路径

• classpath：. 类库

• java 命令：关于运行，运行字节码文件的名称

  • java class_name --对某个类运行,执行其main方法

• javac 命令 关于编译，指定java源文件进行编译产生.class文件

  • javac xx.java --对源文件进行遍历

• 如果想传参 只需 在多个参数间 空格 即可

16.选项中哪个放到x处可保证程序正常编译（ C ）

interface Foo{
    int bar();
}
public class Sprite{
    public int fubar(Foo foo){
        return foo.bar();
    }
    public void testFoo(){
        fubar();//此处为X
    }
}

A. Foo{ public int bar({return 1;}}
B. new Foo{public int bar({return 1;}}
C. new Foo(){public int bar({return 1;}}
D. new class Foo{public int bar(ireturn 1;}}

//接口 中的方法是抽象方法
//匿名内部类
new Foo(){	//创建匿名内部类对象
    //重写抽象方法
    bar(){
        //...
    }
}

17.下面程序的运行结果（ D ）

class A{
	void foo() throw Exception{
        throw new Exception();
    }
}
class SubA extends A{
    void foo(){
        System.out.println("A");
    }
}
class Tester{
    public static void main(String[] args) {
        A a = new SubA();
        a.foo();
    }
}

A. A
B. A ，抛出Exception
C. 编译失败，7行出现错误
D. 编译失败，14行出现错误
E. 无输出，但抛出Exception

重写的规则：2同2小1大

• 2同：方法名相同，参数列表相同
• 2小：子类方法返回值类型小于等于父类。子类方法抛出的异常小于等于父类（抛出异常数量，子类方法抛出异常类型可以是父类抛出异常类型的子类）
• 1大：子类重写方法的访问控制修饰符必须大于等于父类

通过父类类型的引用调用重写的方法

• 运行期：一定调用的是重写后的方法，即是子类的
• 编译期：调用到的是数据类型所属类的方法，看的是左侧的类型，即调用的方法是父类中的方法

​
所以本题中 14行 需要捕获或抛出异常

18.下面程序的运行结果（ D ）

static void test() throws RuntimeException{
    try{
        System.out.print("test");
        throw new RuntimeException();
    }catch(Exception e){
        System.out.print("exception");	//这里已经捕获了异常
    }
}
public static void main(String[] args) {
    try{
        test();
    }catch(RuntimeException ex){
        System.out.print("runtime");	//已经没有异常要捕获了
    }
    System.out.print("end");
}

A. test end
B．编译失败
C. test runtime end
D. test exception end

19.请指出以下代码是否有错误及其控制台输出

public class test{
    private static Integer b;	//null

    public static void main(String[] args) {
        int a = 10;
        print(a);
        print(b);	//编译期无异常，运行时异常  此时会报空指针异常 
        b = a;
        print(b);
    }

    private static void print(Integer value){
        int add = value + 5;	//value.intValue()
        System.out.println("add value = " + add);
    }
}

//最终  先输出 add value = 15,然后抛出 NullPointerException

20.下面程序的运行结果（ A ）

public class A implements B{
    public static void main(String[] args) {
        int i;
        A c1 = new A();
        i = c1.K;	//正常通过类名、接口名访问；通过实例访问静态常量可以，不过不建议
        System.out.print("i = " + i);
    }
}

interface B{
    int K = 10;
}

A. i = 10
B．编译失败

21.下面程序的运行结果（ B ）

public static void main(String[] args) {
    Thread t = new Thread(){
        public void run(){
            pong();
        }
    }
    t.run();	//并不是启动线程，直接调用run() 只是个普通方法，所以只有一个线程
    System.out.print("ping");
}
static void pong(){
    System.out.print("pong");
}

A. pingpong
B．pongping
C. pingpong 和 pongping 都有可能
D. 都不输出

//start()和run() 
//	start()表示启动线程
//	直接调用run()方法只是普通方法的调用，线程并没有启动

22.下面程序在JDK1.8的环境下，描述正确的是（ A 、D）

interface Er{
    double PI = 3.14;
    void tongdian();
    public default void duandian(){
    }
}
interface Ar{
    public default void duandian(){
    }
}
class Dfqc implements Er,Ar{
    public void tongdian(){
        System.out.print("通电函数" + PI);
    }
    public class Test{
        public static void main(String[] args) {
            Dfqc t = new Dfqc();
            t.tongdian();
            t.duandian();
        }
    }
}

A．在类Dfqc中，没有实现duandian(）方法，编译不通过
B．在接口中定义的PI没有用final修饰，不是常量，可以更改数值
C．编译正确，duandian()方法是接口中定义的普通方法，在JDK1.8后允许，实现类对象可以直接调用
D．编译错误，duandian()方法在卜接口中均存在，类Dfqc实现了两个接口，该类中必须重写duandian()编译才正确

/*
JDK1.8的新特性

1. lambda表达式
2. 新日期 LocalDateTime.now()
3. 接口中可以定义默认方法和static方法
4. ::   方法引用

lambda表达式作用: 为简化代码而出现  ()-> {}
	1.实现功能性接口（函数式接口）
		功能性/函数式接口: 接口中只有一个抽象方法，可以有多个静态方法，默认方法且在接口上方有注解@FunctionalInterface
		lambda表达式各部分代表的意义: 
        	(): 重写方法的参数列表 
        	{}: 重写方法的方法体
		lambda表达式各部分的简化:  
			(): 参数列表中的数据类型都可以省略;若参数列表中只有一个参数,此时()可以省略,若参数列表无参或有多个参数，此时()都不可以省略		
			{}: 若体部分只有一行代码,此时{}可以省略,若体部分只有一行代码且有return，此时return也可以省略	
	2.对集合进行遍历
		集合若想使用lambda表达式遍历，需要集合对lambda的支持，支持是指:看集合中是否提供forEach()，若有则可以使用lambda对集合进行遍历
		list.forEach(str->System.out.println(str));
		set.forEach(str->System.out.println(str));
		map.forEach((k, v)->System.out.println(k+"-"+v));


新日期 LocalDateTime.now()
	LocalDateTime time = LocalDateTime.now();
	System.out.println(time);
	旧日期	Date date = new Date(); 	
	

接口中可以定义默认方法和static方法
	JDK1.8之前，接口中有的成员只有:
		常量(接口为其提供了默认修饰符) public static final
		抽象方法(接口为其提供了默认修饰符) public abstract
	JDK1.8开始，允许在接口中定义默认方法和static方法:
		默认方法需要添加修饰符 default，通过接口的实现类对象来调用方法
		若一个实现类实现了两个接口，且两个接口中有相同的默认方法，此时在实现类汇总必须对该方法进行重写，否则编译不通过
		静态方法 和平时的static方法定义是相同的，通过接口名调用static方法即可


:: 方法引用:  用于简化lambda表达式的，不做其他
		简化的前提:lambda表达式中的参数会作为参数传递给体中调用的方法，且是所有参数都传递给调用的方法，此时使用 :: 来简化lambda表达式
	(a,b,c)->{A.test(a,b,c)}  ==》 A::test
	1. static方法引用
		 1．定义功能性接口
		 2．出现接口作为参数出现
		 3．使用::简写lambda表达式
     2. 实例方法引用
     3. 构造方法引用
     4. 数组的构造方法引用
	
*/

23.下面那些异常是检查异常，需要在编写程序时声明（ C ）

A．NullPointerException
B．ClassCastException
C．FileNotFoundException
D．IndexOutOfBoundsException

//所有异常的父类 Throwable,其子类有 Exception、Error
/*
Error:
栈内存溢出异常:	StackOverFlowError
	递归没有出口、递归深度太深
堆内存溢出异常:	OutOfMemoryError
	创建的对象太大、内存泄漏的一直累积
Exception:
检查异常: 在编译过程中可检测到的，且必须处理的异常，若不处理编译不通过
	文件找不到异常:	FileNotFoundException
	IO异常:	IOException
	中断异常:	InterruptedException
	解析异常:	ParseException
	类找不到异常:	ClassNotFoundException
	特点:所有的检查异常一定是在方法声明位置通过throws来抛出了异常类型
运行时异常: 在编译期检测不到，是在运行期出现的异常
	空指针异常:	NullPointerException
	类转换异常:	ClassCastException
	下标越界异常:	IndexOutOfBoundsException
	数字转换异常:	NumberFormatException

throws 和 throw 的区别:用法不一样
throws: 作用于方法声明位置，抛出的是异常类型
throw: 作用于方法体中，抛出的是异常对象

*/

24.下面程序，当输入2时返回值是多少（ D ）

public static int getValue(int i){
    int result = 0;
    switch(i){
        case 1:
            result = result + i;
        case 2:
            result = result + i * 2;	//分支中没有break; 则继续向下执行
        case 3:
            result = result + i * 3;
        return result;
    }     
}

A. 2   B. 0   C. 4   D. 10  

25.选项中哪一行代码可以替换题目中//add code here 而不产生编译错误（ A ）

public abstract class Myclass{
    public int constInt = 5;
    //add code here
    public void method(){        
    }
}

A．public abstract void method(int a);	//重载
B．constInt = constInt + 5;	//执行代码不能直接写在类的成员位置，必须存在{}中
C．public int method();	//抽象方法没有abstract; 和类中的method方法签名完全一致，不能存在同一个类中
D．public abstract void anotherMethod(){}	//抽象方法不能有方法体

• 重写：是出现在父子类中
• 重载：是指在同一个类中出现的方法名相同，参数列表不同的方法,重载和方法的返回/访问控制修饰符都无关

26.下面程序在执行new Child("mike")的时候输出结果（ D ）

class People(){
    String name;
    public People(){	//这里隐藏了super(); 
        System.out.print(1);
    }
    public People(String name){	//这里隐藏了super(); 
        System.out.print(2);
        this.name = name;
    }
}
class Child extends People(){
    People father;
    public Child(String name){	//这里隐藏了super(); 
        System.out.print(3);
        this.name = name;
        father = new People(name + ":F");
    }
    public Child(){	//这里隐藏了super(); 
        System.out.print(4);
    }
}

A. 312   B. 32   C. 432   D. 132  

//构造方法的第一行代码永远都是super()

27.下面程序的运行结果（0,6）

public class SubCls extends SuperCls{
    int a = 6;
    public SubCls(){
        test();
    }
    public void test(){
        System.out.println(a);
    }
    public static void main(String[] args){
        new SubCls();
    }
}

class SuperCls{
    int a = 8;
    public SuperCls(){
        test();
    }
    public void test(){
        System.out.println(a);
    }
}

//运行结果: 0 6

/*
成员变量不进行初始化的话也会有默认初始值，在刚创建好对象时就赋有初始值
人为初始化后，仍会有默认初始值
关于成员变量人为初始化的时机,在构造方法里面进行初始化
在运行期时，若一个方法在父子类中都存在，到底调用谁，看运行期创建的对象
若父子类中都存在一个相同的变量，值不同，则子类访问子类的，父类访问父类的
*/

28.下面程序的运行结果（ B ）

class Base{
    Base(){
        System.out.println("Base");
    }
}
public class Alpha extends Base{
    public static void main(String[] args){
        new Alpha();
        new Base();
    }
}

A．Base
B．Base Base
C. 编译失败
D．代码运行但没输出
E. 运行时抛出异常

//子类构造方法中第一行是 super()

29.下面程序的运行结果（ B ）

public class Test1{
    public static void main(String[] args){
        System.out.println("返回值为:" + new Test1().test());
    }
    public int test(){
        int i = 1;
        try{
            System.out.println("try中的i值为:" + i);	// 1
            return i;	// 1  返回快照 1
        }finally{
            ++i; // 2
            System.out.println("finally中的i值为:" + i); // 2
        }
    }
}

A． 1 1
B． 1 2 1
C.  1 2 2
D． 1 2

30.哪个语句创建了一个数组实例（ A ）

A．int[] i = new int[15];
B．float f = new float[20];		//左边是变量，右边是对象 类型不匹配
C. char[] c = "Some String";	//左边是字符数组，右边是字符串  类型不匹配
D．int a[][] = {3,12,15}{1123,53,5};	//二维数组  

//数组中的元素类型可以是任意的(机泵数据类型，引用类型),而数组本身就是引用类型，若数组中的元素为数组类型，则出现了二维数组/多维数组
/*

关于二维数组:
定义:
	初始化方式1:直接赋值
		int[][] ary = {{1,3},{4,25,1},{123,5,12,54}};
	初始化方式2:若二维数组的长度一致，此时可以采用以下方法
		int[][] ary = new int[4][2];  
		
访问:
	访问某个位置的元素,通过下标访问 arr[1][1]
遍历:
	for循环遍历,for循环里嵌套for循环
*/

31.下面程序中插入哪行代码可以编译通过（ B 、D）

class Test{
    public static void main(Stirng arg){
        doSomething(1);
        doSomething(1,2);        
    }
    //插入代码处
}

A．static void doSomething(int[] args){}
B．static void doSomething(int...args){}
C. static void doSomething(int...args,int x){}
D．static void doSomething(int x,int...args){}
E. static void doSomething(int...arg1,int...arg2){}

//关于可变参数: 个数可变的参数
/*
格式: int...is
可变参数的访问:
	1.其底层为数组，所以访问方式和数组相同
	2.因为可变参数的底层是数组，所以可以接受数组
	3.但反过来如果方法参数列表是数组，只能传递相同数据类型的值，即接受的值一定是数组，不能是其他类型
	4.可变参数若出现在参数列表中,则必须是参数列表的最后一个参数
	5.参数列表中的可变参数最多只能有一个，不管是不是同一数据类型(一刀切)
*/

32.下面程序中插入哪行代码可以编译通过（A）

public class A{
    public static void main(Stirng arg){
        List list = new ArrayList();
        Teacher a = new Teacher();
        a.name = "王五";
        a.age = 30;
        list.add(a);
        a.name = "张三";
        a.age = 40;
        list.add(a);
        Teacher b = (Teacher) list.get(0);
        b.name = "李四";
        b.age = 50;
        list.add(b);
        System.out.println(list.get(0));	//集合中保存的是对象的引用
        System.out.println(list.get(1));
    }

    static class Teacher{	
        public String name;
        public int age;
        public String toString(){
            return name + ":" + age;
        }
    }
}

A: 李四:50 李四:50
B: 王五:30 李四:50
C: 王五:30 张三:40
D: 张三:40 李四:50

33.编写一个Filter，需要（B）

A: 继承Filter类
B: 实现Filter接口	//含抽象方法 doFilter() 过滤功能写在这个方法中
C: 继承HttpFilter类
D: 实现HttpFilter接口

34.哪一个对象可以用于获取浏览器发送的请求（A）

A: HttpServletRequest
B: HttpServletResponse
C: HttpServlet
D: Http

35.下面程序的运行结果（ A ）

String a = "AAA";
a.toLowerCase();
System.out.println(a);

A. aaa   B. AAA   C. a   D. A 

36.以下语句public class A{}中，能合法定义的有（A、B、C）

A: public class innerClass{}
B: public static class nestedClass{}
C: public interface nestedInterface{}
D: public static Iterator<A> iterator = 

37.父类SuperClass中定义了protected SuperClass map(int a,long b)方法，以下可以在子类中单独声明的方法有（A、C、D）

A: public SuperClass map(int a,long b)
B: private SuperClass map(int a,long b)
C: public SuperClass map(int a,int b)
D: protected ChildClass map(int a,long b)
E: public long map(int a,long b)

• 重写：2同2小1大
  • 2同：方法名相同,参数列表相同
  • 2小：子类抛出异常类型 <= 父类方法抛出异常;子类返回值类型 <= 父类方法返回值类型
  • 1大：子类方法访问控制修饰符 >= 父类方法访问控制修饰符
• 重载：方法名相同,参数列表不同;和方法的其他部分无关

38.数据库有两张表为user表和user_role表，执行以下语句之后获取到的结果为（A）

SELECT u.* ,r.name FROM USER u LEFT JOIN user_role r ON u.id = r.user_id

user表数据            user_role表数据
id username			id  username   user_id
1     张三		     1	  售后        1
2     李四            2    运维        2
3     王五            3    研发        3
4     小刘            4    实施        5

A.  1   张三  售后
    2   李四  运维
    3   王五  研发
    4   小刘  null
B.  1   张三  售后
    2   李四  运维
    3   王五  研发
C.  1   张三  售后
    2   李四  运维
    3   王五  研发
   null null  实施

联查：

• 内连接查询：（inner）join 查询结果为满足所有条件的数据

  select ... from a join b on a.xx = b.xx
  

• 外连接查询：

  • 左外连：left join 左表为主表，即主表中所有的数据为查询的结果，若右表中有匹配的数据，填充值，若无匹配数据，则以null进行填充
  • 右外连：right join 右表为主表，即主表中所有的数据均显示，另外的表中若无匹配数据，则以null进行填充

• 等值连接查询：

  select ... from a,b where a.xx = b.xx