AP Informatique A

Objectif d'apprentissage 1.1.A : Représenter les modèles et algorithmes trouvés dans la vie quotidienne à l'aide du langage écrit ou de diagrammes.

• 1.1.A.1 Les algorithmes définissent des processus étape par étape à suivre lors de l'accomplissement d'une tâche ou de la résolution d'un problème. Ces algorithmes peuvent être représentés à l'aide du langage écrit ou de diagrammes.
• 1.1.A.2 La séquençage définit un ordre pour l'accomplissement des étapes d'un processus. Les étapes d'un processus sont accomplies une à la fois.

Objectif d'apprentissage 1.1.B : Expliquer le processus de compilation et d'exécution du code.

• 1.1.B.1 Le code peut être écrit dans n'importe quel éditeur de texte ; toutefois, un environnement de développement intégré (IDE) est souvent utilisé pour écrire des programmes car il fournit des outils permettant à un programmeur d'écrire, compiler et exécuter du code.
• 1.1.B.2 Un compilateur vérifie le code pour certaines erreurs. Les erreurs détectables par le compilateur doivent être corrigées avant que le programme puisse être exécuté.

Objectif d'apprentissage 1.1.C : Identifier les types d'erreurs de programmation.

• 1.1.C.1 Une erreur de syntaxe est une erreur dans le programme où les règles du langage de programmation ne sont pas respectées. Ces erreurs sont détectées par le compilateur.
• 1.1.C.2 Une erreur logique est une erreur dans l'algorithme ou le programme qui provoque un comportement incorrect ou inattendu. Ces erreurs sont détectées en testant le programme avec des données spécifiques pour voir s'il produit le résultat attendu.
• 1.1.C.3 Une erreur d'exécution est une erreur dans le programme qui se produit pendant l'exécution d'un programme. Les erreurs d'exécution provoquent généralement la terminaison anormale du programme.
• 1.1.C.4 Une exception est un type d'erreur d'exécution qui survient en raison d'une erreur inattendue non détectée par le compilateur. Elle interrompt le flux normal de l'exécution du programme.

Objectif d'apprentissage 1.2.A : Identifier la catégorie de type de données la plus appropriée pour une spécification donnée.

• 1.2.A.1 Un type de données est un ensemble de valeurs et un ensemble correspondant d'opérations sur ces valeurs. Les types de données peuvent être catégorisés comme primitifs ou références.
• 1.2.A.2 Les types de données primitifs utilisés dans ce cours définissent l'ensemble des valeurs et les opérations correspondantes sur ces valeurs pour les nombres et les valeurs booléennes.
• 1.2.A.3 Un type de référence est utilisé pour définir des objets qui ne sont pas des types primitifs.

Objectif d'apprentissage 1.2.B : Développer du code pour déclarer des variables stockant des nombres et des valeurs booléennes.

• 1.2.B.1 Les trois types de données primitifs utilisés dans ce cours sont int, double et boolean. Une valeur int est un entier. Une valeur double est un nombre réel. Une valeur boolean est soit true soit false.
  • Énoncé d'exclusion : Les cinq autres types de données primitifs (long, short, byte, float et char) sont hors du programme du cours et de l'examen AP Computer Science A.
• 1.2.B.2 Une variable est un emplacement de stockage contenant une valeur qui peut changer pendant l'exécution du programme. Chaque variable a un nom et un type de données associé. Une variable de type primitif contient une valeur primitive de ce type.

Objectif d'apprentissage 1.3.A : Développer du code pour générer une sortie et déterminer le résultat qui serait affiché.

• 1.3.A.1 System.out.print et System.out.println affichent des informations sur l'écran de l'ordinateur. System.out.println déplace le curseur sur une nouvelle ligne après l'affichage des informations, tandis que System.out.print ne le fait pas.

Objectif d'apprentissage 1.3.B : Développer du code pour utiliser des littérales de chaîne et déterminer le résultat de l'utilisation de littérales de chaîne.

• 1.3.B.1 Une littérale est la représentation codée d'une valeur fixe.
• 1.3.B.2 Une littérale de chaîne est une séquence de caractères enfermée entre guillemets doubles.
• 1.3.B.3 Les séquences d'échappement sont des séquences spéciales de caractères qui peuvent être incluses dans une chaîne. Elles commencent par un \ et ont une signification spéciale en Java. Les séquences d'échappement utilisées dans ce cours incluent guillemet double \", trait de soulignement inversé \\ et nouveau trait de soulignement \n.

Objectif d'apprentissage 1.3.C : Développer du code pour des expressions arithmétiques et déterminer le résultat de ces expressions.

• 1.3.C.1 Les expressions arithmétiques, qui consistent en des valeurs numériques, des variables et des opérateurs, incluent des expressions de type int et double.
• 1.3.C.2 Les opérateurs arithmétiques consistent en l'addition +, la soustraction -, la multiplication *, la division / et le reste %. Une opération arithmétique utilisant deux valeurs int évaluera vers une valeur int. Une opération arithmétique utilisant au moins une valeur double évaluera vers une valeur double.
  • Énoncé d'exclusion : Les expressions qui aboutissent à des valeurs doubles spéciales (par exemple, les infinis et NaN) sont hors du programme du cours et de l'examen AP Computer Science A.
• 1.3.C.3 En divisant des valeurs numériques qui sont toutes deux des valeurs int, le résultat n'est que la portion entière du quotient. En divisant des valeurs numériques utilisant au moins une valeur double, le résultat est le quotient.
• 1.3.C.4 L'opérateur reste % est utilisé pour calculer le reste lorsque le nombre a est divisé par un autre nombre b.
  • Énoncé d'exclusion : L'utilisation de valeurs inférieures à 0 pour a et l'utilisation de valeurs inférieures ou égales à 0 pour b est hors du programme du cours et de l'examen AP Computer Science A.
• 1.3.C.5 Les opérateurs peuvent être utilisés pour construire des expressions composées. Au moment de la compilation, les valeurs numériques sont associées aux opérateurs selon la priorité des opérateurs pour déterminer comment ils sont groupés. Des parenthèses peuvent être utilisées pour modifier la priorité des opérateurs. La multiplication, la division et le reste ont une priorité supérieure à l'addition et à la soustraction. Les opérateurs ayant la même priorité sont évalués de gauche à droite.
• 1.3.C.6 Une tentative de division d'un entier par zéro entraînera une ArithmeticException.
  • Énoncé d'exclusion : L'utilisation de la division par zéro lorsque l'une des valeurs numériques est une double est hors du programme du cours et de l'examen AP Computer Science A.

Objectif d'apprentissage 1.4.A : Développer du code pour des instructions d'affectation avec des expressions et déterminer la valeur stockée dans la variable en conséquence.

• 1.4.A.1 Toute variable doit être affectée d'une valeur avant qu'elle puisse être utilisée dans une expression. Cette valeur doit provenir d'un type de données compatible. Une variable est initialisée la première fois qu'elle reçoit une valeur. Les types de référence peuvent être affectés à un nouvel objet ou à null s'il n'y a pas d'objet. La littérale null est une valeur spéciale utilisée pour indiquer qu'une référence n'est associée à aucun objet.
• 1.4.A.2 L'opérateur d'affectation = permet à un programme d'initialiser ou de modifier la valeur stockée dans une variable. La valeur de l'expression située à droite est stockée dans la variable située à gauche.
  • Déclaration d'exclusion : L'utilisation d'opérateurs d'affectation à l'intérieur d'expressions (p. ex., a = b = 4; ou a[i += 5]) est hors du programme et de l'examen AP Computer Science A.
• 1.4.A.3 Lors de l'exécution, une expression est évaluée pour produire une valeur unique. La valeur d'une expression a un type basé sur l'évaluation de cette expression.

Objectif d'apprentissage 1.4.B : Développer du code pour lire des entrées.

• 1.4.B.1 Les entrées peuvent provenir de diverses formes, telles que tactiles, audio, visuelles ou textuelles. La classe Scanner est un moyen d'obtenir des entrées textuelles depuis le clavier.
  • Déclaration d'exclusion : Toute forme spécifique d'entrée provenant de l'utilisateur est hors du programme et de l'examen AP Computer Science A.

Objectif d'apprentissage 1.5.A : Développer du code pour convertir des valeurs primitives en différents types primitifs dans des expressions arithmétiques et déterminer la valeur produite comme résultat.

• 1.5.A.1 Les opérateurs de conversion (int) et (double) peuvent être utilisés pour convertir une valeur de type double vers un type int (ou inversement).
• 1.5.A.2 Convertir une valeur de type double en type int entraîne la troncature des chiffres situés à droite de la virgule décimale.
• 1.5.A.3 Certains codes provoquent que les valeurs int soient automatiquement converties (élargies) en valeurs double.
• 1.5.A.4 Les valeurs de type double peuvent être arrondies à l'entier le plus proche par (int)(x + 0.5) pour les nombres non négatifs ou (int)(x - 0.5) pour les nombres négatifs.

