Regarding abstract

hi,
when are u going to use abstract
could plz explain clearly

Hi,
We use Abstract class and interface to enforce some rules to the classes which extends/implements. For example we can define a class say "Bird" and we can declare methods say "Fly()", "Walk()". This means whatever the class that is derived from Bird has to override or give definition for Fly() and Walk() and therefore we are making sure that all the derived classes follows or has the common functionalities. In other way the classes derived from superclass should have common properties. In addition to this the derive class can have its own methods like "Swim()"...
In case of Abstract class we can define COMMON functionalities in super class and those can be used in the derived class where as in Interface we cant do that. ( this i would say as advantage of abstract class)
In case of Interface the derived class can implement any number of interface but restricted to extend only one abstract class (this i would say as advantage of Interface)
Check this thread also,
https://forums.sdn.sap.com/click.jspa?searchID=7499780&messageID=4559013
Regards,
Omkar.
Edited by: Omkaram Yanamala on Dec 18, 2007 1:27 PM

Similar Messages

Regarding Abstract Interface

Hello,
What makes the difference between the Normal Interfaces and Abstract Interfaces. Is there any technical differences between these two interfaces.
Thank you

Hi,
You use a message interface to describe a platform-independent or programming-language-independent interface, which you want to use to exchange messages between application components using SAP Exchange Infrastructure.
When you create a message interface you define the communication parameters by using the attributes Mode and Category as Sync/Async, Inbound/Outbound or Abstract.
Message interfaces of this category can perform the role of an inbound or outbound interface within integration processes, depending on whether it is used to send or receive a message. For this reason, no direction is specified during definition. In integration processes, you can use the same abstract interface to receive and send a message. Abstract message interfaces generally receive the message from an outbound interface of a sender system and send it to an inbound interface of a receiver system, thus performing a complementary role.
BPM can interact and deal with only Abstract Interfaces. And so, if you have a transformation step inside the BPM , the source and target interface will have to be abstract interfaces.
These characteristics determine the direction of an interface:
· An outbound interface sends a request message that is only used to make a communication party aware of data sent, without waiting for a response message. In the case of the latter, we also refer to publishing interfaces.
· An inbound interface receives a request message that you reply to with a direct response message or whose data you can process in the system without a response.
Thanks
Swarup

Access overriden method of an abstract class

class Abstract
abstract void abstractMethod(); //Abstract Method
void get()
System.out.print("Hello");
class Subclass extends Abstract
void abstractMethod()
System.out.print("Abstract Method implementation");
void get()
System.out.print("Hiiii");
In the above code, i have an abstract class called "Abstract", which has an abstract method named "abstractMethod()" and another method called "get()".
Now, this class is extended by "Subclass", it provides implementation for "abstractMethod()", and also overrides the "get()" method.
Now my problem is that i want to access the "get()" method of "Abstract" class. Since it is an abstract class, i cant create an object of it directly, and if i create an object like this:
Abstract obj = new Subclass();
then, obj.get() will call the get() method of Subclass, but how do i call the get() method of Abstract class.
Thanks in advance

hey thanks a lot,, i have another doubt regarding Abstract classes.
i was just trying something, in the process, i noticed that i created an abstract class which does not have any abstract method, it gave no compilation errors. was wondering how come this is possible, and what purpose does it solve?

Abstract Class & Interface

Hi ,
I have a fundamental doubt regarding Abstract Class & Interface!!!
What is their real benefit...whether we implement an interface or extend an Abstract class we have to write the code for the abstract method in the concrete class.Then where the benefit remained....
And it is said that Abstract class provide default behaviour...what is the actual meaning of that?
Thanks & Regards
Santosh

