java面试题

Posted 2022-12-08 MyAzhe0ci3

数据库

1.动态查询如何实现?表的结构变化后，如果不需要修改程序，如何设计和实现查询？

答：将查询语句封装进存储过程中,通过调用储存过程实现动态调用;修改相应的存储过程即可不在修改程序的情况下实现查询。

2.如何优化数据库,如何提高数据库的性能？

答：优化数据库主要是优化查询语句,通过高性能的查询语句提高数据库的性能。

3.设计数据库应该注意那些问题?

答:首先应该满足三范式的要求,在一定程度上打破三范式的要求以提高数据库的性能。

4.什么是三范式？

答：
第一范式：每个字段只存储一个值。例如：职工号,姓名，电话号码组成一个表(一个人可能有一个办公室电话和一个家里电话)
第二范式：必须符合1NF的条件,且每一行都能被唯一的识别.将1NF转换成2NF的方法是添加主键。学号,课程名，成绩
第三范式：如果一个表满足了2NF,且不包含传递依赖性,则这个表就是第三范式

5.储存过程和函数的区别？

答：储存过程是用户定义的一系列sql语句的集合,涉及特定的表或其他对象的任务,用户可以调用存储过程,而函数是数据库已经定义好的方法,它接收参数并且返回某种类型的值。

6.主键和外键的区别？

答：主键是唯一,非空的.外键可以重复可以为空；外键和另外一张表的主键关联，不能创建对应表中不存在的外键。

7.什么是事务

答:事务是作为一个逻辑单元执行的一系列操作,一个事务必须有四个属性,简称为ACID(原子性,一致性，隔离性和持久性)

1. 原子性：对于数据修改,要么全部执行,要么全部不执行
2. 一致性：事务在完成之前,必须使所有的数据保持一致状态
3. 隔离性：由并发事务所作的修改必须与任何其他并发事务所作的修改隔离.事务查看数据时所处的状态,要么时另一并发事务修改它之前的状态,要么时修改它之后的状态,事务不会查看中间状态的数据.这成为可串行性
4. 持久性：事务完成之后,它对系统的影响是永久的.改修改即使出现系统 故障也将一直保持

8.游标的作用？

答：如何知道游标已经到了最后？游标用于定位结果集的行,通过判断全局变量@@FETCH_STATUS可以判断是否到了最后,通常此变量不等于0表示出错或到了最后

9.触发器分为事前触发和事后触发,这两种触发有何区别?

答：事前触发器运行于触发事件发生之前,而事后触发器运行于触发事件发生之后。通常事前触发器可以获取事件之前和新的字段值。

10.语句级触发和行级触发有何区别?

答:语句级触发器可以在语句执行钱或后执行,而行级触发在触发器所影响的每一行触发一次。

11.请列举一些当前流行的数据库引擎

答：SQL SERVER,ORACLE,BDE,mysql

12.写出从数据库表Custom中查询No,Name,Num1,Num2并将Name以姓名显示,计算出的和以总和显示的SQL

SELECT No,Name as ‘姓名’ ,Num1,Num2,(Num1+Num2) As ‘总和’ FROM Custom;

13.内联接

select a.id,a.xx,a.xx,b.id,b.xx,b.xx from a inner join b on a.id=b.id

14.批处理

答：是包含一个或多个Transact-SQL语句的组,从应用程序一次性发送到Microsoft SQL Server执行。批作为一个整体执行,以Go命令结束，批处理是客户端作为一个单元发送的一个或多个SQL语句的集合。每个批处理编译为一个执行计划。

15.触发器

答：

• 触发器是在对表进行插入,更新或删除操作时自动执行的储存过程
• 触发器通常用户强制业务规则
• 触发器可以确保数据的完整性和一致性

16.锁

答：是在多用户环境中对数据访问的限制封锁就是事务 T 在对某个对象(如表,记录等)操作之前,先向系统发出请求,对其加锁.加锁后事务 T 就对该数据对象有了一定的控制,在事务T释放它的锁走之前,其他的事务不能更新此数据对象。(锁蕴含的基本概念是用户需要对表的排他访问),从程序员的角度来说：分为乐观锁和悲观锁

• 乐观锁：完全依靠数据库来管理锁的工作
• 悲观锁：程序员自己管理数据或对象上的锁处理

17.什么是子查询？

答：一个SELECT语句嵌套在另一个SELECT语句中.

18.索引

答：是一个数据库对象,它是表中一列或若干列的集合和相应的指向表中物理标识这些值的数据页的逻辑指针清单，然后根据指定的排序次序排列这些指针

• 优点：提高查询执行的速度,强制实施数据的唯一性，提高表之间联接的速度
• 缺点：存储索引要占用磁盘空间,数据修改需要更长的时间,因为索引也要更新

