Java/J2EE面试必看：核心技术与问题解析

需积分: 10 90 浏览量更新于2024-07-21 收藏 2.16MB PDF 举报

"Java/J2EE面试问题指南" 本书《Java/J2EE Job Interview Companion》由K. Arulkumaran撰写，并由Craig Malone、Lara D’Albreo和Stuart Watson担任技术审阅者，旨在帮助读者掌握Java和J2EE的核心概念、设计和编码问题，以应对Java/J2EE相关的工作面试。书中的信息虽然力求准确，但不提供任何形式的明示或暗示保证，作者对因使用本书内容造成的任何直接或间接损害不承担责任。本书分为两个主要部分，每个部分涵盖了一系列与Java和J2EE相关的面试问题和答案。 **第一部分**：这部分主要关注Java语言的基础知识，包括： 1. **语言基础**：涉及Java语法、面向对象编程、异常处理、多线程等基础概念。 2. **Swing**：讲解用于构建桌面应用的Java图形用户界面组件。 3. **Applet**：讨论嵌入在网页中的小型Java程序及其在现代Web开发中的应用。 4. **性能和内存泄露**：介绍如何优化Java应用程序性能以及如何识别和解决内存泄露问题。 **个人部分**：这部分可能包含作者的个人经验分享，关于如何准备面试，提升个人技能等方面。 **第二部分**：这部分则专注于企业级Java技术，包括： 1. **J2EE**：解释Java企业版平台的关键特性，如分布式计算、事务处理和安全性。 2. **Servlet**：讨论服务器端的Java小程序，用于扩展Web服务器的功能。 3. **JSP**：JavaServer Pages，用于创建动态网页的技术。 4. **JDBC**：Java Database Connectivity，用于连接Java应用与数据库的标准接口。 5. **JNDI**：Java Naming and Directory Interface，提供查找和管理分布式环境中的资源的能力。 6. **RMI**：Remote Method Invocation，实现Java对象间的远程调用。 7. **EJB**：Enterprise JavaBeans，为企业级应用提供组件模型。 8. **JMS**：Java Message Service，用于异步通信和消息传递。 9. **XML**：Extensible Markup Language，数据交换和存储的重要格式。 10. **SQL、数据库调优和O/R映射**：涉及数据库查询语言、性能优化及对象关系映射技术。 11. **RUP（统一软件开发过程）和UML（统一建模语言）**：软件开发的方法论和建模工具。 12. **Struts**：一个流行的MVC（模型-视图-控制器）框架，用于构建Web应用。 13. **Web和应用服务器**：如Tomcat、JBoss、WebLogic等，它们提供运行Java应用的环境。 14. **最佳实践和性能**：强调在实际项目中应遵循的开发规范和性能优化策略。通过阅读本书，读者将能够系统地复习和深入理解Java和J2EE的关键技术和面试中可能遇到的问题，从而在面试中展现出扎实的专业知识和技能。

Java

+area() : double

<<abstract>>

Shape

+area() : double

Circle

+area() : double

HalfCircle

+area() : double

Square

//client or calling code

double dim = 5.0; //ie 5 meters radius or width

List listShapes = new ArrayList(20);

Shape s = new Circle();

listShapes.add(s); //add circle

s = new Square();

listShapes.add(s); //add square

getTotArea (listShapes,dim); //returns 78.5+25.0=103.5

//Later on, if you decide to add a half circle then define

//a HalfCircle class, which extends Circle and then provide an

//area(). method but your called method getTotArea(...) remains

//same.

s = new HalfCircle();

listShapes.add(s); //add HalfCircle

getTotArea (listShapes,dim); //returns 78.5+25.0+39.25=142.75

/** called method: method which adds up areas of various

** shapes supplied to it.

**/

public double getTotArea(List listShapes, double dim){

Iterator it = listShapes.iterator();

double totalArea = 0.0;

//loop through different shapes

while(it.hasNext()) {

Shape s = (Shape) it.next();

totalArea += s.area(dim); //polymorphic method call

}

return totalArea ;

}

Sample code:

For example: given a base

class/interface Shape,

polymorphism allows the

programmer to define

different area(double

dim1) methods for any

number of derived classes

such as Circle, Square etc.

No matter what shape an

object is, applying the area

method to it will return the

right results.

Later on HalfCicle can be

added without breaking

your called code i.e.

method getTotalArea(...)

Depending on what the

shape is, appropriate

area(double dim) method

gets called and calculated.

Circle Æ area is 78.5sqm

Square Æ area is 25sqm

HalfCircle Æ area is 39.25

sqm

+area() : double

Circle

+area() : double

HalfCircle

