企业面试问题收集-java基础

Posted 2021-03-14 coder-wf

Java基础部分

1.1   在登录时进行后台验证，后台获取到loginpass与数据库值对比一直？

1.2   Java中的方法覆盖（Overwrite）和方法重载（Overloading）是什么意思？

重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同(即参数个数或类型不同)。

重写Override表示子类中的方法可以与父类的某个方法的名称和参数完全相同，通过子类创建的实例对象调用这个方法时，将调用子类中的定义方法，这相当于把父类中定义的那个完全相同的方法给覆盖了，这也是面向对象编程的多态性的一种表现。

1.3   接口和抽象类的区别是什么？

抽象类：含有abstract修饰的类即为抽象类，抽象类不能创建实例对象。含有abstract方法的类必须定义为抽象类，抽象类中的方法不必是抽象的。抽象类中定义抽象方法必须在具体子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。

接口：可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。

下面比较一下两者的语法区别

1. 抽象类可以有构造方法，接口中不能有构造方法。

2. 抽象类中可以有普通成员变量，接口中没有普通成员变量

3. 抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。

4. 抽象类中的抽象方法的访问类型可以使public、protected和默认类型，但接口中的抽象方法只能是public类型的，并且默认修饰即为public abstract类型。

5. 抽象类中可以包含静态方法，接口中不能包含静态方法

6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

7. 一个类可以实现多个接口，但只能继承一个抽象类。

 

1.4   创建线程有几种不通的方式？

l  自定义类继承Thread类方式

l  自定义类实现Runnable接口方式

(1)进程和线程的概念

进程：运行中的应用程序成为进程，拥有系统资源（cpu，内存）

线程：进程中的一段代码，一个进程中可以有多段代码，本身不拥有资源（共享所在进程的资源）

在Java中程序入口被自动创建为主线程，在主线程中可以创建多个子线程，

两者区别：

1：是否占有资源的问题

2：创建或撤销一个进程所需要的开销比创建或撤销一个线tt程所需要的开销大

3：进程为重量级组件，线程为轻量级组件

多进程：在操作系统中能同时运行多个任务（程序）

多进程：在同一应用程序中有多个功能流同时进行

(2)线程的主要特点

1：不能以一个文件名的方式独立存在在磁盘中

2：不能单独执行，只有在进程启动后才可以启动

3：线程可以共享进程相同的内存（代码和数据）

(3)线程的主要用途

1：利用他可以完成重复性的工作----如实现动画，声音等的播放

2：从事一次性比较费时的初始化工作----如网络连接，声音数据问价的加载

3：并发执行的运行效果（一个进程多个线程）以实现更复杂的功能

（4）多线程（多个线程同时运行）程序的主要优点

1：可以减少系统性能方面的瓶颈，因为可以并行操作；

2：提高cpu的处理器的效率，在多线程中，通过优先级管理，可以使重要的程序优先操作，提高了任务管理的灵活性；另一方面，在多cpu系统中，可以把不同的线程在不同的cpu中执行，真正做到同时处理任务。

（5）线程的创建和启动

看api可以看出，从Tread的构造方法创建一个线程的方式

Thread()           分配新的 Thread 对象。

Thread(Runnable target)           分配新的 Thread 对象。

Thread(Runnable target,String name)           分配新的 Thread 对象。

Thread(String name)           分配新的 Thread 对象。

Thread(ThreadGroup group,Runnable target)           分配新的 Thread 对象。

Thread(ThreadGroup group,Runnable target,String name)           分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，并作为 group 所引用的线程组的一员。

Thread(ThreadGroup group,Runnable target,String name, long stackSize)           分配新的 Thread 对象，以便将 target 作为其运行对象，将指定的 name 作为其名称，作为 group 所引用的线程组的一员，并具有指定的堆栈大小。

Thread(ThreadGroup group,String name)           分配新的 Thread 对象。

后面4个 构造方法创建一个线程并加入到一个线程组中，但是创建线程的方式和前面的相似。

Java中创建一个线程有两种方式：

第一种：继承Tread类，重写run（）方法，然后直接new这个对象的实例，创建一个线程的实例。然后调用start（）方法启动线程

