1. Installation et utilisation de MyEclipse
* Eclipse: est un outil de développement gratuit * MyEclipse: est un plug-in payant pour casser MyEclipse, ** Exigences du répertoire d'installation: Il ne peut pas y avoir de chinois et d'espaces ** Une fois l'installation terminée Java Project Web Project - Sélectionnez la dépendance JDK, vous pouvez utiliser le JDK qui est livré avec MyEclipse, ou vous pouvez utiliser le JDK * installé pour créer un package de package - Cn.itcast.test xx.xx.xx * Créer une classe dans le package - Classe NaMing Specification: ** La lettre initiale devrait être capitalisée, par exemple) ait (TestDemo1 UserManage * Valeur corporelle ou de retour;} - Méthode Noming Spécifications en minuscules première lettre, par exemple: Addnum () * Définir la variable - Spécification de dénomination variable ** La lettre initiale en minuscules, la première lettre du deuxième mot devrait être en majuscule, comme le nom d'utilisateur * de dénomination: voir le nom et savoir ce que cela signifie * le code doit être en retrait * Exécutez le programme exécuté en tant que Java ApplicationDebug comme application Java
2. Mode de débogage de débogage (mode de débogage des points d'arrêt)
* Using this mode, debug the program (see the changes in the data in the program) * The first step to use debug requires setting a breakpoint (let the program run stop on this line) - Show the line number - Double-click on the left, a dot appears, indicating that a breakpoint has been set * Use debug as method, run the program - prompt whether to enter the debug interface, yes- On the breakpoint, there is a green bar, indicating that the program stops on this line and does not run En bas * Vous pouvez laisser le programme s'exécuter en baisse, - Utilisez l'étape sur la touche de raccourci est F6 (exécution en une seule étape) - CV F8: indique que le débogage est terminé, s'exécute directement vers le bas ** par exemple, il n'y a pas de point d'arrêt après le point de rupture actuel, le programme s'exécute directement * Débugg F7 Retour étape: retour
3. Utilisation des touches de raccourci myeclipse
* Invite de code alt / * Package de guide rapide Ctrl Shift O * Commentaire de ligne unique Ctrl / * Supprimer le commentaire de ligne unique Ctrl / * Commentaire multi-ligne Ctrl Shift / * Supprimer le commentaire multi-ligne Ctrl Shift / * Delete Line Ctrl D
4. Utilisation de Junit
* Test unitaire * L'objet de test est une méthode dans une classe * Juint ne fait pas partie de Javase, je veux utiliser le package d'importation ** Cependant, le package JAR avec Junit est apporté dans MyEclipse * Tout d'abord, lorsque la méthode Junit version 3.x 4.x * Unité de la méthode, la méthode Naming Rules @TestPublic void testAdd1 () {testJunit test01 = new TestJunit (); test01.testAdd (2, 3);} - Sélectionnez le nom de la méthode, clic droit pour exécuter l'exécution de l'exécution comme --- Test JUnit - Lorsqu'une barre verte apparaît, cela signifie que le test de méthode passe - lorsqu'une barre de berou Classe, exécuter en tant que --- Test JUnit ** @ignore: signifie que cette méthode n'est pas testée unitaire ** @Before: exécuter sur chaque méthode ** @After: exécuter après chaque méthode ** assert.assertequals ("Tester la valeur attendue", "La valeur réelle de la méthode exécutée") JDK5.0 nouvelles fonctionnalités JDK 1.1 Paramètres ** Réflexion5. Introduction aux génériques
* Pourquoi utiliser des génériques? - Généralement utilisé sur les ensembles ** Par exemple, mettez maintenant une valeur de type de chaîne dans l'ensemble. À l'heure actuelle, après avoir mis cette valeur dans l'ensemble, le type qui perd sa capacité ne peut être que le type d'objet. Pour le moment, par exemple, si vous souhaitez taper convertir cette valeur, il est facile d'avoir des erreurs de conversion de type. Comment résoudre ce problème peut être utilisé pour résoudre ce problème à l'aide de génériques * Comment utiliser les génériques sur des ensembles - Set Courntement utilisé List Set Map - Collection de syntaxe générique <String> Par exemple, List <string> Doublechar - CharacterBoolean - Boolean * Trois implémentations de l'utilisation de listes génériques sur la liste ArrayList LinkedList Vector Code: @TestPublic void TestList () {list <String> list = new ArrayList <string> (); list.add ("aaa"); list.add ("bbb"); list.add ("ccc"); // Loop Iterator Enhancement for // Ordinary for Loop for (int i = 0; i <list.size (); i ++) {String s = list.get(i);System.out.println(s);}System.out.println("============================================================================== ==========================================================. ==========================================================. ===============================================================================. ==========================================================. ==========================================================. ==========================================================. Ces trois différences * utilisent le code générique sur set: // génériques utilisent set sur set @TestPublic void testSet () {set <string> set = new Hashset <string> (); set.add ("www"); set.add ("qqq"); set.Add ("zzz"); // set.add ("qqq"); // transfer Pour // Utiliser l'amélioration pour la traversée pour (String S2: SET) {System.out.println(s2);}System.out.println("==================================================== =======================================================================================================================. =======================================================================================================================. =======================================================================================================================. = set.iterator (); while (it1.hasnext ()) {System.out.println (it1.next ());}} * Utilisez des génériques-map structure sur map: key-valu form Code: // Utilisation de génériques sur map @testpublic void testmap () {map <string, string> map = new hashmap <String, String> (); map.put ("aaa", "111"); map.put ("bbb", "222"); map.put ("ccc", "333"); // map transip il existe plusieurs façons de traverser // 1. Obtenez toutes les clés et obtenir de la valeur via une méthode de clé Get Method // 2. Obtenez la relation entre la clé et la valeur // Utiliser la première méthode // Get All Keyset <String> SetS = Map.KeySet (); // Transfer pour le jeu de touches (String> All SetS = Map.KeySet (););); Clé: sets) {// get ValueString value = map.get (key); system.out.println (key + ": "+value);}System.out.println("============================================================================= ============================================================================================================. ============================================================================================================. ===========================================================================================================. {// Entrée est la relation entre la clé et la valeur String keyv = entry.getKey (); string valuev = entry.getValue (); system.out.println (keyv + ":" + valuev);}}6. Les génériques sont utilisés dans les méthodes
* Définissez un tableau pour implémenter l'échange d'éléments de tableau à la position spécifiée * La logique de la méthode est la même, mais les types de données sont différents. À l'heure actuelle, utilisez des méthodes génériques * / ** Utilisez des méthodes génériques pour définir un type à l'aide de lettres majuscules pour représenter T: Ce T représente tout type * avant que la valeur de retour ne soit écrite <T> * ========= Définir un type. Ce type est t * ici, vous pouvez utiliser ce type t * * / / public static <t> void swap1 (t [] arr, int a, int b) {t temp = arr [a]; arr [a] = arr [b]; arr [b] = temp;} ** travail 2: implémenter une méthode générique, accepter une arrection, et inverser tous les éléments de l'arrivée7. Utilisation des génériques sur les cours (comprendre)
* Définissez un type sur une classe, ce type peut être utilisé directement dans la classe * Classe publique TestDemo04 <T> {// Vous pouvez utiliser T type TAA dans la classe; public void test11 (t bb) {} // Écrivez un générique défini par une méthode statique de la classe, et vous ne pouvez plus utiliser la méthode statique statique publique STATIQUE <A> VOID TEST12 (A CC) {}}8. Introduction à l'énumération
* Qu'est-ce qu'une enum? ** Vous devez prendre une valeur dans une certaine plage, et cette valeur ne peut être que l'une des gammes. ** Scène réaliste: feux de circulation, il y a trois couleurs, mais une seule des trois couleurs peut être lumineuse à la fois * Utiliser un mot clé enum ** enum colore3 {rouge, vert, jaune;} * La méthode de construction enum est également privée * Le fonctionnement de l'enum spécial (comprendre) ** Il existe une méthode de construction dans la classe ENUM ** Il existe un paramètre dans la méthode de construction, et les paramètres doivent être écrits sur chaque instance ** Il existe un paramètre dans la méthode de construction, et les paramètres doivent être écrits sur chaque instance ** Classe ** Réécrivez cette méthode abstraite dans chaque instance de l'énumération9. Le fonctionnement de l'API énuméré
** name (): Renvoie le nom de l'énumération ** ordinal (): L'indice de l'énumération, l'indice commence à partir de 0 ** valeur de (classe <t> enumtype, nom de chaîne): obtenir l'objet de l'énumération ** Il existe deux autres méthodes, les deux ne sont pas dans l'API, et deux méthodes sont générées pendant la compilation *** Conversion entre les objets enum, l'indice de l'objet enum et la représentation du nom de l'objet enum- // Connaissez l'objet enum, obtenez le nom de l'énum et l'indice @TestPublic void test1 () {// Obtenez l'objet Enum Color100 C100 = Color100.red; // Nom de l'énume Nom de chaîne = C100.NAME (); // L'indice de l'énumération int idx = c100.OrDinal (); System.out.println (name + "" + idx);} - // Connaissez le nom de l'énumération, obtenez l'objet et l'indice de l'énumération @TestPublic void test2 () {String name1 = "Green"; // obtenez l'objet Color100 C1 = Color100.ValueOf (Name1); // énum int idx1 = C1.OrDinal (); System.out.println (idx1);} - // Connaissez l'indice de l'énumération, obtenez l'objet et le nom de l'énumération @TestPublic Void test3 () {int idx2 = 2; // obtenir l'objet d'énumération Color100 [] CS = Color100.Values (); // Obtenir l'objet Color100 en fonction de l'abpence C12 = cs [idx2]; // Obtenez le nom d'énumération Nom de chaîne = C12.Name (); System.out.println (nom);}10. Importation statique (comprendre)
* Vous pouvez utiliser directement la méthode d'importation statique dans le code pour importer des méthodes ou des constantes statiques * Importer static xx.xx.xxx * Importer static java.lang.system.out; import static java.util.arrays.sort; ** par exemple, implémentez désormais une calculatrice dans la classe mathématique
11. Déballage et assemblage automatique
* Box ** Convertissez le type de données de base en classe d'emballage * Déblocage ** Convertissez la classe d'emballage en Type de données de base ** // Autobox Integer i = 10; // Autobox int m = i; ** comment se bloquer et unbox dans JDK1.4 - // Autobox dans JDK1.4 Public Void Test1 () {// Box Integer M = New Integer (10); // Unbox int a = M.IntValue ();} ** JDK est compatible en arrière - par exemple, le code écrit dans JDK1.4 peut également fonctionner en 5.0 ** Exercice: Backward Compatible == Le résultat de l'exécution est d'appeler Dosomething (double M) == Tout d'abord, cette méthode doit être appelée JDK1.4. Si la méthode suivante est appelée, la conversion de type est requise, mais JDK1.4 ne peut pas réaliser automatiquement unboxing == puisque JDK est compatible vers l'arrière, si cette méthode est appelée JDK1.4, cette méthode sera toujours appelée dans JDK5.0 public static void Main (String [] args) {dosomething (10);} public static void dosomething (double m) {System.out.println ("Double ...");} public static void Dosomething (entier a) {System.out.println ("Integer ......");} ** Rappelez-vous: la classe de wrapper correspondant aux huit types de données de base * int --- entier * char --- Caractère12. Amélioration de la boucle (*****)
* Syntaxe pour (la valeur traversée: l'ensemble à traverser) {} - pour (String s: list) {System.out.println (s);} * Scénarios d'utilisation: array; Les ensembles qui implémentent l'interface itérable peuvent utiliser la boucle améliorée pour la boucle * Utilisez la boucle améliorée pour traverser la liste définie sur l'interface ITERATOR est implémentée, de sorte que la boucle améliorée peut être utilisée, et l'interface d'itérateur ne peut pas être implémentée, donc la boucle améliorée ne peut pas être utilisée. L'interface itérateur ne peut pas être implémentée, donc la boucle améliorée ne peut pas être utilisée. Le but de la boucle améliorée pour la boucle apparaît: pour remplacer l'itérateur ** La couche sous-jacente de l'amélioration est mise en œuvre par l'itérateur13. Supplément de contenu
(1) Effacer générique * Tout d'abord, les génériques n'apparaissent que dans l'étape du code source. Lorsqu'elles sont compilées, les génériques n'existent plus (2) Exercice: implémentez une méthode générique, acceptez les tableaux de tout type et inversez tous les codes d'élément dans le tableau publique statique <t> void inverse (t [] arr1) {/ ** Idea de base: échangez le premier élément avec le dernier élément et échangez le deuxième élément avec l'élément avant-dernier. . . . * Longueur d'échange / 2 * * /// Transweep le tableau pour (int i = 0; i <arr1.length / 2; i ++) {/ * int temp = arr1 [0]; arr1 [0] = arr1 [arr1.length-1]; * / t temp = ar1 [i]; arr1 [i] = arr1 [arr1.Length-i-1]; arret [Arr1.Length14. Paramètres variables
* Dans quel scénario peut être appliqué paramètres variables: ** Implémentez l'ajout de deux nombres et implémentez l'ajout de trois nombres et quatre nombres - si plusieurs méthodes sont implémentées, la logique de ces méthodes est fondamentalement la même. La seule différence est le nombre de paramètres passés. Vous pouvez utiliser les paramètres variables * Méthode de définition des paramètres variables Type de données ... Le nom du tableau * est compris comme un tableau, qui stocke les paramètres passants de paramètres publics static Void Add1 (int ... nums) {// nums est compris comme un tableau, qui statique les paramètres passés // System.out.println (nums.Length); int sum = 0; // tranQuability pour (intray pour (intring i = 0; i <nums.length; i ++) {sum + = nums [i];} system.out.println (sum);} * note (1) Les paramètres variables doivent être écrits dans la liste des paramètres de la méthode, et ne peut pas être défini séparé - add1 (int a, int ... nums)15. Le principe de réflexion (************)
* Appliqué dans certains codes avec une polyvalence plus élevée * La plupart des cadres apprises ultérieurs sont implémentés à l'aide de la réflexion * Dans le développement de Framework, ils sont développés en fonction du fichier de configuration ** Dans le fichier de configuration, tous les contenus de la classe peuvent être obtenus via la réflexion et une méthode dans la classe peuvent être utilisées pour exécuter * Tous les contenus dans la classe: Attributs, constructeurs sans paramètres, constructeurs avec paramètres, méthodes ordinaires * Les principes de la référence, les constructeurs, les paramètres, Vous devez enregistrer le fichier java sur le disque dur local.java * Compilez le fichier java et devenir un fichier .class * Utilisez JVM pour charger le fichier de classe dans la mémoire via la charge de classe * Tout est un objet, et le fichier de classe est représenté par la classe de classe en mémoire * lorsque vous utilisez la réflexion, vous devez d'abord obtenir la classe de classe. Après avoir obtenu cette classe, vous pouvez obtenir tout le contenu du fichier de classe - y compris les constructeurs d'attribut, les méthodes ordinaires * Les attributs sont déposés * Constructeur * Constructeur * La méthode normale passe par une méthode de classe
16. Utilisez la méthode de construction sans paramètres dans la classe d'opération de réflexion (** écrira **)
* Obtenez d'abord la classe de classe - // Obtenez la classe Classe Classe Class Clazz1 = Person.class; Class Clazz2 = new Person (). GetClass (); Class Clazz3 = class.forname ("CN.itcast.test09.Person"); * Par exemple: pour instancier une classe, vous pouvez nouveau, mais ne pas utiliser de nouveau, comment le faire? - // Get classClass c3 = class.forname ("cn.itcast.test09.person"); // obtenez l'instance de personne de classe Personne P = (personne) c3.NewInstance (); * Code // Fonctionne le constructeur sans paramètres @TestPublic Void test1 () lance une exception {// obtenir la classe CLAS C3 = Class.forname ("cn.itcast.test09.person"); // Obtenez l'instance de la personne de la personne Personne P = (personne) c3.NewInstance (); // Définissez la valeur p.setName ("Zhangsan"); System.out.println (P.GetName ());}17. Utiliser le fonctionnement de la réflexion pour avoir la méthode de construction des paramètres (** écrira **)
//Operate the constructor with parameters @Testpublic void test2() throws Exception {//Get ClassClass c1 = Class.forName("cn.itcast.test09.Person");//Use the constructor with parameters//c1.getConstructors();//Get all constructors//Pass the parameter type in the constructor with parameters, and the type is passed in the form of a class. Cs = c1.getConstructor (string.class, string.class); // Définissez la valeur via le constructeur avec paramètres // Créez l'instance de personne via le constructeur avec des paramètres personne p1 = (personne) cs.newinstance ("lisi", "100"); system.out.println (p1.getid () + "" + p1.getname ());}18. Utiliser les propriétés de l'opération de réflexion (** écrira **)
* // Opération Nom Attribut @TestPublic void test3 () {try {// get class class c2 = class.forname ("cn.itcast.test09.person"); // Get Name Attribute // C2.GetDeclaredFields (); // indiquez pour obtenir tous Cette méthode, le paramètre est le nom du champ d'attribut F1 = C2.GetDeclaredField ("Name"); // L'opération est une propriété privée, et l'opération n'est pas autorisée. Vous devez définir la propriété privée setAccessible (true), qui peut utiliser la propriété privée f1.setAccessible (true); // définir la méthode de définition de la valeur de nom, deux paramètres: la première instance de paramètre, et le deuxième paramètre est la valeur définie f1.set (p11, "wangwu"); // équivalent à p.name = "wangwu"; System.out.println (f1.get (p11)); // équivalent à p.name} catch (exception e) {e.printStackTrace ();}}19. Utiliser des méthodes de fonctionnement génériques (** peut écrire **)
* Utiliser la classe de méthodes pour représenter des méthodes ordinaires * Code // Fonctionne des méthodes ordinaires, telles que l'exploitation setName @ testpublic void test4 () lève une exception {// get class class c4 = class.forname ("cn.itcast.test09.Person"); // Obtenir l'instance de personne p4 = (personne) c4 Méthode // C4.GetDeclaredMethods (); // Obtenez toutes les méthodes ordinaires // Transférer deux paramètres: le premier paramètre, le nom de la méthode; Le deuxième paramètre, le type du paramètre dans la méthode Méthode M1 = C4.GetDeclaredMethod ("setName", string.class); // Laissez la méthode setName exécuter, exécutez la valeur set // use invoke (p4, "niuqi"); Passez deux paramètres: le premier paramètre, instance de personne; Le deuxième paramètre, set value // Après avoir exécuté la méthode invoquée, il équivaut à exécuter la méthode setName, et en même temps, une valeur est définie pour être niuqim1.invoke (p4, "niuqi"); System.out.println (p4.getName ());} * // La méthode privée de l'opération doit être définie sur true * //m1.setaccessible(true) ;* lorsque la méthode d'opération est une méthode statique, car la méthode statique est appelée nom de classe. Nom de la méthode, aucune instance de la classe n'est nécessaire * Lors de l'utilisation de la réflexion pour utiliser la méthode statique, aucune instance n'est nécessaire * Dans le premier paramètre de la méthode invokie, écrivez null- m1.invoke (null, "niuqi");Ce qui précède est l'édition Java Basic améliorée du tutoriel Java Web Basic introduit par l'éditeur. J'espère que ce sera utile à tout le monde. Si vous avez des questions, veuillez me laisser un message et l'éditeur répondra à tout le monde à temps. Merci beaucoup pour votre soutien au site Web Wulin.com!