+area() : double

Square

+area() : double

«interface»

Shape

nheritance – is the inclusion of behaviour (i.e. methods) and state (i.e. variables) of a base class in a derived

class so that they are accessible in that derived class. The key benefit of Inheritance is that it provides the formal

mechanism for code reuse. Any shared piece of business logic can be moved from the derived class into the

base class as part of refactoring process to improve maintainability of your code by avoiding code duplication. The

existing class is called the superclass and the derived class is called the subclass. Inheritance can also be

defined as the process whereby one object acquires characteristics from one or more other objects the same way

children acquire characteristics from their parents.

There are two types of inheritances:

1. Implementation inheritance (aka class inheritance): You can extend an applications’ functionality by reusing

functionality in the parent class by inheriting all or some of the operations already implemented. In Java, you can

only inherit from one superclass. Implementation inheritance promotes reusability but improper use of class

inheritance can cause programming nightmares by breaking encapsulation and making future changes a problem.

With implementation inheritance, the subclass becomes tightly coupled with the superclass. This will make the

design fragile because if you want to change the superclass, you must know all the details of the subclasses to

avoid breaking them. So when using implementation inheritance, make sure that the subclasses depend only

on the behaviour of the superclass, not on the actual implementation. For example in the above diagram the

subclasses should only be concerned about the behaviour known as area() but not how it is implemented.

2. Interface inheritance (aka type inheritance): This is also known as subtyping. Interfaces provide a mechanism

for specifying a relationship between otherwise unrelated classes, typically by specifying a set of common

methods each implementing class must contain. Interface inheritance promotes the design concept of program to

interfaces not to implementations. This also reduces the coupling or implementation dependencies between

systems. In Java, you can implement any number of interfaces. This is more flexible than implementation

inheritance because it won’t lock you into specific implementations which make subclasses difficult to maintain. So

care should be taken not to break the implementing classes by modifying the interfaces.

Which one to use? Prefer interface inheritance to implementation inheritance because it promotes the design

concept of coding to an interface and reduces coupling. Interface inheritance can achieve code reuse with the

help of object composition. If you look at Gang of Four (GoF) design patterns, you can see that it favours

interface inheritance to implementation inheritance. CO

Java

Implementation inheritance Interface inheritance

Let’s assume that savings account and term deposit

account have a similar behaviour in terms of depositing

and withdrawing money, so we will get the super class to

implement this behaviour and get the subclasses to reuse

this behaviour. But saving account and term deposit

account have specific behaviour in calculating the interest.

public abstract class Account {

public void deposit(double amount) {

//deposit logic

}

public void withdraw(double amount) {

//withdraw logic

}

public abstract double calculateInterest(double amount);

}

