0Pricing
Java Academy · Leçon

Déclarer des blocs de texte

Écrire des chaînes multilignes avec des guillemets triples

Déclarer des blocs de texte est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Le problème des textes multilignes

Avant Java 15, écrire un texte multiligne signifiait enchaîner des chaînes avec \n et +. Le résultat était difficile à lire et facile à incorrectement écrire. Les blocs de texte résolvent ce problème.

Guillemets triples

Un bloc de texte s'ouvre avec trois guillemets doubles """ suivis d'un saut de ligne, puis de votre contenu, et se ferme avec """. Tout ce qui se trouve entre les deux constitue la chaîne.

public class Main {
    public static void main(String[] args) {
        String message = """
            Hello
            World
            """;
        System.out.println(message);
    }
}

Règle de la ligne d'ouverture

Le contenu doit commencer sur la ligne qui suit le """ d'ouverture. Vous ne pouvez pas placer de texte juste après le délimiteur d'ouverture. Ce saut de ligne est requis par la syntaxe.

public class Main {
    public static void main(String[] args) {
        String poem = """
            Roses are red
            Violets are blue
            """;
        System.out.println(poem);
    }
}

Sauts de ligne automatiques

Chaque saut de ligne dans un bloc de texte devient un \n dans la chaîne obtenue. Vous n'avez plus besoin d'écrire de séquences d'échappement pour les fins de ligne.

public class Main {
    public static void main(String[] args) {
        String list = """
            Apples
            Bananas
            Cherries
            """;
        System.out.print(list);
    }
}

Fini la concaténation

Comparez l'ancienne méthode ("a\n" + "b\n") avec un bloc de texte. Le bloc de texte se lit exactement comme le résultat produit, ce qui rend les erreurs évidentes.

public class Main {
    public static void main(String[] args) {
        String html = """
            <html>
              <body>Hi</body>
            </html>
            """;
        System.out.println(html);
    }
}

Guillemets sans échappement

Dans un bloc de texte, les guillemets doubles simples " n'ont pas besoin d'être échappés. C'est idéal pour le contenu qui contient des guillemets, comme le JSON.

public class Main {
    public static void main(String[] args) {
        String json = """
            {"name": "Alice", "age": 30}
            """;
        System.out.println(json);
    }
}

Un bloc de texte reste une chaîne

Le résultat est un String ordinaire. Vous pouvez appeler n'importe quelle méthode de String dessus, le concaténer ou le transmettre à d'autres méthodes.

public class Main {
    public static void main(String[] args) {
        String text = """
            one
            two
            """;
        System.out.println("Length: " + text.length());
        System.out.println("Upper: " + text.toUpperCase());
    }
}

Concaténer des blocs de texte

Vous pouvez joindre un bloc de texte à d'autres chaînes avec +, comme pour tout littéral de chaîne.

public class Main {
    public static void main(String[] args) {
        String name = "Bob";
        String greeting = """
            Dear customer,
            """ + "Welcome " + name;
        System.out.println(greeting);
    }
}

Les lignes vides sont conservées

Les lignes vides à l'intérieur du bloc sont conservées comme lignes vides dans la chaîne. Vous pouvez ainsi formater naturellement un résultat espacé.

public class Main {
    public static void main(String[] args) {
        String spaced = """
            Title

            Body text
            """;
        System.out.print(spaced);
    }
}

Extraits de code lisibles

Les blocs de texte sont particulièrement utiles pour intégrer du contenu ressemblant à du code. Ici, un petit bloc de pseudo-configuration reste parfaitement lisible.

public class Main {
    public static void main(String[] args) {
        String config = """
            host = localhost
            port = 8080
            debug = true
            """;
        System.out.print(config);
    }
}

Compter les lignes

Comme les sauts de ligne sont réels, vous pouvez diviser un bloc de texte sur \n pour traiter chaque ligne.

public class Main {
    public static void main(String[] args) {
        String data = """
            red
            green
            blue
            """;
        String[] lines = data.split("\n");
        System.out.println("Lines: " + lines.length);
    }
}

Vérification rapide

Où le contenu d'un bloc de texte doit-il commencer ?

Récapitulatif

Vous avez appris à déclarer des blocs de texte :

  • Ouvrir et fermer avec """
  • Le contenu doit commencer sur la ligne suivante
  • Les sauts de ligne deviennent automatiquement des \n
  • Les guillemets doubles ne nécessitent aucun échappement
  • Le résultat est un String ordinaire

Questions Fréquemment Posées

La leçon « Déclarer des blocs de texte » est-elle gratuite ?

Oui — le texte complet de « Déclarer des blocs de texte » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Déclarer des blocs de texte » ?

Écrire des chaînes multilignes avec des guillemets triples Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Déclarer des blocs de texte » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Déclarer des blocs de texte
  2. Indentation et suppression
  3. Séquences d’échappement dans les blocs de texte
  4. Cas d’utilisation : JSON et SQL
← Retour à Java Academy