Java/J2EE面试宝典：英文原版精华指南

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

《Java/J2EE面试宝典英文原版》是由K.Arulkumaran、Technical Reviewers Craig Malone和Lara D’Albreo以及Stuart Watson共同编写的实用指南，专为准备Java和J2EE技术栈面试的求职者设计。本书旨在帮助读者巩固核心概念、设计问题和编码技巧，以便在面试中展现实力。该书的核心内容分为两个主要部分： 1. **Java基础与核心**： - **语言基础**：这部分将深入探讨Java的基本语法、数据类型、类和对象、异常处理等基础知识，确保求职者对Java编程有扎实的理解。 - **Swing**：讲解Swing组件库，包括图形用户界面设计和事件处理，这对于理解企业级应用的用户界面至关重要。 - **Applet**：介绍Java Applet的概念和开发，虽然现代Web应用程序倾向于使用Web Start或HTML5，但理解这一历史阶段的技术仍有价值。 - **性能与内存管理**：讨论如何识别和避免性能瓶颈，以及内存泄漏的预防措施，这些都是评估应聘者代码优化能力的关键点。 2. **企业Java技术与实践**： - **J2EE**：涵盖了J2EE架构及其组成部分，如Servlet、JSP、EJB、JMS等，这些都是构建企业级Web应用程序的基础。 - **JDBC和数据库管理**：介绍如何通过JDBC进行数据库交互，以及数据库调优和ORM映射的最佳实践。 - **JNDI**：简述Java Naming and Directory Interface（JNDI）在分布式环境中的角色，用于查找和配置资源。 - **RMI**：远程方法邀请（RMI）技术的应用，展示了如何实现跨平台的分布式计算。 - **EJB**：详述Enterprise JavaBeans（EJBs），它们在企业级应用中的作用和设计模式。 - **Web和应用服务器**：涵盖主流应用服务器如Tomcat、WebLogic、JBOSS等，以及它们在部署和管理J2EE应用中的角色。 - **最佳实践与性能优化**：提供关于软件开发和项目管理的最佳实践，如Rational Unified Process (RUP)和统一建模语言(UML)，以及Struts这样的MVC框架的使用。《Java/J2EE面试宝典英文原版》不仅是一本理论知识的集锦，更是实用工具，它鼓励求职者在准备面试时，不仅要掌握理论知识，还要能够将这些技术应用到实际场景中，并展示出高效、可靠的解决方案。作者K.Arulkumaran强调，尽管他们尽力确保信息准确，但读者在使用过程中需自行承担可能产生的风险，因为本书不提供任何形式的法律担保。

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页未读，继续阅读

jeven217

粉丝: 0
资源: 1

Java/J2EE面试宝典：英文原版精华指南

java面试宝典2018版

2023黑马面试宝典-Java面试宝典大全-java面试宝典黑马

Java面试宝典2017.pdf

JAVA面试宝典

Java面试宝典

java面试宝典

Java 面试宝典

java 面试宝典

若依管理存在任何文件读取漏洞检测系统，渗透测试.zip

【java毕业设计】学生社团管理系统源码（完整前后端+说明文档+LW）.zip

最新资源