In this section we will redesign our OneRowNim game to fit within a hierarchy of classes of two-player games. There are many games that characteristically involve two players: checkers, chess, tic-tac-toe, guessing games, and so forth. However, there are also many games that involve just one player: blackjack, solitaire, and others. There are also games that involve two or more players, such as many card games. Thus, our redesign of OneRowNim as part of a two-player game hierarchy will not be our last effort to design a hierarchy of game-playing classes. We will certainly redesign things as we learn new Java language constructs and as we try to extend our game library to other kinds of games.
This case study will illustrate how we can apply inheritance and polymorphism, as well as other object-oriented design principles. The justification for revising OneRowNim at this point is to make it easier to design and develop other two-player games. As we have seen, one characteristic of class hierarchies is that more general attributes and methods are defined in top-level classes. As one proceeds down the hierarchy, the methods and attributes become more specialized. Creating a subclass is a matter of specializing a given class.
8.6.1. Design Goals
One of our design goals is to revise the OneRowNim game so that it fits into a hierarchy of two-player games. One way to do this is to generalize the OneRowNim game by creating a superclass that contains those attributes and methods that are common to all two-player games. The superclass will define the most general and generic elements of two-player games. All two-player games, including OneRowNim, will be defined as subclasses of this top-level superclass and will inherit and possibly override its public and protected variables and methods. Also, our top-level class will contain certain abstract methods, whose implementations will be given in OneRowNim and other subclasses.
Generic superclass
A second goal is to design a class hierarchy that makes it possible for computers to play the game, as well as human users. Thus, for a given two-player game, it should be possible for two humans to play each other, or for two computers to play each other, or for a human to play against a computer. This design goal will require that our design exhibit a certain amount of flexibility. As we shall see, this is a situation in which Java interfaces will come in handy.
[Page 376]
Another important goal is to design a two-player game hierarchy that can easily be used with a variety of different user interfaces, including command-line interfaces and GUIs. To handle this feature, we will develop Java interfaces to serve as interfaces between our two-player games and various user interfaces.
8.6.2. Designing the TwoPlayerGame Class
To begin revising the design of the OneRowNim game, we first need to design a top-level class, which we will call the TwoPlayerGame class. What variables and methods belong in this class? One way to answer this question is to generalize our current version of OneRowNim by moving any variables and methods that apply to all two-player games up to the TwoPlayerGame class. All subclasses of TwoPlayerGamewhich includes the OneRowNim classwould inherit these elements. Figure 8.18 shows the current design of OneRowNim.
Figure 8.18. The current OneRowNim class.
What variables and methods should we move up to the TwoPlayerGame class? Clearly, the class constants, PLAYER_ONE and PLAYER_TWO, apply to all two-player games. These should be moved up. On the other hand, the MAX_PICKUP and MAX_STICKS constants apply just to the OneRowNim game. They should remain in the OneRowNim class.
The nSticks instance variable is a variable that only applies to the OneRowNim game but not to other two-player games. It should stay in the OneRowNim class. On the other hand, the onePlaysNext variable applies to all two-player games, so we will move it up to the TwoPlayerGame class.
Because constructors are not inherited, all of the constructor methods will remain in the OneRowNim class. The instance methods, takeSticks() and getSticks(), are specific to OneRowNim, so they should remain there. However, the other methods, getPlayer(), gameOver(), getWinner(), and reportGameState(), are methods that would be useful to all two-player games. Therefore these methods should be moved up to the superclass. Of course, while these methods can be defined in the superclass, some of them can only be implemented in subclasses. For example, the reportGameState() method reports the current state of the game, so it has to be implemented in OneRowNim. Similarly, the getWinner() method defines how the winner of the game is determined, a definition that can only occur in the subclass. Every two-player game needs methods such as these. Therefore, we will define these methods as abstract methods in the superclass. The intention is that TwoPlayerGame subclasses will provide game-specific implementations for these methods.
[Page 377]
Constructors are not inherited
Given these considerations, we come up with the design shown in Figure 8.19. The design shown in this figure is much more complex than the designs used in earlier chapters. However, the complexity comes from combining ideas already discussed in previous sections of this chapter, so don't be put off by it.
Figure 8.19. TwoPlayerGame is the superclass for OneRowNim and other two-player games.
To begin with, note that we have introduced two Java interfaces into our design in addition to the TwoPlayerGame superclass. As we will show, these interfaces lead to a more flexible design and one that can easily be extended to incorporate new two-player games. Let's take each element of this design separately.
[Page 378]
8.6.3. The TwoPlayerGame Superclass
As we have stated, the purpose of the TwoPlayerGame class is to serve as the superclass for all two-player games. Therefore, it should define the variables and methods shared by two-player games.
The PLAYER_ONE, PLAYER_TWO, and onePlaysNext variables and the getPlayer(), setPlayer(), and changePlayer() methods have been moved up from the OneRowNim class. Clearly, these variables and methods apply to all two-player games. Note that we have also added three new variables, nComputers, computer1, computer2, and their corresponding methods, getNComputers() and addComputerPlayer(). We will use these elements to give our games the capability to be played by computer programs. Because we want all of our two-player games to have this capability, we define these variables and methods in the superclass rather than in OneRowNim and subclasses of TwoPlayerGame.
Note that the computer1 and computer2 variables are declared to be of type IPlayer. IPlayer is an interface containing a single method declaration, the makeAMove() method:
public interface IPlayer {
public String makeAMove(String prompt);
Why do we use an interface here rather than some type of game-playing object? This is a good design question. Using an interface here makes our design more flexible and extensible because it frees us from having to know the names of the classes that implement the makeAMove() method. The variables computer1 and computer2 will be assigned objects that implement IPlayer via the addComputerPlayer() method.
Game-dependent algorithms
The algorithms used in the various implementations of makeAMove() are game-dependentthey depend on the particular game being played. It would be impossible to define a game playing object that would suffice for all two-player games. Instead, if we want an object that plays OneRowNim, we would define a OneRowNimPlayer and have it implement the IPlayer interface. Similarly, if we want an object that plays checkers, we would define a CheckersPlayer and have it implement the IPlayer interface. By using an interface here, our TwoPlayerGame hierarchy can deal with a wide range of differently named objects that play games, as long as they implement the IPlayer interface. Using the IPlayer interface adds flexibility to our game hierarchy and makes it easier to extend it to new, yet undefined, classes. We will discuss the details of how to design a game player in Section 8.6.7.
The IPlayer interface
Turning now to the methods defined in TwoPlayerGame, we have already seen implementations of getPlayer(), setPlayer(), and changePlayer() in the OneRowNim class. We will just move those implementations up to the superclass. The getNComputers() method is the assessor method for the nComputers variable, and its implementation is routine. The addComputerPlayer() method adds a computer player to the game. Its implementation is as follows:
[Page 379]
public void addComputerPlayer(IPlayer player) {
if (nComputers == 0)
computer2 = player;
else if (nComputers == 1)
computer1 = player;
else
return; // No more than 2 players
++nComputers;
As we noted earlier, the classes that play the various TwoPlayerGames must implement the IPlayer interface. The parameter for this method is of type IPlayer. The algorithm we use checks the current value of nComputers. If it is 0, which means that this is the first IPlayer added to the game, the player is assigned to computer2. This allows the human user to be associated with PLAYERONE if this is a game between a computer and a human user.
If nComputers equals 1, which means that we are adding a second IPlayer to the game, we assign that player to computer1. In either of these cases, we increment nComputers. Note what happens if nComputers is neither 1 nor 2. In that case, we simply return without adding the IPlayer to the game and without incrementing nComputers. This, in effect, limits the number of IPlayers to two. (A more sophisticated design would throw an exception to report an error. but we will leave that for a subsequent chapter.)
The addComputerPlayer() method is used to initialize a game after it is first created. If this method is not called, the default assumption is that nComputers equals zero and that computer1 and computer2 are both null. Here's an example of how it could be used:
OneRowNim nim = new OneRowNim(11); // 11 sticks
nim.add(new NimPlayer(nim)); // 2 computer players
nim.add(new NimPlayerBad(nim));
Note that the NimPlayer() constructor takes a reference to the game as its argument. Clearly, our design should not assume that the names of the IPlayer objects would be known to the TwoPlayerGame superclass. This method allows the objects to be passed in at runtime. We will discuss the details of NimPlayerBad in Section 8.6.7.
The getrules() method is a new method whose purpose is to return a string that describes the rules of the particular game. This method is implemented in the TwoPlayerGame class with the intention that it will be overridden in the various subclasses. For example, its implementation in TwoPlayerGame is:
public String getRules() {
return "The rules of this game are: ";
Overriding a method
[Page 380]
and its redefinition in OneRowNim is:
public String getRules() {
return "\n*** The Rules of One Row Nim ***\n" +
"(1) A number of sticks between 7 and " + MAX_STICKS +
" is chosen.\n" +
"(2) Two players alternate making moves.\n" +
"(3) A move consists of subtracting between 1 and\n\t" +
MAX_PICKUP +
" sticks from the current number of sticks.\n" +
"(4) A player who cannot leave a positive\n\t" +
" number of sticks for the other player loses.\n";
The idea is that each TwoPlayerGame subclass will take responsibility for specifying its own set of rules in a form that can be displayed to the user.
You might recognize that defining geTRules() in the superclass and allowing it to be overridden in the subclasses is a form of polymorphism. It follows the design of the toString() method, which we discussed earlier. This design will allow us to use code that takes the following form:
TwoPlayerGame game = new OneRowNim();
System.out.println(game.getRules());
Polymorphism
In this example the call to getrules() is polymorphic. The dynamic-binding mechanism is used to invoke the getrules() method defined in the OneRowNim class.
The remaining methods in TwoPlayerGame are defined abstractly. The gameOver() and getWinner() methods are both game-dependent methods. That is, the details of their implementations depend on the particular TwoPlayerGame subclass in which they are implemented.
This is good example of how abstract methods should be used in designing a class hierarchy. We give abstract definitions in the superclass and leave the detailed implementations up to the individual subclasses. This allows the different subclasses to tailor the implementations to their particular needs, while allowing all subclasses to share a common signature for these tasks. This enables us to use polymorphism to create flexible, extensible class hierarchies.
Figure 8.20 shows the complete implementation of the abstract TwoPlayerGame class. We have already discussed the most important details of its implementation.
Figure 8.20. The TwoPlayerGame class
(This item is displayed on page 381 in the print version)
public abstract class TwoPlayerGame {
public static final int PLAYER_ONE = 1;
public static final int PLAYER_TWO = 2;
protected boolean onePlaysNext = true;
protected int nComputers = 0; // How many computers
// Computers are IPlayers
protected IPlayer computer1, computer2;
public void setPlayer(int starter) {
if (starter == PLAYER_TWO)
onePlaysNext = false;
else onePlaysNext = true;
} // setPlayer()
public int getPlayer() {
if (onePlaysNext)
return PLAYER_ONE;
else return PLAYER_TWO;
} // getPlayer()
public void changePlayer() {
onePlaysNext = !onePlaysNext;
} // changePlayer()
public int getNComputers() {
return nComputers;
} // getNComputers()
public String getRules() {
return "The rules of this game are: ";
} // getRules()
public void addComputerPlayer(IPlayer player) {
if (nComputers == 0)
computer2 = player;
else if (nComputers == 1)
computer1 = player;
else
return; // No more than 2 players
++nComputers;
} // addComputerPlayer()
public abstract boolean gameOver(); // Abstract Methods
public abstract String getWinner();
} // TwoPlayerGame class
Effective Design: Abstract Methods
Abstract methods allow you to give general definitions in the superclass and leave the implementation details to the different subclasses.
[Page 381]
8.6.4. The CLUIPlayableGame Interface
We turn now to the two interfaces shown in Figure 8.19. Taken together, the purpose of these interfaces is to create a connection between any two-player game and a command-line user interface (CLUI). The interfaces provide method signatures for the methods that will implement the details of the interaction between a TwoPlayerGame and a UserInterface. Because the details of this interaction vary from game to game, it is best to leave the implementation of these methods to the games themselves.
Note that CLUIPlayableGame extends the IGame interface. The IGame interface contains two methods that are used to define a standard form of communication between the CLUI and the game. The getGamePrompt() method defines the prompt used to signal the user for a move of some kindfor example, "How many sticks do you take (1, 2, or 3)?" And the reportGameState() method defines how the game will report its current statefor example, "There are 11 sticks remaining." CLUIPlayableGame adds the play() method to these two methods. As we will see shortly, the play() method contains the code that will control the playing of the game.
[Page 382]
Extending an interface
The source code for these interfaces is very simple:
public interface CLUIPlayableGame extends IGame {
public abstract void play(UserInterface ui);
public interface IGame {
public String getGamePrompt();
public String reportGameState();
} // IGame
Note that the CLUIPlayableGame interface extends the IGame interface. A CLUIPlayableGame is a game that can be played through a CLUI. The purpose of its play() method is to contain the game-dependent control loop that determines how the game is played via a user interface (UI). In pseudocode, a typical control loop for a game would look something like the following:
Initialize the game.
While the game is not over
Report the current state of the game via the UI.
Prompt the user (or the computer) to make a move via the UI.
Get the user's move via the UI.
Make the move.
Change to the other player.
The play loop sets up an interaction between the game and the UI. The UserInterface parameter allows the game to connect directly to a particular UI. To allow us to play our games through a variety of UIs, we define UserInterface as the following Java interface:
public interface UserInterface {
public String getUserInput();
public void report(String s);
public void prompt(String s);
Any object that implements these three methods can serve as a UI for one of our TwoPlayerGames. This is another example of the flexibility of using interfaces in object-oriented design.
To illustrate how we use UserInterface, let's attach it to our KeyboardReader class, thereby letting a KeyboardReader serve as a CLUI for TwoPlayerGames. We do this simply by implementing this interface in the KeyboardReader class, as follows:
public class KeyboardReader implements UserInterface
[Page 383]
As it turns out, the three methods listed in UserInterface match three of the methods in the current version of KeyboardReader. This is no accident. The design of UserInterface was arrived at by identifying the minimal number of methods in KeyboardReader that were needed to interact with a TwoPlayerGame.
Effective Design: Flexibility of Java Interfaces
A Java interface provides a means of associating useful methods with a variety of different types of objects, leading to a more flexible object-oriented design.
The benefit of defining the parameter more generally as a UserInterface instead of as a KeyboardReader is that we will eventually want to allow our games to be played via other kinds of command-line interfaces. For example, we might later define an Internet-based CLUI that could be used to play OneRowNim among users on the Internet. This kind of extensibilitythe ability to create new kinds of UIs and use them with TwoPlayerGamesis another important design feature of Java interfaces.
Generality principle
Effective Design: Extensibility and Java Interfaces
Using interfaces to define useful method signatures increases the extensibility of a class hierarchy.
As Figure 8.19 shows, OneRowNim implements the CLUIPlayableGame interface, which means it must supply implementations of all three abstract methods: play(), getGamePrompt(), and reportGameState().
8.6.5. Object-Oriented Design: Interfaces or Abstract Classes?
Why are these methods defined in interfaces? Couldn't we just as easily define them in the TwoPlayerGame class and use inheritance to extend them to the various game subclasses? After all, isn't the net result the same, namely, that OneRowNim must implement all three methods.
These are very good design questions, exactly the kinds of questions one should ask when designing a class hierarchy of any sort. As we pointed out in the Animal example earlier in the chapter, you can get the same functionality from an abstract interface and an abstract superclass method. When should we put the abstract method in the superclass, and when does it belong in an interface? A very good discussion of these and related object-oriented design issues is available in Java Design, 2nd Edition, by Peter Coad and Mark Mayfield (Yourdan Press, 1999). Our discussion of these issues follows many of the guidelines suggested by Coad and Mayfield.
Interfaces vs. abstract methods
We have already seen that using Java interfaces increases the flexibility and extensibility of a design. Methods defined in an interface exist independently of a particular class hierarchy. By their very nature, interfaces can be attached to any class, and this makes them very flexible to use.
Flexibility of interfaces
Another useful guideline for answering this question is that the superclass should contain the basic common attributes and methods that define a certain type of object. It should not necessarily contain methods that define certain roles that the object plays. For example, the gameOver() and getWinner() methods are fundamental parts of the definition of a TwoPlayerGame. One cannot define a game without defining these methods. By contrast, methods such as play(), getGamePrompt(), and reportGameState() are important for playing the game but they do not contribute in the same way to the game's definition. Thus these methods are best put into an interface. Therefore, one important design guideline is:
[Page 384]
Effective Design: Abstract Methods
Methods defined abstractly in a superclass should contribute in a fundamental way to the basic definition of that type of object, not merely to one of its roles or its functionality.
8.6.6. The Revised OneRowNim Class
Figure 8.21 provides a listing of the revised OneRowNim class, one that fits into the TwoPlayerGame class hierarchy. Our discussion in this section will focus on the features of the game that are new or revised.
Figure 8.21. The revised OneRowNim class, Part I.
(This item is displayed on page 385 in the print version)
public class OneRowNim extends TwoPlayerGame implements CLUIPlayableGame {
public static final int MAX_PICKUP = 3;
public static final int MAX_STICKS = 11;
private int nSticks = MAX_STICKS;
public OneRowNim() { } // Constructors
public OneRowNim(int sticks) {
nSticks = sticks;
} // OneRowNim()
public OneRowNim(int sticks, int starter) {
nSticks = sticks;
setPlayer(starter);
} // OneRowNim()
public boolean takeSticks(int num) {
if (num < 1 || num > MAX_PICKUP || num > nSticks)
return false; // Error
else // Valid move
{ nSticks = nSticks - num;
return true;
} // else
} // takeSticks()
public int getSticks() {
return nSticks;
} // getSticks()
public String getRules() {
return "\n*** The Rules of One Row Nim ***\n" +
"(1) A number of sticks between 7 and " + MAX_STICKS +
" is chosen.\n" +
"(2) Two players alternate making moves.\n" +
"(3) A move consists of subtracting between 1 and\n\t" +
MAX_PICKUP + " sticks from the current number of sticks.\n" +
"(4) A player who cannot leave a positive\n\t" +
" number of sticks for the other player loses.\n";
} // getRules()
public boolean gameOver() {   /*** From TwoPlayerGame */
return (nSticks <= 0);
} // gameOver()
public String getWinner() {        /*** From TwoPlayerGame */
if (gameOver()) //{
return "" + getPlayer() + " Nice game.";
return "The game is not over yet."; // Game is not over
} // getWinner()
The gameOver() and getWinner() methods, which are nowinherited from the TwoPlayerGame superclass, are virtually the same as in the previous version. One small change is that getWinner() now returns a String instead of an int. This makes the method more generally useful as a way of identifying the winner for all TwoPlayerGames.
Similarly, the getGamePrompt() and reportGameState() methods merely encapsulate functionality that was present in the earlier version of the game. In our earlier version the prompts to the user were generated directly by the main program. By encapsulating this information in an inherited method, we make it more generally useful to all TwoPlayerGames.
Inheritance and generality
The major change to OneRowNim comes in the play() method, which controls the playing of OneRowNim (Fig. 8.22). Because this version of the game incorporates computer players, the play loop is a bit more complex than in earlier versions of the game. The basic idea is still the same: The method loops until the game is over. On each iteration of the loop, one or the other of the two players, PLAYER_ONE or PLAYER_TWO, takes a turn making a movethat is, deciding how many sticks to pick up. If the move is a legal move, then it becomes the other player's turn.
Figure 8.22. The revised OneRowNim class, Part II.
(This item is displayed on page 386 in the print version)
/** From CLUIPlayableGame */
public String getGamePrompt() {
return "\nYou can pick up between 1 and " +
Math.min(MAX_PICKUP,nSticks) + " : ";
} // getGamePrompt()
public String reportGameState() {
if (!gameOver())
return ("\nSticks left: " + getSticks() +
" Who's turn: Player " + getPlayer());
else
return ("\nSticks left: " + getSticks() +
" Game over! Winner is Player " + getWinner() +"\n");
} // reportGameState()
public void play(UserInterface ui) { // From CLUIPlayableGame interface
int sticks = 0;
ui.report(getRules());
if (computer1 != null)
ui.report("\nPlayer 1 is a " + computer1.toString());
if (computer2 != null)
ui.report("\nPlayer 2 is a " + computer2.toString());
while(!gameOver()) {
IPlayer computer = null; // Assume no computers
ui.report(reportGameState());
switch(getPlayer()) {
case PLAYER_ONE: // Player 1's turn
computer = computer1;
break;
case PLAYER_TWO: // Player 2's turn
computer = computer2;
break;
} // cases
if (computer != null) {                           // If computer's turn
sticks = Integer.parseInt(computer.makeAMove(""));
ui.report(computer.toString() + " takes " + sticks + " sticks.\n");
} else {                                          // otherwise, user's turn
ui.prompt(getGamePrompt());
sticks =
Integer.parseInt(ui.getUserInput()); // Get user's move
if (takeSticks(sticks)) // If a legal move
changePlayer();
} // while
ui.report(reportGameState()); // The game is now over
} // play()
} // OneRowNim class
Let's look now at how the code decides whether it is a computer's turn to move or a human player's turn. Note that at the beginning of the while loop, it sets the computer variable to null. It then assigns computer a value of either computer1 or computer2, depending on whose turn it is. But recall that one or both of these variables may be null, depending on how many computers are playing the game. If there are no computers playing the game, then both variables will be null. If only one computer is playing, then computer1 will be null. This is determined during initialization of the game, when the addComputerPlayer() is called. (See above.)
In the code following the switch statement, if computer is not null, then we call computer.makeAMove(). As we know, the makeAMove() method is part of the IPlayer interface. The makeAMove() method takes a String parameter that is meant to serve as a prompt, and returns a String that is meant to represent the IPlayer's move:
public interface IPlayer {
public String makeAMove(String prompt);
[Page 385]
In OneRowNim the "move" is an integer, representing the number of sticks the player picks. Therefore, in play() OneRowNim has to convert the String into an int, which represents the number of sticks the IPlayer picks up.
On the other hand, if computer is null, this means that it is a human user's turn to play. In this case, play() calls ui.getUserInput(), employing the user interface to input a value from the keyboard. The user's input must also be converted from String to int. Once the value of sticks is set, either from the user or from the IPlayer, the play() method calls takeSticks(). If the move is legal, then it changes whose turn it is, and the loop repeats.
[Page 386]
There are a couple of important points about the design of the play() method. First, the play() method has to know what to do with the input it receives from the user or the IPlayer. This is game-dependent knowledge. The user is inputting the number of sticks to take in OneRowNim. For a tic-tac-toe game, the "move" might represent a square on the tic-tac-toe board. This suggests that play() is a method that should be implemented in OneRowNim, as it is here, because OneRowNim encapsulates the knowledge of how to play the One-Row Nim game.
Encapsulation of game-dependent knowledge
[Page

HEELLLLP with abstract data types(ie. interfaces)

Hello Java World,
I have a few questions regarding abstract data types(ADT) such as interfaces, etc.
1. Which of the following is allowed in Java ?
interface TA extends student, Employee
class teachAssist implements TA, Cloneable, Sortable{..}
2. ADTs cannot be instantiated only extended/implemented(coded)??
3. Can a interface implements/extend classe(s)?
4. Why is a Vector not an ADT? Is it because it contains implementations for its some of its methods?
Thanks for the help, in advance!!
RahimS

Hello Java World,
I have a few questions regarding abstract data
types(ADT) such as interfaces, etc.
1. Which of the following is allowed in Java ?
interface TA extends student, Employee
{...}Allowed (if student and Employee are also Interfaces).
class teachAssist implements TA, Cloneable,
Sortable{..}Allowed.
>
2. ADTs cannot be instantiated only
extended/implemented(coded)??True.
3. Can a interface implements/extend classe(s)?No. An interface simply defines a skeleton...says what methods are present in classes that implement it...therefore an interface cannot 'implement' anything. It may however extend other Interfaces.
4. Why is a Vector not an ADT? Is it because it
contains implementations for its some of its methods?A Vector is not an ADT because it is fully implemented (it contains implementations for ALL of its methods).
>
>
Thanks for the help, in advance!!
RahimS

Reusing functions in ActionScript Classes

I have an MXML Component which I am using as a Base Class for
other components that share similar functionality. The Extended
Classes use some of the same functions. Those functions perform no
logic in the Base Class, but are called by Event Listeners in the
Base Class. Right now, I have those functions setup as protected
functions, and I am overriding them in the Extended Classes, but
I'm thinking this isn't the best way to do this. Should I use an
Interface???
Any suggestions would be greatly appreciated...
Thank you.

"Ansury" <[email protected]> wrote in
message
news:gacbks$1b0$[email protected]..
> Yes, I was referring to having your inheriting classes
implement the
> interface
> (still a pain in the rear), but like I said you have to
remember to add
> the
> interface to each class anyway... It's probably not
worth worrying about
> it at
> this stage of AS's life.
>
> Regarding abstract classes in current AS, that's
interesting. But I
> usually
> avoid fancy hacks that are likely to confuse new people
looking at or
> maintaining my code. Maybe it's not the coolest strategy
but many people
> do
> appreciate it when you omit that fancy fancy automagic
tricky code and go
> with
> something much easier to understand or maintain from the
outsider's
> perspective.
>
> Also I'm not sure what that method gets you over simply
throwing an
> exception
> in a function that must be implemented by an extending
class. I guess
> this:
> "We can make a real abstract class that implements none,
some, or all of
> an
> interface?s methods". (Although really you can still do
that with the
> common
> exception throwing method.) I suppose this is useful if
you're making
> lots of
> complex hierarchies and leveraging polymorphism alot and
so on, but that
> type
> of design tends to get trickier than it's worth in
practice.
>
> And if this gave you a compile time error that might be
cooler, but it
> looks
> like it's still just generating a run-time error.
Anyway, enough rambling
> on.
>
> Cool trick, but I'll wait until Adobe decides to support
abstract natively
> and
> it becomes common knowledge - maybe with Flex 4 and
Flash 10?
Probably too soon after As3 and ECMA parted ways

What is the diff b/w Abstract class and an interface ?

Hey
I am always confused as with this issue : diff b/w Abstract class and an interface ?
Which is more powerful in what situation.
Regards
Vinay

Hi, Don't worry I am teach you
Abstract class and Interface
An abstract class can have instance methods that implement a default behavior. An Interface can only declare constants and instance methods, but cannot implement default behavior and all methods are implicitly abstract. An interface has all public members and no implementation. An abstract class is a class which may have the usual flavors of class members (private, protected, etc.), but has some abstract methods.
Edited by SASIKUMARA
SIT INNOVATIONS- Chennai
Message was edited by:
sasikumara
Message was edited by:
sasikumara

Not yet solve....TAX Report regarding (client)question

Client asked to me in interview, please give me answer
This is regarding US PAYROLL
1 Transaction PU19 Reports for tax reporting/Tax Returns / Files for State Unemployment Reporting on CD or Diskette :-
We have issues on some reports regarding address, page numbers and totals. Alex worked on it and told that we need to contact SAP         for help as he thinks problem is with SAP Forms itself. Currently typing manual returns pending changes to forms.
2 Deposits on 941 form:-
   Can we update the form to include tax deposits made on the 941 line for deposits?
3 State Tax Returns not configured in SAP:-
   Can we have state tax returns configured in the PDF format also?
4 Printing of W-2:-
Need to be able to print W-2s so we can fold/seal so address apprears on outside for mailing. Duplex or 11/14 form? Our folder/sealer uses pressure seal self sealing forms.
5 Documentation of Processes (Benefit and Garnishment):-
6 Configure benefit changes for 2009:-
7 Update benefit tables / rates for 2009:-
8 'Update SUT rates for new year:-
9 New 401k Limits Entered :-
Documentation how to do this
10 W-2 Reporting, Non Taxable Relocation, Personal Use of Company car (Box 12 and 14 items) for W-2 Reporting:-
11 Deceased Employee Payments:-
How do we handle so W-2 is correct and any 1099 items handled correctly
12 'Mag Media File - Federal (annual):-
'RS record missing from Magnetic Media file. Can this be included in the Federal Mag Media file? Kathy has sent some changes that need to be made to Frank.
13 'State Mag Media Files and State annual returns:-
Have some states that we must file by diskette file. Can we also have annual state tax returns configured in the PDF format?
14 Federal 940 Return:-
Make sure this form is configured correctly
15 Pension Plan Indicator box on W-2:-
Tested and is not showing on the W-2 or in the Mag Media file
16 Third Party Sick Pay indicator box on W-2:-
Tested and is not showing on the W-2 or in the Mag Media file
17 Retirement Calculation:-
18 Year end close procedure:-
What all has to be done before we can close the year and print W-2's. Do we have to do any zeroing of wages, taxes and deductions before the first check of the new year can happen?
19 Sort order for W-2 printing:-
20 941 Correction Form (941C):-
Need training on how this is handled
21 'W-2 correction form (W-2C):-
Need training on how this is handled
22 'Payments received in January that affect prior year W-2:-
'How do we handle. We receive info in January that must be included on the prior year W-2. Want to be able to include on original W-2 without filing a W-2C. (Third Party Sick Pay, Payments made in Mexico, Germany, etc) Usually don't receive.
Regards

Aswin,
The client session is your primary TopLink interface abstracting over the shared cache and connection pooling. Depending if you are using internal or external connection pooling and the transaction state you are in TopLink may have a JDBC connection allocated to your client session. A client session does equate to a single dedicated JDBC connection for its entire lifecycle.
Assuming you are using an external connection pool (Application server's data source) your client session will have a connection from this data source when required to perform a read and during the commit of its UnitOfWork.
Doug

ORA-00904: invalid column name in select query by using abstract datatype

Hi,
I had created abstract datatype as PERSON_TY and ADDRESS_TY ,
after inserting the record . i'm tryng to select the column but i got the error , even i refferd all those thing. they are given that same please look this finde me a result.
SQL> DESC PERSON_TY
Name Null? Type
NAME VARCHAR2(25)
ADDRESS ADDRESS_TY
SQL> DESC ADDRESS_TY
Name Null? Type
STREET VARCHAR2(30)
CITY VARCHAR2(25)
STATE CHAR(2)
COUNTRY VARCHAR2(15)
SQL> SELECT * FROM EMPLOYE
2 ;
EMP_CODE
PERSON(NAME, ADDRESS(STREET, CITY, STATE, COUNTRY))
10
PERSON_TY('VENKAT', ADDRESS_TY('112: BLUE MOUNT', 'CHENNAI', 'TN', 'INDIA'))
20
PERSON_TY('SRINI', ADDRESS_TY('144: GREEN GARDEN', 'THAMBARAM', 'TN', 'INDIA'))
SQL> SELECT PERSON.NAME FROM EMPLOYE
2 ;
SELECT PERSON.NAME FROM EMPLOYE
ERROR at line 1:
ORA-00904: invalid column name
regards
venki

SELECT PERSON.NAME FROM EMPLOYEIf you look in the documentation, you will see that we need to alias the table in order to make this work:
select e.person.name from employees e
/Cheers, APC
Blog : http://radiofreetooting.blogspot.com

Abstract list error in nwds 7.2

Hi all,
I am working with nwds 7.2. When I am trying to set values to a structure in a bapi using list it gives code error, so I used abstract list. Please find below the structure and code:
structure:
Model     UploadProdOrderModel
bapi        Zbapi_Por_5003_Upload_So_Input
               I->File_Table of structure type Zbapi_Por_5003_Table
                                        collection cardinality as 0...n and selection cardinality as 0..1
               I->Bapi_Input of structure type Zbapi_Por_5003_Input
                                        collection cardinality as 0..1 and selection cardinality as 0..1
The code is as follows :
     try
     com.sap.crmb2b.uploadproductorder.model.UploadProdOrderModel modalVar = new com.sap.crmb2b.uploadproductorder.model.UploadProdOrderModel();
     com.sap.crmb2b.uploadproductorder.model.Zbapi_Por_5003_Upload_So_Input requestVar = new com.sap.crmb2b.uploadproductorder.model.Zbapi_Por_5003_Upload_So_Input(modalVar);
     Zbapi_Por_5003_Input in = new Zbapi_Por_5003_Input(modalVar);
     Zbapi_Por_5003_Table tab= new Zbapi_Por_5003_Table(modalVar);
     in.setSales_Org("1010");
     in.setDist_Channel("00");
     in.setDivision("00");
wdComponentAPI.getMessageManager().reportSuccess("1");
     requestVar.setBapi_Input(in);
     wdComponentAPI.getMessageManager().reportSuccess("2");
     AbstractList<Zbapi_Por_5003_Table> listin = null;
     wdComponentAPI.getMessageManager().reportSuccess("3");
     tab.setMatnr("0101");
     wdComponentAPI.getMessageManager().reportSuccess("4");
     tab.setShipto("23324");
     wdComponentAPI.getMessageManager().reportSuccess("5");
     tab.setKwmeng("1");
     wdComponentAPI.getMessageManager().reportSuccess("6");
     tab.setSoldto("2345");
     wdComponentAPI.getMessageManager().reportSuccess("7");
     listin.add(tab);
     wdComponentAPI.getMessageManager().reportSuccess("8");
     requestVar.setFile_Table(listin);
     wdComponentAPI.getMessageManager().reportSuccess("9");
     requestVar.execute();
Error on execution:
while trying to invoke the method java.util.AbstractList.add(java.lang.Object) of an object loaded from local variable 'listin'
Thank you
Regards,
Preet Kaur

Hi,
You set
AbstractList<Zbapi_Por_5003_Table> listin = null;
but you never initialized it. Adding to 'null' will give you this exception.
If your Bapi method returns an AbstractList, you need to have something like
AbstractList listin = new <YourBapi>.<YourBapi>_List();

Usage of Abstract Message Interface for non-BPM

Hi,
I have a message that I am using as both as an inbound and an outbound for 2 different mapping. I am not using BPM. Is it better to create 2 message interfacesone for outbound and one for inboundor should I just create 1 abstract message interface that can be used in both mappings? What are the advantages and disadvantages of using 2 message interfaces (1 inbound and 1 outbound) against 1 abstract message interface? Would using abstract cause a lot of problems or performance problems in the future?
Thanks in advance.
Regards,
Elbert

hi,
abstract messages are only used for BPMs
so I suggest creating 2 instead if you don's use a BPM
http://help.sap.com/saphelp_nw2004s/helpdata/en/e3/3355d5617d0a4cb0fe8e042c752caa/content.htm
Regards,
michal
<a href="/people/michal.krawczyk2/blog/2005/06/28/xipi-faq-frequently-asked-questions"><b>XI / PI FAQ - Frequently Asked Questions</b></a>

Need your Suggestion - regarding sjsas & axis

Hi,
I'm working on Sun java System Application Server8.1.. I'm now developing a document based web service client which invokes the service program generated using AXIS.... I have a doubt at this point... I'm using JAX-RPC1.1 specs.... i'm including the saaj-api.jar , xmlsecs.jar in my classpath along with the default jar files which comes with the package.... the above mentioned two packages has SOAPBodyElement.class and XMLUtility.class respectively which i'm using. But when i compile the code it gives the following compilation errors ...
symbol : method newDocument(java.io.FileInputStream)
location: class com.sun.org.apache.xml.internal.security.utils.XMLUtils
reqSOAPBodyElements[0] = new SOAPBodyElement(XMLUtils.newDocument(fis).getDocumentElement());
^
CatalogPublisherServiceClient.java:73: javax.xml.soap.SOAPBodyElement is abstract; cannot be instantiated
reqSOAPBodyElements[0] = new SOAPBodyElement(XMLUtils.newDocument(fis).getDocumentElement());
^
CatalogPublisherServiceClient.java:83: cannot find symbol
symbol : method getAsDOM()
location: interface javax.xml.soap.SOAPBodyElement
System.out.println(XMLUtils.ElementToString(resSOAPBodyElement.getAsDOM()));
But when i include axis.jar file in my classpath instead of the above mentioned jar files the code gets compiled suuccessfully.... axis.jar file contains both the above mentioned class files which i'm using... My main concern is if i use axis.jar which comes with axis, jakarta's product does it mean that i'm going out of my technological environment.. can i do that or is ther any other solution to over come this problem..
When i analyse the class files of axis package it implements javax.xml.soap which is from saaj-api.jar file.. i'm bit confused with this...
if i'm using axis.jar file in my classpath does it mean that i'm working on axis environment instead of sjsas environment...
can any body provide me a solution
thanks in advance
regards,
R Vijay

FICO forums
[ERP Financials|/community [original link is broken]://SAP ERP Financials;
[ERP Financials - Asset Accounting|SAP ERP Financials - Asset Accounting;
[ERP Financials - Financial Supply Chain Management|SAP ERP Financials - Financial Supply Chain Management;
[ERP Financials - Treasury Applications|SAP ERP Financials - Treasury Applications;

Unable to view Abstract Message Interface(Sync) in Container Step of BPM

Dear Friends,
This is IDOC---SOAP Sync Communication Interface
I have created the External Def by exporting & importing the Standard Idoc
and Imported the WSDL File which has the Request & response Structure
I have created the Outbound Sync message Interface for Idoc side
and Abstract Sync message Interface for the same to use in BPM
and also created Inbound Sync Message Interface for Webservice side
and Abstract Sync Message Interface for the same to use in BPM
Problem is::::
While creating the Container varible inside the Integration Process, i have to select the Abstract Message Interface which i created for Idoc.
But it is not at all visible in the list.
What might be the problem
REgards
Seshagiri

Hi,
I have created
For Idoc side
1) Create O/b Sync by having request of Idoc and response structure of Idoc
2) Create ABS Sync by having the request of Idoc and response structure of Idoc
3) Create ABS Async by having the Request of Idoc Only
For Webservice side
1) Create I/b Sync by having the request of webservice and response of that
2) Create ABS Sync by having the request of webservice and response of that
3) Create ABS Async by having the Response of Webservice only
I created the Steps inside the Integration Process as showed in the screens.
1)Integration Process graph
http://img145.imageshack.us/img145/4848/ipviewwv1.jpg
2)Receive Step
http://img293.imageshack.us/img293/1756/receivepropng8.jpg
3)Send step1
http://img179.imageshack.us/img179/2200/send1bd0.jpg
4)Send Step2
http://img182.imageshack.us/img182/8468/send2wl1.jpg
When i check the F7, it is throwing the error like
http://img247.imageshack.us/img247/4356/errortx3.jpg
Regards
Seshagiri

BPM, abstract interface unavailable

Hello,
I want to build a business process. Therefore I need some container elements. One container element has the type abstract interface. The message interface is defined in some namespace of some software component. But unfortunately I can't select this message interface in the dialog. Of course I have already activated my change list. I also refreshed the CPA cache, but this doesn't help a lot. What can I do in order to see this abstract interface.
Thank you very much,
Oliver

Hallo Oliver,
XI currently only allows BPM to use interfaces within the same software component or within a software component with which you have a based on relationship defined.
I think, that this does not make too much sense, but that's the answer we got to an according OSS message.
Best Regards
Christine

Abstract message

hi expect,
why should we are creating abstract message?in bpm why we are using abstract message?

HI rohit,
we create abstract interface in bpm because this type of interface has no direction i.e. inbound or outbond. so as per our requirement we can use this interface for any direction
also check these links
/people/krishna.moorthyp/blog/2005/06/09/walkthrough-with-bpm - Walk through BPM
/people/siva.maranani/blog/2005/05/22/schedule-your-bpm - Schedule BPM
/people/sriram.vasudevan3/blog/2005/01/11/demonstrating-use-of-synchronous-asynchronous-bridge-to-integrate-synchronous-and-asynchronous-systems-using-ccbpm-in-sap-xi - Use of Synch - Asynch bridge in ccBPM
https://www.sdn.sap.com/irj/sdn/weblogs?blog=/pub/wlg/1403 [original link is broken] [original link is broken] [original link is broken] [original link is broken] - Use of Synch - Asynch bridge in ccBPM
reward if help
regards
Trapti

Regarding abstract

Similar Messages

Maybe you are looking for