1. 首页首页
  2. 科技前沿科技前沿

java面试基础代码题及答案

科技前沿 • • 阅读 46

java面试基础代码题及答案面试题及答案 基础题 道 代码题 道 相关基础知识 面向对象的特征有哪些方面 抽象 抽象 就是 忽略 一个 主题 中与 当前 目标 无关 的那 些方 面 以便 更充 分地 注意 与当 前目 标 有关 的方 面 抽象 并不 打算 了解 全部 问题 而 只是 选择 其中 的一 部分 暂 时不 用部

大家好，我是讯享网，很高兴认识大家。



 面试题及答案（基础题  道，代码题  道）
　　  相关基础知识
　　 、面向对象的特征有哪些方面
　　 抽象：
　　 抽象 就是 忽略 一个 主题 中与 当前 目标 无关 的那 些方 面， 以便 更充 分地 注意 与当 前目 标
有关 的方 面。 抽象 并不 打算 了解 全部 问题 ，而 只是 选择 其中 的一 部分 ，暂 时不 用部 分细 节
抽象包括两个方面，一是过程抽象，二是数据抽象。
　　 继承：
　　 继承 是一 种联 结类 的层 次模 型， 并且 允许 和鼓 励类 的重 用， 它提 供了 一种 明确 表述 共java面试基础代码题及答案
性的 方法 。对 象的 一个 新类 可以 从现 有的 类中 派生 ，这 个过 程称 为类 继承 。新 类继 承了 原
始类 的特 性， 新类 称为 原始 类的 派生 类（ 子类 ）， 而原 始类 称为 新类 的基 类（ 父类 ）。 派
生类 可以 从它 的基 类那 里继 承方 法和 实例 变量 ，并 且类 可以 修改 或增 加新 的方 法使 之更 适
合特殊的需要。
　　 封装：
　　 封装 是把 过程 和数 据包 围起 来， 对数 据的 访问 只能 通过 已定 义的 界面 。面 向对 象计 算
始于 这个 基本 概念 ，即 现实 世界 可以 被描 绘成 一系 列完 全自 治、 封装 的对 象， 这些 对象 通
过一个受保护的接口访问其他对象。
　　 多态性：
　　 多态 性是 指允 许不 同类 的对 象对 同一 消息 作出 响应 。多 态性 包括 参数 化多 态性 和包 含
多态 性。 多态 性语 言具 有灵 活、 抽象 、行 为共 享、 代码 共享 的优 势， 很好 的解 决了 应用 程
序函数同名问题。
　　 、  是最基本的数据类型吗
　　基本数据类型包括 、 、 、 、 、 、  和 。
  类是  类型的，因此不可以继承这个类、不能修改这个类。为了提高效
率节省空间，我们应该用 !" 类
　　 、 和 #有什么区别
　　 提供两种不 同的类型：引 用类型和原始 类型（或内置 类型）。 # 是  的原始数
据类型， # 是  为  提供的封装类。 为每个原始类型提供了封装类。
　　原始类型封装类
　　 　　 !
　　 　　 $
　　 　　 !
　　 　　 
　　 　　 #
　　 　　 %
　　 　　 &
　　 　　 '
　　 引用 类型 和原 始类 型的 行为 完全 不同 ，并 且它 们具 有不 同的 语义 。引 用类 型和 原始 类
型具 有不 同的 特征 和用 法， 它们 包括 ：大 小和 速度 问题 ，这 种类 型以 哪种 类型 的数 据结 构
存储 ，当 引用 类型 和原 始类 型用 作某 个类 的实 例数 据时 所指 定的 缺省 值。 对象 引用 实例 变
量的缺省值为 ，而原始类型实例变量的缺省值与它们的类型有关。
　　 、 和 !" 的区别
　 　  平台提供了两个类： 和 !"，它们可以储存和操作字符串，即包含
多个 字符 的字 符数 据。 这个  类 提供 了数 值不 可改 变的 字符 串。 而这 个 !" 类
提供 的字 符串 进行 修改 。当 你知 道字 符数 据要 改变 的时 候你 就可 以使 用 !"。典型
地，你可以使用 !" 来动态构造字符数据。
　　 (、运行时异常与一般异常有何异同？
异常 表示 程序 运行 过程 中可 能出 现的 非 正常 状态 ，运 行时 异常 表示 虚拟机的通 常操 作中 可
能 遇到的异 常 ，是 一 种常 见运 行 错误。  编译器要 求方法 必须声明 抛出可 能 发生 的 非运
行时异常， 但是并不要 求必须声明 抛出 未被 捕获的运行时异常。
　　 )、 说出  的生 命周期，并 说出  和 $*# 的区别。
 被服务器实例化后，容器运行其  方法，请求到达时运行其  方法，