Objectif d'apprentissage 1.5.B : Décrire les conditions dans lesquelles une expression entière évalue à une valeur hors limite.

• 1.5.B.1 La constante Integer.MAX_VALUE contient la valeur de la plus grande valeur possible de type int. La constante Integer.MIN_VALUE contient la valeur de la plus petite valeur possible de type int.
• 1.5.B.2 Les valeurs entières en Java sont représentées par des valeurs de type int, qui sont stockées en utilisant une quantité finie (4 octets) de mémoire. Par conséquent, une valeur de type int doit se situer dans la plage de Integer.MIN_VALUE à Integer.MAX_VALUE inclusivement.
• 1.5.B.3 Si une expression évaluerait à une valeur de type int hors de la plage autorisée, un dépassement d'entier se produit. Le résultat est une valeur de type int dans la plage autorisée mais pas nécessairement la valeur attendue.

Objectif d'apprentissage 1.5.C : Décrire les conditions limitant la précision des expressions.

• 1.5.C.1 Les ordinateurs allouent une quantité spécifiée de mémoire pour stocker des données selon le type de données. Si une expression évaluerait à une valeur de type double plus précise que ce qui peut être stocké dans la quantité de mémoire allouée, une erreur d'arrondi se produit. Le résultat sera arrondi à la valeur représentable. Pour éviter les erreurs d'arrondi inévitables, utilisez des valeurs de type int.
  • Déclaration d'exclusion : D'autres types de données décimales spéciales pouvant être utilisées pour éviter les erreurs d'arrondi sont hors du programme et de l'examen AP Computer Science A.

Objectif d'apprentissage 1.6.A : Développer du code pour des instructions d'affectation avec des opérateurs d'affectation composés et déterminer la valeur stockée dans la variable en tant que résultat.

• 1.6.A.1 Les opérateurs d'affectation composés +=, -=, *=, /= et %= peuvent être utilisés à la place de l'opérateur d'affectation dans des expressions numériques. Un opérateur d'affectation composé effectue l'opération arithmétique indiquée entre la valeur de gauche et la valeur de droite, puis assigne le résultat à la variable de gauche.
• 1.6.A.2 L'opérateur d'incrémentation postérieure ++ et l'opérateur de décrémentation postérieure -- sont utilisés pour ajouter 1 ou soustraire 1 de la valeur stockée dans une variable numérique. La nouvelle valeur est assignée à la variable.
  • Déclaration d'exclusion : L'utilisation d'opérateurs d'incrémentation et de décrémentation sous forme préfixe (p. ex., ++x) est hors du programme et de l'examen AP Computer Science A. L'utilisation d'opérateurs d'incrémentation et de décrémentation à l'intérieur d'autres expressions (p. ex., arr[x++]) est hors du programme et de l'examen AP Computer Science A.

Objectif d'apprentissage 1.7.A : Identifier les attributs et comportements d'une classe trouvée dans les bibliothèques contenues dans une API.

• 1.7.A.1 Les bibliothèques sont des collections de classes. Une spécification d'application programming interface (API) informe le programmeur comment utiliser ces classes. La documentation trouvée dans les spécifications API et les bibliothèques est essentielle pour comprendre les attributs et comportements d'une classe définie par l'API. Une classe définit un type de référence spécifique. Les classes dans les APIs et les bibliothèques sont regroupées en paquets. Des classes existantes et des bibliothèques de classes peuvent être utilisées pour créer des objets.
• 1.7.A.2 Les attributs se réfèrent aux données liées à la classe et sont stockés dans des variables. Les comportements se réfèrent à ce que les instances de la classe peuvent faire (ou ce qui peut être fait avec elles) et sont définis par des méthodes.

Objectif d'apprentissage 1.8.A : Décrire la fonctionnalité et l'utilisation du code via des commentaires.

• 1.8.A.1 Les commentaires sont écrits pour le programmeur original et d'autres programmeurs afin de comprendre le code et sa fonctionnalité, mais ils sont ignorés par le compilateur et ne sont pas exécutés lors de l'exécution du programme. Trois types de commentaires en Java incluent /* */, qui génère un bloc de commentaires ; //, qui génère un commentaire sur une seule ligne ; et /** */, qui sont des commentaires Javadoc et sont utilisés pour créer de la documentation API.
• 1.8.A.2 Une précondition est une condition qui doit être vraie juste avant l'exécution d'une méthode afin qu'elle se comporte comme prévu. Il n'y a aucune attente que la méthode vérifie si les préconditions sont satisfaites.
• 1.8.A.3 Une postcondition est une condition qui doit toujours être vraie après l'exécution d'une méthode. Les postconditions décrivent le résultat de l'exécution en termes de ce qui est retourné ou de la valeur actuelle des attributs d'un objet.

Objectif d'apprentissage 1.9.A : Identifier la bonne méthode à appeler en se basant sur la documentation et les signatures de méthodes.

• 1.9.A.1 Une méthode est un bloc de code nommé qui ne s'exécute que lorsqu'elle est appelée. Un bloc de code est toute section de code enfermée entre accolades. L'abstraction procédurale permet à un programmeur d'utiliser une méthode en sachant ce qu'elle fait, même s'il ne sait pas comment elle a été écrite.
• 1.9.A.2 Un paramètre est une variable déclarée dans l'en-tête d'une méthode ou d'un constructeur et peut être utilisé à l'intérieur du corps de la méthode. Cela permet de passer et d'utiliser des valeurs ou arguments par une méthode ou un constructeur. Une signature de méthode pour une méthode avec des paramètres consiste en le nom de la méthode et la liste ordonnée des types de paramètres. Une signature de méthode pour une méthode sans paramètres consiste en le nom de la méthode et une liste de paramètres vide.

Objectif d'apprentissage 1.9.B : Décrire comment appeler des méthodes.

• 1.9.B.1 Une méthode void n'a pas de valeur de retour et n'est donc pas appelée dans le cadre d'une expression.
• 1.9.B.2 Une méthode non-void retourne une valeur qui est du même type que le type de retour dans l'en-tête. Pour utiliser la valeur de retour lors de l'appel d'une méthode non-void, elle doit être stockée dans une variable ou utilisée comme partie d'une expression.
• 1.9.B.3 Un argument est une valeur qui est passée à une méthode lors de son appel. Les arguments passés à une méthode doivent être compatibles en nombre et ordre avec les types identifiés dans la liste des paramètres de la signature de méthode. Lors de l'appel de méthodes, les arguments sont passés par valeur. Passage par valeur initialise les paramètres avec des copies des arguments.
• 1.9.B.4 Les méthodes sont dites surchargées lorsqu'il existe plusieurs méthodes ayant le même nom mais des signatures différentes.
• 1.9.B.5 Un appel de méthode interrompt l'exécution séquentielle des instructions, faisant en sorte que le programme exécute d'abord les instructions dans la méthode avant de continuer. Une fois la dernière instruction de la méthode exécutée ou qu'une instruction return est exécutée, le flux de contrôle retourne au point immédiatement après où la méthode a été appelée.

Objectif d'apprentissage 1.10.A : Développer du code pour appeler des méthodes de classe et déterminer le résultat de ces appels.

• 1.10.A.1 Les méthodes de classe sont associées à la classe, pas aux instances de la classe. Les méthodes de classe comprennent le mot-clé static dans l'en-tête avant le nom de la méthode.
• 1.10.A.2 Les méthodes de classe sont généralement appelées en utilisant le nom de la classe avec l'opérateur point. Lorsque l'appel de méthode se produit dans la classe définissante, l'utilisation du nom de la classe est optionnelle dans l'appel.

Objectif d'apprentissage 1.11.A : Développer du code pour écrire des expressions intégrant des appels à des bibliothèques mathématiques intégrées et déterminer la valeur produite en résultat.

• 1.11.A.1 La classe Math fait partie du package java.lang. Les classes du package java.lang sont disponibles par défaut.
• 1.11.A.2 La classe Math contient uniquement des méthodes de classe. Les méthodes de classe suivantes de Math—y compris ce qu'elles font et quand elles sont utilisées—font partie de la référence rapide Java :
  • static int abs(int x) retourne la valeur absolue d'une valeur int.
  • static double abs(double x) retourne la valeur absolue d'une valeur double.
  • static double pow(double base, double exponent) retourne la valeur du premier paramètre élevé à la puissance du deuxième paramètre.
  • static double sqrt(double x) retourne la racine carrée positive d'une valeur double.
  • static double random() retourne une valeur double supérieure ou égale à 0.0 et inférieure à 1.0.
• 1.11.A.3 Les valeurs retournées par Math.random() peuvent être manipulées à l'aide d'opérateurs arithmétiques et de cast pour produire un int ou un double aléatoire dans une plage définie basée sur des critères spécifiés. Chaque extrémité de la plage peut être inclusive, signifiant que la valeur est incluse, ou exclusive, signifiant que la valeur n'est pas incluse.

Objectif d'apprentissage 1.12.A : Expliquer la relation entre une classe et un objet.

