Ce que j'ai recherché sur Java 5

Aperçu

Ma connaissance de Java s'est presque arrêtée à "1.4". Afin de changer la situation actuelle, je vais l'améliorer petit à petit.

Actuellement, l'application que j'ai principalement touchée en entreprise fonctionne à "1,5", À l'origine, c'était une application avant "1.4", et l'ancienne description demeure. Je décrirai ce que j'ai étudié sur les fonctions ajoutées dans "1.5" via la mise à jour de version de cette application.

Ce que j'ai regardé

Les noms des variables ont map, lst, str, etc., ce qui peut vous mettre mal à l'aise. Ne vous inquiétez pas, il est simplement écrit selon la convention de dénomination de votre entreprise (qui est différente maintenant).

Type générique (génériques)

Puisqu'il y avait un endroit où je pouvais utiliser le type générique (génériques), Je l'ai modifié comme suit.

• Avant correction

private Map mapPref = new HashMap();
public String getPrefID(String strName) {
  if (strName == null) {
    return "";
  }
  return mapPref.get(strName) == null ? "" : (String)mapPref.get(strName);
}

Le nom de la préfecture (Tokyo, etc.) est stocké dans la clé et l'ID de la préfecture (01 à Hokkaido, 13 dans le cas de Tokyo, etc.) est stocké dans la valeur.

• Modifié

private Map<String, String> mapPref = new HashMap<String, String>();
public String getPrefID(String strName) {
  if (strName == null) {
    return "";
  }
  return mapPref.get(strName) == null ? "" : mapPref.get(strName);
}

En utilisant des génériques, vous pouvez connaître explicitement le type de valeur qui entre dans une collection telle que Map. De plus, si vous essayez d'entrer une valeur autre que le type spécifié, une erreur se produira, ce qui facilitera la recherche des erreurs de compilation. Cette fois, nous utilisons des génériques pour les collections, mais vous pouvez également utiliser des génériques pour implémenter des classes et des méthodes.

Référence: [Generics](https://github.com/travitu/Java-Tips/wiki/%E3%82%B8%E3%82%A7%E3%83%8D%E3%83%AA%E3%82 % AF% E3% 82% B9% EF% BC% 88% E7% B7% 8F% E7% A7% B0% E5% 9E% 8B% EF% BC% 89)

MakerCode.java

public class MakerCode<T> {
  public void show(T[] id) {
    for (T v : id) {
      System.out.println(v);
    }
  }
}

Car.java

public class Car {
  private String[] id = {"TY", "NS", "HN"};
  public String[] getId() {
    return id;
  }
}

Bike.java

public class Bike {
  private Integer[] id = {10, 20, 30}; //Boxe automatique
  public Integer[] getId() {
    return id;
  }
}

Main.java

public class Main {
  public static void main(String[] args) {
    Car car = new Car();
    MakerCode<String> carMakerCode = new MakerCode<String>();
    carMakerCode.show(car.getId());

    Bike bike = new Bike();
    MakerCode<Integer> bikeMakerCode = new MakerCode<Integer>();
    bikeMakerCode.show(bike.getId());
  }
}

De plus, il semble que des ** wildcards ** puissent être utilisés, mais c'est difficile ... Je pense que j'ai besoin d'en savoir plus. Référence: Wild Card

Étendu pour déclaration

Puisqu'il y avait un endroit où je pouvais utiliser la déclaration Extended for, Je l'ai modifié comme suit.

• Avant correction

List<String> lstMaker = new ArrayList<String>();
SQLParameters sqlParams = new SQLParameters();
for (int i = 0; i < lstMaker.size(); i++) {
  sqlParams.add(lstMaker.get(i));
}

lstMaker contient l'ID attribué au fabricant (par exemple 1 pour l'entreprise A).

• Modifié

List<String> lstMaker = new ArrayList<String>();
SQLParameters sqlParams = new SQLParameters();
for (String id : lstMaker) {
  sqlParams.add(id);
}

La description est plus simple que la normale pour l'instruction. La quantité de codage a été légèrement réduite. Ça a l'air rafraîchissant!

Boxe automatique

Il est utilisé dans Bike.java décrit dans le" Type générique (génériques) "ci-dessus. Jusqu'à "1,4"

private Integer[] id = {new Integer(10), new Integer(20), new Integer(30)};

Si vous n'écrivez pas comme ça, ce sera " type mismatch: cannot convert from int to Integer ", mais À partir de "1.5", conversion du type primitif en classe wrapper, conversion de la classe wrapper au type primitif Est maintenant fait automatiquement.

Arguments variables

Je n'ai pas trouvé d'endroit pouvant être utilisé dans l'application, Il peut être défini comme un argument de variable en écrivant "..." après le type de variable.

public void print(String... value) {
  for (String v : value) {
    System.out.println(v);
  }
}

public static void main(String[] args) {
  (new Main()).print("Tokyo", "Préfecture de Kanagawa", "Saitama", "Préfecture de Chiba");
}

Vous pouvez également transmettre un tableau.

public static void main(String[] args) {
  String[] pref = {"Hokkaido", "Préfecture d'Aomori", "Préfecture de Yamagata", "Préfecture d'Iwate"};
  (new Main()).print(pref);
}

Un seul argument de variable peut être spécifié pour chaque méthode et seul le dernier argument peut être spécifié.

Type d'énumération

Un type qui peut gérer plusieurs constantes en une La description suivante peut être combinée en un seul type.

• Avant correction

public static final String STATUS_SUCCESS  = "1";
public static final String STATUS_SHORTAGE = "2";
public static final String STATUS_MISMATCH = "3";

• Après modification (en utilisant le type d'énumération)

public enum Status {
  SUCCESS,
  SHORTAGE,
  MISMATCH,
}

Il peut avoir une valeur spécifique comme indiqué ci-dessous.

public enum Status {
  SUCCESS  ("1"),
  SHORTAGE ("2"),
  MISMATCH ("3"),
  ;
  private final String value;
  private Status(final String value) {
    this.value = value;
  }
}

Vous pouvez également avoir une méthode.

public enum Status {
  SUCCESS  ("1"),
  SHORTAGE ("2"),
  MISMATCH ("3"),
  ;
  private final String value;
  private Status(final String value) {
    this.value = value;
  }
  public String getValue() {
    return this.value;
  }
}

Autre

Il y avait d'autres fonctions ajoutées, mais j'aimerais passer une fois à "1.6" pour "1.5". Examinons un peu plus en profondeur les annotations.

Référence: Fonctions nouvelles et étendues