方法自动派 遣运行与 请求对应的 +++ 方法（*，,）等，当服务器决定将实例销
毁 的时候调 用其  方法。
与  的 区 别 在于  处于 服务器进 程中 ， 它通 过 多 线程 方 式运行 其  方 法 ，一 个
实例 可 以 服务于 多个 请求， 并 且其 实 例一 般 不 会销毁， 而 $*# 对 每个 请求都产生新 的 进程 ，
服务 完成后 就销毁 ，所以效率上低 于 。
　　 -、 说出 %..%/% 的存储性能和特性
 % 和  都是使用数组方式存储数据，此数组元素数大于实际存储的数据以便增
加和 插入元素，它 们 都允 许 直接 按序 号索引 元素， 但是 插入元素要 涉及 数 组元素移动 等内
存操 作， 所以 索引 数据 快而 插入数 据 慢，  由于使用了 0 方法（线程安全），
通常性能 上较 % 差，而 %/% 使用双向链表实现存储，按序号索引数据需要进行
前向或 后向 遍历， 但是 插入数据时只需要 记录本 项的前 后项即可，所以 插入速度 较快。
　　 1、 2! 是基于哪些 技术实现的？并 说出 ! 和 23! 的区别， 4!
和 ! 的区别。
2! 包括  ! 、23 ! 、5 ' ! ，基于 6'# 、75# 、 8 等技术实
现。
! 在 22 应用程序中被用来完成一些服务器端的业务操作，例如访问数据库、调
用其他 2! 组件。 23! 被用来代表应用系 统中用 到的数据。
对于 客户机， ! 是一种非 持久性对象，它实现某些 在服务器上运行的 业务逻辑。
对 于 客户机， 23! 是 一 种 持久性 对 象 ， 它 代表 一 个 存 储 在持久性 存储 器中 的 实 体的
对象 视图，或是一个 由现有 企业应用程序实现的实 体。
 ! 还可以再细分为 4  ! 与   ! ，这两种的
! 都可以将系统逻辑放在9 之中执行，不同的是 4! 可以
记录呼 叫者 的状 态，因此通常来说 ，一个使用者会 有一个相对应的 4!的
实 体。 !虽然也是 逻辑组件， 但是他 却不 负责记录使用 者状态 ， 也就是
说 当使用者 呼 叫 !的时候，2!$并不会 找 寻 特定的
 ! 的实体来执行这个9 。换言之，很可能数个使用者在执行某个
 ! 的9 时，会是同一个! 的#  在执行。从内存方面来看，
 4! 与! 比较， 4! 会消耗22
较 多的内存，然 而4!的优势却在于他可以维持使用者的状态。
　　 、 $3和 $3 的区别。
　　 $3 是 集合类的 上级接口，继承与他的接口主要有 和 %
　 　 $3 是 针对 集合类 的 一 个 帮助类 ，他 提 供 一 系 列 静态方 法 实 现 对 各种 集合 的 搜
索 、排 序、线 程安 全化等 操作。
　　 :、 ;和 ;;的区别。
; 是位运算符，表示按位与运算，;; 是逻辑运算符，表示逻辑与（ ）。
　　 、 <5= 和 < 的区别。
　 　 <5= 是 < 的 轻量 级实 现（ 非 线程 安全 的 实现 ） ， 他 们 都完 成了 5= 接 口 ，
主 要 区 别 在于 <5= 允 许 空 （ ） 键值 （ /）.由于非线程安全，效率上可能高于
<  。
<5= 允许将  作为一个  的 / 或者  ，而 <  不允许。
<5= 把 <  的   方法 去 掉 了 ， 改成    和  >  。 因 为
  方法容易让人引起误解。
<  继承自 '3 类，而 <5= 是  引进的 5= 4 的一个实现。
最 大 的 不 同 是 ， < 的方法是 0 的，而 <5= 不是，在多个线程访问
<  时，不需要自己为它的方法实现同步，而 <5= 就必须为之提供外同步（如
果 是 %：%?$30%@A%@BBC如果是 <5=：5=
9=?$3 0 5=@A<5=@BBC ）。
<  和 <5= 采用的 D 算法都大概一样，所以性能不会有很大的差异。
　　 、 . . 0 的区别。
　　 用于 声明 属性，方法和类，分别表示 属性不可变，方法不可 覆盖，类不可继承。
 是异常处理语句结构的一部分，表示总是执行。
