error checking without if_else statements, possible?

> i was thinking that if i have a lof of textfields and

> i want to check whether the user has filled in all the

> required fields or not. The simplest way of doing this

> is to use a series of if-else statements. But can it

> be done in another way which is more OO style or

> without using of if-else statements?

Yes you can do this in a more OO way, you need to make use of two fundamental OO techniques, polymorphism, and delegation.

Polymorphism allows you to handle a bunch of things (i.e. fields) in a uniform manner, (i.e. validation).

The second technique is to use delegation, get the fields to validate themselves.

Checkout the ValueObject and ValueAssembler patterns.

Firstly you need to create a common base for your text fields, this could be concrete if you wanted to use it for all your fields, or abstract if you wanted to specialise some of your fields.

interface ValueObject {

boolean validate() ;

}

abstract class StringValueObject {

String string;

boolean validate() {

super.validate() ;

}

}

abstract class PersonNameObject {

String string;

boolean validate() {

super.validate() ;

}

}

abstract class AddressObject {

String string;

boolean validate() {

super.validate() ;

}

}

// define your text fields as an array of the common base.

...

ValueObject[] record = new ValueObject[MAX_FIELDS] ;

// process your text fields polymorphically.

for( int i =0 ; i<MAX_FIELDS ; i++) {

record[i].validate() ;

}

>

MartinS. at 2007-7-7 0:35:50 >

Hi,

You could do something like this:

/* StringValidator.java */

/* This interface describes a method for validating strings */

public interface StringValidator

{

boolean validateString( String string );

}

/* NotEmptyStringValidator.java */

/* This is an example implementation, you would have others */

/* NB. It is a singleton */

public class NotEmptyStringValidator

implements StringValidator

{

private static final NotEmptyStringValidator INSTANCE =

new NotEmptyStringValidator();

public static NotEmptyStringValidator getInstance()

{return INSTANCE;}

private NotEmptyStringValidator() {}

public boolean validateString( String string )

{

if ( string == null ) return false;

if ( string.length() == 0 ) return false;

if ( string.trim().length() == 0 ) return false;

return true;

}

}

/* ValidatedTextField.java */

/* This class connects a validator to a text field */

import javax.swing.*;

public class ValidatedTextField

{

private final JTextField textField;

private final StringValidator stringValidator;

public ValidatedTextField( JTextField textField ,

StringValidator stringValidator )

{

if ( textField == null ) throw new

NullPointerException( "textField" );

if ( stringValidator == null ) throw new

NullPointerException( "stringValidator" );

this.textField = textField;

this.stringValidator = stringValidator;

}

public boolean validate()

{ /* delegates validation to the StringValidator */

return stringValidator.validateString( textField.getText() );

}

}

/* ValidatedTextFields.java */

/* This class is for holding, and validating, many text fields */

import java.util.*;

import javax.swing.*;

public class ValidatedTextFields

{

private final Collection fields = new ArrayList();

public ValidatedTextFields() {}

public void add( JTextField textField ,

StringValidator stringValidator )

{

fields.add( new ValidatedTextField( textField , stringValidator ) );

}

public boolean validate()

{

for ( Iterator i = fields.iterator() ; i.hasNext() ; )

{

ValidatedTextField f = (ValidatedTextField) i.next();

if ( ! f.validate() ) return false;

}

return true;

}

}

/* ValidatedTextFieldTest.java */

/* An example program to test the classes above */

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

public class ValidatedTextFieldTest

extends JFrame

implements ActionListener

{

private final JButton validateButton;

private final JLabel label;

private final JButton quitButton;

private final ValidatedTextFields fields;

public static void main( String[] argv )

{

ValidatedTextFieldTest frame = new ValidatedTextFieldTest();

frame.pack();

frame.setVisible( true );

return;

}

public ValidatedTextFieldTest()

{

StringValidator notEmpty = NotEmptyStringValidator.getInstance();

JTextField a = new JTextField( 20 );

JTextField z = new JTextField( 20 );

validateButton = new JButton( "Validate" );

label = new JLabel( "Blah blah" );

quitButton = new JButton( "Quit" );

fields = new ValidatedTextFields();

fields.add( a , notEmpty ); /* connect fields and validators here */

fields.add( z , notEmpty );

getContentPane().setLayout( new GridLayout(5,1) );

getContentPane().add( a );

getContentPane().add( z );

getContentPane().add( validateButton );

getContentPane().add( label );

getContentPane().add( quitButton );

validateButton.addActionListener( this );

quitButton.addActionListener( this );

}

public void actionPerformed( ActionEvent e )

{

if ( e.getSource() == quitButton ) System.exit(0);

if ( fields.validate() )

label.setText( "GOOD" );

else

label.setText( "BAD" );

}

}

This doesn't get rid of the if/elses of course, but it does put them in a validator class which is where they probably belong. Also the validators know nothing of gui text fields, which is as it should be.

Ol.

0s at 2007-7-7 0:35:50 >