¿Cuántos capítulos tiene Pensamientos de programación JAVA?
1*** Capítulo 17
¡Te recomiendo encarecidamente que compres este libro! Aunque hay muchos documentos electrónicos, se pueden encontrar en todas partes en Baidu, ¡pero no son muy convenientes! ¡Leer este libro realmente me hizo cambiar de opinión! !
Capítulo 1 Introducción a los objetos
1.1 Progreso de la abstracción
1.2 Interfaz de objetos
1.3 Plan de implementación oculto
1.4 Reutilización de soluciones
1.5 Herencia: Reutilización de interfaces
1.5.1 Mejora de clases básicas
1.5.2 Equivalencia y similitud
1.6 Uso intercambiable de objetos polimórficos
1.6.1 Vinculación dinámica
1.6.2 Clases base abstractas e interfaces
1.7 Tiempo de creación y existencia de objetos
1.7.1 Colecciones y herederos
1.7.2 Estructura de raíz única
1.7.3 Bibliotecas de colecciones y colecciones fáciles de usar
1.7 .4 Dilema durante la limpieza: ¿Quién es responsable de la limpieza?
1.8 Control de errores: resolución de errores
1.9 Multihilo
1.10 Persistencia
1.11 Java e Internet
1.11.1 ¿Qué es la Web?
1.11.2 Programación del lado del cliente
1.11.3 Programación del lado del servidor
1.11.4 Un dominio independiente: las aplicaciones
1.12 Análisis y Diseño
1.12.1 No te pierdas
1.12.2 Fase 0: Elabora un plan
1.12.3 Fase 1: ¿Qué hacer?
1.12.4 Fase 2: ¿Empezar a construir?
1.12.5 Fase 3: Creación formal
1.12.6 Fase 4: Revisión
1.12.7 Devolución del plan
1.13 ¿Java o C?
Capítulo 2 Todo es un objeto
2.1 Usar identificadores para manipular objetos
2.2 Todos los objetos deben ser creados
2.2.1 Guardar en Donde
2.2.2 Caso especial: tipo principal
2.2.3 Matrices en Java
2.3 Nunca borrar objetos
2.3. 1 Alcance
2.3.2 Alcance del objeto
2.4 Nuevo tipo de datos: clase
2.4.1 Campos y métodos
2.5 Métodos , argumentos y valores de retorno
2.5.1 Lista de argumentos
2.6 Creación de programas Java
2.6.1 Visibilidad de nombres
p>
2.6.2 Uso de otros componentes
2.6.3 Palabra clave estática
2.7 Nuestro primer programa Java
2.8 Comentarios e incorporación de documentación
2.8.1 Documento de comentarios
2.8.2 Sintaxis específica
2.8.3 Incrustar HTML
2.8.4 @see: Referencia a otras clases
2.8.5 Marca de documento de clase
2.8.6 Marca de documento variable
2.8.7 Marca de documento de método
2.8 .8 Ejemplo de documento
2.9 Estilo de codificación
2.10 Resumen
2.11 Ejercicio
Capítulo 3 Control del flujo del programa
3.1 Uso de operadores Java
3.1.1 Prioridad
3.1.2 Asignación
3.1.3 Operadores aritméticos
3.1.4
Incremento y decremento automático
3.1.5 Operadores relacionales
3.1.6 Operadores lógicos
3.1.7 Operadores bit a bit
3.1.8 Operador de turno
3.1.9 Operador ternario if-else
3.1.10 Operador de coma
3.1.11 Operadores de cadena
3.1. 12 Reglas generales de funcionamiento para operadores
3.1.13 Operadores de forma
3.1.14 Java no tiene "sizeof"
3.1.15 Revisar el orden de cálculo
3.1.16 Resumen de operadores
3.2 Control de ejecución
3.2.1 Verdadero y falso
3.2.2 if-else
3.2.3 Repetir
3.2.4 hacer-mientras
3.2.5 para
3.2 .6 Interrumpir y continuar
3.2.7 Interruptor
3.3 Resumen
3.4 Ejercicio
Capítulo 4 Inicialización y autorización
4.1 Inicialización garantizada por parte del constructor
4.2 Sobrecarga de métodos
4.2.1 Distinguir métodos sobrecargados
4.2.2 Sobrecarga de tipos principales
4.2.3 Valor de retorno sobrecarga
4.2.4 Constructor predeterminado
4.2.5 esta palabra clave
4.3 Limpieza: acabado y recolección de basura
4.3.1 Qué es el propósito de finalizar()
4.3.2 Se debe realizar la limpieza
4.4 Inicialización de miembros
4.4.1 Inicialización requerida
4.4.2 Inicialización del constructor
4.5 Inicialización de matrices
4.5.1 Matriz multidimensional
4.6 Resumen
4.7 Ejercicios
Capítulo 5 Proceso de implementación oculto
5.1 Paquete: Unidad de biblioteca
5.1.1 Crear un nombre de paquete único
5.1.2 Personalizar bibliotecas de herramientas
5.1.3 Usar importaciones para cambiar el comportamiento
5.1.4 Desactivación de paquetes
5.2 Indicadores de acceso a Java
5.2.1 "Amigable"
5.2.2 público: acceso a la interfaz
5.2.3 privado: no accesible
5.2.4 protegido: "Uno amigable"
5.3 Interfaz e implementación
5.4 Acceso a clases
5.5 Resumen
5.6 Ejercicio
Capítulo 6 Regeneración de clases
6.1 Sintaxis de Síntesis
6.2 Sintaxis de Herencia
6.2.1 Inicializando Clases Básicas
6.3 Combinación de composición y herencia
6.3 .1 Garantizar la limpieza correcta
6.3.2 Ocultar nombres
6.4 Elegir composición o herencia
6.5 protegido
6.6 Desarrollo incremental
6.7 Modelado ascendente
6.7.1 ¿Qué es el "modelado ascendente"?
6.8 palabra clave final
6.8.1 datos finales
6.8.2 método final
6.8.3 clase final
6.8.4 Notas finales
6.9 Inicialización y carga de clases
6.9.1 Inicialización de herencia
6.10 Resumen
6.1
1 Ejercicio
Capítulo 7 Polimorfismo
7.1 Backcasting
7.1.1 Por qué Backcasting
7.2 Comprensión en profundidad
7.2.1 Vinculación de llamadas a métodos
7.2.2 Producir un comportamiento correcto
7.2.3 Extensibilidad
7.3 Cobertura y sobrecarga
7.4 Clases y métodos abstractos
7.5 Interfaces
7.5.1 "Herencia múltiple" de Java
7.5.2 Mediante herencia Interfaz extendida
7.5.3 Agrupación constante
7.5.4 Inicializando campos en la interfaz
7.6 Clase interna
7.6.1 Clases internas y upcasting
7.6.2 Métodos y clases internas en el alcance
7.6.3 Vinculación a clases externas
7.6.4 clases internas estáticas
7.6.5 Referencia a objetos de clases externas
7.6.6 Heredar de clases internas
7.6.7 ¿Se pueden anular las clases internas?
7.6.8 Identificador de clase interna
7.6.9 Por qué usar clases internas: marco de control
7.7 Constructores y polimorfismo
7.7. 1 La secuencia de llamada de los constructores
7.7.2 Herencia y finalize()
7.7.3 Comportamiento de los métodos polimórficos dentro de los constructores
7.8 Diseño mediante herencia
p>7.8.1 Herencia pura y extensión
7.8.2 Downcasting e identificación del tipo de tiempo de ejecución
7.9 Resumen
7.10 Ejercicios
Capítulo 8 Acomodación de objetos
8.1 Matrices
8.1.1 Matrices y objetos de primera clase
8.1.2 Devolución de matriz
8.2 Colección
8.2.1 Desventaja: tipo desconocido
8.3 Enumerador (iterador)
8.4 Tipos de conjuntos
8.4. 1 Vector
8.4.2 BitSet
8.4.3 Pila
8.4.4 Hashtable
8.4.5 Otra discusión sobre enumeradores
8.5 Ordenar
8.6 Biblioteca de colecciones generales
8.7 Nueva colección
8.7.1 Usar colecciones
8.7. 2 Usar listas
8.7.3 Usar conjuntos
8.7.4 Usar mapas
8.7.5 Decidir la implementación
8.7.6 Operaciones no admitidas
8.7.7 Ordenar y buscar
8.7.8 Utilidades
8.8 Resumen
8.9 Ejercicios
Capítulo 9 Control de errores e infracciones
9.1 Infracciones básicas
9.1.1 Variables propias de la infracción
9.2 Captura de errores
9.2.1 try block
9.2.2 Controlador de errores
9.2.3 Especificación de errores
9.2.4 Detectar todas las excepciones
9.2.5 Re -lanzamiento de excepciones
9.3 Excepciones estándar de Java
9.3.1 RuntimeException Casos especiales
9.4 Crea tus propias excepciones
9.5 Limitaciones de las infracciones
9.6 Limpiar con finalmente
9.6.1 Usar finalmente Qué
9.
6.2 Desventajas: Faltan excepciones
9.7 Constructores
9.8 Coincidencia de infracciones
9.8.1 Criterios de infracción
9.9 Resumen
9.10 Ejercicio
Capítulo 10 Sistema Java IO
10.1 Entrada y salida
10.1.1 Tipo de flujo de entrada
10.1.2 Tipo de OutputStream
10.2 Agregar propiedades e interfaces útiles
10.2.1 Leer datos de InputStream a través de FilterInputStream
10.2.2 A través de FilterOutputStream Escribir datos en OutputStream
10.3 Sus propios defectos: RandomAccessFile
10.4 Clase de archivo
10.4.1 Listador de directorios
10.4 .2 Verificar y crear directorios
10.5 Aplicaciones típicas de flujos IO
10.5.1 Flujos de entrada
10.5.2 Flujos de salida
10.5.3 Procesamiento rápido de archivos
10.5.4 Lectura de datos de entrada estándar
10.5.5 Flujo de datos de canalización
10.6 StreamTokenizer
10.6.1 StringTokenizer
10.7 Flujo IO de Java 1.1
10.7.1 Inicio y recepción de datos
10.7.2 Modificación del comportamiento del flujo de datos
10.7.3 Clases sin cambios
10.7.4 Un ejemplo
10.7.5 Redirección de IO estándar
10.8 Compresión
p>
10.8.1 Simple compresión usando GZIP
10.8.2 Guardado de múltiples archivos usando Zip
10.8.3 Utilidad de archivo Java (jar)
10.9 Concatenación de objetos
10.9.1 Encontrar clases
10.9.2 Control de serialización
10.9.3 Usar "persistencia"
10.10 Resumen
10.11 Ejercicios
Capítulo 11 Identificación del tipo de tiempo de ejecución
11.1 La necesidad de RTTI
11.1 1 objeto de clase
11.1.2 Verificar antes de realizar la conversión.
11.2 Sintaxis RTTI
11.3 Reflexión: información de clase en tiempo de ejecución
11.3. 1 Un extractor de métodos de clase
11.4 Resumen
11.5 Ejercicios
Capítulo 12 Pasar y devolver objetos
12.1 Pasar identificadores
p>12.1.1 Problema de alias
12.2 Hacer una copia local
12.2.1 Pasar por valor
12.2.2 Clonar objetos
12.2.3 Hacer una clase capaz de clonar
12.2.4 Clonación exitosa
12.2.5 Efecto de Object.clone()
12.2.6 Clonar objetos sintéticos
12.2.7 Profunda copiar usando Vector
12.2.8 Copia profunda mediante serialización
12.2.9 Agrandar los clones Profundidad de
12.2.10 ¿Por qué existe este diseño extraño? p>
12.3 Control de clones
12.3.1 Generador de copias
>
12.4 Clases de solo lectura
12.4.1 Crear clases de solo lectura
12.4.2 Desventajas de "sin cambios"
12.4.3 Sin cambios palabras String
12.4.4 Clases String y StringBuffer
12.4.5 Características especiales de las cadenas
12.5 Resumen
12.6 Ejercicio p>
Capítulo 13 Creación de Windows y programas
13.1 ¿Por qué utilizar AWT?
13.2 Porciones de programa básicas
13.2.1 Pruebas de porciones de programa
13.2.2 Un ejemplo más gráfico
13.2. del método framework
13.3 Crear botones
13.4 Capturar eventos
13.5 Campo de texto
13.6 Área de texto
13.7 Etiqueta
13.8 Casilla de verificación
13.9 Botón de opción
13.10 Lista desplegable
13.11 Cuadro de lista
13.11.1 handleEvent()
13.12 Control de diseño
13.12.1 FlowLayout
13.12.2 BorderLayout
13.12 .3 GridLayout
13.12.4 CardLayout
13.12.5 GridBagLayout
13.13 Alternativas de acción
13.14 Limitaciones del programa
13.14.1 Ventajas de los programas
13.15 Aplicaciones en ventana
13.15.1 Menú
13.15.2 Cuadro de diálogo
13.16 Nuevo AWT
13.16.1 Nuevo modelo de eventos
13.16.2 Tipos de eventos y receptores
13.16.3 Uso de Java 1.1 AWT Creación de ventanas y programas
13.16.4 Revisando ejemplos anteriores
13.16.5 Eventos vinculantes dinámicamente
13.16.6 Distinguir la lógica empresarial de la lógica de UI Abierto
13.16.7 Recomendado método de codificación
13.17 Java 1.1 UI API
13.17.1 Color de escritorio
13.17.2 Imprimir
13.17.3 Portapapeles
13.18 Programación Visual y Beans
13.18.1 Qué son los Beans
13.18.2 Extracción con Introspector BeanInfo
13.18.3 Una versión más compleja Bean
13.18.4 Encapsulación de Beans
13.18.5 Soporte de Beans más complejo
13.18.6 Más conocimiento sobre Beans
13.19 Obtención comenzó con Swing
13.19.1 ¿Cuáles son las ventajas de Swing?
13.19.2 Conversión conveniente
13.19.3 Marcos de visualización
13.19.4 Información sobre herramientas
13.19.5 Bordes
13.19.6 Botones
13.19 .7 Grupo de botones
13.19.8 Icono
13.19.9 Menú
13.19.10 Menú emergente
13.19.11 Cuadros de lista y cuadros combinados
13
.19.12 Barra deslizante y indicador de progreso
13.19.13 Árbol
13.19.14 Tabla
13.19.15 Cuadro de diálogo Tarjeta
13.19 .16 Cuadro de mensaje de Swing
13.19.17 Más conocimientos sobre Swing
13.20 Resumen
13.21 Ejercicio
Capítulo 14 Multihilo
14.1 Interfaz de usuario responsiva
14.1.1 Herencia de subprocesos
14.1.2 Multiproceso para interfaz de usuario
14.1.3 Utilice la clase principal para fusionar hilos
14.1.4 Crear múltiples hilos
14.1.5 Hilos Daemon
14.2 ***Disfrutar de recursos limitados
14.2. 1 Métodos incorrectos de acceso a recursos
14.2.2 Cómo compartir recursos en Java
14.2.3 Revisión de Java Beans
14.3 Bloqueo
14.3.1 Por qué se bloquea
14.3.2 Punto muerto
14.4 Prioridad
14.4.1 Grupos de subprocesos
14.5 Revisión de runnables
14.5.1 Demasiados subprocesos
14.6 Resumen
14.7 Ejercicios
Capítulo 15 Programación de redes
15.1 Identificación de la máquina
15.1.1 Servidor y cliente
15.1.2 Puerto: un lugar único en la máquina
15.2 Sockets
15.2.1 Un programa cliente y servidor simple
15.3 Sirviendo a múltiples clientes
15.4 Datagrama
p>15.5 Una aplicación web
15.5.1 Aplicación de servidor
15.5.2 Pieza del programa NameSender
15.5.3 15.5.3 Cosas a tener en cuenta Preguntas
15.6 Comunicación entre Java y CGI
15.6.1 Codificación de datos CGI
15.6.2 Porciones de programa
15.6.3 Programa CGI escrito en C
15.6.4 El concepto de POST
15.7 Conexión a la base de datos usando JDBC
15.7.1 Obtener ejemplos de aprendizaje
15.7.2 Encontrar la versión GUI del programa
15.7.3 ¿Por qué es complicada la API JDBC?
15.8 Método remoto
15.8.1 Concepto de interfaz remota
15.8.2 Implementación de control remoto interfaz
15.8.3 Crear raíces y tallos
15.8.4 Usar objetos remotos
15.8.5 Alternativas RMI
15.9 Resumen
15.10 Ejercicios
Capítulo 16 Paradigmas de diseño
16.1 El concepto de paradigmas
16.1.1 Mónada
16.1 .2 Clasificación de paradigmas
16.2 Paradigma del observador
16.3 Simulación de contenedor de recolección de basura
16.4 Diseño mejorado
16.4.1 "Hacer más objetos "
16.4.2 Un paradigma para la creación de prototipos
16.5 Aplicación de la abstracción
16.6 Despacho múltiple
16.6.1 Implementación de doble despacho
16.7 Paradigma de acceso
16.8 ¿Es RTTI perjudicial?
<p>16.9 Resumen
16.10 Ejercicios
Proyecto del Capítulo 17
17.1 Procesamiento de textos
17.1.1 Extracción de lista de códigos
17.1.2 Comprobación de estilos de casos
17.2 Buscador de métodos
17.3 Teoría de la complejidad
17.4 Resumen
17.5 Práctica