19.视图

答：视图是一种虚拟表,通常是作为来自一个或多个表的行或列的子集创建的

• 视图从本质上来讲,就是保存在数据库中select查询.
• 视图并不是数据库储存的数据值的集合
• 对最终用户的好处：结果更容易理解-获取数据更容易
• 对开发人员的好处：限制检索数据更容易-维护应用程序更方便

JAVA基础

1. JDK 和 JRE 有什么区别？

答：

• JDK：Java Development Kit 的简称，java 开发工具包，提供了 java 的开发环境和运行环境。
• JRE：Java Runtime Environment 的简称，java 运行环境，为 java 的运行提供了所需环境。

具体来说 JDK 其实包含了 JRE，同时还包含了编译 java 源码的编译器 javac，还包含了很多 java 程序调试和分析的工具。简单来说：如果你需要运行 java 程序，只需安装 JRE 就可以了，如果你需要编写 java 程序，需要安装 JDK。

2. final 在 java 中有什么作用？

答：

• final 修饰的类叫最终类，该类不能被继承。
• final 修饰的方法不能被重写。
• final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。

3. java 中的 Math.round(-2.5) 等于多少？

答：等于 -2，因为在数轴上取值时，中间值（0.5）向右取整，所以正 0.5 是往上取整，负 0.5 是直接舍弃。

4.如何将字符串反转？

答：使用 StringBuilder 或者 stringBuffer 的 reverse() 方法。

// StringBuffer reverse 反转
StringBuffer stringBuffer = new StringBuffer();
stringBuffer.append("abcdefgh");
System.out.println(stringBuffer.reverse()); // hgfedcba
// StringBuilder reverse
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.append("abcdefgh");
System.out.println(stringBuilder.reverse()); // hgfedcba

5. 抽象类必须要有抽象方法吗？

答：抽象类也可以定义非抽象方法

abstract class Dog 
    public static void hiDog() 
        System.out.println("hello Dog");
    

代码可以正常运行

二丶javaSE基础知识方面

1.面向对象的特征有那些方面

答：

• 封装：封装就是把过程和数据包围起来，对数据的访问只能通过已定义的界面。现实世界可以被描绘成一系列完全自治，封装的对象。这些对象通过一个受保护的接口访问其他对象
• 继承：继承是一种联结类的层次模型，并且允许类的重用，对象的一个新类可以从现有的类中派生，这个过程成为类继承，新类继承了原始类的特性，新类就是原始类的子类，原始类就是父类，子类可以从父类继承方法和实例变量，并且子类可以修改或增加新的方法
• 多态： 所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。
• 抽象： 抽象并不打算了解全部问题,而只是选择其中的一部分,暂时不用部分细节,抽象包括两个方面,一是过程抽象，二是数据抽象

1.面向对象的特征有那些方面

设计模式

1.单例模式

此处参考https://www.runoob.com/design-pattern/singleton-pattern.html
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

注意：

1、单例类只能有一个实例。
2、单例类必须自己创建自己的唯一实例。
3、单例类必须给所有其他对象提供这一实例

优点：

1、在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如管理学院首页页面缓存）。
2、避免对资源的多重占用（比如写文件操作）。
缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例化。

1. 创建一个 Singleton 类。

public class SingleObject 
 
   //创建 SingleObject 的一个对象
   private static SingleObject instance = new SingleObject();
 
   //让构造函数为 private，这样该类就不会被实例化
   private SingleObject()
 
   //获取唯一可用的对象
   public static SingleObject getInstance()
      return instance;
   
 
   public void showMessage()
      System.out.println("Hello World!");
   

2.从 singleton 类获取唯一的对象

public class SingletonPatternDemo 
   public static void main(String[] args) 
 
      //不合法的构造函数
      //编译时错误：构造函数 SingleObject() 是不可见的
      //SingleObject object = new SingleObject();
 
      //获取唯一可用的对象
      SingleObject object = SingleObject.getInstance();
 
      //显示消息
      object.showMessage();
   

单例模式的几种实现方式
单例模式的实现有多种方式，如下所示：

1、懒汉式，线程不安全
是否 Lazy 初始化：是

是否多线程安全：否

实现难度：易

描述：这种方式是最基本的实现方式，这种实现最大的问题就是不支持多线程。因为没有加锁 synchronized，所以严格意义上它并不算单例模式。
这种方式 lazy loading 很明显，不要求线程安全，在多线程不能正常工作。

public class Singleton   
    private static Singleton instance;  
    private Singleton ()  
  
    public static Singleton getInstance()   
    if (instance == null)   
        instance = new Singleton();  
      
    return instance;  
      

2、懒汉式，线程安全
是否 Lazy 初始化：是

是否多线程安全：是

实现难度：易

