public class SomeClass {
  public staic void doSomething(Object param1, Object param2) {
    // body
  }
}

That said, there are options in Java for accomplishing the use of optional parameters. There are three options that seem the most obvious solutions:

1. Declare a method with all the possible parameters, and pass in null for the optional parameters. So, the method call above would look like SomeClass.doSomething(someObject, null)
   
   


2. Instead of having multiple parameters, have one object that encapsulates the possible parameters. Then the class' method above would look like:
   

   
   public class SomeClass {
     public staic void doSomething(ParamWrapper wrapper) {
       // body
     }
   }
   

   
   Where ParamWrapper looks like:
   

   
   public class ParamWrapper {
     private Object param1;
     private Object param2;
     public getParam1() { return param1; }
     public getParam2() { return param2; }
     // rest of body
   }
   

   
   Now, all parameters are wrapped in a single "query" object.
   
   


3. And I think this is the best OO approach Overload the method. This OO feature is perfect for this situation. Then, your class could look like:
   

   
   public class SomeClass {
     public staic void doSomething(Object param2) {
       // body
     }
   
     public staic void doSomething(Object param1, Object param2) {
       // body
     }
   }
   

   
   Now, the second parameter becomes optional. However, this assumes that the first parameter is always mandatory. If more the one parameter is optional and each has the same data type in the method signature (such as two optional String parameters), then the method call becomes ambiguous. In this case, method overloading is not an option and I would recommend using option #2. Also, if the number of parameters (optional or not) grows to large (e.g 12 parametes), I would also suggest option #2.

• Use of Collections: In most cases, certain types of collections may be used for passing in a list of objects that are actually the optional parameters. The drawback with this approach is that you will have to use objects to represent your optional parameters - which means that for every case where you want to pass a primitive type, you will have to pass the corresponding wrapper like java.lang.Integer for a normal int argument. The advantages you have with this approach are many. You could have ordered collections indicating the order of the parameters passed if that is of any significant consequence to your application. You could have Map constructs that associate descriptive keys to the arguments, which may help provide extra information to process these parameters and so on.
  
  
• Lazy Method Invocation: This is a much less known strategy which involves the repetitive calls to secondary helper methods to set the state of the object, followed by the actual method call with no arguments whatsoever. So you could call the setArgument(Object arg) method as many times as you want (or any other specialized strain of this method), before calling the method that will deal with all these arguments.
  

if( args != null )


for( int i = 0 ; i < args.length ; i++ )


//do something with .... args[i] ....

You can't use optional parameters in Java.

The closest thing you can do is to overload the method:

void myMethod(int number, String name) {
  // code goes here
}

void myMethod(int number) {
  myMethod(number,"jGuru");
}