Passing Information to a Method or a Constructor (The Java™ Tutorials > Learni... - The Diigo Meta page

• 21 Apr 10
  

  c v
  • Primitive arguments, such as an int or a double, are passed into methods by value.
  • Reference data type parameters, such as objects,  are also passed into methods by value. This means that when the method returns, the passed-in reference still  references the same object as before. However, the values of the object's fields can be changed in the  method, if they have the proper access level.
  • reassignment has no permanence, however, because the  reference was passed in by value and cannot change. Within the method, the object pointed to by circle  has changed, but, when the method returns, myCircle still references the same  Circle object as before the method was called.

  1 more annotation...

• 24 Oct 09
  

  Ricky Robinson
• 24 Aug 09
  

  Lance Pedersen
  • When you invoke a method, the arguments used must match the declaration's  parameters in type and order.
  • accepts an array as an argument. In this example, the method creates a new  Polygon object and initializes it from an array of  Point objects
  • The Java programming language doesn't let you pass methods into methods. But you  can pass an object into a method and then invoke the object's methods
  • varargs to pass an arbitrary number of values to a method. You use  varargs when you don't know how many of a particular type of argument will be  passed to the method
  • To use varargs, you follow the type of the last parameter by an ellipsis (three  dots, ...), then a space, and the parameter name
  • public Polygon polygonFrom(Point... corners)
  • public PrintStream printf(String format, Object... args)
  • System.out.printf("%s: %d, %s, %s, %s%n", name, idnum, address, phone, email);
  • This means that any changes to the values of the parameters exist only within  the scope of the method. When the method returns, the parameters are gone and  any changes to them are lost. Here is an example:
  • When you run this program, the output is:  

    After invoking passMethod, x = 3
  • However, the values of the object's fields can be changed in the  method, if they have the proper access level.

  9 more annotations...

• 21 Mar 09
  

  Kalyani
  • Parameters refers to the list of variables in a method declaration. Arguments  are the actual values that are passed in when the method is invoked.
• 16 Feb 09
  

  Roy Jensen
  • The declaration for a method or a constructor  declares the number and the type of the arguments  for that method or constructor.
  • Note : Parameters refers to the list of variables in a method declaration. Arguments  are the actual values that are passed in when the method is invoked.  When you invoke a method, the arguments used must match the declaration's parameters in type and order.
  • You can use any data type for a parameter of a method  or a constructor.

  • Arbitrary Number of Arguments

       You can use a construct called varargs to pass an arbitrary number of values to a method.  You use varargs when you don't know how many of a particular type of argument will be passed to the method. It's a shortcut to creating an array manually (the previous method could have used varargs rather than an array). 

     To use varargs, you follow the type of the last parameter by an ellipsis (three dots, ...),  then a space, and the parameter name. The method can then be called with any number of that parameter, including none. 

  • You will most commonly see varargs with the printing methods; for example, this printf method: 

    public PrintStream printf(String format, Object... args) 
  • allows you to print an arbitrary number of objects. It can be called like this: 

    System.out.printf("%s: %d, %s%n", name, idnum, address); 

     or like this 

    System.out.printf("%s: %d, %s, %s, %s%n", name, idnum, address, phone, email); 

     or with yet a different number of arguments.
  • When you declare a parameter to a method or a constructor, you  provide a name for that parameter. This name is used within the  method body to refer to the passed-in argument.   

    The name of a parameter must be unique in its scope. It cannot  be the same as the name of another parameter for the same method  or constructor, and it cannot be the name of a local variable within the method  or constructor.   
  • A parameter can have the same name as one of the class's  fields. If this is the case, the parameter is said to shadow  the field. Shadowing fields can make your code  difficult to read and is conventionally used only within  constructors and methods that set a particular  field.
  • Primitive arguments, such as an int or a double, are passed into methods by value.  This means that any changes to the values of the parameters exist only within  the scope of the method. When the method returns, the parameters are gone and any changes to them are lost.
  • Reference data type parameters, such as objects,  are also passed into methods by value. This means that when the method returns, the passed-in reference still  references the same object as before. However, the values of the object's fields can be changed in the  method, if they have the proper access level.

  8 more annotations...

• 11 Sep 08
  

  vaisha prabhu
  • circle
  • circle
  • : Parameters refers to the list of variables in a method declaration. Arguments  are the actual values that are passed in when the method is invoked.  When you invoke a method, the arguments used must match the declaration's parameters in type and order.
  • Note : The Java programming language doesn't let you pass methods  into methods. But you can pass an object into a method and  then invoke the object's methods.
  • You can use a construct called varargs to pass an arbitrary number of values to a method.  You use varargs when you don't know how many of a particular type of argument will be passed to the method. It's a shortcut to creating an array manually (the previous method could have used varargs rather than an array).
  • To use varargs, you follow the type of the last parameter by an ellipsis (three dots, ...),  then a space, and the parameter name. The method can then be called with any number of that parameter, including none.
  • You can see that, inside the method, corners is treated like an array. The method can be called either with an array or with a sequence of arguments. The code in the method body will treat the parameter as an array in either case.
  • public PrintStream printf(String format, Object... args)
  • System.out.printf("%s: %d, %s%n", name, idnum, address);
  • System.out.printf("%s: %d, %s, %s, %s%n", name, idnum, address, phone, email);
  • A parameter can have the same name as one of the class's  fields. If this is the case, the parameter is said to shadow  the field
  • used only within
  • constructors and methods that set a particular  field.
  • To access the field
  • "Using the this Keyword."
  • Reference data type parameters, such as objects,  are also passed into methods by value. This means that when the method returns,
  • the passed-in reference still  references the same object as before. However, the values of the object's fields can be changed in the  method, if they have the proper access level.
  • Circle circle
  • circle
  • Within the method, the object pointed to by circle  has changed, but, when the method returns, myCircle still references the same  Circle object as before the method was called.

  18 more annotations...

• 30 May 07
  

  splatman
  • double
• 27 Mar 07
  

  Mukesh Soni
  • Reference data type parameters, such as objects,  are also passed into methods by value.
  • These changes will persist when the method returns.
  • This reassignment has no permanence, however, because the  reference was passed in by value and cannot change. Within the method, the object pointed to by circle  has changed, but, when the method returns, myCircle still references the same  Circle object as before the method was called.
  • You can use a construct called varargs to pass an arbitrary number of values to a method.
  • The method can be called either with an array or with a sequence of arguments. The code in the method body will treat the parameter as an array in either case.
  • used only within  constructors and methods that set a particular  field.
  • However, the values of the object's fields can be changed in the  method, if they have the proper access level.
  • A parameter can have the same name as one of the class's  fields. If this is the case, the parameter is said to shadow  the field.
  • Primitive arguments, such as an int or a double, are passed into methods by value.  This means that any changes to the values of the parameters exist only within  the scope of the method. When the method returns, the parameters are gone and any changes to them are lost

  7 more annotations...

• 18 Nov 06
  

  Danny armstrong

  java

  • Parameters refers to the list of variables in a method declaration. Arguments  are the actual values that are passed in when the method is invoked.  When you invoke a method, the arguments used must match the declaration's parameters in type and order.

  •  You will most commonly see varargs with the printing methods; for example, this printf method: 

    public PrintStream printf(String format, Object... args) 

     allows you to print an arbitrary number of objects. It can be called like this: 

    System.out.printf("%s: %d, %s%n", name, idnum, address); 
• 15 Sep 06
  

  the_fish
• 17 Oct 05
  

  seabay becy123

Would you like to comment?

Join Diigo for a free account, or sign in if you are already a member.