Este artículo fue traducido de: parámetros opcionales de Java
¿Cómo uso los parámetros opcionales en Java? ¿Cómo uso los parámetros opcionales en Java ? ¿Qué especificación admite parámetros opcionales? ¿Qué especificación admite parámetros opcionales?
Piso # 1
Referencia: https://stackoom.com/question/43De/Java parámetros opcionales
# 2F
En JDK> 1.5 puede usarlo así; en JDK> 1.5, puede usarlo así ;
public class NewClass1 {
public static void main(String[] args) {
try {
someMethod(18); // Age : 18
someMethod(18, "John Doe"); // Age & Name : 18 & John Doe
} catch (Exception e) {
e.printStackTrace();
}
}
static void someMethod(int age, String... names) {
if (names.length > 0) {
if (names[0] != null) {
System.out.println("Age & Name : " + age + " & " + names[0]);
}
} else {
System.out.println("Age : " + age);
}
}
}
Piso # 3
Existen varias formas de simular parámetros opcionales en Java: Existen varias formas de simular parámetros opcionales en Java :
Método de sobrecarga Método de sobrecarga.
void foo(String a, Integer b) { //... } void foo(String a) { foo(a, 0); // here, 0 is a default value for b } foo("a", 2); foo("a");Una de las limitaciones de este enfoque es que no funciona si tiene dos parámetros opcionales del mismo tipo y cualquiera de ellos puede ser omitido. Es una limitación de este enfoque es que si usted tiene dos del mismo tipo de opcional Los parámetros y cualquier parámetro pueden omitirse, entonces no tiene ningún efecto.
Varargs, parámetros variables.
a) Todos los parámetros opcionales son del mismo tipo: a) Todos los parámetros opcionales son del mismo tipo :
void foo(String a, Integer... b) { Integer b1 = b.length > 0 ? b[0] : 0; Integer b2 = b.length > 1 ? b[1] : 0; //... } foo("a"); foo("a", 1, 2);b) Los tipos de parámetros opcionales pueden ser diferentes: b) Los tipos de parámetros opcionales pueden ser diferentes :
void foo(String a, Object... b) { Integer b1 = 0; String b2 = ""; if (b.length > 0) { if (!(b[0] instanceof Integer)) { throw new IllegalArgumentException("..."); } b1 = (Integer)b[0]; } if (b.length > 1) { if (!(b[1] instanceof String)) { throw new IllegalArgumentException("..."); } b2 = (String)b[1]; //... } //... } foo("a"); foo("a", 1); foo("a", 1, "b2");El principal inconveniente de este enfoque es que si los parámetros opcionales son de diferentes tipos, pierde la verificación de tipo estático. La principal desventaja de este enfoque es que si los parámetros opcionales pertenecen a diferentes tipos, se perderá la verificación de tipo estático. Además, si cada parámetro tiene un significado diferente, necesita alguna forma de distinguirlos. Además, si cada parámetro tiene un significado diferente, necesita alguna forma de distinguirlos.
Nulos Valor nulo. Para abordar las limitaciones de los enfoques anteriores, puede permitir valores nulos y luego analizar cada parámetro en un cuerpo de método: Para abordar las limitaciones del método anterior, puede permitir valores nulos y luego analizar cada parámetro en el cuerpo del método :
void foo(String a, Integer b, Integer c) { b = b != null ? b : 0; c = c != null ? c : 0; //... } foo("a", null, 2);Ahora se deben proporcionar todos los valores de argumentos, pero los valores predeterminados pueden ser nulos. Ahora se deben proporcionar todos los valores de parámetros , pero el valor predeterminado puede ser nulo.
Clase opcional Clase opcional. Este enfoque es similar a los nulos, pero usa la clase opcional Java 8 para los parámetros que tienen un valor predeterminado: este método es similar a nulo , pero usa la clase opcional Java 8 para los parámetros con valores predeterminados:
void foo(String a, Optional<Integer> bOpt) { Integer b = bOpt.isPresent() ? bOpt.get() : 0; //... } foo("a", Optional.of(2)); foo("a", Optional.<Integer>absent());Opcional hace que un contrato de método sea explícito para una persona que llama, sin embargo, uno puede encontrar dicha firma demasiado detallada. Opcional hace que el contrato de método se muestre para la persona que llama, pero uno puede encontrar que dicha firma es demasiado larga.
La Actualización: Java 8 incluye la clase
java.util.Optionalfuera-de-la-caja, hay SO hay necesidad de guayaba para su uso en la esta razón, el Java especial 8. El nombre del método diferente, aunque es un 'poco. Actualización: Java 8, que comprende clasesjava.util.Optionalfuera de la caja , Por lo que no es necesario usar guayaba por este motivo especial en Java 8. El nombre del método es un poco diferente.Builder. Builder. El patrón de constructor se usa para constructores y se implementa mediante la introducción de una clase de constructor separada: El patrón de constructor se usa para constructores y se implementa mediante la introducción de una clase de constructor separada :
class Foo { private final String a; private final Integer b; Foo(String a, Integer b) { this.a = a; this.b = b; } //... } class FooBuilder { private String a = ""; private Integer b = 0; FooBuilder setA(String a) { this.a = a; return this; } FooBuilder setB(Integer b) { this.b = b; return this; } Foo build() { return new Foo(a, b); } } Foo foo = new FooBuilder().setA("a").build();Mapas. Mapa. Cuando el número de parámetros es demasiado grande y para la mayoría de los valores predeterminados generalmente se usan, puede pasar argumentos de método como un mapa de sus nombres / valores: cuando el número de parámetros es demasiado grande y la mayoría de los valores predeterminados generalmente se usan, puede cambiar Los parámetros del método se pasan como una asignación de sus nombres / valores:
void foo(Map<String, Object> parameters) { String a = ""; Integer b = 0; if (parameters.containsKey("a")) { if (!(parameters.get("a") instanceof Integer)) { throw new IllegalArgumentException("..."); } a = (Integer)parameters.get("a"); } if (parameters.containsKey("b")) { //... } //... } foo(ImmutableMap.<String, Object>of( "a", "a", "b", 2, "d", "value"));En Java 9, este enfoque se hizo más fácil: en Java 9, este enfoque se hizo más fácil :
@SuppressWarnings("unchecked") static <T> T getParm(Map<String, Object> map, String key, T defaultValue) { return (map.containsKey(key)) ? (T) map.get(key) : defaultValue; } void foo(Map<String, Object> parameters) { String a = getParm(parameters, "a", ""); int b = getParm(parameters, "b", 0); // d = ... } foo(Map.of("a","a", "b",2, "d","value"));
Tenga en cuenta que puede combinar cualquiera de estos enfoques para lograr un resultado deseable. Tenga en cuenta que puede usar cualquiera de estos métodos en combinación para lograr los resultados deseados.
# 4F
Los argumentos predeterminados no se pueden usar en Java. Los argumentos predeterminados no se pueden usar en Java . Donde en C #, C ++ y Python, podemos usarlos ... En C #, C ++ y Python, podemos usarlos ...
En Java, debemos usar 2 métodos (funciones) en lugar de uno con parámetros predeterminados.En Java, debemos usar 2 métodos (funciones) en lugar de métodos que usan parámetros predeterminados.
Ejemplo: Ejemplo:
Stash(int size);
Stash(int size, int initQuantity);
http://parvindersingh.webs.com/apps/forums/topics/show/8856498-java-how-to-set-default-parameters-values-like-c- http://parvindersingh.webs.com/apps/ foros / temas / show / 8856498-java-how-to-set-default-parameter-values-like-c-
# 5F
Depende de lo que quiere lograr, la sobrecarga de métodos o varargs debería resolver la mayoría de los escenarios. Depende de lo que desea lograr, la sobrecarga de métodos o varargs debería resolver la mayoría de las situaciones. Aquí hay algunos buenos ejemplos de cómo usarlos: Aquí hay algunos buenos ejemplos de cómo usarlos :
http://blog.sleekface.com/in/java-core/method-with-optional-parameters/ http://blog.sleekface.com/in/java-core/method-with-optional-parameters/
pero tenga en cuenta no usar en exceso la sobrecarga de métodos, pero tenga en cuenta no usar en exceso la sobrecarga de métodos . trae confusión , trae confusión.
Piso # 6
Hay parámetros opcionales con Java 5.0. Java 5.0 tiene parámetros opcionales. Simplemente declare su función de esta manera: Simplemente declare su función :
public void doSomething(boolean... optionalFlag) {
//default to "false"
//boolean flag = (optionalFlag.length >= 1) ? optionalFlag[0] : false;
}
se podría llamar con doSomething(); usted puede doSomething();llamar doSomething(); o doSomething(true); o doSomething(true); ahora. Ahora.
