java遇到的面试题

超、凢脫俗 2022-03-15 16:20 580阅读 0赞

# 1.java面向对象的特性: #

**封装**  
封装可以看作是面向对象的基本原则，也就是把对象的属性和行为（数据）集合为一个独立的整体，并且尽可能的隐藏对象的内部实现细节，也就是说吧不想告诉或者不该告诉别人的东西隐藏起来，把可以告诉别人的通过方法向别人公开，别人只能用我提供的功能实现需求，但不知道是如何实现的，增加了安全性  
**继承**  
可以看作是面向对象最显著的特征，继承是从已经有的类中派生出新的类 子类继承了父类的属性和行为，并且根据自己的需求扩展出新的行为，从而提高了代码的复用性  
**多态**  
封装继承几乎都是为了多态做准备的 ，在执行期间判断对象的实际类型，根据实际类型调用响应的方法  
动态的理解和项目应用  
方法重载( overload ) : 实现的是编译时的多态性（也称为前绑定）  
方法重写 ( override) : 实现的是运行时的多态性 （也称为后绑定）。运行时的多态是面向对象最精髓的东西。  
要实现多态需要做两件事:  
1 方法重写（子类继承父类并重写父类中已有的或抽象的方法）  
2 对象造型 （用父类型引用引用子类型对象，这样同样的引用调用同样的方法就回根据子类对象的不同而表现出不同的行为）。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDUzMzAw_size_16_color_FFFFFF_t_70]  
举一个简单的例子：在物流管理系统中，有两种用户：订购客户和卖方客户，两个客户都可以登录系统，他们有相同的方法login，但登陆之后他们会进入不同的页面，也就是在登录的时候会有不同的操作，两种客户都继承父类的login方法，但对于不同的对象，拥有不同的操作

# 2.项目中何时用到泛型 #

