«

which is the recommended way?

1)
private Action createExitAction() {
return new ExitAction();
}

2)
private AbstractAction createExitAction() {
return new ExitAction();
}

3)
private ExitAction createAction() {
return new ExitAction();
}


if no. 1 is recommended, why then do most people do a

private JPanel createSomePanel() {
....
}

rather than a

private JComponent createSomePanel() {
....
}


thank you.

"-" <> a écrit dans le message de
news:...
> which is the recommended way?
>
> 1)
> private Action createExitAction() {
> return new ExitAction();
> }
>
> 2)
> private AbstractAction createExitAction() {
> return new ExitAction();
> }
>
> 3)
> private ExitAction createAction() {
> return new ExitAction();
> }
>
>
> if no. 1 is recommended, why then do most people do a
>
> private JPanel createSomePanel() {
> ...
> }
>
> rather than a
>
> private JComponent createSomePanel() {
> ...
> }
>
>
> thank you.

If you want to make your application the most "evolutive" possible, you must
use the 1st solution.
The JPanel example, comes from code that's not going to evolve about the
type returned, this method will always return a JPanel, so the conceptors
didnt find it coherent to return a JComponent, which would therefore imply
that someday eventually that method could return something else.

my guess,
K

"-" <> wrote in message news:...
> which is the recommended way?
>
> 1)
> private Action createExitAction() {
> return new ExitAction();
> }
>
> 2)
> private AbstractAction createExitAction() {
> return new ExitAction();
> }
>
> 3)
> private ExitAction createAction() {
> return new ExitAction();
> }
>
>
> if no. 1 is recommended, why then do most people do a
>
> private JPanel createSomePanel() {
> ...
> }
>
> rather than a
>
> private JComponent createSomePanel() {
> ...
> }
>
>
> thank you.

Use the most abstract type.
Where some twit has failed to use interfaces appropriately, you'll have to
concede and use a class reference type, or write the dependant framework
yourself.

--
Tony Morris
http://xdweb.net/~dibblego/

KiLVaiDeN coughed up:
> "-" <> a écrit dans le message de
> news:...
>> which is the recommended way?
>>
>> 1)
>> private Action createExitAction() {
>> return new ExitAction();
>> }
>>
>> 2)
>> private AbstractAction createExitAction() {
>> return new ExitAction();
>> }
>>
>> 3)
>> private ExitAction createAction() {
>> return new ExitAction();
>> }
>>
>>
>> if no. 1 is recommended, why then do most people do a
>>
>> private JPanel createSomePanel() {
>> ...
>> }
>>
>> rather than a
>>
>> private JComponent createSomePanel() {
>> ...
>> }
>>
>>
>> thank you.
>
> If you want to make your application the most "evolutive" possible,
> you must use the 1st solution.

Not necessarily in this particular (weird) case. His method is specifically
for returning an exit action.

*If* there is a reason (I'm dubious of this in your design for some reason)
for making a method hardwired to returning a specific type of action, then
there are likely things required in the return type that are only found
there (in ExitAction). If he chooses a class/interface upstream in the
hierarchy he must downcast later in order to access that functionality
specific to ExitAction.

It is true that in general you are best off using the highest possible base
class that provides all the functionality desired. In that way: 1. you
don't accidentally "stray" into functionality you don't need to use, and 2.
you have gained the greatest possible mobility in changing the datatype
later.





> The JPanel example, comes from code that's not going to evolve about
> the type returned, this method will always return a JPanel, so the
> conceptors didnt find it coherent to return a JComponent, which would
> therefore imply that someday eventually that method could return
> something else.
>
> my guess,
> K



--
"It's easier to be terrified by an enemy you admire."
-Thufir Hawat, Mentat and Master of Assassins to House Atreides

Tony Morris coughed up:
> "-" <> wrote in message
> news:...
>> which is the recommended way?
>>
>> 1)
>> private Action createExitAction() {
>> return new ExitAction();
>> }
>>
>> 2)
>> private AbstractAction createExitAction() {
>> return new ExitAction();
>> }
>>
>> 3)
>> private ExitAction createAction() {
>> return new ExitAction();
>> }
>>
>>
>> if no. 1 is recommended, why then do most people do a
>>
>> private JPanel createSomePanel() {
>> ...
>> }
>>
>> rather than a
>>
>> private JComponent createSomePanel() {
>> ...
>> }
>>
>>
>> thank you.
>
> Use the most abstract type.
> Where some twit has failed to use interfaces appropriately, you'll
> have to concede and use a class reference type, or write the
> dependant framework yourself.

Again, this depends. Take for example the following declaration:

List myList = new ArrayList();

or

Collection myList = new ArrayList();

I use these all the time when what I'm doing is fairly simple, like mostly
add(), because it allows changing this to any other kind of list later.
*HOWEVER*, if my algorithm is *without a doubt* going to need random access
into this collection, then I would chose this:

ArrayList myList = new ArrayList();

Because I specifically would not want a LinkedList() to find its way in
there.

--
"It's easier to be terrified by an enemy you admire."
-Thufir Hawat, Mentat and Master of Assassins to House Atreides

- <> scribbled the following:
> which is the recommended way?

> 1)
> private Action createExitAction() {
> return new ExitAction();
> }

> 2)
> private AbstractAction createExitAction() {
> return new ExitAction();
> }

> 3)
> private ExitAction createAction() {
> return new ExitAction();
> }

As a general rule, use the most abstract type possible that gives you
full access to every method you need (not necessarily every method there
is) without casting.
This is an "if in doubt" rule. For special needs, this rule might have
to be broken.

--
/-- Joona Palaste () ------------- Finland --------\
\-------------------------------------------------------- rules! --------/
"Outside of a dog, a book is a man's best friend. Inside a dog, it's too dark
to read anyway."
- Groucho Marx