• 1.12.A.1 Un objet est une instance spécifique d'une classe avec des attributs définis. Une classe est l'implémentation formelle, ou plan, des attributs et comportements d'un objet.
• 1.12.A.2 Une hiérarchie de classes peut être développée en regroupant les attributs et comportements communs de classes apparentées dans une seule classe appelée superclasse. Les classes qui étendent une superclasse, appelées sous-classes, peuvent puiser dans les attributs et comportements existants de la superclasse sans les remplacer dans le code. Cela crée une relation d'héritage des sous-classes vers la superclasse.
  • Énoncé d'exclusion : La conception et l'implémentation de relations d'héritage sont hors du programme du cours et de l'examen AP Computer Science A.
• 1.12.A.3 Toutes les classes en Java sont des sous-classes de la classe Object.

Objectif d'apprentissage 1.12.B : Développer du code pour déclarer des variables afin de stocker des types de référence.

• 1.12.B.1 Une variable de type de référence contient une référence d'objet, qui peut être considérée comme l'adresse mémoire de cet objet.

Objectif d'apprentissage 1.13.A : Identifier, en utilisant sa signature, le constructeur correct appelé.

• 1.13.A.1 Une classe contient des constructeurs qui sont appelés pour créer des objets. Ils ont le même nom que la classe.
• 1.13.A.2 Une signature de constructeur consiste en le nom du constructeur, qui est le même que celui de la classe, et dans la liste ordonnée des types de paramètres. La liste des paramètres, dans l'en-tête d'un constructeur, répertorie les types des valeurs transmises ainsi que leurs noms de variables.
• 1.13.A.3 Les constructeurs sont dit surchargés lorsqu'il existe plusieurs constructeurs avec des signatures différentes.

Objectif d'apprentissage 1.13.B : Développer du code pour déclarer des variables des types corrects afin de contenir des références d'objets.

• 1.13.B.1 Une variable de type référence contient une référence d'objet ou, s'il n'y a pas d'objet, null.

Objectif d'apprentissage 1.13.C : Développer du code pour créer un objet en appelant un constructeur.

• 1.13.C.1 Un objet est généralement créé à l'aide du mot-clé new suivi d'un appel à l'un des constructeurs de la classe.
• 1.13.C.2 Les paramètres permettent aux constructeurs d'accepter des valeurs pour définir les valeurs initiales des attributs de l'objet.
• 1.13.C.3 Un argument de constructeur est une valeur qui est passée à un constructeur lors de son appel. Les arguments passés à un constructeur doivent être compatibles par ordre et nombre avec les types identifiés dans la liste des paramètres de la signature du constructeur. Lors de l'appel aux constructeurs, les arguments sont passés par valeur. Le passage par valeur initialise les paramètres avec des copies des arguments.
• 1.13.C.4 Un appel de constructeur interrompt l'exécution séquentielle des instructions, amenant le programme à exécuter d'abord les instructions du constructeur avant de continuer. Une fois la dernière instruction du constructeur exécutée, le flux de contrôle retourne au point immédiatement après l'endroit où le constructeur a été appelé.

Objectif d'apprentissage 1.14.A : Développer du code pour appeler des méthodes d'instance et déterminer le résultat de ces appels.

• 1.14.A.1 Les méthodes d'instance sont appelées sur des objets de la classe. L'opérateur point est utilisé avec le nom de l'objet pour appeler des méthodes d'instance.
• 1.14.A.2 Un appel de méthode sur une référence null entraînera une NullPointerException.

Objectif d'apprentissage 1.15.A : Développer du code pour créer des objets de chaîne de caractères et déterminer le résultat de la création et de la combinaison de chaînes.

