Java/J2EE核心概念与设计编码问题解析

需积分: 3 145 浏览量更新于2024-07-18 收藏 2.16MB PDF 举报

“Learn Java/J2EE Core Concepts and Design/Coding Issues” 本书《Learn Java/J2EE Core Concepts and Design/Coding Issues》旨在帮助读者深入理解Java和J2EE（Java 2 Platform, Enterprise Edition）的核心概念、设计原则以及编程中的常见问题。通过作者K. Arulkumaran与技术审阅者Craig Malone、Lara D’Albreo和Stuart Watson的共同努力，这本书为Java/J2EE求职者提供了一份详实的面试指南。版权为2005年K. Arulkumaran所有，作者尽力确保书中信息的准确性，但不提供任何明示或暗示的保证。对于因使用本书内容直接或间接导致的任何损害，作者不承担任何责任。书中的内容分为两个主要部分： **SECTION 1:** 这部分主要涵盖Java语言基础及应用相关的面试问题和答案： 1. **语言基础**：深入讨论Java的基础语法、特性及其用法。 2. **Swing**：讲解Java GUI开发框架Swing的组件和使用技巧。 3. **Applet**：介绍Java小程序（Applet）的原理和在Web环境中的应用。 4. **性能和内存泄漏**：探讨如何优化代码性能以及如何识别和处理内存泄漏问题。 5. **个人部分**：可能包含作者的个人经验分享和建议。 **SECTION 2:** 这部分聚焦于企业级Java开发，包括J2EE、Web服务及最佳实践： 1. **J2EE**：讲解J2EE平台的架构、服务和组件。 2. **Servlet**：讨论用于动态生成Web内容的Servlet技术。 3. **JSP**：介绍Java Server Pages（JSP）的用法和模板表达式。 4. **JDBC**：探讨Java数据库连接（JDBC）的API和数据库操作。 5. **JNDI**：Java Naming and Directory Interface的使用，用于查找和绑定资源。 6. **RMI**：远程方法调用（RMI）的概念和实现远程对象的方法。 7. **EJB**：企业级Java Bean（EJB）的生命周期和角色，包括会话Bean、实体Bean和消息驱动Bean。 8. **JMS**：Java消息服务（JMS）的使用，涉及消息队列和发布/订阅模型。 9. **XML**：XML文档的处理和在Java应用程序中的应用。 10. **SQL, 数据库调优和O/R映射**：SQL查询优化，以及对象关系映射（ORM）工具的使用，如Hibernate。 11. **RUP & UML**：统一过程（RUP）和统一建模语言（UML）在软件开发中的应用。 12. **Struts**：讲解Struts框架，一种流行的MVC（Model-View-Controller）架构实现。 13. **Web和应用服务器**：介绍Tomcat、JBoss、WebLogic等服务器的配置和管理。 14. **最佳实践和性能**：提供在开发过程中应遵循的最佳实践，以提高系统性能和可维护性。本书不仅适合准备Java/J2EE面试的求职者，也对正在提升技能的开发者具有很高的参考价值，它涵盖了广泛的主题，从基础到高级，有助于读者全面了解和掌握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页未读，继续阅读

身份认证购VIP最低享 7 折!

30元优惠券

leogod

粉丝: 3

Java/J2EE核心概念与设计编码问题解析

I/O Concepts详解：SmartClient用户指南

Core Java 10th Edition: Fundamental Concepts

"基于Java的大学生救援队网站设计与实现

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

A Java/J2EE technical job interview guide - 英文版

distributed systems concepts and design 5th instructor's solutions

分布式系统Distributed Systems: Concepts and Design 第五版 习题答案

distributed systems: concepts and design 第五版知识点概括

分布式系统:概念与设计(原书第3版) 原书名： Distributed Systems: Concepts and Design (4th Edition)

Interactive C# Fundamentals, Core Concepts and Patterns epub

最新资源

分布式系统Distributed Systems: Concepts and Design 第五版习题答案