第二种：实现Runnable接口，重写run（）方法，然后调用new Tread（runnable）的方式创建一个线程，然后调用start（）方法启动的线程

 

1.5   Java集合框架的基本接口有哪些？

Collection接口

Ø  List接口

Ø  Set接口

Map接口

1.6   BlockingQueue是什么？

1.BlockingQueue:支持两个附加操作的 Queue，这两个操作是：检索元素时等待队列变为非空，以及存储元素时等待空间变得可用。

2.BlockingQueue 不接受 null 元素。

3.BlockingQueue 可以是限定容量的。

4.BlockingQueue 实现是线程安全的。Queue不是线程安全的。因此可以将Blockingqueue用于用于生产者-消费者模式。

对于BlockingQueue队列而然，如果BlockQueue是空的，从BlockingQueue取东西的操作将会被阻断进入等待状态，直到BlockingQueue进了东西才会被唤醒，同样，如果BlockingQueue是满的，任何试图往里存东西的操作也会被阻断进入等待状态，直到BlockingQueue里有空间才会被唤醒继续操作。

1.7   Java中的两种异常类型是什么？

Error：称为错误，由java虚拟机生成并抛出，包括动态链接失败，虚拟机错误等，程序对其不做处理。

Exception：所有异常类的父类，其子类对应了各种各样的可能出现的异常事件，一般需要用户显示的声明或捕获。

Runtime Exception:一类特殊的异常，如被0除、数组下标超范围等，其产生比较频繁，处理麻烦，如果显示的声明或捕获将会对程序可读性和运行效率影响很大。因此由系统自动检测并将它们交给缺省的异常处理程序（用户可不必对其处理）。

1.8   Final,finallyfinalize的区别？

final用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。内部类要访问局部变量，局部变量必须定义成final类型。

finally是异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提高垃圾收集时的其他资源回收，例如关闭文件等。JVM不保证此方法总被调用。

1.9   Java中如何实现序列化，有什么意义？

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决对象流读写操作时可能引发的问题（如果不进行序列化可能会存在数据乱序的问题）。

要实现序列化，需要让一个类实现Serializable接口，该接口是一个标识性接口，标注该类对象是可被序列化的，然后使用一个输出流来构造一个对象输出流并通过writeObject(Object)方法就可以将实现对象写出（即保存其状态）；如果需要反序列化则可以用一个输入流建立对象输入流，然后通过readObject方法从流中读取对象。序列化除了能够实现对象的持久化之外，还能够用于对象的深度克隆。

1.10          多线程问题

1.11          都用过什么设计模式

单例设计模式

工厂设计模式

模板设计模式

装饰设计模式

代理设计模式

适配器设计模式

1.12          写一个单例模式出来

饿汉模式

 1 public class Single {
 2 
 3         //私有本类中的构造函数
 4 
 5         private Single(){}
 6 
 7         //创建本类对象
 8 
 9         private static Single s = new Single();
10 
11         //对外提供获取本来对象方法
12 
13         public static Single getInstance(){
14 
15                 return s;
16 
17         }
18 
19 }

 

注意问题：

　　由于外界无法创建Single对象，没有对象，那就无法调用getInstance方法，这时需要将getInstance方法静态化，这样外界就可以通过类名直接调用该方法。

 

懒汉模式

 1 public class Single
 2 
 3 {
 4 
 5         //私有构造函数
 6 
 7         private Single(){}
 8 
 9         //在本类中创建本类对象
10 
11         private static Single instance = null;
12 
13         //对外提供静态访问方法，获取本类实例对象
14 
15         public static Single getInstance(){ 
16 
17                 if(instance == null )  // 这里会有线程安全问题
18 
19                 {
20 
21                         instance = new Single();
22 
23                 }
24 
25                 return instance;
26 
27         }
28 
29 }

 

 1 class SingleDemo
 2 
 3 {
 4 
 5         public static void main(String[] args)
 6 
 7         {
 8 
 9                 //获取Single类的实例对象s
10 
11                 Single s = Single.getInstance();
12 
13                 //获取Single类的实例对象s2
14 
15                 Single s2 = Single.getInstance();
16 
17                 System.out.println(s==s2); //true
18 
19         }
20 
21 }