15道面试题

1、面向对象的三大特征？

封装、继承、多态

封装就是把同一类事物的属性和方法归到同一个类中，方便使用防止该类的代码和数据被外部类定义的代码随意访问要访问该类的数据和代码必须通过严格的方法控制

继承继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法

多态封装和继承几乎都是为多态而准备的多态是同一个行为具有多个不同表现实行或形态的能力多态是一个接口，使用不同的实例而执行不同的操作

2、ArrayList和LinkedList区别？

ArrayList是基于数组实现，LinkedList是基于链表实现。
ArrayList在查找时速度快，LinkedList在插入与删除时更具优势。
LinkedList 比 ArrayList 需要更多的内存

3、接口和抽象类的异同是什么？

相同点：
--都可以出现抽象方法
--都不能被实例化
--都需要子类重写抽象方法
--接口和抽象类体现了继承结构里的抽象层

 附：问题: 抽象层的表现可以是接口?也可以是抽象类?--到底设计成谁?
 答案: 看需不需要提供方法体。
        如果都是抽象方法,那就直接设计成接口,还可以多继承多实现更灵活。
        如果有普通方法,那就还是设计成抽象类吧,坏处是只能单继承。

不同点：
--抽象类里有构造方法,用来给子类创建对象.接口里没有构造方法.
--抽象类里有变量,但是接口里,只有常量,会为简写的常量自动拼接public static final
--抽象类里有普通方法,但是接口里,都是抽象方法(除了jdk1.8)
--接口里的抽象方法可以简写,会为简写的抽象方法自动拼接public abstract
--抽象类只能是和子类之间发生单根继承关系 -
-接口和实现类之间是实现关系,而且可以多实现
--接口和接口之间是继承关系,而且可以多继承
--接口是为了突破java单继承的局限性来的

4、说说反射的用途？

反射最重要的用途就是开发各种通用框架。

反射机制是Java语言中一个非常重要的特性，它允许程序在运行时进行自我检查，同时也允许对其内部成员进行操作。反射机制提供的功能主要有：得到一个对象所属的类；获取一个类的所有成员变量和方法；在运行时创建对象；在运行时调用对象的方法。

5、解释什么是JSON？

json就是一种在各个编程语言中流通的数据格式，负责不同编程语言中的数据传递和交互。

(1)JSON 是一种轻量级的数据交换格式。
(2)JSON 独立于语言和平台，JSON 解析器和 JSON 库支持许多不同的编程语言。
(3)JSON的语法表示三种类型值，简单值(字符串，数值，布尔值，null),数组，对象

6、AJAX请求的时候get和post方式有什么区别？

1.使用Get请求时,参数在URL中显示,而使用Post方式,则不会显示出来
2.使用Get请求发送数据量小,Post请求发送数据量大
3.get请求需注意缓存问题,post请求不需担心这个问题

7、简单解释JavaScript中闭包的用法？

闭包可以用在许多地方。它的最大用处有两个，一个是可以读取函数内部的变量。另一个就是让这些变量的值始终保持在内存中。

1、提供一种间接访问函数内部变量的方法
2、延长函数内部的局部变量的生命周期(慎用！局部变量过多会占大量内存)
3、全局变量私有化，减少全局变量污染
4、函数局部变量在函数执行完后释放内存(函数执行完毕，其内部的变量立即销毁)
5、更新复杂变量(可以对变量进行校验和判断，保证安全性和稳定性)

8、数据库事务ACID原则？

A 原子性：顾名思义原子就不可在分的，事务作为一个整体，对数据库的执行要么成功，要么失败。
C 一致性：事务从一个一致状态转换到另一个一致状态。
I 隔离性：多个事务并发执行，事务之间的执行互不干扰。
D 持久性：一旦一个事务提交，它对数据库的操作将永久保存到数据库当中。

9、SQL语句

10、请说明进程和线程的区别？并说出三种进程间通讯的方式及三种线程同步的方法？

1.进程是资源分配的最小单位，线程是程序执行的最小单位（资源调度的最小单位）

2.进程有自己的独立地址空间，每启动一个进程，系统就会为它分配地址空间，建立数据表来维护代码段、.堆栈段和数据段，这种操作非常昂贵。而线程是共享进程中的数据的，使用相同的地址空间，因此CPU切换一个线程的花费远比进程要小很多，同时创建一个线程的开销也比进程要小很多。

3.线程之间的通信更方便，同一进程下的线程共享全局变量、静态变量等数据，而进程之间的通信需要以通信的方式（IPC)进行。

4.多进程程序更健壮，多线程程序只要有一个线程死掉，整个进程也死掉了，而一个进程死掉并不会对另外一个进程造成影响，因为进程有自己独立的地址空间。

11、请对冒泡排序、插入排序、堆排序、快速排序的速度进行排序？并说明哪种算法是稳定的？如果对学生成绩进行排序应该使用哪一种？

冒泡排序>插入排序>快速排序>堆排序

稳定的：冒泡排序、插入排序、

冒泡插入

12、请说明IO操作中同步和异步的区别？

同步是阻塞模式，异步是非阻塞模式。

