Pause café #139. Surcharge et remplacement en Java. 5 méthodes Java que vous ne connaissiez pas

Surcharge et remplacement en Java

Source : Medium Dans cet article, vous découvrirez les méthodes de remplacement et de surcharge dans le langage Java. Étant donné que ces deux termes sont souvent confondus, il convient de bien comprendre le but de chaque méthode et ses options d'application.

Surcharge

L’utilisation de plusieurs méthodes portant le même nom mais avec des paramètres différents dans la même classe ou méthode entre la superclasse et la sous-classe en Java est appelée surcharge. Pour éviter cela, une seule méthode est utilisée au lieu de plusieurs méthodes effectuant des actions similaires. Expliquons avec un exemple :

public class MethodOverloading {

    public static void main(String[] args){
        MethodOverloading operation = new MethodOverloading();
        operation.mod(12,4);
        operation.mod(12.4,4.2);
    }

    void mod(double a, double b){
        System.out.println(a % b);
    }

    void mod(int a, int b){
        System.out.println(a % b);
    }
}

Dans ce code, la méthode d'opération est surchargée. Les méthodes portant les mêmes noms acceptent des paramètres de types différents. Le choix du mode est déterminé séparément pour les paramètres int et double . Lorsque nous exécutons le programme, operation.mod (12,4) exécute void.mod (int a, int b) et operation.mod (12.4,4.2) exécute void.mod (double a, double b) .

Primordial

En Java, nous pouvons créer une superclasse et des sous-classes qui héritent de cette classe. Ces sous-classes peuvent remplacer et remplacer les méthodes de la classe parent dont elles héritent. Cela se fait en utilisant la méthode Overriding. Cela peut être mieux compris avec un exemple :

public class MethodOverriding {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.sound();

        Bee bee = new Bee();
        bee.sound();
    }
}

class Animal {
    void sound(){
        System.out.println("Animal sounds");
    }
}

class Cat extends Animal{
    @Override
    void sound() {
        System.out.println("Cat : meow meow");
    }
}

class Bee extends Animal{
    @Override
    void sound() {
        System.out.println("Bee : buzz buzz");
    }
}

Cet exemple de code crée une superclasse nommée Animal et des sous-classes nommées Cat et Bee qui héritent de cette superclasse. La méthode sound dans la superclasse est remplacée. Remarque : La séparation des méthodes surchargées s'effectue au stade de la compilation. La séparation des méthodes remplacées se produit au moment de l'exécution.

5 méthodes Java que vous ne connaissiez pas

Source : Javarevisited L'écosystème de développement Java dispose de nombreux outils que les programmeurs peuvent importer et utiliser dans leurs programmes. Ceux-ci incluent des classes et des méthodes intégrées. Ils simplifient considérablement le travail du programmeur et lui permettent de mieux comprendre et écrire du code. Chaque développeur devrait les connaître. Voici 5 méthodes Java assez rares, mais qui peuvent s’avérer très utiles dans votre travail.

1. décrémenterExact

decrementExact() est une fonction Java de base de la classe Math qui décrémente/soustrait un argument (nombre) donné de un et renvoie le résultat. Cette fonction est l'opposé de la fonction incrémentExact() . Par exemple, si l'argument donné est 11, alors le résultat est 10. Si la décrémentation d'un argument entraîne un débordement de son type de données, une exception est levée. Il est donc important d’être prudent lors de l’utilisation de cette fonction, notamment pour les grands nombres. Généralement, des nombres entiers sont utilisés pour cette fonction. Syntaxe:

Math.decrementExact(number);

Exemple:

System.out.println(Math.decrementExact(11));
// Output: 10

2.getAsDouble

getAsDouble() est une méthode appartenant à la classeOptionalDouble . Un objet OptionDouble est un objet qui peut potentiellement contenir un nombre double. Les méthodes de la classe peuvent être utilisées pour opérer sur une valeur double présente dans un objet, ou pour indiquer que la valeur double n'est pas du tout contenue. getAsDouble() est l’une de ces méthodes et renvoie la valeur double si elle est présente. Sinon, une NoSuchElementException est levée . Syntaxe:

OptionalDoubleObject.getAsDouble();

Exemple:

OptionalDouble num = OptionalDouble.of(15.0);
System.out.println(num.getAsDouble());
// Output: 15.0

3. absExact

La méthode absExact() est similaire à la fonction abs() de la classe Math . Il renvoie la valeur absolue d'un nombre, qui est la valeur positive du nombre quel que soit son signe. La seule différence est qu'il ne le fait que s'il est exactement représenté comme son type de données ( int ou long ). Si le résultat de la valeur de retour dépasse le type de données d'origine, une ArithmeticException est levée . Syntaxe:

Math.absExact(number);

Exemple:

System.out.println(Math.absExact(-11));
// Output: 11

4. se termine par

endWith() est une méthode de chaîne intégrée qui renvoie une valeur booléenne selon que la chaîne donnée se termine par un certain suffixe (mot de fin/chaîne) dans les paramètres. Cette méthode est à l’opposé de la méthode startWith() , que de nombreux développeurs connaissent probablement. Syntaxe:

String.endsWith(String suffix);

Exemple:

String phrase = "I like bananas";
System.out.println(phrase.endsWith("bananas")); // true
System.out.println(phrase.endsWith("Tandrew")); // false
/* Output:
true
false
*/

5. diviserNon signé

La méthode DivideUnsigned() est une méthode de la classe Integer qui permet de diviser deux nombres et de renvoyer le résultat de la division. Les entiers non signés, comparés aux entiers signés normaux, ne peuvent représenter que des nombres positifs. Les entiers non signés et les entiers signés ont le même nombre de nombres dans leur plage (la taille de la plage est de 65 536 nombres). Cependant, comme les entiers non signés ne peuvent pas être négatifs, leur valeur maximale dans la plage positive est bien supérieure à la valeur maximale d'un entier signé régulier. Pour simplifier cela, on peut plutôt regarder l’exemple des octets signés et non signés. Les octets ont une plage de 256 nombres. Un octet normal peut avoir une valeur comprise entre -128 et 127. Cependant, un octet non signé peut avoir une valeur comprise entre 0 et 255. Sinon, la fonction fonctionne exactement de la même manière qu'une division normale. Syntaxe:

Integer.divideUnsigned(int dividend, int divisor);

Exemple:

int dividend = 10;
int divisor = 5;
int quotient = Integer.divideUnsigned(dividend, divisor);
System.out.println(quotient);
// Output: 2

Conclusion

Voici un résumé des fonctions et méthodes abordées dans cet article :

• decrementExact - diminue/soustrait un nombre donné de 1

• getAsDouble - fait partie de la fonction OptionDouble , renvoie un nombre avec une valeur double ou indique son absence

• absExact - renvoie la valeur absolue d'un nombre s'il peut être représenté comme le type de données d'origine

• endWith() - renvoie une valeur booléenne selon que le suffixe spécifié existe dans la chaîne donnée

• DivideUnsigned() - effectue une division normale, renvoie le résultat de la division d'un nombre