Methods are how we implement actions actions that

  • Slides: 21
Download presentation
Methods are how we implement actions – actions that objects can do, or actions

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, move. Towards, and rotate.

Method Syntax In Java, a method consists of a method header and a method

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 =

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 <accessor> <return type> <name> (<parameter list>) { <body> }

Syntax <accessor> <return type> <name> (<parameter list>) { <body> }

Parameters are how we pass information into a method. The method header contains a

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

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: <object>. <method>(<argument list>). For example: Rational rat 3 = rat 1. add(rat 2);

Arguments In the call to the method, values are specified for the initial values

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 rat 2. 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 are like miniature programs. They have input (through the parameters), output

More on 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

Return Value A method which returns a value does so by using the return statement. The syntax is just: return <value> 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

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 are similar to methods, but instead of returning a value, they return a

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

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 n 0, int

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

Default Constructor If you do not declare any constructors, there is always one created

Default Constructor If you do not declare any constructors, there is always one created by default. This is a zeroargument 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

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

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 n 0){ n = n 0; d = 1; }

Multiple Constructors (cont'd) Similarly, the zero-argument constructor should probably set the values to something

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

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

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 n 0, and passing 1 for d: public Rational(int n 0) { this(n 0, 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

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

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 n 0; int d 0) { n = n 0; d = d 0; reduce(); } This one change effects all the constructors as they call this one (directly or indirectly).