programmer defined classes part 2 n.
Skip this Video
Download Presentation
Programmer-defined classes, part 2

Loading in 2 Seconds...

play fullscreen
1 / 19

Programmer-defined classes, part 2 - PowerPoint PPT Presentation

  • Uploaded on

Programmer-defined classes, part 2. More on identifier scope & Parameter passing. Categories of data storage. As we’re aware, we store data in memory, either in variables or constants

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Programmer-defined classes, part 2' - linus-barry

Download Now An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
programmer defined classes part 2

Programmer-defined classes, part 2

More on identifier scope


Parameter passing

categories of data storage
Categories of data storage
  • As we’re aware, we store data in memory, either in variables or constants
  • Each of these storage units must be declared; the location of the declaration determines the unit identifier’s scope:
    • Class-wide variables and constants are declared within the class but outside any method
    • Local variables and constants are declared within the body of a method
    • The scope of an identifier is defined by the boundaries of the block in which it is declared
one more category
One more category
  • A local variable is one that is declared within the body of a method
  • Another kind of local variable can be declared in the method’s parameter list
  • A part of the method’s heading, the parameter list specifies what, how many, and in what order arguments must be passed in a message that calls the method
general syntax for a method
General syntax for a method
  • The general syntax for a method definition consists of a heading and body, as follows:
  • The generic syntax for a method, as we’ve seen before, is:

Modifier(s) returnType identifier (parameter(s)) {

method body


  • The parameter list looks like a list of variable declarations, separated by comma
  • The scope of a parameter is local to its method
mutator methods and parameters
Mutator methods and parameters
  • Data that is stored in variables that belong to the class are automatically accessible to member methods, as we have already seen
  • Member methods that are used to change these data values are called mutators; it is this type of method that almost always requires parameters
setter methods for the bettertherm class
Setter methods for the BetterTherm class
  • Consider the example class we looked at in the last lecture, the BetterTherm class
  • This class featured a constructor that set a default value for the lone class variable, kelvinTemp, and getter methods that gave us access to this value in various forms
  • What is missing from the class are mutator methods that allow us to change the temperature value
setter methods for the bettertherm class1
Setter methods for the BetterTherm class
  • The purpose of a “setter” method is to assign a new value to a class variable
  • Such a method usually specifies a parameter; the value passed to the parameter is then assigned to the class variable
  • The methods on the next slide illustrate this concept for the BetterTherm class
setter methods for the bettertherm class2
Setter methods for the BetterTherm class

public void setKtemp (int k)


kelvinTemp = Math.abs(k);


public void setCtemp (int c)


kelvinTemp = c + CFACTOR;


public void setFtemp (int f)


int cTemp = (int)((f - FCONVI) / FCONVD);

kelvinTemp = cTemp + CFACTOR;


general pattern for a setter method
General pattern for a setter method
  • Most setter methods follow this pattern:

public void setValue (dataType param) {

classVariable = param;



    • “dataType” is the same type as the class variable to be set
    • “classVariable” is the name of the previously-declared class variable
  • As we have seen, there are variations on the pattern; the three setter methods for BetterTherm use expressions that incorporate the parameter, rather than just the parameter itself, to set the value of variable kelvinTemp
calling setter methods
Calling setter methods
  • A method that includes one or more parameters in its heading must be called with arguments that match its parameters
  • For example, consider the code below:

BetterTherm bt = new BetterTherm();

bt.setCtemp(32); // sets kelvinTemp to 32° Celsius

Random rg = new Random();

bt.setCtemp (Math.abs(rg.nextInt()) % 100);

// sets kelvinTemp to a random value between 0° and 100° Celsius

parameter matching
Parameter matching
  • Parameters specify the number, ordering, and data type(s) of the argument(s) that can be passed to a method.
  • When a parameter is one of the simple numeric types, we can pass as an argument to the parameter any expression that is assignment-compatible with the parameter’s specified data type.
parameter matching1
Parameter matching
  • Recall that expressions can include:
    • literal values, e.g. -4, 13.02
    • initialized variables or constants
    • messages to value-returning methods (e.g. Integer.parseInt(), Math.sqrt(a))
    • arithmetic operators & parentheses
    • explicit type casts
  • Assignment compatibility means that the value being passed is only valid if it can be assigned to a variable of the parameter’s type
  • The following are valid examples of messages requesting BetterTherm’s setFtemp method:


bt.setFtemp(bt.getCtemp() + 5);


  • The following are invalid examples of calls to BetterTherm’s setFtemp method – what is the matter with each?


bt.setFtemp(“new temperature”);



parameter matching and identifiers
Parameter matching and identifiers
  • Parameters, are variables local to the method they are declared in. As we already know, all variables have two properties: a data type and an identifier.
  • Arguments can have identifiers too. If we pass a variable or constant as an argument, we are passing a named argument.
  • There is no relationship between the name of a parameter and the name of its corresponding argument
parameter matching and identifiers1
Parameter matching and identifiers
  • Parameters and arguments can have different names (and usually do)
  • A parameter and its corresponding argument can have the same name, but:
    • The two variables (parameter and argument) belong to different methods
    • They do not have the same scope
yet another analogy
Yet another analogy
  • I had a grandfather named Joe; he had a son named Joe, who was my uncle
  • My mother had a son named Joe, who is my brother
  • The three Joes are not the same person; and we can easily distinguish between them, because they exist(ed) in different locations – hence, different scope
  • Consider the following code:

public class SimpleClass {

private int x;

public void setVar (int y) {

x = y;


int getVar () {

return x;



Consider variables x and y; what is the scope of each one?

The code on the next slide contains a tester class for the class shown here. What happens when a new variable named x is declared there?


import java.util.*;

public class TestSimp {

public static void main (String [] args) {

SimpleClass simp = new SimpleClass();

int x;

Scanner kb = new Scanner (;

System.out.print ("Enter a whole number: ");

x = kb.nextInt();


System.out.println ("Value of SimpleClass’s x = "

+ simp.getVar());

x += 10;

System.out.println ("Value of TestSimp’s x = " + x);

System.out.println ("Value of SimpleClass’s x = "

+ simp.getVar());