• 1.15.A.1 Un objet String représente une séquence de caractères et peut être créé en utilisant une littérale de chaîne ou en appelant le constructeur de la classe String.
• 1.15.A.2 La classe String fait partie du package java.lang. Les classes du package java.lang sont disponibles par défaut.
• 1.15.A.3 Un objet String est immuable, ce qui signifie qu'une fois qu'un objet String est créé, ses attributs ne peuvent pas être modifiés. Les méthodes appelées sur un objet String ne changent pas le contenu de l'objet String.
• 1.15.A.4 Deux objets String peuvent être concaténés ensemble ou combinés à l'aide de l'opérateur + ou +=, résultant en un nouvel objet String. Une valeur primitive peut être concaténée avec un objet String. Cela provoque la conversion implicite de la valeur primitive en un objet String.
• 1.15.A.5 Un objet String peut être concaténé avec n'importe quel objet, ce qui appelle implicitement la méthode toString de l'objet (un comportement garanti par la relation d'héritage que toute classe entretient avec la classe Object). La méthode toString d'un objet retourne une valeur de chaîne représentant l'objet. Les sous-classes de Object remplacent souvent la méthode toString par une implémentation spécifique à la classe. Le remplacement de méthode se produit lorsqu'une méthode publique dans une sous-classe a la même signature de méthode qu'une méthode publique dans la classe parente, mais que le comportement de la méthode est spécifique à la sous-classe.
  • Énoncé d'exclusion : Remplacer la méthode toString d'une classe est hors du programme du cours et de l'examen AP Computer Science A.

Objectif d'apprentissage 1.15.B : Développer du code pour appeler des méthodes sur des objets de chaîne de caractères et déterminer le résultat de l'appel de ces méthodes.

• 1.15.B.1 Un objet String a des valeurs d'index allant de 0 à un moins que la longueur de la chaîne. Tenter d'accéder à des indices en dehors de cette plage entraînera une StringIndexOutOfBoundsException.
• 1.15.B.2 Les méthodes String suivantes — incluant ce qu'elles font et quand elles sont utilisées — font partie de la Référence Rapide Java :
  • int length() retourne le nombre de caractères dans un objet String.
  • String substring(int from, int to) renvoie la sous-chaîne commençant à l'index from et se terminant à l'index to - 1.
  • String substring(int from) retourne substring(from, length()).
  • int indexOf(String str) retourne l'index de la première occurrence de str ; retourne -1 si non trouvé.
  • boolean equals(Object other) retourne true si this correspond à la même séquence de caractères que other ; retourne false sinon.
  • int compareTo(String other) retourne une valeur < 0 if this is less than other; returns zero if this is equal to other; returns a value > 0 si this est supérieur à other. Les chaînes sont ordonnées selon l'alphabet.
  • Énoncé d'exclusion : L'utilisation de la méthode equals pour comparer un objet String avec un objet d'un autre type que String est hors du programme du cours et de l'examen AP Computer Science A.
• 1.15.B.3 Une chaîne identique au seul élément de la sous-chaîne à la position index peut être créée en appelant substring(index, index + 1).

Objectif d'apprentissage 2.1.A : Représenter des modèles et algorithmes impliquant sélection et répétition trouvés dans la vie quotidienne en langage écrit ou diagrammes.

• 2.1.A.1 Les briques de base des algorithmes comprennent la séquence, la sélection et la répétition.
• 2.1.A.2 Les algorithmes peuvent contenir une sélection, par prise de décision, et une répétition, via des boucles.
• 2.1.A.3 La sélection se produit lorsque le choix de la façon dont l'exécution d'un algorithme va procéder est basé sur une décision vraie ou fausse.
• 2.1.A.4 La répétition est quand un processus se répète jusqu'à ce qu'un résultat souhaité soit atteint.
• 2.1.A.5 L'ordre dans lequel la séquence, la sélection et la répétition sont utilisées contribue au résultat de l'algorithme.

Objectif d'apprentissage 2.2.A : Développer du code pour créer des expressions booléennes avec des opérateurs relationnels et déterminer le résultat de ces expressions.

• 2.2.A.1 Les valeurs peuvent être comparées en utilisant les opérateurs relationnels == et != pour déterminer si les valeurs sont identiques. Avec les types primitifs, cela compare les valeurs primitives réelles. Avec les types de référence, cela compare les références d'objet.
• 2.2.A.2 Les valeurs numériques peuvent être comparées à l'aide des opérateurs relationnels <, >, <= et >= pour déterminer la relation entre les valeurs.
• 2.2.A.3 Une expression impliquant des opérateurs relationnels évalue une valeur booléenne.

Objectif d'apprentissage 2.3.A : Développer du code pour représenter des processus logiques de branchement en utilisant des instructions de sélection et déterminer le résultat de ces processus.

• 2.3.A.1 Les instructions de sélection modifient l'exécution séquentielle des instructions.
• 2.3.A.2 Une instruction if est un type d'instruction de sélection qui affecte le flux de contrôle en exécutant différents segments de code en fonction de la valeur d'une expression booléenne.
• 2.3.A.3 Une sélection à un seul chemin (instruction if) est utilisée lorsqu'il y a un segment de code à exécuter sous une certaine condition. Dans ce cas, le corps n'est exécuté que lorsque l'expression booléenne est true.
• 2.3.A.4 Une sélection à deux chemins (instruction if-else) est utilisée lorsqu'il y a deux segments de code — l'un à exécuter lorsque l'expression booléenne est true et un autre segment pour le cas où l'expression booléenne est false. Dans ce cas, le corps de la⟩if⟩ est exécuté lorsque l'expression booléenne est true, et le corps de la⟩else⟩ est exécuté lorsque l'expression booléenne est false.

Objectif d'apprentissage 2.4.A : Développer du code pour représenter des processus logiques de branchement imbriqués et déterminer le résultat de ces processus.

• 2.4.A.1 Les instructions if imbriquées consistent en des instructions if, if-else ou if-else-if situées dans des instructions if, if-else ou if-else-if.
• 2.4.A.2 L'expression booléenne de l'instruction if imbriquée intérieure n'est évaluée que si l'expression booléenne de l'instruction if extérieure évalue à true.
• 2.4.A.3 Une sélection multi-chemin (if-else-if) est utilisée lorsqu'il existe une série d'expressions avec des segments de code différents pour chaque condition. La sélection multi-chemin se fait de sorte qu'aucun plus d'un segment de code n'est exécuté basé sur la première expression qui évalue à true. Si aucune expression n'évalue à true et qu'il y a une instruction else finale, alors le corps de la⟩else⟩ est exécuté.

Objectif d'apprentissage 2.5.A : Développer du code pour représenter des expressions booléennes composées et déterminer le résultat de ces expressions.

• 2.5.A.1 Les opérateurs logiques ! (non), && (et), et || (ou) sont utilisés avec des expressions booléennes. L'expression !a évalue à true si a est false et évalue à false sinon. L'expression a && b évalue à true si les deux a et b sont true et évalue à false sinon. L'expression a || b évalue à true si a est true, b est true, ou les deux, et évalue à false sinon. L'ordre de priorité pour l'évaluation des opérateurs logiques est ! (non), && (et), puis || (ou). Une expression impliquant des opérateurs logiques évalue à une valeur booléenne.
• 2.5.A.2 L'évaluation en court-circuit se produit lorsque le résultat d'une opération logique utilisant && ou || peut être déterminé en évaluant uniquement la première expression booléenne. Dans ce cas, la seconde expression booléenne n'est pas évaluée.

Objectif d'apprentissage 2.6.A : Comparer des expressions booléennes équivalentes.

• 2.6.A.1 Deux expressions booléennes sont équivalentes si elles évaluent à la même valeur dans tous les cas. Des tables de vérité peuvent être utilisées pour prouver que des expressions booléennes sont équivalentes.
• 2.6.A.2 La loi de De Morgan peut être appliquée aux expressions booléennes pour créer des expressions booléennes équivalentes. Selon la loi de De Morgan, l'expression booléenne !(a && b) est équivalente à !a || !b et l'expression booléenne !(a || b) est équivalente à !a && !b.

Objectif d'apprentissage 2.6.B : Développer du code pour comparer des références d'objets à l'aide d'expressions booléennes et déterminer le résultat de ces expressions.

• 2.6.B.1 Deux variables différentes peuvent contenir des références vers le même objet. Les références d'objet peuvent être comparées à l'aide de == et !=.
• 2.6.B.2 Une référence d'objet peut être comparée avec null, en utilisant == ou !=, pour déterminer si la référence pointe réellement vers un objet.
• 2.6.B.3 Les classes définissent souvent leur propre méthode equals, qui peut être utilisée pour spécifier les critères d'équivalence pour deux objets de la classe. L'équivalence de deux objets est généralement déterminée à l'aide d'attributs provenant des deux objets.
  • Instruction d'exclusion : Redéfinir la méthode equals sort du champ d'application du cours et de l'examen AP Computer Science A.

Objectif d'apprentissage 2.7.A : Identifier quand un processus itératif est nécessaire pour atteindre un résultat souhaité.

• 2.7.A.1 L'itération est une forme de répétition. Les instructions d'itération modifient le flux de contrôle en répétant un segment de code zéro ou plusieurs fois tant que l'expression booléenne contrôlant la boucle évalue à true.
• 2.7.A.2 Une boucle infinie se produit lorsque l'expression booléenne dans une instruction itérative évalue toujours à true.
• 2.7.A.3 Le corps de la boucle d'une instruction itérative ne s'exécutera pas si l'expression booléenne évalue initialement à false.
• 2.7.A.4 Les erreurs off by one surviennent lorsque l'instruction d'itération parcourt la boucle une fois de trop ou une fois de moins.

Objectif d'apprentissage 2.7.B : Développer du code pour représenter des processus itératifs en utilisant des boucles while et déterminer le résultat de ces processus.

• 2.7.B.1 Une boucle while est un type d'instruction itérative. Dans les boucles while, l'expression booléenne est évaluée avant chaque itération du corps de la boucle, y compris la première. Lorsque l'expression évalue à true, le corps de la boucle est exécuté. Cela continue jusqu'à ce que l'expression booléenne évalue à false, moment où l'itération se termine.

Objectif d'apprentissage 2.8.A : Développer du code pour représenter des processus itératifs à l'aide de boucles for et déterminer le résultat de ces processus.

• 2.8.A.1 Une boucle for est un type d'instruction itérative. Il y a trois parties dans l'en-tête d'une boucle for : l'initialisation, l'expression booléenne et la mise à jour.
• 2.8.A.2 Dans une boucle for, l'instruction d'initialisation n'est exécutée qu'une seule fois avant la première évaluation de l'expression booléenne. La variable initialisée est appelée variable de contrôle de boucle. L'expression booléenne est évaluée immédiatement après l'initialisation de la variable de contrôle de boucle, puis après chaque exécution de l'instruction d'incrémentation jusqu'à ce qu'elle soit false. À chaque itération, la mise à jour est exécutée après l'exécution complète du corps de la boucle et avant que l'expression booléenne ne soit évaluée à nouveau.
• 2.8.A.3 Une boucle for peut être réécrite sous la forme d'une boucle while équivalente (et vice versa).

Objectif d'apprentissage 2.9.A : Développer du code pour des algorithmes standards et originaux (sans structures de données) et déterminer le résultat de ces algorithmes.

• 2.9.A.1 Il existe des algorithmes standards pour :
  • identifier si un entier est ou non divisible par un autre entier
  • identifier les chiffres individuels d'un entier
  • déterminer la fréquence à laquelle un critère spécifique est rempli
  • déterminer une valeur minimale ou maximale
  • calculer une somme ou une moyenne

Objectif d'apprentissage 2.10.A : Développer du code pour des algorithmes standards et originaux impliquant des chaînes et déterminer le résultat de ces algorithmes.

• 2.10.A.1 Il existe des algorithmes de chaînes standards pour :
  • trouver si une ou plusieurs sous-chaînes ont une propriété particulière
  • déterminer le nombre de sous-chaînes répondant à des critères spécifiques
  • créer une nouvelle chaîne avec les caractères inversés

Objectif d'apprentissage 2.11.A : Développer du code pour représenter des processus itératifs imbriqués et déterminer le résultat de ces processus.

• 2.11.A.1 Les instructions d'itération imbriquées sont des instructions d'itération apparaissant dans le corps d'une autre instruction d'itération. Lorsqu'une boucle est imbriquée dans une autre boucle, la boucle interne doit terminer toutes ses itérations avant que la boucle externe puisse continuer à son prochaine itération.

Objectif d'apprentissage 2.12.A : Calculer les comptes d'exécution d'instructions et comparer informellement le temps d'exécution des statements itératifs.

• 2.12.A.1 Un compte d'exécution d'instruction indique le nombre de fois qu'une instruction est exécutée par le programme. Les comptes d'exécution d'instructions sont souvent calculés informellement par traçage et analyse des instructions itératives.

Objectif d'apprentissage 3.1.A : Représenter la conception d'un programme en utilisant un langage naturel ou en créant des diagrammes indiquant les classes du programme et les abstractions de données et procédurales trouvées dans chaque classe en incluant tous les attributs et comportements.

• 3.1.A.1 L'abstraction est le processus de réduction de la complexité en se concentrant sur l'idée principale. En masquant les détails irrelevants pour la question en cours et en regroupant des détails connexes et utiles, l'abstraction réduit la complexité et permet de se concentrer sur l'idée.
• 3.1.A.2 L'abstraction de données fournit une séparation entre les propriétés abstraites d'un type de données et les détails concrets de sa représentation. L'abstraction de données gère la complexité en donnant un nom aux données sans faire référence aux détails spécifiques de la représentation. Les données peuvent prendre la forme d'une variable unique ou d'une collection de données, comme dans une classe ou un ensemble de données.
• 3.1.A.3 Un attribut est un type d'abstraction de données défini dans une classe hors de toute méthode ou constructeur. Une variable d'instance est un attribut dont la valeur est unique pour chaque instance de la classe. Une variable de classe est un attribut partagé par toutes les instances de la classe.
• 3.1.A.4 L'abstraction procédurale fournit un nom à un processus et permet à une méthode d'être utilisée en ne sachant que ce qu'elle fait, pas comment elle le fait. Grâce à la décomposition de méthodes, un programmeur décompose les grands comportements de la classe en petits comportements en créant des méthodes pour représenter chaque petit comportement individuel. Une abstraction procédurale peut extraire des caractéristiques partagées pour généraliser la fonctionnalité au lieu de dupliquer du code. Cela permet la réutilisation du code, ce qui aide à gérer la complexité.
• 3.1.A.5 L'utilisation de paramètres permet de généraliser les procédures, rendant les procédures réutilisables avec une gamme de valeurs d'entrée ou d'arguments.
• 3.1.A.6 L'utilisation de l'abstraction procédurale dans un programme permet aux programmateurs de modifier l'interne d'une méthode (pour la rendre plus rapide, plus efficace, utiliser moins de stockage, etc.) sans avoir besoin d'avertir les utilisateurs de la méthode du changement, tant que la signature de la méthode et ce que fait la méthode sont préservés.
• 3.1.A.7 Avant d'implémenter une classe, il est utile de prendre le temps de concevoir chaque classe, y compris ses attributs et comportements. Cette conception peut être représentée à l'aide d'un langage naturel ou de diagrammes.

Objectif d'apprentissage 3.2.A : Expliquer les implications sociales et éthiques des systèmes informatiques.

• 3.2.A.1 La fiabilité du système désigne la capacité du programme à effectuer ses tâches comme prévu dans des conditions spécifiées sans défaillance. Les programmateurs doivent s'efforcer de maximiser la fiabilité du système en testant le programme avec une variété de conditions.
• 3.2.A.2 La création de programmes a des impacts sur la société, l'économie et la culture. Ces impacts peuvent être à la fois bénéfiques et préjudiciables. Les programmes conçus pour répondre à un besoin ou résoudre un problème peuvent avoir des effets néfastes involontaires au-delà de leur usage prévu.
• 3.2.A.3 Des questions juridiques et des préoccupations relatives à la propriété intellectuelle surgissent lors de la création de programmes. Les programmeurs réutilisent souvent du code écrit par d'autres et publié en open source et gratuit. L'intégration de code qui n'est pas publié en open source exige que le programmeur obtienne une autorisation et achète souvent le code avant de l'intégrer à son programme.

Objectif d'apprentissage 3.3.A : Écrire du code pour définir les contraintes d'accès et de visibilité des classes, des données, des constructeurs et des méthodes.

• 3.3.A.1 L'encapsulation des données est une technique selon laquelle les détails d'implémentation d'une classe sont cachés aux classes externes. Les mots-clés public et private affectent l'accès des classes, des données, des constructeurs et des méthodes. Le mot-clé private restreint l'accès à la classe déclarante, tandis que le mot-clé public permet l'accès depuis des classes extérieures à la classe déclarante.
• 3.3.A.2 Dans ce cours, les classes sont toujours désignées public et déclarées avec le mot-clé class.
• 3.3.A.3 Dans ce cours, les constructeurs sont toujours désignés public.
• 3.3.A.4 Les variables d'instance appartiennent à l'objet, et chaque objet possède sa propre copie de la variable.
• 3.3.A.5 L'accès aux attributs doit être maintenu interne à la classe afin de réaliser l'encapsulation. Il s'agit donc d'une bonne pratique de programmation de désigner les variables d'instance pour ces attributs comme private sauf si la spécification de la classe stipule le contraire.
• 3.3.A.6 L'accès aux comportements peut être interne ou externe à la classe. Les méthodes désignées comme public peuvent être accédées internement ou externement à une classe, tandis que les méthodes désignées comme private ne peuvent être accédées qu'internement à la classe.

Objectif d'apprentissage 3.4.A : Écrire du code pour déclarer des variables d'instance pour les attributs à initialiser dans le corps des constructeurs d'une classe.

• 3.4.A.1 L'état d'un objet fait référence à ses attributs et à leurs valeurs à un moment donné et est défini par les variables d'instance appartenant à l'objet. Cela définit une relation « posséder » (has-a) entre l'objet et ses variables d'instance.
• 3.4.A.2 Un constructeur sert à définir l'état initial d'un objet, ce qui devrait inclure des valeurs initiales pour toutes les variables d'instance. Lorsqu'un constructeur est appelé, de la mémoire est allouée pour l'objet et la référence d'objet associée est retournée. Les paramètres du constructeur, s'ils sont spécifiés, fournissent des données pour initialiser les variables d'instance.
• 3.4.A.3 Lorsqu'un objet mutable est un paramètre de constructeur, la variable d'instance doit être initialisée avec une copie de l'objet référencé. De cette manière, la variable d'instance ne conserve pas une référence à l'objet original, et les méthodes sont empêchées de modifier l'état de l'objet original.
• 3.4.A.4 Lorsqu'aucun constructeur n'est écrit, Java fournit un constructeur sans paramètre, et les variables d'instance sont définies sur des valeurs par défaut selon le type de donnée de l'attribut. Ce constructeur est appelé le constructeur par défaut.
• 3.4.A.5 La valeur par défaut pour un attribut de type int est 0. La valeur par défaut d'un attribut de type double est 0.0. La valeur par défaut d'un attribut de type boolean est false. La valeur par défaut d'un type de référence est null.

Objectif d'apprentissage 3.5.A : Écrire du code pour définir les comportements d'un objet via des méthodes écrites dans une classe en utilisant des valeurs primitives et déterminer le résultat de l'appel de ces méthodes.

• 3.5.A.1 Une méthode void ne retourne pas de valeur. Son en-tête contient le mot-clé void avant le nom de la méthode.
• 3.5.A.2 Une méthode non-void (non vide) retourne une seule valeur. Son en-tête inclut le type de retour à la place du mot-clé void.
• 3.5.A.3 Dans les méthodes non-void, une expression de retour compatible avec le type de retour est évaluée, et la valeur est retournée. C'est ce qu'on appelle le retour par valeur.
• 3.5.A.4 Le mot-clé return est utilisé pour retourner le flux de contrôle au point où la méthode ou le constructeur a été appelé. Tout code situé séquentiellement après une instruction return ne sera jamais exécuté. L'exécution d'une instruction return à l'intérieur d'une instruction de sélection ou d'itération arrêtera cette instruction et sortira de la méthode ou du constructeur.
• 3.5.A.5 Une méthode d'accès (accessor) permet aux objets d'autres classes d'obtenir une copie de la valeur des variables d'instance ou de classe. Une méthode d'accès est une méthode non-void.
• 3.5.A.6 Une méthode mutatrice (modificatrice) est une méthode qui modifie les valeurs des variables d'instance ou de classe. Une méthode mutatrice est souvent une méthode void.
• 3.5.A.7 Les méthodes avec des paramètres reçoivent des valeurs par l'intermédiaire de ces paramètres et utilisent ces valeurs pour accomplir la tâche de la méthode.
• 3.5.A.8 Lorsqu'un argument est une valeur primitive, le paramètre est initialisé avec une copie de cette valeur. Les modifications apportées au paramètre n'ont aucun effet sur l'argument correspondant.

Objectif d'apprentissage 3.6.A : Écrire du code pour définir les comportements d'un objet via des méthodes écrites dans une classe en utilisant des références d'objets et déterminer le résultat de l'appel de ces méthodes.

• 3.6.A.1 Lorsqu'un argument est une référence d'objet, le paramètre est initialisé avec une copie de cette référence ; cela ne crée pas une nouvelle copie indépendante de l'objet. Si le paramètre fait référence à un objet mutable, la méthode ou le constructeur peut utiliser cette référence pour modifier l'état de l'objet. Il s'agit d'une bonne pratique de programmation de ne pas modifier les objets mutables passés en paramètre sauf si requis dans la spécification.
• 3.6.A.2 Lorsque l'expression de retour évalue une référence d'objet, la référence est retournée, et non une référence vers une nouvelle copie de l'objet.
• 3.6.A.3 Les méthodes ne peuvent accéder aux données privées et aux méthodes d'un paramètre qui contient une référence vers un objet, sauf si le paramètre est du même type que la classe englobante de la méthode.

Objectif d'apprentissage 3.7.A : Écrire du code pour définir les comportements d'une classe via des méthodes de classe.

• 3.7.A.1 Les méthodes de classe ne peuvent pas accéder ni modifier les valeurs des variables d'instance ni appeler des méthodes d'instance sans recevoir une instance de la classe via un paramètre.
• 3.7.A.2 Les méthodes de classe peuvent accéder ou modifier les valeurs des variables de classe et peuvent appeler d'autres méthodes de classe.

Objectif d'apprentissage 3.7.B : Écrire du code pour déclarer les variables de classe qui appartiennent à la classe.

• 3.7.B.1 Les variables de classe appartiennent à la classe, tous les objets d'une classe partageant une seule copie de la variable de classe. Les variables de classe sont désignées avec le mot-clé static avant le type de variable.
• 3.7.B.2 Les variables de classe désignées public sont accédées à l'extérieur de la classe en utilisant le nom de la classe et l'opérateur point, car elles sont associées à une classe, et non à des objets d'une classe.
• 3.7.B.3 Lorsqu'une variable est déclarée final, sa valeur ne peut pas être modifiée.

Objectif d'apprentissage 3.8.A : Expliquer où les variables peuvent être utilisées dans le code.

• 3.8.A.1 Les variables locales sont des variables déclarées dans les en-têtes ou les corps de blocs de code. Les variables locales ne peuvent être accédées que dans le bloc dans lequel elles sont déclarées. Puisque les constructeurs et les méthodes sont des blocs de code, les paramètres des constructeurs ou des méthodes sont également considérés comme des variables locales. Ces variables ne peuvent être utilisées que dans le constructeur ou la méthode et ne peuvent pas être déclarées comme public ou private.
• 3.8.A.2 Lorsqu'il existe une variable locale ou un paramètre ayant le même nom qu'une variable d'instance, le nom de la variable fera référence à la variable locale plutôt qu'à la variable d'instance à l'intérieur du corps du constructeur ou de la méthode.

Objectif d'apprentissage 3.9.A : Écrire du code pour des expressions auto-référentielles et déterminer le résultat de ces expressions.

• 3.9.A.1 À l'intérieur d'une méthode d'instance ou d'un constructeur, le mot-clé this agit comme une variable spéciale contenant une référence vers l'objet courant — l'objet dont la méthode ou le constructeur est appelé.
• 3.9.A.2 Le mot-clé this peut être utilisé pour passer l'objet courant en tant qu'argument dans un appel de méthode.
• 3.9.A.3 Les méthodes de classe n'ont pas de référence this.

Objectif d'apprentissage 4.1.A : Expliquer les risques pour la vie privée liés à la collecte et au stockage de données personnelles sur des ordinateurs.

• 4.1.A.1 Lors de l'utilisation d'un ordinateur, la vie privée personnelle est menacée. Lors du développement de nouveaux programmes, les programmeurs devraient essayer de protéger la vie privée personnelle de l'utilisateur.

Objectif d'apprentissage 4.1.B : Expliquer l'importance de reconnaître la qualité des données et les problèmes potentiels lors de l'utilisation d'un ensemble de données.

• 4.1.B.1 Le biais algorithmique décrit des erreurs systémiques et répétées dans un programme qui créent des résultats injustes pour un groupe spécifique d'utilisateurs.
• 4.1.B.2 Les programmeurs doivent être conscients de la méthode de collecte de l'ensemble de données et du potentiel de biais lors de l'utilisation de cette méthode avant d'utiliser les données pour extrapoler de nouvelles informations ou tirer des conclusions.
• 4.1.B.3 Certains ensembles de données sont incomplets ou contiennent des données inexactes. L'utilisation de telles données dans le développement ou l'utilisation d'un programme peut entraîner un fonctionnement incorrect ou inefficace du programme.

Objectif d'apprentissage 4.1.C : Identifier un ensemble de données approprié à utiliser afin de résoudre un problème ou répondre à une question spécifique.

• 4.1.C.1 Le contenu d'un ensemble de données peut être lié à une question ou un sujet spécifique et pourrait ne pas être approprié pour donner des réponses correctes ou extrapoler des informations pour une autre question ou un autre sujet.

Objectif d'apprentissage 4.2.A : Représenter des modèles et des algorithmes impliquant des jeux de données trouvés dans la vie quotidienne à l'aide de langage écrit ou de diagrammes.

• 4.2.A.1 Un jeu de données est une collection de pièces d'informations ou de données spécifiques.
• 4.2.A.2 Les jeux de données peuvent être manipulés et analysés pour résoudre un problème ou répondre à une question. Lors de l'analyse des jeux de données, les valeurs du jeu sont accédées et utilisées une par une, puis traitées selon le résultat souhaité.
• 4.2.A.3 Les données peuvent être représentées dans un diagramme en utilisant un graphique ou un tableau. Cette visualisation peut être utilisée pour planifier l'algorithme qui sera utilisé pour manipuler les données.

Objectif d'apprentissage 4.3.A : Développer du code utilisé pour représenter des collections de données apparentées à l'aide d'objets tableaux unidimensionnels (1D).

• 4.3.A.1 Un tableau stocke plusieurs valeurs du même type. Les valeurs peuvent être soit des valeurs primitives, soit des références d'objets.
• 4.3.A.2 La longueur d'un tableau est établie au moment de sa création et ne peut pas être modifiée. La longueur d'un tableau peut être accédée via l'attribut length.
• 4.3.A.3 Lorsqu'un tableau est créé en utilisant le mot-clé new, tous ses éléments sont initialisés avec les valeurs par défaut pour le type de données des éléments. La valeur par défaut pour int est 0, pour double est 0.0, pour boolean est false, et pour un type de référence est null.
• 4.3.A.4 Les listes d'initialisation peuvent être utilisées pour créer et initialiser des tableaux.
• 4.3.A.5 Les crochets [ ] sont utilisés pour accéder à et modifier un élément dans un tableau 1D en utilisant un index.
• 4.3.A.6 Les valeurs d'index valides pour un tableau s'étendent de 0 à une unité inférieure à la longueur du tableau, inclus. L'utilisation d'une valeur d'index hors de cette plage entraînera une ArrayIndexOutOfBoundsException.

Objectif d'apprentissage 4.4.A : Développer du code servant à parcourir les éléments d'un tableau 1D et déterminer le résultat de ces parcours.

• 4.4.A.1 Parcourir un tableau consiste à utiliser des instructions de répétition pour accéder à tous ou à une séquence ordonnée d'éléments dans un tableau.
• 4.4.A.2 Parcourir un tableau avec une boucle for indexée ou une boucle while nécessite l'accès aux éléments via leurs indices.
• 4.4.A.3 Une en-tête de boucle élargie for comprend une variable, appelée variable de boucle élargie for. Pour chaque itération de la boucle élargie for, la variable de boucle élargie for est affectée d'une copie d'un élément sans utiliser son index.
• 4.4.A.4 Affecter une nouvelle valeur à la variable de boucle élargie for ne change pas la valeur stockée dans le tableau.
• 4.4.A.5 Lorsqu'un tableau stocke des références d'objets, les attributs peuvent être modifiés en appelant des méthodes sur la variable de boucle élargie for. Cela ne change pas les références d'objets stockées dans le tableau.
• 4.4.A.6 Du code écrit avec une boucle élargie for pour parcourir les éléments d'un tableau peut être réécrit en utilisant une boucle indexée for ou une boucle while.

Objectif d'apprentissage 4.5.A : Développer du code pour des algorithmes standards et originaux dans un contexte ou une spécification donnée impliquant des tableaux et déterminer le résultat de ces algorithmes.

• 4.5.A.1 Il existe des algorithmes standards qui utilisent des parcours de tableaux pour :
  • déterminer une valeur minimale ou maximale
  • calculer une somme ou une moyenne
  • déterminer si au moins un élément possède une propriété particulière
  • déterminer si tous les éléments possèdent une propriété particulière
  • déterminer le nombre d'éléments ayant une propriété particulière
  • accéder à toutes les paires consécutives d'éléments
  • déterminer la présence ou l'absence d'éléments dupliqués
  • décaler ou faire pivoter des éléments vers la gauche ou la droite
  • inverser l'ordre des éléments

Objectif d'apprentissage 4.6.A : Développer du code pour lire des données à partir d'un fichier texte.

• 4.6.A.1 Un fichier est un stockage de données persistant lorsque le programme n'est pas en cours d'exécution. Les données dans un fichier peuvent être récupérées lors de l'exécution du programme.
• 4.6.A.2 Un fichier peut être connecté au programme en utilisant les classes File et Scanner.
• 4.6.A.3 Un fichier peut être ouvert en créant un objet File, en utilisant le nom du fichier comme argument du constructeur.
  • File(String str) est le constructeur File qui accepte un nom de fichier String à ouvrir en lecture, où str est le chemin d'accès du fichier.
• 4.6.A.4 En utilisant la classe File, il est requis d'indiquer quoi faire si le fichier avec le nom fourni ne peut pas être ouvert. Une façon de réaliser cela est d'ajouter throws IOException à l'en-tête de la méthode qui utilise le fichier. Si le nom de fichier est invalide, le programme se terminera.
• 4.6.A.5 Les classes File et IOException font partie du package java.io. Une instruction import doit être utilisée pour rendre ces classes disponibles pour l'utilisation dans le programme.
• 4.6.A.6 Les méthodes et constructeurs Scanner suivants — y compris ce qu'ils font et quand ils sont utilisés — font partie de la référence rapide Java :
  • Scanner(File f) est le constructeur Scanner qui accepte un File pour la lecture.
  • int nextInt() retourne le prochain int lu depuis le fichier ou la source d'entrée s'il est disponible. Si le prochain int n'existe pas ou est hors plage, cela entraînera une InputMismatchException.
  • double nextDouble() retourne le prochain double lu depuis le fichier ou la source d'entrée. Si le prochain double n'existe pas, cela entraînera une InputMismatchException.
  • boolean nextBoolean() retourne le prochain boolean lu depuis le fichier ou la source d'entrée. Si le prochain boolean n'existe pas, cela entraînera une InputMismatchException.
  • String nextLine() retourne la prochaine ligne de texte sous forme de String lu depuis le fichier ou la source d'entrée ; peut retourner la chaîne vide si appelée immédiatement après une autre méthode Scanner qui lit depuis le fichier ou la source d'entrée.
  • String next() retourne le prochain String lu dans le fichier ou la source d'entrée.
  • boolean hasNext() retourne true s'il y a un prochain élément à lire dans le fichier ou la source d'entrée ; retourne false sinon.
  • void close() ferme ce scanner.
  • Instruction d'exclusion : Accepter l'entrée clavier est hors du programme du cours et de l'examen AP Computer Science A.
• 4.6.A.7 L'utilisation de nextLine et des autres méthodes Scanner ensemble sur la même source d'entrée nécessite parfois du code pour ajuster les différentes façons dont les méthodes gèrent les espaces blancs.
  • Instruction d'exclusion : Écrire ou analyser du code utilisant à la fois nextLine et d'autres méthodes Scanner sur la même source d'entrée est hors du programme du cours et de l'examen AP Computer Science A.
• 4.6.A.8 La méthode additionnelle suivante String — y compris ce qu'elle fait et quand elle est utilisée — fait partie de la référence rapide Java :
  • String[] split(String del) retourne un tableau String où chaque élément est un sous-chaîne de this String, qui a été découpé autour des correspondances de l'expression donnée del.
  • Instruction d'exclusion : Le paramètre del utilise un format appelé expression régulière. Écrire ou analyser du code utilisant l'une des propriétés spéciales des expressions régulières (par exemple, \\*, \\.) est hors du programme du cours et de l'examen AP Computer Science A.
• 4.6.A.9 Une boucle élargie while peut être utilisée pour détecter si le fichier contient encore des éléments à lire en utilisant la méthode hasNext comme condition de la boucle.
• 4.6.A.10 Un fichier doit être fermé lorsque le programme a fini de l'utiliser. La méthode close de Scanner est appelée pour fermer le fichier.

Objectif d'apprentissage 4.7.A : Développer du code pour utiliser des objets Integer et Double à partir de leurs homologues primitifs et déterminer le résultat de l'utilisation de ces objets.

• 4.7.A.1 La classe Integer et la classe Double font partie du package java.lang. Un objet Integer est immuable, ce qui signifie qu'une fois un objet Integer créé, ses attributs ne peuvent pas être changés. Un objet Double est immuable, ce qui signifie qu'une fois un objet Double créé, ses attributs ne peuvent pas être changés.
• 4.7.A.2 L'autoboxing est la conversion automatique que le compilateur Java effectue entre les types primitifs et leurs classes enveloppes d'objet correspondantes. Cela inclut la conversion d'un int en un Integer et d'un double en un Double. Le compilateur Java applique l'autoboxing lorsqu'une valeur primitive est :
  • passée comme paramètre à une méthode attendant un objet de la classe enveloppe correspondante
  • affectée à une variable de la classe enveloppe correspondante
• 4.7.A.3 L'unboxing est la conversion automatique que le compilateur Java effectue de la classe enveloppe vers le type primitif. Cela inclut la conversion d'un Integer en un int et d'un Double en un double. Le compilateur Java applique l'unboxing lorsqu'un objet de classe enveloppe est :
  • passé comme paramètre à une méthode attendant une valeur du type primitif correspondant
  • affectée à une variable du type primitif correspondant
• 4.7.A.4 La méthode de classe Integer suivante — y compris ce qu'elle fait et quand elle est utilisée — fait partie de la référence rapide Java :
  • static int parseInt(String s) retourne l'argument String sous forme de int.
• 4.7.A.5 La méthode de classe Double suivante — y compris ce qu'elle fait et quand elle est utilisée — fait partie de la référence rapide Java :
  • static double parseDouble(String s) retourne l'argument String sous forme de double.

Objectif d'apprentissage 4.8.A : Développer du code pour des collections d'objets liés utilisant des objets ArrayList et déterminer le résultat de l'appel de méthodes sur ces objets.

• 4.8.A.1 Un objet ArrayList est mutable en taille et contient des références d'objets.
• 4.8.A.2 Le constructeur ArrayList ArrayList() construit une liste vide.
• 4.8.A.3 Java permet le type générique ArrayList<E>, où le paramètre de type E spécifie le type des éléments. Lorsque ArrayList<E> est spécifié, les types des paramètres de référence et du type de retour lors de l'utilisation des méthodes ArrayList sont le type E. ArrayList<E> est préféré à ArrayList. Par exemple, ArrayList<String> names = new ArrayList<String>(); permet au compilateur de trouver des erreurs qui seraient autrement trouvées à l'exécution.
• 4.8.A.4 La classe ArrayList fait partie du package java.util. Une instruction import doit être utilisée pour rendre cette classe disponible pour l'utilisation dans le programme.
• 4.8.A.5 Les méthodes ArrayList suivantes — y compris ce qu'elles font et quand elles sont utilisées — font partie de la référence rapide Java :
  • int size() retourne le nombre d'éléments dans la liste.
  • boolean add(E obj) ajoute obj à la fin de la liste ; retourne true.
  • void add(int index, E obj) insère obj à la position index (0 <= index <= size), déplaçant les éléments aux positions index et supérieures vers la droite (ajoute 1 à leurs indices) et ajoute 1 à la taille.
  • E get(int index) retourne l'élément à la position index dans la liste.
  • E set(int index, E obj) remplace l'élément à la position index par obj ; retourne l'élément auparavant situé à la position index.
  • E remove(int index) retire l'élément à la position index, déplaçant les éléments aux positions index + 1 et supérieures vers la gauche (soustrait 1 à leurs indices) et soustrait 1 à la taille ; retourne l'élément auparavant situé à la position index.
• 4.8.A.6 Les indices d'un ArrayList commencent à 0 et se terminent au nombre d'éléments - 1.

Objectif d'apprentissage 4.9.A : Développer du code servant à parcourir les éléments d'un ArrayList et déterminer les résultats de ces parcours.

• 4.9.A.1 Parcourir un ArrayList consiste à utiliser des instructions d'itération ou récursives pour accéder à tous ou à une séquence ordonnée des éléments dans un ArrayList.
• 4.9.A.2 Supprimer des éléments pendant un parcours d'un ArrayList nécessite l'utilisation de techniques spéciales pour éviter de sauter des éléments.
• 4.9.A.3 Tenter d'accéder à une valeur d'index hors de sa plage entraînera une IndexOutOfBoundsException.
• 4.9.A.4 Changer la taille d'un ArrayList tout en le parcourant avec une boucle élargie for peut entraîner une ConcurrentModificationException. Par conséquent, lorsqu'on utilise une boucle élargie for pour parcourir un ArrayList, vous ne devez pas ajouter ou supprimer d'éléments.

Objectif d'apprentissage 4.10.A : Écrire du code pour des algorithmes standards et originaux pour un contexte ou une spécification particulière impliquant des objets ArrayList et déterminer le résultat de ces algorithmes.

• 4.10.A.1 Il existe des algorithmes ArrayList standards qui utilisent des traversées pour :
  • déterminer une valeur minimale ou maximale
  • calculer une somme ou une moyenne
  • déterminer si au moins un élément possède une propriété particulière
  • déterminer si tous les éléments possèdent une propriété particulière
  • déterminer le nombre d'éléments ayant une propriété particulière
  • accéder à toutes les paires consécutives d'éléments
  • déterminer la présence ou l'absence d'éléments dupliqués
  • décaler ou faire pivoter des éléments vers la gauche ou la droite
  • inverser l'ordre des éléments
  • insérer des éléments
  • supprimer des éléments
• 4.10.A.2 Certains algorithmes nécessitent la traversée simultanée de plusieurs String, tableaux bidimensionnels (array) ou objets ArrayList.

Objectif d'apprentissage 4.11.A : Développer du code utilisé pour représenter des collections de données apparentées à l'aide d'objets tableaux bidimensionnels (2D).

• 4.11.A.1 Un tableau 2D est stocké sous forme de tableau de tableaux. Par conséquent, la façon dont les tableaux 2D sont créés et indexés est similaire à celle des objets tableaux unidimensionnels (1D). La taille d'un tableau 2D est établie au moment de sa création et ne peut pas être modifiée. Les tableaux 2D peuvent stocker soit des données primitives, soit des références d'objets.
  • Énoncé d'exclusion : Les objets tableaux 2D non rectangulaires sont hors programme du cours et de l'examen AP Computer Science A.
• 4.11.A.2 Lorsqu'un tableau 2D est créé en utilisant le mot-clé new, tous ses éléments sont initialisés avec les valeurs par défaut pour le type de données des éléments. La valeur par défaut pour int est 0, pour double est 0.0, pour boolean est false, et pour un type de référence est null.
• 4.11.A.3 La liste d'initialisation utilisée pour créer et initialiser un tableau 2D consiste en des listes d'initialisation représentant des tableaux 1D ; par exemple, int[][] arr2D = { {1, 2, 3}, {4, 5, 6} };.
• 4.11.A.4 Les crochets [row][col] sont utilisés pour accéder et modifier un élément dans un tableau 2D. Aux fins de l'examen, lors de l'accès à l'élément à arr[first][second], le premier indice est utilisé pour les lignes, le second indice est utilisé pour les colonnes.
• 4.11.A.5 Un tableau unique qui constitue une ligne d'un tableau 2D peut être accédé en utilisant le nom du tableau 2D suivi d'une seule paire de crochets contenant l'indice de ligne.
• 4.11.A.6 Le nombre de lignes contenues dans un tableau 2D peut être accédé via l'attribut length. Les valeurs d'indice de ligne valides pour un tableau 2D s'étendent de 0 jusqu'à une unité inférieure au nombre de lignes ou à la longueur du tableau, inclus. Le nombre de colonnes contenues dans un tableau 2D peut être accédé via l'attribut length de l'une des lignes. Les valeurs d'indice de colonne valides pour un tableau 2D s'étendent de 0 jusqu'à une unité inférieure au nombre de colonnes ou à la longueur de toute ligne donnée du tableau, inclus. Par exemple, étant donné un tableau 2D nommé values, le nombre de lignes est values.length et le nombre de colonnes est values[0].length. L'utilisation d'une valeur d'indice en dehors de ces plages entraînera une ArrayIndexOutOfBoundsException.

Objectif d'apprentissage 4.12.A : Développer du code utilisé pour parcourir les éléments d'un tableau 2D et déterminer le résultat de ces traversées.

• 4.12.A.1 Les instructions d'itération imbriquées sont utilisées pour parcourir et accéder à tous ou à une séquence ordonnée d'éléments dans un tableau 2D. Puisque les tableaux 2D sont stockés comme des tableaux de tableaux, la façon dont les tableaux 2D sont parcourus en utilisant des boucles for et des boucles améliorées for est similaire aux objets de tableau 1D. Les instructions d'itération imbriquées peuvent être écrites pour parcourir le tableau 2D en ordre ligne-major, colonne-major, ou un ordre défini de manière unique. L'ordre ligne-major fait référence à un ordre des éléments de tableau 2D où la traversal se fait à travers chaque ligne, tandis que la traversal colonne-major se fait vers le bas chaque colonne.
• 4.12.A.2 La boucle externe d'une boucle imbriquée for améliorée utilisée pour parcourir un tableau 2D parcourt les lignes. Par conséquent, la variable de boucle for améliorée doit être du type de chaque ligne, c'est-à-dire un tableau 1D. La boucle interne parcourt une ligne unique. Par conséquent, la variable de boucle for améliorée interne doit être du même type que les éléments stockés dans le tableau 1D. L'attribution d'une nouvelle valeur à la variable de boucle for améliorée ne modifie pas la valeur stockée dans le tableau.

Objectif d'apprentissage 4.13.A : Développer du code pour des algorithmes standards et originaux dans un contexte ou une spécification particulière impliquant des tableaux 2D et déterminer le résultat de ces algorithmes.

• 4.13.A.1 Il existe des algorithmes standards qui utilisent des traversées de tableaux 2D pour :
  • déterminer une valeur minimale ou maximale de tous les éléments ou pour une ligne, colonne ou autre sous-section désignée
  • calculer une somme ou une moyenne de tous les éléments ou pour une ligne, colonne ou autre sous-section désignée
  • déterminer si au moins un élément possède une propriété particulière dans tout le tableau 2D ou pour une ligne, colonne ou autre sous-section désignée
  • déterminer si tous les éléments du tableau 2D ou d'une ligne, colonne ou autre sous-section désignée possèdent une propriété particulière
  • déterminer le nombre d'éléments dans le tableau 2D ou dans une ligne, colonne ou autre sous-section désignée ayant une propriété particulière
  • accéder à toutes les paires consécutives d'éléments
  • déterminer la présence ou l'absence d'éléments dupliqués dans le tableau 2D ou dans une ligne, colonne ou autre sous-section désignée
  • décaler ou faire pivoter des éléments dans une ligne vers la gauche ou la droite ou dans une colonne vers le haut ou le bas
  • inverser l'ordre des éléments dans une ligne ou une colonne

Objectif d'apprentissage 4.14.A : Développer du code utilisé pour des algorithmes de recherche linéaire afin de rechercher des informations spécifiques dans une collection et déterminer les résultats de l'exécution d'une recherche.

• 4.14.A.1 Les algorithmes de recherche linéaire sont des algorithmes standards qui vérifient chaque élément dans l'ordre jusqu'à ce que la valeur souhaitée soit trouvée ou que tous les éléments du tableau ou de ArrayList aient été vérifiés. Les algorithmes de recherche linéaire peuvent commencer le processus de recherche depuis n'importe quelle extrémité du tableau ou de ArrayList.
• 4.14.A.2 Lors de l'application d'algorithmes de recherche linéaire aux tableaux 2D, chaque ligne doit être accédée puis la recherche linéaire appliquée à chaque ligne du tableau 2D.

Objectif d'apprentissage 4.15.A : Déterminer le résultat de l'exécution de chaque étape des algorithmes de tri pour trier les éléments d'une collection.

• 4.15.A.1 Le tri par sélection et le tri par insertion sont des algorithmes de tri itératifs qui peuvent être utilisés pour trier des éléments dans un tableau ou un ArrayList.
• 4.15.A.2 Le tri par sélection sélectionne répétés le plus petit (ou le plus grand) élément de la partie non triée de la liste et l'échange contre sa position correcte (et finale) dans la partie triée de la liste.
• 4.15.A.3 Le tri par insertion insère un élément de la partie non triée d'une liste dans sa position correcte (mais pas nécessairement finale) dans la partie triée de la liste en décalant les éléments de la partie triée pour faire de la place au nouvel élément.

Objectif d'apprentissage 4.16.A : Déterminer le résultat de l'appel de méthodes récursives.

• 4.16.A.1 Une méthode récursive est une méthode qui s'appelle elle-même. Les méthodes récursives contiennent au moins un cas de base, qui arrête la récursion, et au moins un appel récursif. La récursivité est une autre forme de répétition.
• 4.16.A.2 Chaque appel récursif possède son propre ensemble de variables locales, y compris les paramètres. Les valeurs des paramètres capturent les progrès d'un processus récursif, tout comme les valeurs des variables de contrôle de boucle capturent les progrès d'une boucle.
• 4.16.A.3 Toute solution récursive peut être reproduite par l'utilisation d'une approche itérative et vice versa.
  • Énoncé d'exclusion : L'écriture de code récursif est hors programme du cours et de l'examen AP Computer Science A.

Objectif d'apprentissage 4.17.A : Déterminer le résultat de l'exécution d'algorithmes récursifs utilisant des chaînes de caractères ou des collections.

• 4.17.A.1 La récursivité peut être utilisée pour parcourir des objets String, des tableaux et des objets ArrayList.

Objectif d'apprentissage 4.17.B : Déterminer le résultat de chaque itération d'un algorithme de recherche binaire utilisé pour rechercher des informations dans une collection.

• 4.17.B.1 Les données doivent être dans un ordre trié pour utiliser l'algorithme de recherche binaire. La recherche binaire commence au milieu d'un tableau trié ou d'un ArrayList et élimine la moitié du tableau ou de ArrayList à chaque appel récursif jusqu'à ce que la valeur souhaitée soit trouvée ou que tous les éléments aient été éliminés.
• 4.17.B.2 La recherche binaire est généralement plus efficace que la recherche linéaire.
  • Énoncé d'exclusion : Les algorithmes de recherche autres que la recherche linéaire et binaire sont hors programme du cours et de l'examen AP Computer Science A.
• 4.17.B.3 L'algorithme de recherche binaire peut être écrit de manière itérative ou récursive.

Objectif d'apprentissage 4.17.C : Déterminer le résultat de chaque itération de l'algorithme de tri fusion (merge sort) lorsqu'il est utilisé pour trier une collection.

• 4.17.C.1 Le tri fusion est un algorithme de tri récursif qui peut être utilisé pour trier des éléments dans un tableau ou un ArrayList.
  • Énoncé d'exclusion : Les algorithmes de tri autres que le tri par sélection, le tri par insertion et le tri fusion sont hors programme du cours et de l'examen AP Computer Science A.
• 4.17.C.2 Le tri fusion divise répétés un tableau en sous-tableaux plus petits jusqu'à ce que chaque sous-tableau ne contienne qu'un seul élément, puis fusionne récursivement les sous-tableaux triés ensemble dans l'ordre trié pour former le tableau final trié.