1. Instalación y uso de MyEClipse
* Eclipse: es una herramienta de desarrollo gratuita* myEClipse: es un complemento pagado para crack myeclipse, ** Requisitos de directorio de instalación: no puede haber chinos y espacios ** Después de completar la instalación, seleccione un espacio de trabajo, que no puede tener chinos y espacios* MyEClipse ** ejecutar el archivo de ejecución. Proyecto de proyecto Java Proyecto: seleccione la dependencia JDK, puede usar el JDK que viene con MyECLIPSE, o puede usar el JDK* instalado* para crear un paquete de paquete: cn.itcast.test xx.xx.xx* Crear una clase en el paquete de clases de la clase: ** La carta inicial debe ser capitalizada, por ejemplo: TestDemo1 Usermanager: Crear Método de Método (Método Test Ayque 1 (Lista de parámetros). o Valor de retorno;} - Método Especificación de nomenclatura en la primera letra de la primera letra, por ejemplo: addnum ()* Definir variable - Especificación de nomenclatura variable ** La letra inicial en minúsculas, la primera letra de la segunda palabra debe ser la mayúscula, como el nombre de usuario* Hay otra forma de nombrar ** usar el pinyin chino para usar la mima de la mima ** no puede mezclar el pinyin chino y el inglés de la que usa la mayor cantidad de petróleo*. Naming: vea el nombre y sepa lo que significa * El código debe ser sangrado * Ejecutar el programa Ejecutar como Java ApplicationDebug como aplicación Java
2. Modo de depuración de depuración (modo de depuración de punto de interrupción)
* Usando este modo, depurar el programa (consulte los cambios en los datos en el programa) * El primer paso para usar la depuración requiere configurar un punto de interrupción (deje que el programa ejecute detenerse en esta línea) - Muestre el número de línea: haga doble clic en la izquierda, aparece un punto, indicando que un punto de interrupción se ha establecido * Usar el debug como el método, ejecute el programa, si ingresa la interfaz de debug, sí, sí, en el punto de interrupción, hay una barra de verde, existe una barra verde, indica que el programa es el programa de la línea de la línea, lo que se detiene y se detiene en el que se detiene el programa y se detiene en el que se detiene el programa y se detiene en el programa. Down* puede dejar que el programa se ejecute: - Use el paso sobre la tecla de acceso directo es F6 (ejecución de un solo paso) - Reanudar F8: indica que la depuración termina, ejecute directamente hacia abajo ** Por ejemplo, hay un punto de ruptura después del punto de interrupción actual, salte al siguiente punto de interrupción, ** si no hay un punto de ruptura detrás del punto de ruptura actual, el programa ejecuta directamente final* ... vea el código ** vea el código de la fuente del programa el programa del programa* Retorno del paso F7: regreso
3. Uso de las teclas de atajo de Myeclipse
* Código Aviso ALT /* Guía rápida Paquete Ctrl Shift O* Comentario de una sola línea Ctrl /* Eliminar comentario de línea única Ctrl /* Comentario de múltiples líneas Ctrl Shift /* Eliminar comentario de múltiples líneas Ctrl Shift /* Eliminar línea Ctrl D
4. Uso de Junit
* Prueba unitaria* El objeto de prueba es un método en una clase* Juint no forma parte de Javase, quiero usar el paquete de importación de importación ** Sin embargo, el paquete jar con Junit se trae en myEClipse* En primer lugar, en primer lugar, cuando Junit versión 3.x 4.x* Unidad de prueba, método, el método Nombre del método público name () {}* Ejecutar el método de anotación con el método de anotación, por encima del método el método ** @Test: Método que el métod @TestPublic void testAdd1 () {testJunit test01 = new testjunit (); test01.testadd (2, 3);}-Seleccione el nombre del método, haga clic con el botón derecho para ejecutar ejecutar la ejecución como --- Junit Test- Cuando aparece una barra verde, significa que la prueba de los métodos se ejecuta, cuando aparece una barra roja de Brown, significa que el método Test falla en la ejecución de la base de ejecución de la Class, hace clic en la Casea, se realiza la Class en la Clases de la Clases, hace clic en la Casea en la Clases, se realiza la Casta de Clases en la Casea, se realiza la Casta, se hace. como --- Junit Test ** @ignore: significa que este método no se prueba la unidad ** @bebore: ejecutando cada método ** @After: ejecutar después de cada método ** afirmar.AssertEquals ("prueba el valor esperado", "el valor real del método ejecutando") JDK5.0 nuevas características JDK 1.1 1.2 1.4 5.0 ** Generals, enumeración, importación estática, automaticing, mejoración, mejoras, mejoras variables, mejor parámetros, variables* Reflexión5. Introducción a los genéricos
* ¿Por qué usar genéricos? - Generalmente utilizado en conjuntos ** Por ejemplo, ahora coloque un valor de tipo de cadena en el conjunto. En este momento, después de poner este valor en el conjunto, el tipo que pierde su capacidad solo puede ser el tipo de objeto. En este momento, por ejemplo, si desea escribir este valor, es fácil tener errores de conversión de tipo. Cómo resolver este problema se puede utilizar para resolver este problema usando genéricos*Cómo usar genéricos en conjuntos - Lista establecida de uso común Conjunto de mapas de sintaxis genérica <String> Por ejemplo, la lista <string>*está escrita como un objeto en un objeto genérico, y string no puede escribir tipos de datos básicos, como int (****) ** Escribir tipos de datos básicos correspondientes a la clase byte - byteShort - shortint - shortint - INTERGERLONG - - INTERGER - - INTERGOT - FLOATFLONT - FLOATFLON -- Doublechar -- Characterboolean -- Boolean* Three implementations of using generic lists on list ArrayList linkedList Vector code: @Testpublic void testList() {List<String> list = new ArrayList<String>();list.add("aaa");list.add("bbb");list.add("ccc");//There are several ways to traverse the list colección.//ordinary para la mejora del iterador de bucle para // ordinary para bucle para (int i = 0; i <list.size (); i ++) {String s = list.get(i);System.out.println(s);}System.out.println("============================================================================== ======================================================================= ======================================================================= ===================================================================== ======================================================================= ======================================================================= ======================================================================= Estas tres diferencias * Usar código genérico en set: // genics use set en set @testpublic void testSet () {set <string> set = new Hashset <string> (); set.add ("www"); set.add ("qqq"); set.add ("zzz"); // set.add ("qqq"); // transfiere hay varias formas de ser de forma a que hay varias formas de ser to traverator treerator treerator para // Use Mejora para el recorrido para (String S2: SET) {System.out.println (S2);} System.out.println ("===================================================================================================== ==========================================================================================================================================================================. ==========================================================================================================================================================================. ====================================================================================================================================================================== ¡ = set.iterator (); while (it1.hasnext ()) {system.out.println (it1.next ());}}}* Use la estructura de mapas de genéricos en map: clave de formulario Key-valu: // usando genéricos en map @testpublic void testMap () {map <string, string> map = new Hashmap <String, string String. "111"); map.put ("bbb", "222"); map.put ("ccc", "333"); // mapa transip Hay varias formas de atravesar // 1. Obtenga todas las claves y obtenga valor a través del método de uso de la clave // 2. Obtenga la relación entre la tecla y el valor // Use el primer método // obtenga todas las teclas <cadena> sets = map. keyset (); (Tecla de cadena: sets) {// get valuestring value = map.get (key); system.out.println (clave+": "+valor);} system.out.println (" ============================================================================================================================================ =========================================================================================================== =========================================================================================================== ============================================================================================================ {// La entrada es la relación entre la clave y la cadena de valores keyV = entry.getKey (); string valuev = entry.getValue (); system.out.println (keyv+":"+valuev);}}6. Los genéricos se utilizan en métodos
* Defina una matriz para implementar el intercambio de elementos de matriz en la posición especificada* La lógica del método es la misma, pero los tipos de datos son diferentes. En este momento, use métodos genéricos* /** Use métodos genéricos para definir un tipo usando letras mayúsculas para representar t: este t representa cualquier tipo* antes de que el valor de retorno se escriba <T>* ========== Defina un tipo. Este tipo es t* Aquí puede usar este tipo t***/public static <t> void swap1 (t [] arr, int a, int b) {t temp = arr [a]; arr [a] = arr [b]; arr [b] = temp;} ** Trabajo 2: Implemente un método genérico, acepte cualquier matriz e invierta todos los elementos en el matrimonio7. Uso de genéricos en clases (comprender)
* Defina un tipo en una clase, este tipo se puede usar directamente en la clase * clase pública testdemo04 <t> {// Puede usar t tipo TAA en la clase; public void test11 (t bb) {} // Escriba un genérico definido por un método estático en la clase, y ya no puede usar el método estático público estático <a> test12 (a cc) {}}8. Introducción a la enumeración
* ¿Qué es un enum? ** Debe tomar un valor dentro de un cierto rango, y este valor solo puede ser cualquiera de los rangos. ** Escena realista: los semáforos, los semáforos, hay tres colores, pero solo uno de los tres colores puede ser brillante a la vez* use una palabra clave enum ** enum color3 {rojo, verde, amarillo;}* El método de construcción enum en enum también es privado* La operación de enume especial (comprensión) ** Existe un método de construcción en la clase de enum ** Hay un parámetro en el método de construcción, y los parámetros deben ser escritos en cada instancia de cada instancia. Reescribe este método abstracto en cada instancia del enum9. La operación de la API enumerada
** nombre (): devuelve el nombre del enum ** ordinal (): el subíndice del enum, el subíndice comienza desde 0 ** valuef (class <t> enumType, name de cadena): Obtener el objeto del enum ** Hay otros dos métodos, ambos de los cuales no están en la API, y dos métodos se generan dos métodos durante la compilación *** ValorOf (Nombre de cadena) CONVERTO los valores de Enum ***. Conversión entre objetos enum, subíndice de objetos enum y representación del nombre del objeto enum- // conoce el objeto enum, obtenga el nombre enum y el subíndice @testpublic void test1 () {// Obtenga el objeto enum color100 c100 = color100.red; // enum name string = c100.name (); // El subgrado de la enumeración int idx = = c100.ordinal (); system.out.println (nombre+""+idx);}- // Conozca el nombre de la enumeración, obtenga el objeto y el subíndice de la enumeración @TestPublic Void test2 () {String name1 = "verde"; // Obtenga el objeto color100 c1 = color100.valueOf (name1); // enum int idx1 = c1.ordinal (); System.out.println (IDX1);}- // Conozca el subíndice de la enumeración, obtenga el objeto y el nombre de la enumeración @testpublic void test3 () {int idx2 = 2; // Obtenga el objeto de enumeración Color100 [] cs = color100.values (); // get the Object Color100 de acuerdo con el subscript C12 = CS [IDX2]; // Obtenga el nombre de nombre de enumeración name = c12.name (); system.out.println (nombre);}10. Importación estática (comprender)
* Puede usar directamente el método de importación estática en el código para importar métodos o constantes estáticos* Importar estática xx.xx.xxx* Importar java.lang.system.utstem.out; importar java.util.arrays.sort; ** Por ejemplo, ahora implementa una calculadora en la clase de matemáticas en la clase de matemáticas
11. Desempacado y ensamblaje automático
* Cuadro ** Convierta el tipo de datos básico en la clase de empaque* Unboxing ** Convierta la clase de empaque al tipo de datos básico ** // Autobox Integer i = 10; // Autobox int m = i; ** Cómo boxear y unbox en jdk1.4 - // autobox en jdk1.4 public void test1 () {// box íteue m = new integer (10); // Unbox int a = m.intValue ();} ** JDK es compatible con retroceso, por ejemplo, el código escrito en JDK1.4 también puede ejecutarse en 5.0 ** Ejercicio: Compatible con retroceso == El resultado de la ejecución es llamar a DosomiMing (doble m) == Primero, este método debe llamarse en JDK1.4. Si se llama al siguiente método, se requiere conversión de tipo, pero JDK1.4 no puede realizar un Unboxing automático == Dado que JDK es compatible con retroceso, si este método se llama en JDK1.4, este método aún se llamará en JDK5.0 public static void main (String [] arguments) {Dosómetros (10);} Public Void void dosomting (doble m) {System.out.println ("Double ...");} public static void dosomething (Integer a) {System.out.println ("Integer ......");} ** Recuerde: la clase de envoltorio correspondiente a los ocho tipos de datos básicos* int ---- Integer* Carácter --- Carácter12. Mejorado para bucle (*****)
* Sintaxis para (el valor atravesado: el conjunto que se atraviesa) {}- for (string s: list) {system.out.println (s);}* Escenarios de uso: array; Los conjuntos que implementan la interfaz Itererable pueden usar el bucle mejorado* Usar el bucle mejorado para atravesar el conjunto de lista en el conjunto de interfaz iterator se implementa, por lo que se puede usar el bucle mejorado para el bucle, y la interfaz iteradora no se puede implementar, por lo que no se puede usar el bucle mejorado para el bucle. La interfaz Iterator no se puede implementar, por lo que no se puede utilizar el bucle mejorado para el bucle. Aparece el propósito del bucle mejorado: para reemplazar el iterador ** la capa subyacente de la mejora es implementada por el iterador13. Suplemento de contenido
(1) Borrado genérico* En primer lugar, los genéricos solo aparecen en la etapa del código fuente. Cuando se compila, los genéricos ya no existen (2) ejercicio: implementen un método genérico, acepte matrices de cualquier tipo e invierta todos los códigos de elementos en la matriz publicitaria publicitaria <t> void reversa (t [] arr1) {/** Idea básica: intercambie el primer elemento con el último elemento e intercambie el segundo elemento con el elemento penúltimo. . . . *Longitud de intercambio/2**/// transweep la matriz para (int i = 0; i <arr1.length/2; i ++) {/*int temp = arr1 [0]; arr1 [0] = arr1 [arr1.length-1];*/t temp = arr1 [i]; arr1 [i] = arr1 [arr1.length-i-1]; arr1 [arr1. temp;}}14. Parámetros variables
* ¿En qué escenario se puede aplicar los parámetros variables: ** Implemente la adición de dos números e implementa la adición de tres números y cuatro números; si se implementan múltiples métodos, la lógica en estos métodos es básicamente la misma. La única diferencia es el número de parámetros aprobados. Puede usar parámetros variables* Método de definición de parámetros variables Tipo de datos ... El nombre de la matriz* se entiende como una matriz, que almacena el código de parámetros pasados está en público void void add1 (int ... nums) {// nums se entiende como una matriz, que almacena los parámetros pasados // system.println (nums.length); int sum = 0; // tranquily storks (inter (/ system.out.println (nums.length); int sum = 0; // tranque i=0;i<nums.length;i++) {sum += nums[i];}System.out.println(sum);}* Note (1) Variable parameters need to be written in the parameter list of the method, and cannot be defined separately (2) There can only be one variable parameter in the parameter list of the method (3) Variable parameters in the parameter list of the method must be placed at the end of the parameter - add1 (int a, int ... nums)15. El principio de reflexión (************)
* Applied in some codes with higher versatility* Most of the frameworks learned later are implemented using reflection* In framework development, they are developed based on configuration file** In configuration file, all contents in the class can be obtained through reflection, and a method in the class can be used to execute * All contents in the class: attributes, constructors without parameters, constructors with parameters, ordinary methods* The principle of drawing and analyzing reflection* Primero, debe guardar el archivo Java en el disco duro local.java* compilar el archivo Java y convertirse en el archivo .class* Usar JVM para cargar el archivo de clase en la memoria a través de la carga de clase* Todo es un objeto, y el archivo de clase está representado por clase de clase en memoria* cuando usa reflexión, primero debe obtener la clase de clase. Después de obtener esta clase, puede obtener todos los contenidos en el archivo de clase, incluidos los constructores de atributos, los métodos ordinarios* se presentan los atributos* Constructor* Constructor* El método normal pasa a través de un método de clase
16. Use el método de construcción sin parámetros en la clase de operación de reflexión (** escribirá **)
* Primero obtenga la clase de clase - // Obtenga la clase Class Class Class Clazz1 = Person.Class; Class Clazz2 = New Person (). GetClass (); Class Clazz3 = Class.Forname ("Cn.itcast.test09.person");* Por ejemplo: para instanciar una clase, puede nuevo, pero no utiliza nuevos, ¿cómo obtenerlo? - // get classClass c3 = class.forname ("cn.itcast.test09.person"); // Obtenga la instancia de persona de clase persona p = (persona) c3.newinstance ();* código // operar el constructor sin parámetros @testpublic void test1 () Excepción {// get classclass c3 = Class.forname ("cn.itcast.test09.person"); // Obtenga la instancia de persona de clase persona p = (persona) c3.newinstance (); // establece el valor p.setName ("zhangsan"); system.out.println (p.getName ());}17. Use la operación de reflexión para tener parámetros método de construcción (** escribirá **)
//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 clase. Cs = c1.getConstructor (string.class, string.class); // Establezca el valor a través del constructor con los parámetros // Cree la instancia de la persona a través del constructor con parámetros persona p1 = (persona) cs.newinstance ("lisi", "100"); system.out.println (p1.getid ()+"+p1.getName ());});}18. Use propiedades de operación de reflexión (** escribirá **)
* //Operate name attribute @Testpublic void test3() {try {//Get Class Class c2 = Class.forName("cn.itcast.test09.Person");//Get name attribute//c2.getDeclaredFields();//Indicate to get all attributes//Get the instance of Person class Person p11 = (Person) c2.newInstance();//Get the attribute through this Método, el parámetro es el nombre del campo de atributo f1 = c2.getDeclaredfield ("nombre"); // La operación es una propiedad privada, y la operación no está permitida. Debe establecer la propiedad privada setAccessible (true), que puede operar la propiedad privada f1.setAccessible (true); // Establecer el método de conjunto de valor de nombre, dos parámetros: la primera instancia de parámetro y el segundo parámetro es el valor establecido f1.set (p11, "wangwu"); // equivalente a p.name = "wangwu"; system.out.println (f1.get (p11)); // equivalente a p.name} capt (excepción e) {e.printstacktrace ();}}19. Use métodos de operación genérica (** puede escribir **)
* Use la clase de método para representar métodos ordinarios* Código // Operar métodos ordinarios, como operar setname@testPublic void test4 () lanza la excepción {// get class c4 = class.forname ("cn.itcast.test09.person"); // Obtener una persona de instancia P4 = (persona) c4.newinStance (); // método // c4.getDeclaredMethods (); // Obtener todos los métodos ordinarios // transferir dos parámetros: el primer parámetro, el nombre del método; El segundo parámetro, el tipo de parámetro en el método del método m1 = c4.getDeclaredMethod ("setname", string.class); // deja que el método setName ejecute, ejecute el valor establecer // use invoke (p4, "niuqi"); pasar dos parámetros: el primer parámetro, instancia de persona; El segundo parámetro, establecer valor // Después de ejecutar el método de invocación, es equivalente a ejecutar el método setname, y al mismo tiempo, se establece un valor para ser niuqim1.invoke (p4, "niuqi"); System.out.println (p4.getName ());}* // El método privado de la operación debe establecerse en True* //m1.SetAccessible(true);* Cuando el método de operación es un método estático, porque el método estático se llama nombre de clase. Nombre del método, no se necesita ninguna instancia de la clase* Al usar Reflexión para operar el método estático, no se necesita ninguna instancia* En el primer parámetro del método de invocación, escriba null- m1.invoke (null, "niuqi");Lo anterior es la edición mejorada básica de Java del tutorial básico de Java Web presentado por el editor. Espero que sea útil para todos. Si tiene alguna pregunta, déjame un mensaje y el editor responderá a todos a tiempo. ¡Muchas gracias por su apoyo al sitio web de Wulin.com!