methods in java
DESCRIPTION
Methods in Java. Program Modules in Java. Java programs are written by combining new methods and classes with predefined methods in the Java Application Programming Interface ( Java API or Java class library ) and in various other class libraries - PowerPoint PPT PresentationTRANSCRIPT
Program Modules in Java
Java programs are written by combining new methods and classes with predefined methods in the Java Application Programming Interface (Java API or Java class library) and in various other class libraries
Related classes are grouped into packages so that they can be imported into programs and reused
Predefined Classesof the Java API
methods for performing common mathematical calculations
string manipulationscharacter manipulations input/output operations database operationsnetworking operations file processingerror checking and more.http://docs.oracle.com/javase/7/docs/api/
static MethodsSometimes a method performs a task that does not
depend on an object. Such a method applies to the class in which it’s declared
as a whole and is known as a static method or a class method.
To declare a method as static, place the keyword static before the return type in the method’s declaration.
For any class imported into program, call the class’s static methods by specifying the name of the class followed by a dot (.) and the method name
ClassName.methodName(arguments)
Math Class Methods as a Static Method
Class Math provides a collection of methods that enable you to perform common mathematical calculations.
all Math class methods are staticEach is called by preceding its name with the class name
Math and the dot (.) separatorClass Math is part of the java.lang package,
it is implicitly imported by the compilerit’s not necessary to import class Math to use its methods.
System.out.println(Math.sqrt(900.0));
static Variables
There are variables for which each object of a class does not need its own separate copy
Such variables are declared static They are called as class variables. When objects of a class containing static
variables are created, all the objects of that class share one copy of those variables.
Together a class’s static variables and instance variables are known as its fields.
A Kind of Variable in Java: Class Variables (Static Fields)
A class variable is any field declared with the static modifier;Tells the compiler that there is exactly one copy of this variable in existence, regardless of how many times the class has been instantiated.The keyword final could be added to indicate that the value of the class variable will never change.
Other Kind of Variable in Java Instance Variables (Non-Static Fields)
Objects store their individual states in "non-static fields"
Fields declared without the static keyword. Non-static fields are also known as instance
variables Their values are unique to each instance of a class
(to each object)
Another Kind of Variable in Java Local Variables
A method will often store its temporary state in local variables.
The syntax for declaring a local variable is similar to declaring a field .
int count = 0;There is no special keyword designating a variable as
localdetermination comes from the location which is between
the opening and closing braces of a method.Local variables are only visible to the methods in which
they are declaredthey are not accessible from the rest of the class.
Another Kind of Variable in Java : Parameters
public static void main(String[] args)The args variable is the parameter to the method. The important thing to remember is that parameters are always classified as "variables" not "fields”This applies to other parameter such as constructors and exception handlers.
Examplepublic class Bicycle { ……..private static int numberOfBicycles = 0; …………
public static int getNumberOfBicycles() { return numberOfBicycles; } ………….}
Class variables are referenced by the class name itself Bicycle.numberOfBicycles
This makes it clear that they are class variables.
It is also possible to refer static fields with an object reference myBike.numberOfBicycles
but this is discouraged because it does not make it clear that they are class variables.
Referring Class Variables
Static MethodsA common use for static methods is to access static fields.Not all combinations of instance and class variables and
methods are allowed:Instance methods can access instance variables and instance methods directly.Instance methods can access class variables and class methods directly.Class methods can access class variables and class methods directly.Class methods cannot access instance variables or instance methods directlythey must use an object referenceclass methods cannot use the this keyword as there is no
instance for this to refer to.
Constants
The static modifier, in combination with the final modifier is used to define constants. The final modifier indicates that the value of this field cannot change. static final double PI = 3.141592653589793; Constants defined in this way cannot be reassigned, and it is a compile-time error if the program tries to do so.
// MaximumFinder.java// method is declared with maximum with three double parameters. import java.util.Scanner; public class MaximumFinder { // obtain three floating-point values and locate the maximum value public static void main(String[] args) { // create Scanner for input from command window Scanner input = new Scanner(System.in); // prompt for and input three floating-point values System.out.print( "Enter three floating-point values "); double number1 = input.nextDouble(); // read first double double number2 = input.nextDouble(); // read second double double number3 = input.nextDouble(); // read third double// determine the maximum value double result = maximum(number1, number2, number3);System.out.println("Maximum is: " + result); // display maximum value } // returns the maximum of its three double parameters
public static double maximum (double x, double y, double z) { double maximumValue = x; // determine whether y is greater than maximumValue if (y > maximumValue) maximumValue = y; // determine whether z is greater than maximumValue if (z > maximumValue) maximumValue = z; return maximumValue; } } // end class Enter three floating-point values 9.35 2.11 5.91Maximum is: 9.35
Keywords public and staticMethod maximum’s declaration begins with
keyword public to indicate that the method is “available to the public”it can be called from methods of other classes.
The keyword static enables the main method to call maximum without qualifying the method name with the class name MaximumFinderstatic methods in the same class can call each other
directly. Any other class that uses maximum must fully
qualify the method name with the class name.
Method maximum The maximum method requires three double parameters (x, y
and z) to accomplish its taskWhen maximum is called the parameters x, y and z are
initialized with copies of the values of arguments number1, number2 and number3, respectively. each argument must be consistent with the type of the
corresponding parameterThere must be one argument in the method call for each
parameter in the method declarationWhen program control returns to the point in the program
where maximum was called, maximum’s parameters x, y and z no longer exist in memory
Important
Methods can return at most one value, but the returned value could be a reference to an object that contains many values.Variables should be declared as fields only if they’re required for use in more than one method of the class or if the program should save their values between calls to the class’s methods.
Implementing Method maximum by Reusing Method Math.max
The entire body of our maximum method could also be implemented with two calls to Math.max, as follows:
return Math.max(x, Math.max(y, z));The first call to Math.max specifies arguments x and
Math.max(y, z). Before any method can be called, its arguments must be
evaluated to determine their values. If an argument is a method call, the method call must be
performed to determine its return value. Then the result is passed as the second argument to the other
call to Math.max, which returns the larger of its two arguments.
Assembling Strings with String Concatenation
Java allows you to assemble String objects into larger strings by using operators + or +=. This is known as string concatenation.
When both operands of operator + are String objects, operator + creates a new String object in which the characters of the right operand are placed at the end of those in the left operandthe expression "hello " + "there" creates the String "hello
there«the expression "Maximum is: " + result uses operator + with operands of types String and double.
Assembling Strings with String Concatenation
Every primitive value and object in Java can be represented as a String.
When one of the + operator’s operands is a String, the other is converted to a String, then the two are concatenated.
System.out.println ("Maximum is: " + result);The double value is converted to its String
representation and placed at the end of the String If there are any trailing zeros in a double value, these will
be discarded when the number is converted to a String for example 9.3500 would be represented as 9.35.