[https://www.imooc.com/article/18159][https_www.imooc.com_article_18159] 这个是介绍泛型  
[https://blog.hduzplus.xyz/articles/2016/11/05/1478278228884.html这个对泛型讲的很好][https_blog.hduzplus.xyz_articles_2016_11_05_1478278228884.html]  
在使用java对数据库操作时候，很常见的一个功能分页操作，java接收的常常是一个count和相应的记录列表，然后，一般定义bean的方法如下：

public class Goods{
        private int id;
        private String name;
        private String descrption;
    
        setter ang getter
    }

//用来接收的bean

public class ListResult{
        private int count;
        private List<Goods> goodsList;
    
        ...
        setter ang getter
    }

然后使用ListResult来接收来自数据库查询得到的数据。  
这样的一个弊端就是，现在是Goods，下次换成Order，又要重新写一个ListResult来接收，在这样的情况下，可以使用泛型。  
修改ListResult如下：

//用来接收的bean
    public class ListResult<T>{
        private int count;
        private List<T> list;
    
        ...
        setter ang getter
    }

当接收Goods时，`ListResult<Goods>`；接收Order时，`ListResult<Order>`

# 3.谈谈你对spring boot,spring cloud的看法 #

# 4.Java集合和数组的区别,项目中何时用到数组,何时用到集合 #

因为集合是对数组做的封装,所以,数组永远比任何一个集合要快  
但任何一个集合,比数组提供的功能要多  
一：数组声明了它容纳的元素的类型，而集合不声明。这是由于集合以object形式来存储它们的元素。  
二：一个数组实例具有固定的大小，不能伸缩。集合则可根据需要动态改变大小。  
三：数组是一种可读/可写数据结构－－－没有办法创建一个只读数组。然而可以使用集合提供的ReadOnly方法，以只读方式来使用集合。该方法将返回一个集合的只读版本。  
集合和数组的区别：  
1、数组声明了数据类型，然后就只能存储那一种数据类型。集合能存放多种（不加泛型时，类型是Object）。  
2、数组是静态的，一个数组实例具有固定的大小，一旦创建了就无法改变容量了。集合是动态扩展容量的，可以根据需要动态改变大小。  
3、数组是java语言中内置的数据类型，是线性排列的，执行效率或类型检查都是最快的。

# 5.数组,集合,字符串的长度的方法 #

1.  数组(array)  
    使用.length来获取数组的长度。
2.  集合(Collection)或映射(Map)  
    使用.size()来获取集合或映射的大小
3.  字符序列(CharSequence，包括CharBuffer，Segment，String，StringBuffer，StringBuilder)  
    使用.length()来获取其长度

# 6.类加载器的用法,项目中何时用到 #

类加载器使得 Java 类可以被动态加载到 Java 虚拟机中并执行  
类加载器（class loader）用来加载 Java 类到 Java 虚拟机中。一般来说，Java 虚拟机使用 Java 类的方式如下：Java 源程序（.java 文件）在经过 Java 编译器编译之后就被转换成 Java 字节代码（.class 文件）。类加载器负责读取 Java 字节代码，并转换成 java.lang.Class类的一个实例。每个这样的实例用来表示一个 Java 类。通过此实例的 newInstance()方法就可以创建出该类的一个对象

#### 项目使用 ####

1.比如Tomcat容器，每个WebApp有自己的ClassLoader,加载每个WebApp的ClassPath路径上的类，一旦遇到Tomcat自带的Jar包就委托给CommonClassLoader加载；  
2.对于公司的一些核心类库，可能会把字节码加密，这样加载类的时候就必须对字节码进行解密，可以通过findClass读取URL中的字节码，然后加密，最后把字节数组交给defineClass()加载  
[https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html][https_www.ibm.com_developerworks_cn_java_j-lo-classloader_index.html] 参考资料

# 7.为何用spring,优点,谈谈使用感受,spring创建对象的三种方式 #

1.方便解耦，简化开发  
通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所  
造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需  
求编写代码，可以更专注于上层的应用。  
2.AOP编程的支持  
通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过  
AOP轻松应付。  
3.声明事物的支持  
在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的  
管理，提高开发效率和质量。  
4.方便程序的测试  
可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，  
而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。  
5.方便集成各种优秀框架  
Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了  
对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。  
6.降低Java EE API的使用难度  
Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，  
通过Spring的简易封装，这些Java EE API的使用难度大为降低。  
总结起来，Spring有如下优点：  
1.低侵入式设计，代码污染极低  
2.独立于各种应用服务器，基于Spring框架的应用，可以真正实现Write Once,Run Anywhere的  
承诺  
3.Spring的DI机制降低了业务对象替换的复杂性，提高了组件之间的解耦  
4.Spring的AOP支持允许将一些通用任务如安全、事务、日志等进行集中式管理，从而提供了更好  
的复用  
5.Spring的ORM和DAO提供了与第三方持久层框架的良好整合，并简化了底层的数据库访问  
6.Spring并不强制应用完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

#### 创建对象 ####

IOC:控制反转:将对象的创建权,由Spring管理.  
DI(依赖注入):在Spring创建对象的过程中,把对象依赖的属性注入到类中。  
所谓的依赖注入，其实是当一个bean实例引用到了另外一个bean实例时spring容器帮助我们创建依赖bean实例并注入（传递）到另一个bean中，如上述案例中的AccountService依赖于AccountDao，Spring容器会在创建AccountService的实现类和AccountDao的实现类后，把AccountDao的实现类注入AccountService实例中，  
分类:**setter注入\*\*\*\*和构造函数注入**

# 9.单点登录的技术点 #

# 10.购物车的技术点 #

# 11.服务器如何分布式存储图片 #

# 12.手动写约瑟夫环和判断回文数字 #

之前的文章写过了

# 13.传输协议的理解程度 #

http ftp dnp乱七八糟的

# 14.谈谈对aop的理解,介绍spring aop #

传统的OOP程序经常表现出一些不自然的现象，核心业务中总掺杂着一些不相关联的特殊业务，如日志记录，权限验证，事务控制，性能检测，错误信息检测等等，这些特殊业务可以说和核心业务没有根本上的关联而且核心业务也不关心它们，比如在用户管理模块中，该模块本身只关心与用户相关的业务信息处理，至于其他的业务完全可以不理会  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDUzMzAw_size_16_color_FFFFFF_t_70 1]  
Spring AOP的实现原理是基于动态织入的动态代理技术，而AspectJ则是静态织入，而动态代理技术又分为Java JDK动态代理和CGLIB动态代理，前者是基于反射技术的实现，后者是基于继承的机制实现  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDUzMzAw_size_16_color_FFFFFF_t_70 2]  
太复杂了.参考https://blog.csdn.net/javazejian/article/details/56267036\#oop%E7%9A%84%E6%96%B0%E7%94%9F%E6%9C%BA

