methods
Functions/methods
method signature
Defines the inputs and outputs of the method
ie
void aMethod(String firstParam, Intger secondParam)output is void
inputs is firstParam of type STring and secondParam of type Integer
Can also have
throwsexceptionie
void aMethod(String firstParam, Intger secondParam) throws Exception
Method body
can be empty
ie
String method() {}
where the logic happens
any thing that needs to be returned
Should use the params provided
Although should not change the param
Parameter list
No parameters
String method(){...}parameters
parameters are the type of data that the method can receive
with one parameter
String method(int a){...}with multiple parameters
String method(int a, NewType b){...}Can have any length of parameters in method parameter list
best to keep this small
varags ie
Integer method(String... x){...}can pass in any number of arguments of type String, and these will then be a seen as an array of type string, where you can get those arguments
multiple parameters and varags
if there are one or more params along with the varags, the varags needs to be last
ie
Integer method(Integer a, String b, String... x){...}Cannot have multiple varage parameters
Old school way of doing varags
String[] arg
final parameters
String method(final int a){...}cannot change parameter
if parameter is an object (ie
Integer b), then the reference of the object cannot be changedbut state of object can be changed
Overloading methods
Same method name with different number of parameter types or type of parameters
for example
String method(){...}String method(int a){...}String method(String a){...}
Instance method
no static keyword
only used with an instance of class
Static method
use of static keyword
static String method() {...}no instance needed to be created to be used
Cannot be overridden
Disadvantage - breaks encapsulation
allow state to be maintained across all instances of a class
If a variable can be altered by any instance of a class then the fundamental principle behind encapsulation/information hiding is lost entirely
Disadvantage - Cannot mock if used in a classes
If a instance method calls a static method, and you need to mock it as it is calls an expensive (time/money/performance) operation (ie database), it becomes hard to add a mock for it. Thus hard to test the instance method as a unit.
Disadvantage - polymorphism goes out the window
Cannot override
Disadvantage - Cannot handle state
As other calls, which is not the class of the static method can change it's state
Causes concurrency bugs
One rule-of-thumb: ask yourself "does it make sense to call this method, even if no Obj has been constructed yet?" If so, it should definitely be static.
Requirements for static methods
If you are writing utility classes and they are not supposed to be changed.
If the method is not using any instance variable.
If any operation is not dependent on instance creation.
If there is some code that can easily be shared by all the instance methods, extract that code into a static method.
Reason for static methods
Performance: if you want some code to be run, and don't want to instantiate an extra object to do so, shove it into a static method. The JVM also can optimize static methods a lot
Practicality: instead of calling new Util().method(arg), call Util.method(arg), or method(arg) with static imports. Easier, shorter.
Adding methods: you really wanted the class String to have a removeSpecialChars() instance method, but it's not there (and it shouldn't, since your project's special characters may be different from the other project's), and you can't add it , so you create an utility class, and call removeSpecialChars(s) instead of s.removeSpecialChars().
Purity: taking some precautions, your static method will be a pure function, that is, the only thing it depends on is its parameters. Data in, data out. This is easier to read and debug, since you don't have inheritance quirks to worry about. You can do it with instance methods too, but the compiler will help you a little more with static methods (by not allowing references to instance attributes, overriding methods, etc.).
Return type is declared
static String method() {... return ....}return should match the type to be returned of the method in the method signature.
Can return
nullmultiple returns of same type
using a control flow statement like if else, both blocks should return the same type.
returnon its own?exits the level ie if statement or method returns the to higher leve.
Example:
in the above code, if isSunday() == true, then add to list then exit method.
throw Exception
can throw exception and no need to return anything
but the method should throw that exception
also any other method that uses this method should throw that exception too.
but can use
try/catchand placing the method which throws the exception in the try block and do something with it in the catch block, thus no need to add thethrow exceptionin the method signature.
Return multiple types
not possible
Can get around this by:
returning an object wrapper which holds all the types you want to return
return a Pair (part of jdk) or a tuple library
return an Object ArrayList/Array
Return a string with delimiters
void
The void type is used to declare that a method does not return a value.
Using methods
passing arguments to a method
within class, private method
just use the name of method
ie
method(1)
in different class
where instance is initialized and thus intance can be used ie
Instance instance = new Instance();instance.method(1);instance.methodTwo(1, "hello");instance.methodThree(1, new Car(new Engine(), "Honda"), Arrays.asList(1,2,3), (x, y) -> x > y);
Use of static methods
Instance.staticMethod();
Defining variable for storing/referencing output of method
Integer a = instance.method(1);Integer a = method(1);
Naming conventions
camel case
aMethod()
method()
Should be descriptive
side effects
Avoid using setters to alter the Instance
new up another instance with changed state instead
make fields private
Called Methods instead of functions as functions cannot have side effects and only effect he arguments passed to it
Links
https://en.wikipedia.org/wiki/Side_effect_(computer_science)
https://stackoverflow.com/questions/1073909/side-effect-whats-this
CQRS
method should either query and return something, or do something (ie delegate to another object and its behaviour) and return void
Recusion
Calling the itself to complete some tasks
Java does not handle this well out of the box
can lead to stack overflow exception for large values, as stack is continually adding the methods, and only evaluated (and popped off the stack) when it reaches the base case
Common problem is fibonacci
Need a base case, to allow evaluation
otherwise will go into infinite loop
Corecusion
How handled by java
When a method is called, Java suspends what it’s currently doing and pushes the environment on the stack to make a place for executing the called method.
When this method returns, Java pops the stack to restore the environment and resume program execution.
If you call one method after another, the stack always holds at most one of these method call environments.
But methods aren’t composed only by calling them one after the other. Methods call methods.
If method1 calls method2 as part of its implementation, Java again suspends the method1 execution, pushes the current environment on the stack, and starts executing method2.
When method2 returns, Java pops the last pushed environment from the stack and resumes execution (of method1 in this case).
When method1 completes, Java again pops the last environment from the stack and resumes what it was doing before calling this method.
Method calls may be deeply nested, and this nesting depth does have a limit, which is the size of the stack.
Around few thousands
depends on the java version and system used
Can be increased using flags
the same stack size is used for all threads, increasing the stack size generally wastes space.
Generally, you won’t need more, except in specific cases. One such case is recursive method calls.
Links
https://www.tutorialspoint.com/java/java_methods.htm
http://tutorials.jenkov.com/java/methods.html
Last updated
Was this helpful?