描述：这种方式具备很好的 lazy loading，能够在多线程中很好的工作，但是，效率很低，99% 情况下不需要同步。
优点：第一次调用才初始化，避免内存浪费。
缺点：必须加锁 synchronized 才能保证单例，但加锁会影响效率。
getInstance() 的性能对应用程序不是很关键（该方法使用不太频繁）。

public class Singleton   
    private static Singleton instance;  
    private Singleton ()  
    public static synchronized Singleton getInstance()   
    if (instance == null)   
        instance = new Singleton();  
      
    return instance;  
      

3、饿汉式
是否 Lazy 初始化：否

是否多线程安全：是

实现难度：易

描述：这种方式比较常用，但容易产生垃圾对象。
优点：没有加锁，执行效率会提高。
缺点：类加载时就初始化，浪费内存。
它基于 classloader 机制避免了多线程的同步问题，不过，instance 在类装载时就实例化，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用 getInstance 方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，这时候初始化 instance 显然没有达到 lazy loading 的效果。

public class Singleton   
    private static Singleton instance = new Singleton();  
    private Singleton ()  
    public static Singleton getInstance()   
    return instance;  
      

2.策略模式

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。

在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。
介绍
意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决：在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

介绍
意图：定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

主要解决：在有多种算法相似的情况下，使用 if…else 所带来的复杂和难以维护。

何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决：将这些算法封装成一个一个的类，任意地替换。

关键代码：实现同一个接口。

应用实例： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。

优点： 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。

使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式，解决策略类膨胀的问题。：一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决：将这些算法封装成一个一个的类，任意地替换。

关键代码：实现同一个接口。

1. 创建一个接口

public interface Strategy 
   public int doOperation(int num1, int num2);

2. 创建接口的实现类

public class OperationAdd implements Strategy
   @Override
   public int doOperation(int num1, int num2) 
      return num1 + num2;
   

public class OperationSubtract implements Strategy
   @Override
   public int doOperation(int num1, int num2) 
      return num1 - num2;
   

3. 创建 Context 类。

public class OperationMultiply implements Strategy
   @Override
   public int doOperation(int num1, int num2) 
      return num1 * num2;
   

public class Context 
   private Strategy strategy;
 
   public Context(Strategy strategy)
      this.strategy = strategy;
   
 
   public int executeStrategy(int num1, int num2)
      return strategy.doOperation(num1, num2);
   

4. 使用 Context 来查看当它改变策略 Strategy 时的行为变化。

public class StrategyPatternDemo 
   public static void main(String[] args) 
      Context context = new Context(new OperationAdd());    
      System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationSubtract());      
      System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
 
      context = new Context(new OperationMultiply());    
      System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
   

3.代理模式

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

介绍
意图：为其他对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

何时使用：想在访问一个类时做一些控制。

如何解决：增加中间层。

关键代码：实现与被代理类组合。

应用实例： 1、Windows 里面的快捷方式。 2、猪八戒去找高翠兰结果是孙悟空变的，可以这样理解：把高翠兰的外貌抽象出来，高翠兰本人和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟空，所以说孙悟空是高翠兰代理类。 3、买火车票不一定在火车站买，也可以去代售点。 4、一张支票或银行存单是账户中资金的代理。支票在市场交易中用来代替现金，并提供对签发人账号上资金的控制。 5、spring aop。

优点： 1、职责清晰。 2、高扩展性。 3、智能化。

缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

使用场景：按职责来划分，通常有以下使用场景： 1、远程代理。 2、虚拟代理。 3、Copy-on-Write 代理。 4、保护（Protect or Access）代理。 5、Cache代理。 6、防火墙（Firewall）代理。 7、同步化（Synchronization）代理。 8、智能引用（Smart Reference）代理。

注意事项： 1、和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口。 2、和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。

1. 创建一个接口

public interface Image 
   void display();

2. 创建实现接口的实体类。

public class RealImage implements Image 
 
   private String fileName;
 
   public RealImage(String fileName)
      this.fileName = fileName;
      loadFromDisk(fileName);
   
 
   @Override
   public void display() 
      System.out.println("Displaying " + fileName);
   
 
   private void loadFromDisk(String fileName)
      System.out.println("Loading " + fileName);
   

public class ProxyImage implements Image
 
   private RealImage realImage;
   private String fileName;
 
   public ProxyImage(String fileName)
      this.fileName = fileName;
   
 
   @Override
   public void display() 
      if(realImage == null)
         realImage = new RealImage(fileName);
      
      realImage.display();
   

3. 当被请求时，使用 ProxyImage 来获取 RealImage 类的对象。

public class ProxyPatternDemo 
   
   public static void main(String[] args) 
      Image image = new ProxyImage("test_10mb.jpg");
 
      // 图像将从磁盘加载
      image.display(); 
      System.out.println("");
      // 图像不需要从磁盘加载
      image.display();  
   