0 是 E 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可
以 覆盖此方法提供 垃圾收集时的其他 资源回收，例 如关 闭文件等。
　　 、 =@B和 A@B有什么区别 
　　 = 是 线程类（ 8）的 方法， 导致此 线程暂 停执行指定 时间， 给执行 机会给其他
线 程，但 是监控状 态依然 保持 ，到 时后会 自动恢复 。调 用 = 不会释放 对象锁 。
A 是 E 类的方法，对此对象调用 A 方法导致本线程放弃对象锁，进入等待此对象
的 等待锁定 池，只有 针对 此对象 发出 34 方 法（或 34） 后本 线程 才进 入对象 锁定 池
准备获得 对象锁 进入 运行状 态。
　　 、 E 和 E 的区别。 E 的方法是 否可以改变 返回值的类型
　 　 方 法 的 重 写 E 和 重 载 E 是  多 态 性 的 不 同 表 现 。 重 写 E
是父类与子 类之间多态性 的一种表现， 重 载 E 是一个类中多 态性的一种表 现。 如
果在 子类中定义某方法与其父类有相同的名称和参数，我们说 该方法被重写 @EB。
子 类 的 对 象 使 用 这 个 方 法 时 ， 将调用 子 类 中 的 定 义 ， 对 它 而 言 ， 父 类 中 的 定 义 如同 被 “屏
蔽” 了。如 果在 一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数
类型， 则称为方法的重 载@EB。 E 的方法是可以改变 返回值的类型。
　　 (、  和 F=3 有什么区别
　　 表示 恢复不是不可 能 但很 困难的 情况下的 一种 严重问题 。 比如说内存 溢出。不可
能指 望程序能 处理这 样的 情况。
　　 F=3表示一 种 设计 或实现 问题。 也就 是 说， 它表示 如果程 序运行 正常， 从不 会发
生的 情况。
　　 )、同 步和异 步有何异同， 在什么 情况下分别使用他们？ 举例 说明。
如果 数据将在 线 程间共享。例如正 在写 的数据以后 可能被另 一个线 程读 到 ，或者正 在读 的
数据可能已 经被 另一个 线程 写过了，那么这些数据就是共享数据， 必须进行同 步存 取。
当应 用程 序 在对象 上调用 了一 个需 要 花费很 长时 间来 执行 的方 法， 并且 不 希望让程 序 等待
方法的 返回时，就应该使用异 步编程， 在很多 情况下采用异 步途径往往更有效率。
　　 -、  和 4 有什么区别
声 明方法的存在 而不去 实现它的类被叫做 抽象类（），它用于要创建一个体现
某 些 基 本 行 为 的 类 ， 并 为 该 类 声明 方 法 ， 但不 能 在该 类 中 实 现 该 类 的 情况。 不 能 创建
  类的实例。然而可以创建一个变量，其类型是一个抽象类，并让它指向具体子类的
一 个实 例 。 不 能 有抽 象 构 造 函 数 或 抽象 静态 方法 。 类的子类为它们父类中的所有
抽象 方法 提供 实现 ， 否则它们 也是 抽象 类为 。 取而代 之， 在子 类中 实现 该方 法。 知道 其行
为的其它类可以 在类中实现这些方法。
接 口（ 4）是抽象类的变体。在接口中，所有方法都是抽象的。多继承性可通过实
现这 样的 接口 而 获得。接 口中 的所 有方 法 都是抽 象的 ， 没有一 个有 程序 体。接 口只 可以 定
义 3  成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。
当类 实现 特殊 接口 时， 它定 义（ 即 将程 序 体给予）所 有这 种接 口的 方法 。 然后，它 可以 在
实现 了该 接口 的类 的 任何 对象 上调用接 口的 方法 。 由于有 抽象 类， 它允 许使 用接 口名 作为
引 用 变 量 的 类 型 。 通 常 的 动 态 联 编将生 效 。 引 用 可 以 转换到接 口 类 型 或 从 接 口 类 型 转换 ，
 4 运算符可以用来决定某对象的类是否实现了接口。
　　 1、 = 和 / 有什么区别。
　　 栈是 一种 线形集合， 其 添加和 删除元素的操 作应 在同 一 段完成 。 栈按照后进 先出的 方
式 进行处理 。
　　 堆是 栈的一个 组成 元素
　　 、 4A和  的区别
　　 4A 是 服务器请求资源， 服务器直接访 问目标 地 址的 G7%，把那 个 G7% 的响 应内 容
读取 过来，然 后 把这些内容再 发给 浏览 器 ，浏览 器根 本不知道服务 器发 送 的内容 是从哪儿
来的，所以它的地 址栏中 还是原来的地 址。
  就是服务端根据逻辑. 发送一个状态码. 告诉浏览器重新去请求那个地址，一般来说