# 15.谈谈concurrent\_hashmap的理解 #

ConcurrentHashMap是J.U.C(java.util.concurrent包)的重要成员，它是HashMap的一个线程安全的、支持高效并发的版本。在默认理想状态下，ConcurrentHashMap可以支持16个线程执行并发写操作及任意数量线程的读操作  
其他太难了 不懂

参考:[https://blog.csdn.net/justloveyou\_/article/details/72783008][https_blog.csdn.net_justloveyou_article_details_72783008]

# 16.spring事务管理 #

Spring并不直接管理事务，而是提供了多种事务管理器 ，他们将事务管理的职责委托给Hibernate或者JTA等持久化机制所提供的相关平台框架的事务来实现。 Spring事务管理器的接口是： org.springframework.transaction.PlatformTransactionManager ，通过这个接口，Spring为各个平台如JDBC、Hibernate等都提供了对应的事务管理器，但是具体的实现就是各个平台自己的事情了。  
mybatis

<bean id="transactionManager"
    		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    		
    		<property name="dataSource" ref="dataSource" />
    	</bean>

1.事务隔离级别  
TransactionDefinition 接口中定义了五个表示隔离级别的常量：

TransactionDefinition.ISOLATION\_DEFAULT: 使用后端数据库默认的隔离级别，Mysql 默认采用的 REPEATABLE\_READ隔离级别 Oracle 默认采用的 READ\_COMMITTED隔离级别.  
TransactionDefinition.ISOLATION\_READ\_UNCOMMITTED: 最低的隔离级别，允许读取尚未提交的数据变更，可能会导致脏读、幻读或不可重复读  
TransactionDefinition.ISOLATION\_READ\_COMMITTED: 允许读取并发事务已经提交的数据，可以阻止脏读，但是幻读或不可重复读仍有可能发生  
TransactionDefinition.ISOLATION\_REPEATABLE\_READ: 对同一字段的多次读取结果都是一致的，除非数据是被本身事务自己所修改，可以阻止脏读和不可重复读，但幻读仍有可能发生。  
TransactionDefinition.ISOLATION\_SERIALIZABLE: 最高的隔离级别，完全服从ACID的隔离级别。所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。  
2.事务传播行为（为了解决业务层方法之间互相调用的事务问题）  
一般用默认的TransactionDefinition.PROPAGATION\_REQUIRED： 如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。

[https://juejin.im/post/5b00c52ef265da0b95276091][https_juejin.im_post_5b00c52ef265da0b95276091]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDUzMzAw_size_16_color_FFFFFF_t_70]: /images/20220315/33c4cfcccf4246adbf1716353c4da2a9.png
[https_www.imooc.com_article_18159]: https://www.imooc.com/article/18159
[https_blog.hduzplus.xyz_articles_2016_11_05_1478278228884.html]: https://blog.hduzplus.xyz/articles/2016/11/05/1478278228884.html%E8%BF%99%E4%B8%AA%E5%AF%B9%E6%B3%9B%E5%9E%8B%E8%AE%B2%E7%9A%84%E5%BE%88%E5%A5%BD
[https_www.ibm.com_developerworks_cn_java_j-lo-classloader_index.html]: https://www.ibm.com/developerworks/cn/java/j-lo-classloader/index.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDUzMzAw_size_16_color_FFFFFF_t_70 1]: /images/20220315/78a472e15d2547dd994d9d53bb0f911d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM0NDUzMzAw_size_16_color_FFFFFF_t_70 2]: /images/20220315/1da02beafa8f4f3ca82fa5aa85fca158.png
[https_blog.csdn.net_justloveyou_article_details_72783008]: https://blog.csdn.net/justloveyou_/article/details/72783008
[https_juejin.im_post_5b00c52ef265da0b95276091]: https://juejin.im/post/5b00c52ef265da0b95276091