4. 执行程序，输出结果：

 Loading test_10mb.jpg
Displaying test_10mb.jpg

Displaying test_10mb.jpg

4.装饰模式

装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。

这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。

我们通过下面的实例来演示装饰器模式的用法。其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类。

介绍
意图：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。

主要解决：一般的，我们为了扩展一个类经常使用继承方式实现，由于继承为类引入静态特征，并且随着扩展功能的增多，子类会很膨胀。

何时使用：在不想增加很多子类的情况下扩展类。

如何解决：将具体功能职责划分，同时继承装饰者模式。

关键代码： 1、Component 类充当抽象角色，不应该具体实现。 2、修饰类引用和继承 Component 类，具体扩展类重写父类方法。

应用实例： 1、孙悟空有 72 变，当他变成"庙宇"后，他的根本还是一只猴子，但是他又有了庙宇的功能。 2、不论一幅画有没有画框都可以挂在墙上，但是通常都是有画框的，并且实际上是画框被挂在墙上。在挂在墙上之前，画可以被蒙上玻璃，装到框子里；这时画、玻璃和画框形成了一个物体。

优点：装饰类和被装饰类可以独立发展，不会相互耦合，装饰模式是继承的一个替代模式，装饰模式可以动态扩展一个实现类的功能。

缺点：多层装饰比较复杂。

使用场景： 1、扩展一个类的功能。 2、动态增加功能，动态撤销。

注意事项：可代替继承。

1. 创建一个接口

public interface Shape 
   void draw();

2. 创建实现接口的实体类。

public class Rectangle implements Shape 
 
   @Override
   public void draw() 
      System.out.println("Shape: Rectangle");
   

public class Circle implements Shape 
 
   @Override
   public void draw() 
      System.out.println("Shape: Circle");
   

3. 创建实现了 Shape 接口的抽象装饰类。

public abstract class ShapeDecorator implements Shape 
   protected Shape decoratedShape;
 
   public ShapeDecorator(Shape decoratedShape)
      this.decoratedShape = decoratedShape;
   
 
   public void draw()
      decoratedShape.draw();
     

4. 创建扩展了 ShapeDecorator 类的实体装饰类。

public class RedShapeDecorator extends ShapeDecorator 
 
   public RedShapeDecorator(Shape decoratedShape) 
      super(decoratedShape);     
   
 
   @Override
   public void draw() 
      decoratedShape.draw();         
      setRedBorder(decoratedShape);
   
 
   private void setRedBorder(Shape decoratedShape)
      System.out.println("Border Color: Red");
   

5. 使用 RedShapeDecorator 来装饰 Shape 对象。

public class DecoratorPatternDemo 
   public static void main(String[] args) 
 
      Shape circle = new Circle();
      ShapeDecorator redCircle = new RedShapeDecorator(new Circle());
      ShapeDecorator redRectangle = new RedShapeDecorator(new Rectangle());
      //Shape redCircle = new RedShapeDecorator(new Circle());
      //Shape redRectangle = new RedShapeDecorator(new Rectangle());
      System.out.println("Circle with normal border");
      circle.draw();
 
      System.out.println("\\nCircle of red border");
      redCircle.draw();
 
      System.out.println("\\nRectangle of red border");
      redRectangle.draw();
   

6. 执行程序，输出结果：

Circle with normal border
Shape: Circle

Circle of red border
Shape: Circle
Border Color: Red

Rectangle of red border
Shape: Rectangle
Border Color: Red

5.简单工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

介绍
意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。

主要解决：主要解决接口选择的问题。

何时使用：我们明确地计划不同条件下创建不同实例时。

如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。

关键代码：创建过程在其子类执行。

应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。 2、Hibernate 换数据库只需换方言和驱动就可以。

优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。 2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。 3、屏蔽产品的具体实现，调用者只关心产品的接口。

缺点：每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。

使用场景： 1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。 2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。 3、设计一个连接服务器的框架，需要三个协议，“POP3”、“IMAP”、“HTTP”，可以把这三个作为产品类，共同实现一个接口。

注意事项：作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

1. 创建一个接口

public interface Shape 
   void draw();

2. 创建实现接口的实体类

public class Rectangle implements Shape 
 
   @Override
   public void draw(以上是关于java面试题的主要内容，如果未能解决你的问题，请参考以下文章
 
 2020年1-6月份Java面试题总结，20多类1100道面试题含答案解析
 Java面试题，Java面试题及答案，2021最新的，都整理好了
 2020 年最新版 Java 面试题大全（文末附参考答案）
 2020年最新版Java面试题大全（文末附参考答案）
 java面试题
 Java常用API面试题Java面试题