浏览器会 用刚才请求 的所有参数重新请求 ，所以 .H 参数都 可以获取 。
　　 :、 2! 与 !26 的区别？
　　 !是可复用的组件，对 ! 并没有严格的规范，理论上讲，任何一个 
类 都可 以 是 一 个 !。 但通 常 情况下， 由于 ! 是被 容器所 创建（ 如 89）的，
所 以 ! 应 具 有 一 个 无 参 的 构 造 器， 另外， 通 常 ! 还要实现 0 接口
用于实现 ! 的 持久性。 ! 实 际上相当于 微软 $E5 模型中的本地进程内 $E5 组件，
它 是 不 能 被 跨进 程 访 问 的 。 2=!相当于 '$E5，即分布式组件。它是基于
 的远程方法调用（75# ）技术的，所以 2! 可以被远程访问（跨进程、跨计算机）。但
2! 必须被布署在诸如 I = 、I% 这样的容器中，2! 客户从不直接访问真正的
2! 组件，而是通过其容器访问。2! 容器是 2 ! 组件的代理，2 ! 组件由容器所创建和管理。
客户 通过容器 来访问真正 的 2! 组件 。
　　 、 36$和#$ 的不同。
　　 36$ 是 被 声明 为 静态 （ 3）的内部类，它可以不依赖于外部类实例被
实例化。而通常的内部类需要 在外部类实例化 后才能实例化。
　　 、 , 中动态 #6$%G'2 与 静态 #6$%G'2 的区别？
　 　 动 态 #6$%G'2 用 =J 动 作 实 现 K=J=?L=L?LLDM它
总 是会检查 所含文件 中的变化，适合用于包含动态页 面，并且可以带 参数。
静 态 #6$%G'2 用  伪 码实现.定不会 检 查 所含文 件 的变化，适用于包含静 态页 面KNO
 ?L9LNM
　　 、什么时候用 。
　　 3@断言 B在软件开发中是一种 常用的 调试方 式，很多 开发语言中 都支持这种 机制。
在 实现中，3 就是在 程序中的一条 语句 ，它对一个  表达 式 进行检 查 ，一个
正 确程序必 须 保证 这个  表达 式 的值为 ； 如 果 该值为 4，说 明程序已经 处 于
不 正确的 状态 下， 系 统将给出 警告或 退出。 一般 来 说， 3 用 于保 证程 序最 基本 、关
键 的正 确性。3 检 查 通常在 开 发 和测 试时开 启 。为了提高性能，在 软 件 发 布 后 ，
3 检查通常是关闭的。
　　 、 *$ 是什么 为什么要有 *$
　　 *$ 是 垃圾收集的 意 思（ *$3） .内存 处理是 编程 人员容易出现 问题 的地 方 ，
忘 记或者错误的内存回收会导致程序或系统的不稳 定甚至崩溃 ， 提供的 *$ 功 能可以自
动 监测对 象是 否超过 作用 域从 而 达到自 动 回收内 存的 目的 ，  语言 没有提 供 释放已 分 配
内存的 显示操作方法。
　　 (、 ?C?PC有什么 错?CP?C有什么 错
　　 ?C?PC（ P 运算结 果是  型，需要 强制转换类型）
　　 ?CP?C（可以 正确 编译）
　　 )、 5@(B等於多 少5@Q(B等於多少
5 @(B??
5 @Q(B??Q
 方法返回与参数最接近的长整数，参数加 D 后求其 
　　 -、 ?A@LF0LBC创建了 几个 E
两个
　 　 1、 设计 个 线程 ， 其 中 两 个 线程 每 次 对 增 加 ， 另外两 个 线程对 每 次 减少 。 写
出程序。
以 下程序使用内部类实现 线程，对 增 减的时候 没有 考虑顺序问题。
复制 代码
=/9 FC

DRR
R
(ROF
)RD
-=8 '9S
1= C

:=3 9@ TUBS
8 '9V?A8  '9@BC
#?VA#@BC
'?VA'@BC
4 @?:CKCPPBS
(8?A8 @BC
) @BC
-?A8@BC
1 @BC
W
:W

=  0 @BS
小讯
上一篇 2024-12-25 17:50
下一篇 2024-12-31 17:10

相关推荐

版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请联系我们，一经查实，本站将立刻删除。
如需转载请保留出处：https://51itzy.com/kjqy/9436.html