Methods Methods are how we implement actions – actions that objects can do, or actions that can be done to objects. In Alice, we have methods such as move, turn, moveTowards, and rotate.

Method Syntax In Java, a method consists of a method header and a method body. The header says who can call the method, the type of the value that is returned by the method, the name of the method, and the parameters that are passed into the method. The body gives the code for the method – that is what is actually done.

Example public Rational add(Rational b) { Rational c = new Rational(); c.n = n * b.d + b.n * d; c.d = d * b.d; return c; }

Syntax ( ) { }

Parameters Parameters are how we pass information into a method. The method header contains a parameter list – a comma separated list of parameters. Each parameter consists of a type and a variable. Parameters are similar to variable declarations, except that they are initialized to values given in the call to the method.

Calling a method Most methods are associated with an object (although some methods may be associated with the entire class). A method is called by apply the method to an object of the class. The call may occur in an expression. The syntax is:. ( ). For example: Rational rat3 = rat1.add(rat2);

Arguments In the call to the method, values are specified for the initial values of the parameters. In the previous example, the parameter b would be initialized with the value rat2. The list of arguments must match in number and type with the list of parameters. Sometimes, one type may be automatically converted to another. For example, if the parameter is of type double, and the argument is an int, the argument will be converted.

More on Methods Methods are like miniature programs. They have input (through the parameters), output (via the return statement) and processing steps (the method body). Methods may have their own local variables.

Return Value A method which returns a value does so by using the return statement. The syntax is just: return The value must be of the same type as specified in the method header.

Void Methods A method which does not return a value should be of return type void. You can return from the method before reaching the end of it, by using a return statement without a value, e.g. return; The call to a void method may not be in an expression, but should be a separate statement.

Constructors Constructors are similar to methods, but instead of returning a value, they return a newly created object. Basically, constructors are used to initialize the fields of the new object, often given information from the caller, or using default value.

Syntax Constructors look very similar to methods, but there are two differences:  Constructors do not return a value, but rather the newly created object. Thus constructors do not have a return type (not even void)  Constructors always have the same name as the class.

Example A constructor for the Rational class could be: public Rational(int n0, int d0) { n = n0; d = d0; } Constructors are almost always public.

Default Constructor If you do not declare any constructors, there is always one created by default. This is a zero- argument constructor. It takes no arguments and just creates the object. If fields are initialized, those values are used. If not, numbers are set to 0, and chars to null characters.

More on Constructors If you do declare any constructors and you use the zero-argument constructor, you must declare it yourself: public Rational() {}

Multiple Constructors Often classes contain more than one constructor. This is useful if the user may omit values and default values are to be used. For example, the Rational class may have a one-place constructor which is given the numerator, and the denominator is assumed to be 1. This converts ints to Rationals. public Rational(int n0){ n = n0; d = 1; }

Multiple Constructors (cont'd) Similarly, the zero-argument constructor should probably set the values to something reasonable, such as 0/1: public Rational() { n = 0; d = 1; }

Disambiguation So as not to confuse the compiler, constructors (like methods) must be distinguishable when called. That means that they must differ in the number or types of the arguments.

Nested Constructors One constructor may invoke another constructor. In Java convention, this is commonly done to set default arguments. For example, the one-place constructor would invoke the two-place constructor, by passing the value of n0, and passing 1 for d: public Rational(int n0) { this(n0,1); } The keyword this is used to invoke another constructor of the class.

Nested Constructors (cont'd) Similarly, the zero-argument constructor would invoke the one-argument constructor (which in turns invokes the two-place constructor). public Rational() { this(0); } This makes more sense when the code for the constructor is complicated, and we want to avoid duplication of code in all the constructors. For example, if we need to change it, we need only make the change once.

Example In our example of the Rational constructors, we forgot that Rational numbers are to be stored in lowest terms. The constructor should reduce the rational number. public Rational(int n0; int d0) { n = n0; d = d0; reduce(); } This one change effects all the constructors as they call this one (directly or indirectly).