同步： 就是指一个进程在执行某个请求的时候，若该请求需要一段时间才能返回信息，那么这个进程将会一直等待下去，直到收到返回信息才继续执行下去；

异步： 是指进程不需要一直等下去，而是继续执行下面的操作，不管其他进程的状态。当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率。

13、单例模式特点？你还知道哪些设计模式？

java中单例模式是一种常见的设计模式，单例模式分两种：懒汉式单例、饿汉式单例

特点:
1、单例类只能有一个实例。
2、单例类必须自己自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例。
单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例。在计算机系统中，线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例。这些应用都或多或少具有资源管理器的功能。每台计算机可以有若干个打印机，但只能有一个Printer Spooler，以避免两个打印作业同时输出到打印机中。每台计算机可以有若干通信端口，系统应当集中管理这些通信端口，以避免一个通信端口同时被两个请求同时调用。

23种设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

14、什么是视图？有什么优缺点？

视图(VIEW)也被称作虚表，即虚拟的表，是一组数据的逻辑表示,其本质是对应于一条SELECT语句，结果集被赋予一个名字，即视图名字。视图本身并不包含任何数据，它只包含映射到基表的一个查询语句，当基表数据发生变化，视图数据也随之变化。

视图的优点
(1)视图能简化用户的操作
(2)视图机制可以使用户以不同的方式查询同一数据
(3)视图对数据库重构提供了一定程度的逻辑独立性
(4)视图可以对机密的数据提供安全保护

15、1³+5³+3³=153 这样的数叫水仙花数，请编程写出1000以内水仙花数水仙花数？

 public class Test {
        public static void main(String[] args) {
            //  打印1-1000的水仙花数水仙花数：
            // 例如 153=1*1*1+5*5*5+3*3*3
            //定义标记，水仙花数起始值位0
            int count =0;
            //要找出1000以内的水仙花数，先要遍历其每个数字；因为水仙花数是三位数所以从100开始
            for (int i = 100; i < 1000; i++) {
                //取出个位
                int g = i%10;
                //取出十位
                int s = i/10%10;
                //取出百位
                int b = i/100;
                //判断每个位上的立方和是否等于它自己,如果是则打印出该数字
                if (g*g*g+s*s*s+b*b*b==i){
                    //如果是水仙花数，count加一
                    count++;
                    System.out.println(i);
                }
            }
            System.out.println("1000以内水仙花数的个数："+count);
        }
    }

16.Java语言中访问修饰符有哪些？作用域分别是什么？

public 当前类同包类子孙类所有包
protected 当前类同包类子孙类
default 当前类同包类
private 当前类

17.下列程序会输出什么？

String a="abc";
String b="a";
String c=b+"bc";
String d="a"+"bc";
String e=c.intern();
System.out.println(a==c); //false
System.out.println(a==d); //true
System.out.println(a==e); //true

18.创建线程的方式有哪些？线程的生命周期有哪些?

实现Runnable接口
继承Thread类
生命周期：新建可运行运行阻塞死亡

19.简述List、Set、Map集合有哪些子类？子类的使用场景有哪些？应用场景

20.简述接口和抽象类的区别与使用场景？

接口中没有构造方法抽象类中有构造方法
接口与类之间是实现关系可以多实现、接口和接口是继承的关系可以是多继承抽象类与子类之间是继承关系单继承
接口使用interface修饰抽象类是abstract 修饰
接口中只有常量抽象类中可以有变量
接口中的普通方法必须需要加default或static修饰抽象类中不需要

21.数组[2,3,5,8,9,0,7,6,1],请用程序找出数组中最大的三个数。

package 面试;

import java.util.Arrays;

public class 排序 {

    public static void main(String[] args) {

        int[] arr = {2,3,5,8,9,0,7,6,1};
        int date;
        for(int i = 0;i<arr.length;i++) {
            for (int j = i+1; j < arr.length; j++) {
                if (arr[i]<=arr[j]) {
                    date=arr[j];
                    arr[j]=arr[i];
                    arr[i]=date;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
        System.out.println(arr[0]+","+arr[1]+","+arr[2]);
        
        int[] arr1 = {2,3,5,8,9,0,7,6,1};
        Arrays.sort(arr1);
        System.out.println(arr1[arr1.length-1]+","+arr1[arr1.length-2]+","+arr1[arr1.length-3]);
        
    }

}

22.有三个线程A、B、C，请写出程序使得三个线程

（1）同时执行
（2）A、B同时执行后执行C
（3）先执行线程A，A执行结束后执行线程B，B执行结束后执行线程C

package 面试;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Thread3 implements Runnable {

    final Lock lock = new ReentrantLock();

    private String name;

    public Thread3(String name) {
        super();
        this.name = name;
    }

    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            System.out.println("线程" + name + ":" + i);
        }
    }

    public static void main(String[] args) {
        Thread3 t1 = new Thread3("A");
        Thread3 t2 = new Thread3("B");
        Thread3 t3 = new Thread3("C");

        Thread A = new Thread(t1);
        Thread B = new Thread(t2);
        Thread C = new Thread(t3);
//第二题答案~~~~
        try {
            A.start();
            B.start();
            B.join();
            C.start();
            C.join();

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}