public class SavingsAccount extends Account {

public double calculateInterest(double amount) {

//calculate interest for SavingsAccount

}

public class TermDepositAccount extends Account {

public double calculateInterest(double amount) {

//calculate interest for TermDeposit

}

The calling code can be defined as follows for illustration

purpose only:

public class Test {

public static void main(String[] args) {

Account acc1 = new SavingsAccount();

acc1.deposit(5.0);

acc1.withdraw(2.0);

Account acc2 = new TermDepositAccount();

acc2.deposit(10.0);

acc2.withdraw(3.0);

acc1.calculateInterest(500.00);

acc2.calculateInterest(500.00);

}

Let’s look at an interface inheritance code sample, which makes

use of composition for reusability. In the following example the

methods deposit(…) and withdraw(…) share the same piece of code

in AccountHelper class. The method calculateInterest(…) has its

specific implementation in its own class.

public interface Account {

public abstract void deposit(double amount);

public abstract void withdraw(double amount);

public abstract int getAccountType();

}

public interface SavingsAccount extends Account{

public abstract double calculateInterest(double amount);

}

public interface TermDepositAccount extends Account{

public abstract double calculateInterest(double amount);

}

The classes SavingsAccountImpl, TermDepositAccountImpl

should implement the methods declared in its interfaces. The class

AccountHelper implements the methods deposit(…) and

withdraw(…)

public class SavingsAccountImpl implements SavingsAccount{

private int accountType = 1;

//helper class which promotes code reuse through composition

AccountHelper helper = new AccountHelper();

public void deposit(double amount) {

helper.deposit(amount, getAccountType());

}

public void withdraw(double amount) {

helper.withdraw(amount, getAccountType());

}

public double calculateInterest(double amount) {

//calculate interest for SavingsAccount

}

public int getAccountType(){

return accountType;

}

public class TermDepositAccountImpl implements

TermDepositAccount {

private int accountType = 2;

//helper class which promotes code reuse through composition

AccountHelper helper = new AccountHelper();

public void deposit(double amount) {

helper.deposit(amount, getAccountType());

}

public void withdraw(double amount) {

helper.withdraw(amount, getAccountType());

}

public double calculateInterest(double amount) {

//calculate interest for TermDeposit

}

public int getAccountType() {

return accountType;

}

The calling code can be defined as follows for illustration purpose

only:

public class Test {

public static void main(String[] args) {

Java

Account acc1 = new SavingsAccountImpl();

acc1.deposit(5.0);

Account acc2 = new TermDepositAccountImpl();

acc2.deposit(10.0);

if (acc1.getAccountType() == 1) {

((SavingsAccount) acc1).calculateInterest(500.00);

}

if (acc2.getAccountType() == 2) {

((TermDepositAccount) acc2).calculateInterest(500.00);

}

ncapsulation – refers to keeping all the related members (variables and methods) together in an object.

Specifying members as private can hide the variables and methods. Objects should hide their inner workings from

the outside view. Good encapsulation improves code modularity by preventing objects interacting with

each other in an unexpected way, which in turn makes future development and refactoring efforts easy.

Being able to encapsulate members of a class is important for security and integrity. We can protect variables

from unacceptable values. The sample code below describes how encapsulation can be used to protect the

MyMarks object from having negative values. Any modification to member variable “vmarks” can only be carried

out through the setter method setMarks(int mark). This prevents the object “MyMarks” from having any negative

values by throwing an exception. CO

(

)

(

)

(

)

(

)

private int vmarks;

private String name;

Member

variables are

encapsulated,

so that they

can only be

accessed via

encapsulating

methods.

Class MyMarks {

private int vmarks = 0;

private String name;

public void setMarks(int mark)

throws MarkException {

if(mark > 0)

this.vmarks = mark;

else {

throw new MarkException("No negative

Values");

}

public int getMarks(){

return vmarks;

}

//getters and setters for attribute name goes here.

}

Sample code

Q 09: What is design by contract? Explain the assertion construct? DC

A 09: Design by contract specifies the obligations of a calling-method and called-method to each other. Design by

contract is a valuable technique, which should be used to build well-defined interfaces. The strength of this

programming methodology is that it gets the programmer to think clearly about what a function does, what pre

and post conditions it must adhere to and also it provides documentation for the caller. Java uses the assert

statement to implement pre- and post-conditions. Java’s exceptions handling also support design by contract

especially checked exceptions (Refer Q34 in Java section for checked exceptions). In design by contract in

addition to specifying programming code to carrying out intended operations of a method the programmer also

specifies:

1. Preconditions – This is the part of the contract the calling-method must agree to. Preconditions specify the

conditions that must be true before a called method can execute. Preconditions involve the system state and the

arguments passed into the method at the time of its invocation. If a precondition fails then there is a bug in the

calling-method or calling software component.

Java

On public methods On non-public methods

Preconditions on public methods are enforced by explicit checks

that throw particular, specified exceptions. You

should not use

assertion to check the parameters of the public methods but

can use for the non-public methods.

Assert is inappropriate

because the method guarantees that it will always enforce the

argument checks. It must check its arguments whether or not

assertions are enabled. Further, assert construct does not throw

an exception of a specified type. It can throw only an

AssertionError.

public void setRate(int rate) {

if(rate <= 0 || rate > MAX_RATE){

throw new IllegalArgumentException(“Invalid rate Æ ” + rate);

}

setCalculatedRate(rate);

}

You can use assertion to check the parameters of the

non-public methods.

private void setCalculatedRate(int rate) {

assert (rate > 0 && rate < MAX_RATE) : rate;

//calculate the rate and set it.

}

Assertions can be disabled, so programs must not

assume that assert construct will be always executed:

//Wrong: if assertion is disabled, CarpenterJob never

//Get removed

assert jobsAd.remove(PilotJob);

//Correct:

boolean pilotJobRemoved = jobsAd.remove(PilotJob);

assert pilotJobRemoved;

2. Postconditions – This is the part of the contract the called-method agrees to. What must be true after a

method completes successfully. Postconditions can be used with assertions in both public and non-public

methods. The postconditions involve the old system state, the new system state, the method arguments and the

method’s return value. If a postcondition fails then there is a bug in the called-method or called software

component.

public double calcRate(int rate) {

if(rate <= 0 || rate > MAX_RATE){

throw new IllegalArgumentException(“Invalid rate !!! ”);

}

//logic to calculate the rate and set it goes here

assert this.evaluate(result) < 0 : this; //this Æ message sent to AssertionError on failure

return result;

}

3. Class invariants - what must be true about each instance of a class? A class invariant as an internal invariant

that can specify the relationships among multiple attributes, and should be true before and after any method

completes. If an invariant fails then there could be a bug in either calling-method or called-method. There is

no particular mechanism for checking invariants but it is convenient to combine all the expressions required for

checking invariants into a single internal method that can be called by assertions. For example if you have a class,

which deals with negative integers then you define the isNegative() convenient internal method:

class NegativeInteger {

Integer value = new Integer (-1); //invariant

//constructor

public NegativeInteger(Integer int) {

//constructor logic goes here

assert isNegative();

}

//rest of the public and non-public methods goes here. public methods should call assert isNegative(); prior to its return

//convenient internal method for checking invariants. Returns true if the integer value is negative

private boolean isNegative(){

return value.intValue() < 0 ;

}

The isNegative() method should be true before and after any method completes

, each public method and

constructor should contain the following assert statement immediately prior to its return.

assert isNegative();

Explain the assertion construct? The assertion statements have two forms as shown below:

assert Expression1;

Java

assert Expression1 : Expression2;

Where:

 Expression1 Æ is a boolean expression. If the Expression1 evaluates to false, it throws an AssertionError without any

detailed message.

 Expression2 Æ if the Expression1 evaluates to false throws an AssertionError with using the value of the Expression2 as

the errors’ detailed message.

Note: If you are using assertions (available from JDK1.4 onwards), you should supply the JVM argument to

enable it by package name or class name.

Java -ea[:packagename...|:classname] or Java -enableassertions[:packagename...|:classname]

Java –ea:Account

Q 10: What is the difference between an abstract class and an interface and when should you use them? LF DP DC

A 10: In design, you want the base class to present only an interface for its derived classes. This means, you don’t want

anyone to actually instantiate an object of the base class. You only want to upcast to it (implicit upcasting, which

gives you polymorphic behaviour), so that its interface can be used. This is accomplished by making that class

abstract using the abstract keyword. If anyone tries to make an object of an abstract class, the compiler prevents

it.

The interface keyword takes this concept of an abstract class a step further by preventing any method or function

implementation at all. You can only declare a method or function but not provide the implementation. The class,

which is implementing the interface, should provide the actual implementation. The interface is a very useful and

commonly used aspect in OO design, as it provides the separation of interface and implementation and

enables you to:

 Capture similarities among unrelated classes without artificially forcing a class relationship.

 Declare methods that one or more classes are expected to implement.

 Reveal an object's programming interface without revealing its actual implementation.

 Model multiple interface inheritance in Java, which provides some of the benefits of full on multiple

inheritances, a feature that some object-oriented languages support that allow a class to have more than one

superclass.

Shape

Circle

Square

CircleOnSquare

Diamond problem & use of interface

No multiple inheritance in JAVA

Circle Square CircleOnSquare

<<Interface>>

ShapeIF

<<Interface>>

CircleIF

<<Interface>>

SquareIF

Multiple interface inheritance in JAVA

Abstract class Interface

Have executable methods and abstract methods. Have no implementation code. All methods are abstract.

Can only subclass one abstract class.

A class can implement any number of interfaces.

Can have instance variables, constructors and any

visibility: public, private, protected, none (aka package).

Cannot have instance variables, constructors and can have

only public and none (aka package) visibility.

When to use an abstract class?: In case where you want to use implementation inheritance then it is usually

provided by an abstract base class. Abstract classes are excellent candidates inside of application frameworks.

Abstract classes let you define some default behaviour and force subclasses to provide any specific behaviour.

Care should be taken not to overuse implementation inheritance as discussed in Q8 in Java section.

剩余236页未读，继续阅读

sinat_30746675

粉丝: 0
资源: 1

Java/J2EE面试必看：核心技术与问题解析

Java面试宝典(Java/J2EE Job Interview Companion)

Java/J2EE面试400问 英文版

java.lang.NoClassDefFoundError:javax/managment/j2ee/statitics/Stats 缺少那个包?

https://ddkk.com/category/j2ee/！！，，n，你！！！！！9 0/1/index.html

给我一个spring mvc的web.xml的配置

error: skipping "/tmp/j2ee.log" because parent directory has insecure permissions (It's world writable or writable by group which is not "root") Set "su" directive in config file to tell logrotate which user/group should be used for rotation.

ubuntu使用idea

实现(源码+文档)_java_j2ee_jsp_城市公交查询系统.zip

jsp 需要如何封装页面组件，能给我一个实际的代码例子吗

eclipes中怎样自动生成jstl所需的标签库

最新资源

Java/J2EE面试400问英文版