Mostrando entradas con la etiqueta por: Francisco Vargas. Mostrar todas las entradas
miércoles, 6 de mayo de 2020
JS: Scope en Javascript
Francisco
18:58
bloque
,
franvarvil
,
informática
,
java
,
javascript
,
js
,
por: Francisco Vargas
,
programación
,
propiedad
,
scope
,
script
,
util
No hay comentarios
:
Introducción
El scope es el ámbito donde una variable o sentencias pueden ser accedidas,
recordemos que javascript cuenta con un global scope donde se declaran
elementos comunes y el local scope que es dentro cualquier bloque
javascript.
Desarrollo
En javascript cualquier bloque crea un local scope, incluye estructuras de
control y métodos.
Para entenderlo vamos a realizar unos ejemplos.
'use strict'
var variable = 1
function local(){ // Acá un bloque javascript
var variable = 5; // Se declara una variable local
console.log(variable) // Se imprime la variable local
}
local() // Se llama a la función con una variable local
console.log(variable) // se imprime la variable global
//Output: 5
// 1
Sin embargo si no crea la variable localmente y solo se declara el nombre
utilizará la variable global, como en el siguiente ejemplo.
'use strict'
var variable = 1
function local(){ // Acá un bloque javascript
variable = 5; // NO se declara la variable
console.log(variable) // Se imprime la variable
}
local() // Se llama a la función que no declara la variable local
console.log(variable) // se imprime la variable global
//Output: 5
// 5
Esta misma lógica aplica para bloques if/else, buqles for, while entre otros.
Conclusión
Es importante conocer el comportamiento de los scope de javascript al programar, más aún si se trabaja con múltiples archivos independientes con variables globales. Con el uso de la sentencia use strinct, no evitaremos muchos comportamientos de javascript y nos alertará de muchas situaciones que puede pasar por alto.
domingo, 3 de mayo de 2020
VB.Net: Sentencia Using y With
Francisco
11:48
action
,
basic
,
basico
,
clases
,
class
,
collector
,
franvarvil
,
función
,
garbage
,
garbage collector
,
informática
,
internet
,
por: Francisco Vargas
,
sentencias
,
using
,
vb.net
,
visual
,
visual basic
,
with
No hay comentarios
:
Introducción
La sentencia using es muy utilizada al momento de desarrollar aplicaciones en VB .Net, su importancia radica en que libera los recursos al finalizar el bloque, es decir, cuando se ejecute el Garbarge Collector, los espacios en memoria estarán marcados para que este los libere y deje accesibles.
Desarrollo
Para aprender a utilizarlo, vamos a realizar un pequeño ejemplo con una clase persona, el único detalle es que, para una clase ser usada dentro de la sentencia Using y With esta debe implementar la Interfaz IDisposable, tal como se muestra en el siguiente código.
Una vez tenemos nuestra clase, realizaremos una instancia a esta a través de la sentencia Using de la siguiente forma:
Como vemos al implementar la interfaz podremos utilizar la sentencia Using, adicionalmente al utilizar la sentencia With podremos facilitar el uso de nuestro objeto lPerson, es decir, todo lo que esté dentro del bloque With pertence al objeto Person, es por esto que no es necesario establecer lPersona.Name, basta con .Name.
Esto aplica para las demás propiedades o métodos y al finalizar el proceso se liberará el recurso lPerson, por lo cual no podrá se accedido nuevamente.
Esto es útil cuando se cargar archivos o cuando realizamos operaciones sobre base de datos, para liberar los recursos una vez que terminamos de procesar.
Conclusión
La sentencia Using ayuda a liberar recursos de una forma más eficiente, mientra que la sentencia With nos ayudará a manejar características de un objeto de forma sencilla.
La sentencia using es muy utilizada al momento de desarrollar aplicaciones en VB .Net, su importancia radica en que libera los recursos al finalizar el bloque, es decir, cuando se ejecute el Garbarge Collector, los espacios en memoria estarán marcados para que este los libere y deje accesibles.
Desarrollo
Para aprender a utilizarlo, vamos a realizar un pequeño ejemplo con una clase persona, el único detalle es que, para una clase ser usada dentro de la sentencia Using y With esta debe implementar la Interfaz IDisposable, tal como se muestra en el siguiente código.
Public Class Person
Implements IDisposable ' Se implementa la interfaz
Public Property Name As String
Public Property LastName As String
Public Sub Dispose() Implements IDisposable.Dispose
Me.Finalize() ' Se da funcionalidad al método implementado
End Sub
Public Function GetFullName() As String
Return Me.Name & " " & Me.LastName
End Function
End Class
Una vez tenemos nuestra clase, realizaremos una instancia a esta a través de la sentencia Using de la siguiente forma:
Using lPerson As New Person
With lPerson
.Name = "Using"
.LastName = "Statement"
Console.WriteLine(.GetFullName)
End With
End Using
Como vemos al implementar la interfaz podremos utilizar la sentencia Using, adicionalmente al utilizar la sentencia With podremos facilitar el uso de nuestro objeto lPerson, es decir, todo lo que esté dentro del bloque With pertence al objeto Person, es por esto que no es necesario establecer lPersona.Name, basta con .Name.
Esto aplica para las demás propiedades o métodos y al finalizar el proceso se liberará el recurso lPerson, por lo cual no podrá se accedido nuevamente.
Esto es útil cuando se cargar archivos o cuando realizamos operaciones sobre base de datos, para liberar los recursos una vez que terminamos de procesar.
Conclusión
La sentencia Using ayuda a liberar recursos de una forma más eficiente, mientra que la sentencia With nos ayudará a manejar características de un objeto de forma sencilla.
sábado, 2 de mayo de 2020
VB.Net: Entendiendo los punteros
Francisco
12:41
action
,
basic
,
basico
,
clases
,
class
,
franvarvil
,
función
,
informática
,
método
,
por: Francisco Vargas
,
programación
,
tecnologías de información
,
vb.net
,
visual
,
visual basic
No hay comentarios
:
Introducción
En muchas ocaciones tenemos dudas cuando trabajamos con punteros pero, hay un pista que nos ayudará a identificar rápidadmente si el valor se hace por referencia o por valor.
Todos los tipos primitivos (enteros, char, double, etc), son automáticamente por valor, mientras que los objetos complejos (objetos de clases) son por referencia.
Desarrollo
Para ejemplificar esto crearemos el enumerable Genero y la Clase persona:
Ahora crearemos una función que cree dos objetos persona, uno masculino y uno femenino, de la siguiente forma.
Finalmente nuestra salida es:
Conclusión
Siempre es importante ver el comportamiento de los objetos que utilicemos y controlarlos de la forma en que queremos para evitar posibles perdidas de integridad en la información de los objetos durante la ejecución de nuestra aplicación.
En muchas ocaciones tenemos dudas cuando trabajamos con punteros pero, hay un pista que nos ayudará a identificar rápidadmente si el valor se hace por referencia o por valor.
Todos los tipos primitivos (enteros, char, double, etc), son automáticamente por valor, mientras que los objetos complejos (objetos de clases) son por referencia.
Desarrollo
Para ejemplificar esto crearemos el enumerable Genero y la Clase persona:
Public Enum Genero
Femenino = 1
Masculino = 0
End Enum
Public Class Person
Public Property Name As String
Public Property LastName As String
End Class
Ahora crearemos una función que cree dos objetos persona, uno masculino y uno femenino, de la siguiente forma.
Sub Puntero()
Dim persona1 = New Persona(Genero.Femenino)
Dim persona2 = New Persona(Genero.Masculino)
persona1.asignaEdad(persona1, 32)
persona2 = persona1
persona2.asignaEdad(persona2, 25)
Console.WriteLine($"{persona1.Genero},{persona1.Edad},{persona2.Genero},{persona2.Edad}")
End Sub
Como vemos se crea la persona1 y la persona2 con se les asigna espacios en memoria distintos. Luego se le asigna la edad de 32 a la persona1. Y tenemos la parte importante, igualamos la persona2 a la persona1, es decir ahora ambos objetos persona direccionan al mismo espacio en memoria, por lo que al cambiar la edad de la persona2 a 25, ambos, persona1 y persona2 al apuntar al mismo espacio en memoria se ven modificadados.Finalmente nuestra salida es:
Console.WriteLine($"{persona1.Genero},{persona1.Edad},{persona2.Genero},{persona2.Edad}")
'Output: 1,25,1,25
Conclusión
Siempre es importante ver el comportamiento de los objetos que utilicemos y controlarlos de la forma en que queremos para evitar posibles perdidas de integridad en la información de los objetos durante la ejecución de nuestra aplicación.
sábado, 9 de noviembre de 2019
Excel: Macro: Cambiar color de texto entre paréntesis
Francisco
12:09
cambio
,
change
,
color
,
excel
,
informática
,
macro
,
microsoft
,
parentesis
,
por: Francisco Vargas
,
util
No hay comentarios
:
Introducción
Este es un pequeño macro que es de gran utilidad para resaltar texto entre paréntesis, por ejemplo, en cualquier lugar del documento en el que se esté trabajando.
Desarollo
Este macro cambia de color el texto dinámicamente según la configuración que puede realizar el usuario en una de sus hojas.
En la imagen anterior podemos ver que se han configurado cuatro tipos de caractéres para que al escribir un texto entre paréstesis este cambia al color seleccionado en las celdas de color.
Esto resulta muy útil cuando es importante estar resaltando diferentes tipos de texto o para hacer correcciones y que estas llamen la atención rápidamente.
Los cambios Row Begin y Row End sirven para indicar las filas de inicio y fin respectivamente, es decir, el macro tomará el rango A2:B5 como el conjunto evaluador y cambiará los colores según corresponda.
La imagen anterior sería el resultado final según la configuración de la imagen uno, si se desean añadir más tipos de evaluaciones por ejemplo en A6:B6, se deben modificar el valor de RowEnd para que considere esta nueva evaluación.
El macro responble de está gran herramienta para resaltar texto entre paréstesis en Excel o en cualquier otro caractér es el siguiente, y está ubicando en ThisWorkbook en el visor de Visual Basic de Excel.
Private Sub Workbook_SheetChange(ByVal Sh As Object, ByVal Target As Range)
On Error GoTo Oops
' Declare Dim
Dim y As Integer
Dim esY As Integer
' Dim for chars
Dim lBegin As String
Dim lEnd As String
' Application config
Application.ScreenUpdating = False
Application.DisplayAlerts = False
'Dinamyc adding chars
For q = CInt(ActiveWorkbook.Sheets("Config").Range("G2").Text) To CInt(ActiveWorkbook.Sheets("Config").Range("H2").Text)
'Get chars
lBegin = ActiveWorkbook.Sheets("Config").Range("A" & q).Text
lEnd = ActiveWorkbook.Sheets("Config").Range("B" & q).Text
'Reset Dim
y = 0
esY = 0
'Target is the current selection
For x = 1 To Len(Target)
'Remove Text Bold
With Target.Characters(k, 1).Font
.Bold = False
End With
' Search the first symbol
If (Mid(Target.Text, x, 1) = lBegin And esY = 0) Then
y = x
esY = 1
' Search end symbol
MsgBox lBegin & x
Else
If (Mid(Target.Text, x, 1) = lEnd And esY = 1) Then
MsgBox y & lEnd & x
For k = y To x
' Paint text with cell color
With Target.Characters(k, 1).Font
.Color = ActiveWorkbook.Sheets("Config").Range("C" & q).Characters.Font.Color
.Bold = True
End With
Next
esY = 0
End If
End If
Next
Next
' Do not show error messages
Oops:
Resume Next
End Sub
ConslusiónEspero que este macro sea de gran ayuda para ustedes y que puedan sacarle provecho. En el siguiente enlace puede descargar el archivo completo.
lunes, 11 de marzo de 2019
Internet, derecho a la información y propiedad intelectual.
Francisco
22:20
derecho
,
derecho a la información
,
derechos
,
información
,
informática
,
intelectual
,
internet
,
moral
,
por: Francisco Vargas
,
propiedad
,
propiedad intelectual
,
TIC
No hay comentarios
:
Muchas veces se escuchan temas y
noticias sobre la propiedad intelectual, asegurando que en el internet todo es
de todos, que todo es de la comunidad y que se pueden utilizar los recursos y
documento desarrollados por otros autores o investigadores indiscriminadamente.
Tomar las palabras de artículos y noticias, haciendo pasar estas ideas como
propias, cuando realmente no los son.
Esto es un problema que se agrava debido
a que el internet, al ser tan grande, es difícilmente regida por un
“reglamento” general que permita gestionar el contenido, accesos, uso adecuado
de la información, entre muchos otros temas incluyendo ámbitos
socio-culturales, morales y éticos.
A todo esto, surge la pregunta: ¿Qué es
la propiedad intelectual?
Tal como lo define la Organización
Mundial de la Propiedad Intelectual (s. an) es:
“La
propiedad intelectual (P.I.) se relaciona con las creaciones de la mente:
invenciones, obras literarias y artísticas, así como símbolos, nombres e
imágenes utilizados en el comercio.”
Esta misma organización menciona los
siguientes tipos de propiedad intelectual:
- Derecho de autor, esto se refiere a una terminología jurídica utilizada para nombrar el derecho de autor sobre sobre obras literarias o artísticas. Desde libros, pinturas, composiciones musicales, películas, programas informáticos, bases de datos, publicaciones, mapas y dibujos técnicos.
- Patentes, son para uso exclusivo de invenciones realizadas por personas o empresas. La patente regula si la invención puede ser utilizada por terceros. En caso esta se pueda usar se declaran las limitaciones y condiciones de dicha utilización. Sin embargo, el dueño de la patente debe colocar a disposición del público general la información técnica sobre la invención.
- Marcas, es un signo que permite distinguir un servicio o producto de una organización de los demás.
- Diseños industriales, constituye el diagrama, forma y diseño artístico de un producto. Puede ser un plano de dos dimensiones o un diseño en 3D realizado en un ordenador, incluyendo colores, líneas entre otros.
Como se mencionaba es muy difícil
controlar en contenido que se publica en medios digitales como el internet, por
ejemplo, por lo que muchos autores, empresas y organizaciones toman ciertas
medidas para el seguimiento y protección de su propiedad intelectual, tales
como los que menciona Organización Mundial de la Propiedad Intelectual (s. an)
en su artículo sobre la distribución de contenido en internet:
- Marcas de agua.
- Creando codificaciones para protección del contenido.
- Creando sistema de identificación y rastreo.
Estos últimos son utilizados por consorcios
comerciales para controlar como se utilizan sus contenidos y si tiene
autorización o no de hacerlo. Hoy día cada vez más empresas utilizan estas
herramientas principalmente en el mundo de la música o contenido audio
visuales.
Está bien que los propietarios de las
ideas y obras cuiden sus derechos, pero se ha inculcado en la sociedad un
“derecho”, el derecho del acceso a la información. Muchas personas consideran
que este “derecho” les da la capacidad de utilizar el contenido de otros
indiscriminadamente o bien sentirse dueños de ese contenido por el siempre
hecho de “utilizarlo”.
Esto nos lleva a la interrogante de:
¿Cómo funciona realmente el derecho a la información? Principalmente en una
época donde podemos buscar y obtener la información que requerimos en minutos
con el simple hecho de realizar una búsqueda en internet.
Para analizar esto lo primero que
debemos hacer es definir que es el derecho a la información realmente.
El Instituto Interamericano de Derechos
Humanos (s. an), define este derecho a la información como:
“El derecho a la información es un
derecho humano, componente clave del derecho a la libertad de pensamiento y
expresión. Consiste en el derecho de una persona de buscar y recibir
información en poder de órganos, entes y empresas públicas, exceptuando casos
en que la información sea calificada como secreto de estado o de acceso
restringido por la Constitución y/o por alguna ley. El derecho al
acceso a información es un derecho fundamental para el desarrollo pleno de una
sociedad democrática y transparente, y un ejercicio vital para la rendición de
cuentas de las autoridades. Es un derecho multiplicador de otros
derechos, ya que es necesario para poder ejercer plenamente nuestros
derechos.”
El derecho de información nos capacita a
tener acceso a la información siempre que esta sea pública y esté disponible. Claro
que se puede utilizar la información que encontramos, mucha información es
publica, por ejemplo, cómo resolver una suma, esa información que pertenece a
la sociedad y podemos utilizar libremente. Sin embargo, utilizar ideas de
otros, hacerlas pasar por nuestras y obtener un beneficio monetario o de
reconocimiento por este, eso es plagio y actualmente existen muchas leyes sobre
este tema.
Sin embargo, no se debe caer en el
miedo, se puede utilizar información de terceros, leer sus investigaciones,
generar un nuevo proceso a partir de este si se desea, pero, siempre debemos
referenciar y dar mérito al autor o autores originales sobre su trabajo
realizado.
De todo esto podemos resumir que el
derecho a la información no habilita a tener acceso a esta, estudiarla,
utilizarla para entender nuestro entorno y a nosotros mismos, conocer leyes,
reglamentos y como aplicar correctamente los derechos y deberes en la sociedad.
Todo esto siempre bajo un marco de responsabilidad sobre la información que se
obtiene y como se retransmite esta.
Es importante tener presente que gracias
a la transmisión de conocimientos la sociedad avanza, algunas veces este
conocimiento debe tener regulaciones ya sean legislativas o personales que se
deben respetar, existen muchos licenciamientos que permiten utilizar la
información, investigaciones o proyectos de terceros libremente y generar un
retorno monetario sobre la implementación de este sin tener repercusiones
sociales o legales.
Finalmente, como menciona el Instituto
Ítalo-Ibero-Brasileiro de los estados jurídicos en su artículo sobre este tema
menciona:
“Información, cultura y mercado se
encuentran estrechamente entrelazados en la Sociedad de la Información. Se
complementan, pero también pueden colisionar abiertamente si no se hace una
interpretación equilibrada que coordine sus respectivos ámbitos de influencia.
La información entendida en sentido amplio incrementa el conocimiento
individual y colectivo de toda la Sociedad, generando y enriqueciendo la
cultura. Pero aprovechando el fuerte crecimiento en la demanda de información y
de bienes y servicios “culturales” (“informacionales” en la ruda terminología
anglosajona) entre los ciudadanos, el mercado amplía considerablemente su radio
de acción, su ámbito de influencia al sector de la información y la cultura: y
de esa manera contribuye también a fomentar el conocimiento y enriquecer la
cultura.”
El derecho de información no es poder
tener acceso a toda la información que se quiera si no, al hecho de en
cualquier lugar tener acceso a consultar y ser informado del tema que se desea
conocer.
La propiedad intelectual protege a los
materiales realizados por las personas o empresas, es importante que al hacer
uso de estos materiales se haga bajo el margen legal que se ajuste o tenga
vigente en ese momento.
El derecho a la información además de
ser un derecho humano fundamental debe analizarse con respecto a las TIC y como
estas se desenvuelven en un ambiente caótico como lo son los medios digitales y
el internet. Además de las afectaciones y limitación de este derecho sobre la
información publicada en internet.
Este derecho de información no debe
afectar la propiedad intelectual, ni viceversa, pero deben coexistir de una
forma apropiada donde ninguna de las partes se vean afectadas, o al menos, esta
afectación se reduzca a factores mínimos.
Biblioguías (2019). Gestión de datos de
investigación. Recuperado de: https://biblioguias.cepal.org/c.php?g=495473&p=4398138
Instituto Ítalo-Ibero-Brasileiro de
Estados Jurídicos (2012). Propiedad intelectual y acceso a la información en la
sociedad del conocimiento. Recuperado de: https://institutoiib.org/propiedad-intelectual-y-acceso-a-la-informacion-en-la-sociedad-del-conocimiento/
Interamericano de Derechos Humanos (s.
an). ¡El derecho de la información en acción! Recuperado de: https://www.iidh.ed.cr/derecho-informacion/
Organización Mundial de la Propiedad
Intelectual (s. an) ¿Qué es la propiedad intelecutal? Recuperado de: https://www.wipo.int/about-ip/es/
Organización Mundial de la Propiedad
Intelectual (s. an) Cuestiones de propiedad intelectual relativas a la distribución
de contenido en internet. Recuperado de: https://www.wipo.int/sme/es/e_commerce/internet_content.htm
La ética y las tecnologías de información y comunicación
Francisco
22:02
ética
,
información
,
informática
,
moral
,
por: Francisco Vargas
,
tecnologías
,
tecnologías de información
,
TIC
No hay comentarios
:
Ética, moralidad, bueno, malo… Todos
estos términos siempre han y serán controversiales, debido a un simple factor:
la subjetividad. Es esta subjetividad la que permite que estos términos sean
“moldeables” según el contexto socioeconómico, ambiental, temporal y personal.
En palabras simples, la ética y la
moralidad son regidas según factores externos y de percepción en un momento
dado, esto acarrea a su vez una falta de comprensión y –mucho más importante-
de medición. Lo cual genera una gran indeterminación de estándares y métricas
globales para aplicarlas a nivel macro de la sociedad. Sin embargo a pesar de
todo esto, los humanos hemos logrado reunir un “estándar” moral y éticamente
aceptado por todos –o la mayoría- que nos permite de cierta manera poder vivir
bajo una serie de reglas generalizadas para todos.
Pero al ser la ética un elemento
subjetivo y por ende cualitativo, ¿cómo puede regir la ética en un ambiente
como lo son las tecnologías de información y telecomunicación (en adelante
TIC)?
Para tener un real análisis y
entendimiento de esta relación tan estrecha y con una línea divisoria tan
delgada, tenemos que comprender a cabalidad los términos y su contexto. Por
ello lo primero que se hará es aclarar “las reglas de juego”.
Aclarando las reglas del juego
Se deben tener tres términos sumamente
claros:
- Moralidad
- Ética
- TIC
Aunque nos enfocaremos en la relación de
las dos últimas no podemos dejar la moralidad de un lado por completo, más aún
que muchas personas confunden moralidad y ética o bien, no tienen claros sus
límites. Por lo cual estableceremos los límites y ámbitos para cada uno de
ellos.
Moralidad
La moralidad, desde el punto de vista de
la psicología, tal como lo define Regader (s. an) es: “[…] es el conjunto de
principios o ideales que ayudan al individuo a distinguir el bien del mal, a
actuar de acuerdo con esta distinción […]”.
Ética
La ética, se refiere a como un individuo
interpreta las normas morales, y como estas normas actúan sobre sus decisiones
y sus valores. Esto es de suma importancia cuando veamos cómo están
relacionadas las TIC y la ética.
Varó (2018), define la ética como “la
reflexión filosófica sobre la moral”. Con esta reflexión, se da un caso curioso
con la moralidad y como esta se transforma en la ética de una persona. A través
de un proceso de internalización como lo explica Regader (s. an), durante este
proceso el individuo adopta normas moralmente aceptadas y las hace parte de sí,
es decir, de su ética.
TIC
Las TIC (Tecnologías de Información y
Comunicación), son como las define Luna (2018): “[…] un conjunto de
herramientas para la transmisión, procesamiento y almacenamiento digitalizado
de la información […]”. Es decir son medios tecnológicos que nos ayudan a
realizar tareas específicas agilizando y asegurando los distintos procesos.
Relación Ética - TIC
Con el mundo –no tan regulado- del
internet, la ética viene a ser un elemento escaso. Dado que la libertad que
propone esta red abierta es utilizada por muchas personas inescrupulosas para
realizar actividades ilegales o en contra de la moral.
Pero más allá de esto, que es un tema de
nunca acabar, la ética en las TIC busca definir y viene a ser una “disciplina”,
como lo menciona Torrez (2013), que busca analizar los problemas éticos que son
generados a partir de las TIC o bien, que son agravados por estas.
Según Rodríguez (2014) la ética en las
TIC tiene ciertas características que deben regir el uso de las TIC:
- Democrático, es decir que todos las
pueda usar. Sin embargo esto no implica que se usen sin barreras, ser refiere
más bien al acceso de las personas a las TIC.
- Relevante, quiere decir que las TIC
tenga un efecto significativo en la vida de los individuos y de su forma de
interactuar con su entorno y en contexto socioeconómico. Además implica un uso
de recursos adecuados a las actividades por realizar.
- Pertinente, este punto es de suma
importancia por la definición de la autora, ella define que para que las TIC
sean pertinentes significa no dañarse a sí mismo ni a otros.
Como se mencionó anteriormente, las TIC
están en un ambiente poco regulado por lo que es difícil definir donde están
los derechos de los individuos respecto a las TIC y la ética misma de cada
individuo. Además se deben incluir las legislaciones, derechos humanos,
políticas, reglamentos y las distintas leyes para realizar un verdadero
análisis de la relación entre TIC y la ética.
Todos los profesionales en las TIC,
podemos y debemos ser parte e inculcar las normas éticas en nuestros distintos
grupos sociales y laborales. La ética de los individuos puede variar añadiendo
o eliminado recursos los cuales pueden ser gracias a una influencia externa.
Uno de los más famosos temas que se tocan al hablar de la ética en las TIC es
la intimidad o privacidad personal en el internet. Los profesionales de las TIC
tienen en sus manos un recurso muy valioso, la información, y en muchos casos
esta información es confidencial por lo
cual no debe ser comentada o publicada, todos los profesionales tenemos el
deber de resguardar la información a la cual tenemos acceso para generar
confianza en las personas y organizaciones que creen en la ética profesional de
la que no jactamos.
Para finalizar la relación TIC – Ética,
podemos definir los siguientes puntos clave:
- La ética es un conjunto de normas
interpretadas y basadas en la moralidad de la ubicación tiempo-espacial del
individuo.
- Las TIC viven en un entorno sin
fronteras y por tanto, muy difícil de controlar.
- La ética en las TIC, busca establecer
las normas ético-morales que deben regir sobre todos los involucrados en este
ambiente.
- La ética en las TIC no es algo que se
imponga, cada individuo debe hacer un trabajo de internalización que le permita
construir su ética, aplicarla y transmitirla, siempre rigiéndose bajo el
control moral.
- La ética profesional y personal debe ser
combinada con el ámbito en el cual se desenvuelven las TIC. Esto permite genera
un conjunto de normas profesionales-individuales que, bien si no perfectamente,
permiten tener un herramientas para validar que está éticamente correcto y que
no lo está.
Conclusiones
La
ética al ser un factor personal y que es influenciado por factores externos, es
muy complicado de regir o gestionar a todos por igual. Por lo cual la moral
viene a ser el recurso que se toma en cuenta para modelar como la mayoría de
las personas actúa en su entorno.
Las
tecnologías de información y comunicación tienen responsabilidades, todas las
personas deben tener en cuenta que la información se debe transmitir
correctamente, y se deben evaluar las normas morales de la sociedad.
Un
factor importante que se debe tomar en cuenta en la ética es, el análisis de la
moral que circunda a los individuos y realizar un análisis exhaustivo de como
se genera esta y que factores son los que realmente median sobre esta moral y
como afecta su ética.
Todos
los profesionales en las TIC deben realizar conciencia e inculcar esta en su
entorno de desarrollo directo, es importante analizar que herramientas son más
útiles para realizar este tipo de “compartir de información” y como hacerlo
interesante para que las personas del entorno lo adopten como parte de su
ética.
Bibliografía
Biblioguías (2019). Gestión de datos de investigación.
Recuperado de: https://biblioguias.cepal.org/c.php?g=495473&p=4398138
Luna, N. (2018) ¿Qué son las TICs? Recuperado de: https://www.entrepreneur.com/article/308917
Regader, B. (s. an) ¿Qué es la moralidad? Descubriendo
el desarrollo de la ética en la infancia. Recuperado de: https://psicologiaymente.com/desarrollo/que-es-la-moralidad-psicologia-del-desarrollo
Rodríguez, C. (2014). Ética y TIC. Recuperado de: https://ceapat.imserso.es/interpresent3/groups/imserso/documents/binario/eticaytic.pdf
Torrez,
A. (2013) Ética en las tic. Recuperado de: https://eticaenlastic.wordpress.com/etica-en-las-tic/
Varó, A. (2018) ¿Qué es la ética? Recuperado de: https://www.nodo50.org/filosofem/spip.php?article5
domingo, 15 de marzo de 2015
CAKEPHP: Modificar datos de una tabla
Introducción
En esta entrada, aprenderemos nuestra última acción básica sobre una base de datos con CAKEPHP. Como repito siempre, estoy trabajando en un proyecto que ya con esta sería la cuarta entrega, por ende, ya el proyecto lleva muchos puntos realizados, por esta razón si desean seguir todos los pasos hasta llegar aquí pueden ir acá y en la sección básico encontrarán los temas.
Sin más que decir, entraremos con el último paso de nuestro proyecto, modificar.
Desarrollo
Primero trabajaremos en la vistas, que es la parte más sencilla, en nuestra vista vamos a añadir un nuevo enlace para modificar nuestro nombre, esto nos enviará a un nuevo formulario donde se desplegará la diferente información de nuestro nombre para lograr modificarla.
Vamos al archivo app/View/nombres/listar.ctp y añadimos lo encerrado con el signo numeral (#).
Vamos al archivo app/View/nombres/listar.ctp y añadimos lo encerrado con el signo numeral (#).
<?php
echo ('<h1>Nombres de la BASE DE DATOS!</h1>');
// $nombres es la variable a la que le asignábamos el resultado de nuestra consulta en
// la función listar en nuestro controlador
if (empty($nombres)) {
//Si no tienen nada nos dirá que no existen nombre actualmente
echo ("Actualmente no hay Nombres.");
} else {
echo '<table>';
echo '<tr>';
echo '<th>id</th>';
echo '<th>Nombre</th>';
// ---------------------------
echo '<th>Acciiones</th>';
// ---------------------------
echo ' </tr>';
foreach ($nombres as $nombre):
// recorremos nuestra variable para obtener cada uno de nuestros
// nombres individualmente
// luego de nuestro nombre sacamos los datos donde 'Nombre' es el nombre
// de nuestro modelo e 'id' y 'nombre' son los campos de la tabla
echo '<tr>';
echo '<td>';
echo $nombre['Nombre']['id'];
echo '</td>';
echo '<td>';
echo $nombre['Nombre']['nombre'];
echo '</td>';
// --------------------------- Link que se utiliza para eliminar un nombre
// de nuestra tabla, Primero se coloca el nombre a mostrar ("Borrar") y
// posteriormente la acción del controlador que se desea ejecutar en este
// caso delete, además se le concatena el id del nombre que se desea eliminar
echo '<td>';
echo $this->Html->link("Borrar", array("action" => "delete/"
. $nombre['Nombre']['id']));
// ##################################################################
// --------------------------- Link que se utiliza para actualizar un nombre
// de nuestra tabla, Primero se coloca el nombre a mostrar ("Actualizar") y
// posteriormente la acción del controlador que se desea ejecutar en este
// caso update, además se le concatena el id del nombre que se desea actualizar
echo $this->Html->link("Actualizar", array("action" => "update/"
. $nombre['Nombre']['id']));
// ##################################################################
echo '</td>';
// ---------------------------
echo ' </tr>';
endforeach;
echo '</table>';
}
Una vez hecho esto, vamos al controlador ubicado en app/Controller/NombresController.php, para añadir la función que nos ayudará en la tarea de actualizar el nombre.
public function update($id = null) {
// Si la solicitud viene por post, osea desde un formulario
if ($this->request->is('Post')) {
// Verifica que la información entrante no este vacía.
if (!empty($this->data)) {
// Selecciona el nombre con el id de entrada, este id viene del formulario.
$this->Nombre->id = $id;
// Una vez seleccionado el nombre, se le asigna la nueva información y se guarda
// en la base de datos.
if ($this->Nombre->save($this->data)) {
// mensaje para que el usuario se entere que se guardó correctamente.
$this->Session->setFlash('El nombre se actualizó correctamente.');
// Una vez guardado redirecciona al listar para ver los cambios
$this->redirect('/nombres/listar');
} else {
// mensaje para que el usuario se entere que no se guardó correctamente.
$this->Session->setFlash('El nombre no se ha podido actualizar, verifique los
datos e inténtelo de nuevo.');
}
}
}
// En caso que la petición no venga de un formulario, es decir cuando seleccionamos el link
// de nuestra vista listar realizará esta acción.
// Selecciona de la base de datos todos los nombres que la condición sea la especificada.
// La función $this->set setea la variable nombre el contenido de la consulta a base de datos
// y la envía a la vista update.
$this->set('nombre', $this->Nombre->find('all', array('conditions' => array('Nombre.id' => $id))));
// la sección array('conditions' => array('Nombre.id' => $id)) es como decir el where de una
// consulta SQL, sería WHERE Nombre.id = id_de_entrada
// Además esto nos redireccionará a la vista update.ctp creada en app/View/nombres/
}
Ahora el último paso, crear la vista update.ctp que estará ubicada en app/View/nombres. Creamos el archivo update.ctp y pegamos el siguiente código.
<?php
// Se crea un formulario de tipo Nombre, cuya acción a realizar es la función add
// del controllador padre, en este caso NombresController.
// Se envía a través del método post hacia la función.
echo $this->Form->create('Nombre', array('action' => 'update', 'request' => 'post', $nombre[0]['Nombre']['id']));
// Las siguientes dos líneas son para mostrar mensajes, por ejemplo si se actualizó
// o no el nombre en la base de datos
echo $this->Session->flash('auth');
echo $this->Session->flash();
echo ("<legend> Actualizar Nombre </legend>");
// Crea un campo tipo input, correspondiente a la columna nombre de la base de datos
// es decir siempre se debe colocar el nombre de la columna de la base de datos.
// Además se setea el valor del nombre que viene del controlador, en el campo.
// Recordar que $nombre, es la variable que se setea en la función update del
// controlador, cuando seleccionamos de la base de datos.
echo $this->Form->input('nombre', array('label' => 'Nombre:','value' => $nombre[0]['Nombre']['nombre']));
//Una cosa importante, CakePHP asume que estás editando un modelo si su id está
//presente en su array de datos.
//Si no hay un ‘id’ presente, CakePHP asumirá que es un nuevo elemento al llamar
//a la función save()
echo $this->Form->input('id', array('type' => 'hidden', 'value' => $nombre[0]['Nombre']['id']));
// Crea el botón y cierra el formulario.
echo $this->Form->end('Actualizar');
Con esto ya terminamos nuestra funcionalidad de actualizar.
Conclusiones
Siempre tener en cuenta que al momento de modificar se ocupa un id, para que CAKEPHP reconozca que se está actualizando y no que se está creando uno nuevo.
CAKEPHP facilita mucho al momento de la modificación, ya que con pocas líneas se logra dicha acción.
viernes, 13 de febrero de 2015
CAKEPHP: Eliminar datos de una tabla
Introducción
Ahora, ejecutamos nuestra aplicación y podremos eliminar los nombres desde la vista listar o bien colocando la siguiente ruta: http://localhost/MiPrimerCakePHP/nombres/delete/3
Siendo 3 el id de nuestro nombre, en la tabla de la base de datos.
Conclusiones
CAKEPHP, nos ahora tiempo y esfuerzo, como lo hemos visto cada vez es más sencillo realizar las acciones básicas con su ayuda.
En esta entrada aprenderemos a eliminar datos o filas de una tabla de nuestra base de datos, como es una secuencia que se está llevando, es preferible que hagan las partes anteriores sobre CAKEPHP, debido a que en este punto muchos de los elementos fundamentales están hechos y contiene información dentro. Para ir a los inicios del proyecto que estamos realizando ir acá. Y para mas temas y otros pasos de CAKEPHP ir acá.
Desarrollo
Para eliminar una fila de nuestra tabla, es sumamente sencillo. Primero debemos ir a la vista app/View/nombres/listar.ctp. Estando ahí la modificamos para que quede de la siguiente manera.
<?php
echo ('<h1>Nombre de la BASE DE DATOS!</h1>');
// $nombres es la variable a la que le asignábamos el resultado de nuestra consulta en
// la función listar en nuestro controlador
if (empty($nombres)) {
//Si no tienen nada nos dirá que no existen nombre actualmente
echo ("Actualmente no hay Nombres.");
} else {
echo '<table>';
echo '<tr>';
echo '<th>id</th>';
echo '<th>Nombre</th>';
// ---------------------------
echo '<th>Acciiones</th>';
// ---------------------------
echo ' </tr>';
foreach ($nombres as $nombre):
// recorremos nuestra variable para obtener cada uno de nuestros
// nombres individualmente
// luego de nuestro nombre sacamos los datos donde 'Nombre' es el nombre
// de nuestro modelo e 'id' y 'nombre' son los campos de la tabla
echo '<tr>';
echo '<td>';
echo $nombre['Nombre']['id'];
echo '</td>';
echo '<td>';
echo $nombre['Nombre']['nombre'];
echo '</td>';
// --------------------------- Link que se utiliza para eliminar un nombre
// de nuestra tabla, Primero se coloca el nombre a mostrar ("Borrar") y
// posteriormente la acción del controlador que se desea ejecutar en este
// caso delete, además se le concatena el id del nombre que se desea eliminar
echo '<td>';
echo $this->Html->link("Borrar", array("action" => "delete/"
. $nombre['Nombre']['id']));
echo '</td>';
// ---------------------------
echo ' </tr>';
endforeach;
echo '</table>';
}
Lo único que se agregó fue una nueva columna a la tabla html que contendrá el link para eliminar el nombre, algo importante es esta parte, es que, gracias a CAKEPHP, el paso de parametros a las funciones es muy simple, solo colocamos el nombre de la acción a ejecutar, luego un slash "/" y posterior a esto los parámetros que recibe la función en nuestro caso solo es uno, pero si se necesitan muchos más solo se van separando con un slash "/".
Un ejemplo para lo anterior sería: delete/1 o delete/1/2/3/4
Donde los números corresponde a los valores que recibe como parámetro la función delete.
Ahora, que entendimos ese detalle, vamos al controlador app/Controller/NombresController.php, y agregamos la función para eliminar. Importante tener en cuenta que cuando hablamos de $this->Nombre nos estamos refiriendo al modelo.
public function delete($id = null) {
// La función delete, busca el id en la base de datos y lo elimina.
if ($this->Nombre->delete($id)) {
// Muestra un mensaje informando lo sucedido
$this->Session->setFlash('El nombre a sido eliminado correctamente.');
// Una vez eliminado redirecciona a la vista listar, en la cual ya no
// aparecerá el nombre seleccionado previamente.
$this->redirect('/nombres/listar');
} else {
// Muestra un mensaje informando lo sucedido
$this->Session->setFlash('El nombre no se ha podido eliminar');
}
}
Ahora, ejecutamos nuestra aplicación y podremos eliminar los nombres desde la vista listar o bien colocando la siguiente ruta: http://localhost/MiPrimerCakePHP/nombres/delete/3
Siendo 3 el id de nuestro nombre, en la tabla de la base de datos.
Conclusiones
CAKEPHP, nos ahora tiempo y esfuerzo, como lo hemos visto cada vez es más sencillo realizar las acciones básicas con su ayuda.
CAKEPHP: Insertar datos en una tabla
Introducción
Ahora vamos a nuestro controlador ubicado en app/Controller/NombresController.php y añadimos la función para nuestra vista add.ctp.
Con esto ya podremos ingresar nombres a nuestra base de datos ahora solo ejecutamos la aplicación con la siguiente dirección: http://localhost/MiPrimerCakePHP/nombres/add
Al escribir un nombre y presionar añadir, nos enviará a la vista nombres/listar y podremos ver nuestro nuevo en la tabla.
Conclusiones
Como se aprecia la inserción de datos con CAKEPHP es muy simple y ordenado. En este caso es un ejemplo con un solo valor, sin embargo para tablas con más valores lo único que cambia sería la vista de añadir.
Con CAKEPHP nos ahorramos mucho tiempo al solo escribir una pocas líneas de código para lograr ingresar datos en nuestras tablas.
Como continuación del proyecto que hemos iniciado en la entrega anterior Seleccionar datos de una tabla, continuaremos con otra acción básica con CAKEPHP. Esta vez, vamos a introducir datos en nuestra tabla, y como ya contamos con la vista de seleccionar veremos los datos reflejados directamente en nuestra aplicación.
Como nota importante si no cuenta con la parte del proyecto realizada en la entrega anterior, puede ser un poco confuso, por eso es mejor que realicen la parte anterior antes de continuar con esta sección.
Desarrollo
Lo primero que haremos será crear la vista para ingresar los datos, esta vista contendrá un formulario pero creado con los métodos propios de CAKEPHP. Creamos un archivo llamado add.ctp, en la ruta: app/View/nombres
El cual contendrá el siguiente código:
<?php
// Se crea un formulario de tipo Nombre, cuya acción a realizar es la función add
// del controllador padre, en este caso NombresController.
// Se envía a través del método post hacia la función.
echo $this->Form->create('Nombre', array('action' => 'add', 'request' => 'post'));
// Las siguientes dos líneas son para mostrar mensajes, por ejemplo si se insertó
// o no el nombre en la base de datos
echo $this->Session->flash('auth');
echo $this->Session->flash();
echo ("");
// Crea un campo tipo input, correspondiente a la columna nombre de la base de datos
// es decir siempre se debe colocar el nombre de la columna de la base de datos.
echo $this->Form->input('nombre', array('label' => 'Nombre:'));
// Crea el botón y cierra el formulario.
echo $this->Form->end('Añadir');
Ahora vamos a nuestro controlador ubicado en app/Controller/NombresController.php y añadimos la función para nuestra vista add.ctp.
public function add() {
// Verifica si los datos vienen vía post
if ($this->request->is('post')) {
// Si la información no está vacía
if (!empty($this->data)) {
// Crea un nuevo nombre
$this->Nombre->create();
// Inserta los datos en la base de datos, la función save recibe
// como parametro $this->data que son todos los valores del formulario
if ($this->Nombre->save($this->data)) {
// Muestra un mensaje informando lo sucedido
$this->Session->setFlash('El nombre ha sido guardado correctamente.');
// Una vez guardado redirecciona a la vista listar para ver los datos
// ingresados
$this->redirect('/nombres/listar');
} else {
// Muestra un mensaje informando lo sucedido
$this->Session->setFlash('El nombre no se ha podido guardar, verifique los
datos e inténtelo de nuevo.');
}
}
}
}
Con esto ya podremos ingresar nombres a nuestra base de datos ahora solo ejecutamos la aplicación con la siguiente dirección: http://localhost/MiPrimerCakePHP/nombres/add
Al escribir un nombre y presionar añadir, nos enviará a la vista nombres/listar y podremos ver nuestro nuevo en la tabla.
Conclusiones
Como se aprecia la inserción de datos con CAKEPHP es muy simple y ordenado. En este caso es un ejemplo con un solo valor, sin embargo para tablas con más valores lo único que cambia sería la vista de añadir.
Con CAKEPHP nos ahorramos mucho tiempo al solo escribir una pocas líneas de código para lograr ingresar datos en nuestras tablas.
viernes, 12 de diciembre de 2014
CakePHP: Configuración Inicial.
Introducción
Desarrollo
Si no sabes como crear bases de datos ni tablas en MySQL visita el siguiente link: MySql: Crear base de datos y crear tabla.
Estándares Tablas de la Base de Datos:
- El nombre de la tabla debe estar en minúscula y el plural, como CakePHP trabaja con nombres en inglés y nosotros utilizamos el español, terminen los nombres de las tablas con la letra 's', para que no tengan problemas luego.
- La llave primaria siempre se tiene que llamar id.
Por el momento eso es lo que nos importa saber, creada nuestra tabla vamos a establecer la conexión desde CakePHP a nuestra base de datos para ello vamos a abrir el archivo database.php que se encuentra en la siguiente ruta SourceFiles/app/Config/database.php, lo que nos encontramos es el siguiente código:
Guardamos y listo! ya tenemos nuestra conexión a base de datos y nuestra configuración básica de seguridad.
Conclusiones
CakePHP es un framework de desarrollo para el lenguaje PHP, con un patrón de arquitecutra modelo-vista-controlador (MVC), es muy fácil de utilizar como veremos con esta serie de entradas, además brinda un control de permisos que en lo personal me encantó, al principio es un poco complejo de entender pero es muy útil al momento de generar estos permisos.
Pero bueno, en esta entrada veremos las configuraciones básicas antes de empezar a crear nuestra aplicación con CakePHP. Hay que tener en cuenta que CakePHP cuenta con una serie de estándares que se tiene que respetar para que funcione adecuadamente, estos estándares se irán mencionando en la etapa que corresponda.
Desarrollo
Para este ejemplo de CakePHP, estaré utilizando netbeans y xampp.
Aconsejo que antes de empezar este tutorial, busquen información del funcionamiento de CakePHP debido a que en esta entrada no se explican en detalle las relaciones que se producen entre los componentes de CakePHP.
Primero crearemos nuestro proyecto, en mi caso con netbeans crearemos un nuevo proyecto PHP Application, de nombre MiPrimerCakePHP y utilizando el framework CakePHP, si solo cuentan con la carpeta de CakePHP no tienen que hace nada en este paso.
Seguidamente lo que debemos hacer es ir a SourceFiles/app/Config/core.php, y buscar estas líneas:
<?php
/**
* A random string used in security hashing methods.
*/
Configure::write('Security.salt', 'DYhG93b0qyJfIxfs2guVoUubWwvniR2G0FgaC9mi');
/**
* A random numeric string (digits only) used to encrypt/decrypt strings.
*/
Configure::write('Security.cipherSeed', '76859309657453542496749683645');
?>
Y modificar las cadenas, agregando, eliminando o sustituyendo caracteres o la cadena completa, esto es por cuestiones de seguridad. Listo esto ahora vamos a nuestra base de datos debido a que queremos mostrar toda la información de una tabla y creamos la siguiente tabla.
CREATE TABLE nombres( id INT UNSIGNED AUTO_INCREMENT, -- Un entero, sin signo, osea no acepta negativos, incrementable nombre VARCHAR(255), -- Campo de texto CONSTRAINT PERSONAS_PK PRIMARY KEY (id) );
Si no sabes como crear bases de datos ni tablas en MySQL visita el siguiente link: MySql: Crear base de datos y crear tabla.
Por convención de CAKEPHP la tabla debe tener varios estándares para que pueda trabajar adecuadamente con CAKEPHP.
Estándares Tablas de la Base de Datos:
- El nombre de la tabla debe estar en minúscula y el plural, como CakePHP trabaja con nombres en inglés y nosotros utilizamos el español, terminen los nombres de las tablas con la letra 's', para que no tengan problemas luego.
- La llave primaria siempre se tiene que llamar id.
Por el momento eso es lo que nos importa saber, creada nuestra tabla vamos a establecer la conexión desde CakePHP a nuestra base de datos para ello vamos a abrir el archivo database.php que se encuentra en la siguiente ruta SourceFiles/app/Config/database.php, lo que nos encontramos es el siguiente código:
<?php 'Database/Mysql', 'persistent' => false, 'host' => 'localhost', 'login' => 'user', 'password' => '', 'database' => 'database_name', 'prefix' => '', 'encoding' => 'utf8' ); }?>
Lo que tenemos que cambiar es el login, password y nombre de la base de datos, suponiendo que la base de datos se llama 'cake' y mi usuario y contraseña es 'root', mi archivo quedaría de la siguiente manera:
<?php 'Database/Mysql', 'persistent' => false, 'host' => 'localhost', 'login' => 'root', // usuario 'password' => 'root', // contraseña 'database' => 'cake', // nombre de la base de datos 'prefix' => '', 'encoding' => 'utf8' ); }?>
Guardamos y listo! ya tenemos nuestra conexión a base de datos y nuestra configuración básica de seguridad.
Conclusiones
Gracias a CakePHP se ahora mucho tiempo al momento de desarrollo y se puede apreciar que realizar la conexión a base de datos es sumamente sencilla, se resume en modificar valores de un arreglo.
CakePHP hará muchas cosas por nosotros, por tanto, no nos debemos complicar realizando código complejos para la realización de tareas comunes.
sábado, 5 de abril de 2014
MySql: Introducción.
Francisco
16:53
create database
,
create table
,
database
,
MySql
,
por: Francisco Vargas
,
sql
No hay comentarios
:
Introducción
Una parte importante, hoy en día, es como se almacena la información del proyecto que estemos desarrollando, existen múltiples maneras de almacenarla, desde un documento de texto plano, hojas de cálculo, base de datos. En esta entrada se hablará sobre un gestor de base de datos, específicamente, MySql.
Desarrollo
MySql es un gestor de bases de datos relacionales, con licencia GNU GPL (GNU General Public License), esto quiere decir que lo podemos usar sin necesidad de pagar alguna licencia por su uso. Para acceder a las bases de datos creadas en MySql se logra por medio de diversos lenguajes como: Java, PHP, C/C++, C#, entre otros.
Es soportado por diversas plataformas entre ellas: Windows, Solaris, MacOs y Linux. El lenguaje que se utiliza en MySql es el llamado SQL (Structured Query Language), este lenguaje fue desarrollado por la IBM en 1981 y desde ese entonces se a utilizado para las bases de datos relacionales.
Algunas características de MySql son:
- Velocidad y robustez.
- Gran cantidad de tipos de datos para las columnas.
- Mucha portabilidad entre sistemas.
- Cada base de datos cuenta con 3 archivos: Uno de estructura, uno de datos y uno de índice y soporta hasta 32 índices por tabla.
- Es multihilo.
- Muy buen nivel de seguridad, cuenta con gestión de usuarios.
Ventajas de utilizar MySql:
- Rendimiento: tiene una gran velocidad al realizar las operaciones.
- Requerimientos mínimos: al ser tan liviano y casi no consumir recursos puede levantarse el servicio en máquinas con escasos recursos.
- Fácil instalación y configuración.Es soportado por muchos tipos de sistemas operativos y plataformas. Baja probabilidad de corrupción de datos.Maneja módulos para seguridad.
Desventajas al utilizar MySql:
- Muchas de sus utilidades no están documentadas.
- No es tan intuitivo como otras herramientas (esto a mejorado en las nuevas versiones).
Conclusiones
Al utilizar este gestor de base de datos se puede agregar gran funcionalidad y capacidad de almacenaje en nuestra aplicación, además proporciona muchas funciones que facilitan el desarrollo de aplicaciones y es una herramienta muy potente.
Actualmente existe una nueva versión de MySql llamada MariaDB, esta versión está más optimizada y proporciona un mejor rendimiento que MySql, sin embargo si ya se tiene una aplicación con MySql, sería más el costo de migrar el motor que los beneficios obtenidos, por lo cual se dice que si se va a empezar un nuevo proyecto con MySql, mejor empezar a desarrollarlo con MariaDB.
domingo, 26 de enero de 2014
CAKEPHP: Seleccionar datos de una tabla.
Introducción
Veremos como es de fácil seleccionar los datos de una tabla de nuestra base de datos creada en la entrada anterior CakePHP: Configuración Inicial., para esto tendremos que crear un modelo, una vista y un controlador, entonces, vamos a ello.
Es importante que se haga la parte anterior, por que esto es una continuación, entonces, si se continua con el mismo ejemplo se puede tener un mejor aprovechamiento del conocimiento.
Desarrollo
Veremos como es de fácil seleccionar los datos de una tabla de nuestra base de datos creada en la entrada anterior CakePHP: Configuración Inicial., para esto tendremos que crear un modelo, una vista y un controlador, entonces, vamos a ello.
Es importante que se haga la parte anterior, por que esto es una continuación, entonces, si se continua con el mismo ejemplo se puede tener un mejor aprovechamiento del conocimiento.
Desarrollo
Vamos a trabajar en nuestro proyecto haciendo que nos muestre todos los datos que se encuentran en nuestra tabla nombres. Lo primero que haremos es crear un modelo, esto lo crearemos en la siguiente ruta: SourceFiles/app/Model o si es en netbeans veremos que nos crea una carpeta Model en la raíz.
Estándares para la creación de un modelo:
- El nombre sería el de la tabla en singular.
Creamos una nueva clase php que se llamará Nombre.php y contendrá el siguiente código:
<?php
/**
* Description of Nombre
*
* @author Fran
*/
class Nombre extends AppModel{ // SIEMPRE EXTENDER DE AppModel, si no, no va a servir
var $name ='Nombre'; // No es necesario pero acostumbrémonos a colocarla
// para futuros usos que se le puede dar.
}
?>
Y ya!, tenemos nuestro modelo creado, no hace falta definir nada más con eso ya nuestro controlador conocerá a que tabla debe dirigirse.
Lo siguiente es crear un controlador para nuestro modelo, vamos a la ruta: SourceFiles/app/Controller o igual en la raíz tenemos la carpeta controller si usamos netbeans. Estando ahí creamos el controlador:
Estándares para la creación de un controlador
- El nombre sería el nombre de la tabla (recordemos esta en plural) más la palabra Controller por ejemplo: NombresController.php
Creamos nuestra clase NombresController.php y contendrá el siguiente código
<?php
/**
* Description of NombresController
*
* @author Fran
*/
class NombresController extends AppController{ // SIEMPRE EXTENDER DE AppController
var $name = "Nombres"; // al igual que con el modelo no es necesario, pero por estándar mejor colocarlo.
}
?>
Y crearemos una función que se llamará listar, para que haga el select a la tablapublic function listar() {
$this->set('nombres', $this->Nombre->find('all'));
}?>
Vamos a explicar un poco mejor esta función:
$this->Nombre->find('all')
find('all')
equivale a un SELECT *, entonces
esta parte sería como ejecutar en MySQL
SELECT * FROM nombres;
Una vez que terminamos esto crearemos nuestra vista para que nos muestre los datos. Creamos una carpeta en SourceFiles/app/View con el nombre de nuestra tabla, en este caso, nombres, dentro de ella crearemos un archivo .ctp para nuestra vista, esta vista debe tener el nombre de nuestra función creada anteriormente: listar.ctp y contendrá el siguiente código.
<?php echo ('<h1>Nombre de la BASE DE DATOS!</h1>');
// $nombres es la variable a la que le asignábamos el resultado de nuestra consulta en
// la función listar en nuestro controlador
if (empty($nombres)) {
//Si no tienen nada nos dirá que no existen nombre actualmente
echo ("Actualmente no hay Nombres.");
} else {
echo '<table>';
echo '<tr>';
echo '<th>id</th>';
echo '<th>Nombre</th>';
echo ' </tr>';
foreach ($nombres as $nombre):
// recorremos nuestra variable para obtener cada uno de nuestros
// nombres individualmente
// luego de nuestro nombre sacamos los datos donde 'Nombre' es el nombre
// de nuestro modelo e 'id' y 'nombre' son los campos de la tabla
echo '<tr>';
echo '<td>';
echo $nombre['Nombre']['id'];
echo '</td>';
echo '<td>';
echo $nombre['Nombre']['nombre'];
echo '</td>';
echo ' </tr>';
endforeach;
echo '</table>';}
Y bueno con esto ya tenemos un proyecto sencillo en CakePHP que realiza una selección de todos los datos de una tabla en la base de datos.
Y bueno cuando lo corremos tenemos que dar una dirección para acceder a nuestro listar, entonces ponemos esta:
http://localhost/MiPrimerCakePHP/nombres/listar
Donde MiPrimerCakePHP es el nombre del proyecto, nombres es el nombre de la carpeta donde está nuestra vista y listar es nombre de nuestra vista.
Conclusiones
Reiterando esta conclusión que dí en la entrada anterior, CakePHP nos facilita mucho la creación de aplicaciones, como se logra apreciar crear una selección de la base de datos, puede llevar a lo sumo cinco minutos, y queda totalmente funcional.
martes, 23 de julio de 2013
KeyListener (Programación Java)
Esta interface no sirve para crear o ejecutar eventos cuando presionamos, escribimos o soltamos una tecla. Por ejemplo si en un formulario queremos que cuando se presione enter se envíe la información con esta interface lo lograremos.
Primero importaremos la librería de la clase:
Para que nuestra clase pueda usar esta interface debemos implementarla de la siguiente manera:
Esto nos creará tres metodos por defecto para las acciones antes dichas (presionar, escribir, soltar) sobre las teclas. Si utilizamos un IDE nos lo genera automaticamente pero sino acá dejo los tres métodos:
Crearemos una clase que implemente esta interface y que contenga un botón:
En cada método de los anteriores colocaremos una salida a consola de la siguiente manera:
Nuestra clase final quedaría así y con esto ya tenemos un ejemplo demasiado sencillo para entender su utilización.
Documentación Java:
Key Listener: http://docs.oracle.com/javase/6/docs/api/java/awt/event/KeyListener.html
Key Event: http://docs.oracle.com/javase/6/docs/api/java/awt/event/KeyEvent.html
Primero importaremos la librería de la clase:
import java.awt.event.KeyEvent; import java.awt.event.KeyListener;
Para que nuestra clase pueda usar esta interface debemos implementarla de la siguiente manera:
public class EscucharTeclas extends JFrame implements KeyListener {}
Esto nos creará tres metodos por defecto para las acciones antes dichas (presionar, escribir, soltar) sobre las teclas. Si utilizamos un IDE nos lo genera automaticamente pero sino acá dejo los tres métodos:
@Override
public void keyPressed(KeyEvent e) {}
@Override
public void keyReleased(KeyEvent e) {}
@Override
public void keyTyped(KeyEvent e) {}
Crearemos una clase que implemente esta interface y que contenga un botón:
private JButton getbAceptar() {
bAceptar = new JButton("Aceptar");
// Acá es donde se le dice que escuche a las teclas
bAceptar.addKeyListener(this);
bAceptar.setBounds(10, 10, 100, 20);
return bAceptar;
}
En cada método de los anteriores colocaremos una salida a consola de la siguiente manera:
@Override
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode();
if (key == KeyEvent.VK_ENTER) {
System.out.println("Presionó Enter!" + (char) key);
}
if (key == KeyEvent.VK_SPACE) {
System.out.println("Presionó Espacio!" + (char) key);
}
}
@Override
public void keyReleased(KeyEvent e) {
System.out.println("Soltó una tecla");
}
@Override
public void keyTyped(KeyEvent e) {
System.out.println("Escribió una tecla");
}import javax.swing.JTabbedPane;
Nuestra clase final quedaría así y con esto ya tenemos un ejemplo demasiado sencillo para entender su utilización.
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import javax.swing.JButton;
import javax.swing.JFrame;
@SuppressWarnings("serial")
public class EscucharTeclas extends JFrame implements KeyListener {
private JButton bAceptar;
public EscucharTeclas() {
add(getbAceptar());
inicializador();
}
private void inicializador() {
setLayout(null);
setTitle("Prueba con Teclas");
setVisible(true);
setSize(300, 300);
setLocationRelativeTo(null);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
private JButton getbAceptar() {
bAceptar = new JButton("Aceptar");
bAceptar.addKeyListener(this);
bAceptar.setBounds(10, 10, 100, 20);
return bAceptar;
}
@Override
public void keyPressed(KeyEvent e) {
int key = e.getKeyCode();
if (key == KeyEvent.VK_ENTER) {
System.out.println("Presionó Enter!" + (char) key);
}
if (key == KeyEvent.VK_SPACE) {
System.out.println("Presionó Espacio!" + (char) key);
}
}
@Override
public void keyReleased(KeyEvent e) {
System.out.println("Soltó una tecla");
}
@Override
public void keyTyped(KeyEvent e) {
System.out.println("Escribió una tecla");
}
}
Documentación Java:
Key Listener: http://docs.oracle.com/javase/6/docs/api/java/awt/event/KeyListener.html
Key Event: http://docs.oracle.com/javase/6/docs/api/java/awt/event/KeyEvent.html
JTabbedPane (Programación Java)
Hoy aprenderemos a crear las famosas pestañas o tabs para nuestras aplicaciones en Java, y bueno empecemos!
Importamos la librería para poder utilizar este componente:
Vamos a crear tres paneles, uno para cada una de las pestañas que vamos a crear estos paneles solo van a tener un color y un pequeño texto y como ya sabemos crear paneles no nos detendremos en explicalos solo pondre el código de los tres (como crear paneles acá):
Así mismo dejaré el codigo de los JLabel de cada uno de los paneles:
Ahora si a lo que vinimos! como crear las pestañas, pues crearlas es sumamente facil solo hace falta este método y listo:
Bien ya tenemos nuestras pestañas ahora toda nuestra clase queda de la siguiente manera:
Documentación Java:
http://docs.oracle.com/javase/6/docs/api/javax/swing/JTabbedPane.html
Importamos la librería para poder utilizar este componente:
import javax.swing.JTabbedPane;
Vamos a crear tres paneles, uno para cada una de las pestañas que vamos a crear estos paneles solo van a tener un color y un pequeño texto y como ya sabemos crear paneles no nos detendremos en explicalos solo pondre el código de los tres (como crear paneles acá):
/* Paneles de cada una de las pestañas */
private JPanel getpProfesores(JLabel lProfesor) {
pProfesores = new JPanel();
pProfesores.add(lProfesor);
pProfesores.setBackground(Color.BLUE);
return pProfesores;
}
private JPanel getpAlumnos(JLabel lAlumnos) {
pAlumnos = new JPanel();
pAlumnos.add(lAlumnos);
pAlumnos.setBackground(Color.RED);
return pAlumnos;
}
private JPanel getpAula(JLabel bAyuda) {
pAula = new JPanel();
pAula.add(bAyuda);
pAula.setBackground(Color.YELLOW);
return pAula;
}
Así mismo dejaré el codigo de los JLabel de cada uno de los paneles:
/* Textos de Cada Panel */
private JLabel getlProfesor() {
lProfesor = new JLabel("Profesor");
return lProfesor;
}
private JLabel getlAlumno() {
lAlumno = new JLabel("Alumno");
return lAlumno;
}
private JLabel getlAula() {
lAula = new JLabel("Aula");
return lAula;
}
Ahora si a lo que vinimos! como crear las pestañas, pues crearlas es sumamente facil solo hace falta este método y listo:
private JTabbedPane gettbSistema(JPanel pProfesores, JPanel pAlumnos,
JPanel pAula) {
tbSistema = new JTabbedPane();
/* Se añade cada panel en un tab o pestaña */
tbSistema.addTab("Profesores", pProfesores);
tbSistema.addTab("Alumnos", pAlumnos);
tbSistema.addTab("Aulas", pAula);
return tbSistema;
}
Bien ya tenemos nuestras pestañas ahora toda nuestra clase queda de la siguiente manera:
import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;
@SuppressWarnings("serial")
public class Pestanas extends JFrame {
// Elemento para las pestañas
JTabbedPane tbSistema;
// Los paneles que contendrá cada una de las pestañas
JPanel pProfesores;
JPanel pAlumnos;
JPanel pAula;
// Texto de cada panel
JLabel lProfesor;
JLabel lAlumno;
JLabel lAula;
public Pestanas() {
// Enviamos cada panel al método de creación de las pestañas
add(gettbSistema(getpProfesores(getlProfesor()),
getpAlumnos(getlAlumno()), getpAula(getlAula())));
inicializador();
}
private void inicializador() {
setTitle("Pestañas");
setSize(400, 400);
setVisible(true);
setResizable(false);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
private JTabbedPane gettbSistema(JPanel pProfesores, JPanel pAlumnos,
JPanel pAula) {
tbSistema = new JTabbedPane();
// Se añade cada panel en un tab o pestaña
tbSistema.addTab("Profesores", pProfesores);
tbSistema.addTab("Alumnos", pAlumnos);
tbSistema.addTab("Aulas", pAula);
return tbSistema;
}
// Paneles de cada una de las pestañas
private JPanel getpProfesores(JLabel lProfesor) {
pProfesores = new JPanel();
pProfesores.add(lProfesor);
pProfesores.setBackground(Color.BLUE);
return pProfesores;
}
private JPanel getpAlumnos(JLabel lAlumnos) {
pAlumnos = new JPanel();
pAlumnos.add(lAlumnos);
pAlumnos.setBackground(Color.RED);
return pAlumnos;
}
private JPanel getpAula(JLabel bAyuda) {
pAula = new JPanel();
pAula.add(bAyuda);
pAula.setBackground(Color.YELLOW);
return pAula;
}
// Textos de Cada Panel
private JLabel getlProfesor() {
lProfesor = new JLabel("Profesor");
return lProfesor;
}
private JLabel getlAlumno() {
lAlumno = new JLabel("Alumno");
return lAlumno;
}
private JLabel getlAula() {
lAula = new JLabel("Aula");
return lAula;
}
}
Documentación Java:
http://docs.oracle.com/javase/6/docs/api/javax/swing/JTabbedPane.html
JPanel (Programación Java)
Entenderemos un JPanel como un contenedor en el cual podemos colocar y acomodar elementos (dentro del panel) y así luego se nos facilitará mover todos esos componentes relacionados de un lugar a otro solo moviendo el JPanel y no cada uno de los elementos que este contiene.
Lo primero que tenemos que hacer es importar la librería del JPanel:
Primero creamos un JLabel que colocaremos dentro de nuestra objeto JPanel:
Luego crearemos el objeto JPanel dentro de nuestra clase con el siguiente codigo.
Como se puede apreciar no es más complejo que lo que se ha venido viendo en este blog sobre java.
Ahora bien, en lo personal me gusta crear la clase para no tener todos los elementos que contenga el panel junto con los que tenga el JFrame o incluso si tenemos varios JPanel, entonces sacamos cada JPanel en una clase para mayor claridad.
Creamos nuestra clase y lo primero que tenemos que hacer es extender de JPanel, crear el inicializador y el constructor, luego crear todos los componentes e irlos agregando a la clase como cuando los agregabamos al JFrame.
Y acá está la clase donde se agregan tanto el objeto como la clase al JFrame:
http://docs.oracle.com/javase/6/docs/api/javax/swing/JPanel.html
Lo primero que tenemos que hacer es importar la librería del JPanel:
import javax.swing.JPanel;Una vez importada crearemos un objeto JPanel dentro de nuestra clase que extiende a JFrame, y luego crearemos una clase que extienda de JPanel.
Primero creamos un JLabel que colocaremos dentro de nuestra objeto JPanel:
/* Jlabel del Panel */
private JLabel getLabelPanelVariable() {
JLabel label = new JLabel();
label.setText("Este es el panel desde una Variable");
return label;
}
Luego crearemos el objeto JPanel dentro de nuestra clase con el siguiente codigo.
/* Se crea el panel */
private JPanel getPanelVariable() {
JPanel panelVariable = new JPanel();
panelVariable.add(getLabelPanelVariable());
// Se le asigna una posición dentro del JFrame
panelVariable.setBounds(10, 10, 375, 150);
// Le asignamos un color solo para ver sus dimensiones
panelVariable.setBackground(Color.green);
return panelVariable;
}
Como se puede apreciar no es más complejo que lo que se ha venido viendo en este blog sobre java.
Ahora bien, en lo personal me gusta crear la clase para no tener todos los elementos que contenga el panel junto con los que tenga el JFrame o incluso si tenemos varios JPanel, entonces sacamos cada JPanel en una clase para mayor claridad.
Creamos nuestra clase y lo primero que tenemos que hacer es extender de JPanel, crear el inicializador y el constructor, luego crear todos los componentes e irlos agregando a la clase como cuando los agregabamos al JFrame.
import java.awt.Color;
import javax.swing.JLabel;
import javax.swing.JPanel;
@SuppressWarnings("serial")
public class ClasePanel extends JPanel {
public ClasePanel() {
add(getLabelPanelClase());
inicializador();
}
private void inicializador() {
setBounds(10, 170, 375, 150);
setBackground(Color.ORANGE);
setVisible(true);
}
/* Jlabel del panel */
private JLabel getLabelPanelClase() {
JLabel label = new JLabel();
label.setText("Este es el panel desde una Clase");
return label;
}
}
Y acá está la clase donde se agregan tanto el objeto como la clase al JFrame:
import java.awt.Color;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
@SuppressWarnings("serial")
public class VentanaPaneles extends JFrame {
public VentanaPaneles() {
//Agregamos la Variable
add(getPanelVariable());
// Agregamos la Clase
add(new ClasePanel());
inicializador();
}
private void inicializador() {
setLayout(null);
setTitle("Paneles Java");
setSize(400, 370);
setVisible(true);
setResizable(false);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
// Jlabel del Panel
private JLabel getLabelPanelVariable() {
JLabel label = new JLabel();
label.setText("Este es el panel desde una Variable");
return label;
}
/* Se crea el panel */
private JPanel getPanelVariable() {
JPanel panelVariable = new JPanel();
panelVariable.add(getLabelPanelVariable());
// Se le asigna una posición dentro del JFrame
panelVariable.setBounds(10, 10, 375, 150);
// Le asignamos un color solo para ver sus dimensiones
panelVariable.setBackground(Color.green);
return panelVariable;
}
}
Y acá la documentación de Java para más información:http://docs.oracle.com/javase/6/docs/api/javax/swing/JPanel.html
sábado, 20 de abril de 2013
Java: Swing: JCheckBox, JRadioButton y ButtonGroup
Francisco
17:58
botones
,
buttongroup
,
checkbox
,
gui
,
java
,
jcheckbox
,
jframe
,
jlabel
,
jradiobuton
,
por: Francisco Vargas
,
programación java
,
radiobuton
,
swing
5 comentarios
:
Introducción
Esta vez aprenderemos a crear dos elementos nuevos de interfaz de usuario en Java, los JCheckBox, primero que todo para los que no saben que son, los checkbox son unos cuadros que salen en un formulario -por ejemplo- cuando te preguntan: "¿Que te gusta?", salen un montón de opciones y puedes marcar más de una, por otro lado están los JRadioButton son parecidos a los checkbox pero son redondos,
Los radiobutton, son para opciones mutuamente excluyentes, por ejemplo un caso hipotético, en un cuestionario te preguntan "¿Que género eres?", las posibles opciones son "masculino" o "femenino" pero, no puedes tener ambas condiciones a la vez.
Por último tenemos al ButtonGroup, los radiobutton por si solos no pueden ser mutuamente excluyentes, porque son elementos individuales y si no usamos buttonGroup tendríamos que validar esa característica desde código, pero con un buttonGroup lo hacemos automáticamente.
Imaginemos el ButtonGroup como una caja, donde tendremos unas bolitas -los radiobutton- y cerramos la caja, ahora hacemos una salida en la caja por la cual solo puede pasar una bolita a la vez pero, con la condición de que solo puedes sacar una bolita y si la quieres cambiar tienes que devolverla a la caja, entonces si queremos una bolita podremos sacar una -solamente una-, no podemos hacernos de ninguna más, si queremos otra tendremos que devolver la bolita actual y tomar la otra, en caso contrario los checkbox podemos tener todas las bolitas que queramos.
Ahora si todo bien claro a programar, iniciaremos con el JCheckBox:
//Creamos nuestra variable global private JCheckBox check1;
//Creamos el método que regresará el checkbox
private JCheckBox getCheck1() {
//inicializamo
check1 = new JCheckBox();
//le asignamos una posición
check1.setBounds(80, 30, 20, 20);
//Decimos que esté seleccionado por defecto
check1.setSelected(true);
//por ultimo retornamos
return check1;
}
Como ven el método no tiene nada del otro mundo, es muy sencillo crearlos, lo de decir que este seleccionado por defecto es opcional.
//Creamos la variable Global
private JRadioButton radio1;
//Método que retorna el radiobutton
private JRadioButton getRadio1() {
//inicializamos
radio1 = new JRadioButton();
//seleccionamos por defecto
radio1.setSelected(true);
//posicionamos
radio1.setBounds(80, 100, 20, 20);
//retornamos el objeto
return radio1;
}
Es más util usar el selected(boolean) en los radiobutton, para que siempre exista una opción por defecto y no quede vacío.
Bien ya sabemos crearlos entonces, vamos a hacer un ejemplo rápido con estos dos elementos e integramos lo que es el buttonGroup, primero crearemos: seis Jlabel para los textos, dos radioButton y dos Checkbox, acá les dejo el código de todos ellos:
private JLabel getLabel1() {
JLabel l = new JLabel("Seleccione que le gusta");
l.setBounds(10, 5, 180, 30);
return l;
}
private JLabel getLabel2() {
JLabel l = new JLabel("Comer");
l.setBounds(10, 30, 80, 30);
return l;
}
private JLabel getLabel3() {
JLabel l = new JLabel("Dormir");
l.setBounds(10, 50, 80, 30);
return l;
}
private JCheckBox getCheck1() {
check1 = new JCheckBox();
check1.setBounds(80, 30, 20, 20);
check1.setSelected(true);
return check1;
}
private JCheckBox getCheck2() {
check2 = new JCheckBox();
check2.setBounds(80, 53, 20, 20);
return check2;
}
private JLabel getLabel4() {
JLabel l = new JLabel("Genero");
l.setBounds(10, 80, 80, 30);
return l;
}
private JLabel getLabel5() {
JLabel l = new JLabel("Masculino");
l.setBounds(10, 100, 80, 30);
return l;
}
private JLabel getLabel6() {
JLabel l = new JLabel("Femenino");
l.setBounds(10, 115, 80, 30);
return l;
}
private JRadioButton getRadio1() {
radio1 = new JRadioButton();
radio1.setSelected(true);
radio1.setBounds(80, 100, 20, 20);
return radio1;
}
private JRadioButton getRadio2() {
radio2 = new JRadioButton();
radio2.setBounds(80, 120, 20, 20);
return radio2;
}
Hasta ahora todo normal, entonces vamos a crear el buttongroup con el siguiente código:
//Creación del grupo de botones recibe nuestro radiobutton creados
//anteriormente
private void getButtonGroup (JRadioButton radio1, JRadioButton radio2){
//creamos el objeto
ButtonGroup bgroup = new ButtonGroup();
//añadimos al grupo el primer radioButton
bgroup.add(radio1);
//añadimos al grupo el segundo radioButton
bgroup.add(radio2);
}
Como vemos en un método void y esto ¿porque? ¿no lo deberíamos agregar a nuestro JFrame?, la respuesta es no, lo que agregamos son los radiobutton que pueden estar en distintos lugares nosotros solo usamos dos pero, pueden ser muchos más, entonces, para que se entienda mejor diremos que el grupo de botones trabaja por debajo.
Lo llamamos en el constructor más solo trabaja en lógica, no es un elemento de interfaz.
Finalmente agregamos todos los elementos al JFrame, mi costructor quedaría así:
public Checs() {
add(getCheck1());
add(getCheck2());
add(getLabel1());
add(getLabel2());
add(getLabel3());
add(getLabel4());
add(getLabel5());
add(getLabel6());
// acá se añaden los radiobutton al buttongruop getButtonGroup(getRadio1(), getRadio2()); add(this.radio1); add(this.radio2); inicializador(); }
Prestemos atención que llamamos a nuestro método de crear el grupo y le pasamos como parámetro nuestros dos métodos para crear los radioButton, y luego agregamos los radiobutton al JFrame. Al final de todo mi clase queda de la siguiente manera:
import javax.swing.ButtonGroup;
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JRadioButton;
@SuppressWarnings("serial")
public class Checs extends JFrame {
private JCheckBox check1;
private JCheckBox check2;
private JRadioButton radio1;
private JRadioButton radio2;
public Checs() {
add(getCheck1());
add(getCheck2());
add(getLabel1());
add(getLabel2());
add(getLabel3());
add(getLabel4());
add(getLabel5());
add(getLabel6());
getButtonGroup(getRadio1(), getRadio2());
add(this.radio1);
add(this.radio2);
inicializador();
}
private void inicializador() {
setSize(400, 300);
setLayout(null);
setTitle("Aprendiendo Checkbox");
setLocationRelativeTo(null);
setVisible(true);
setResizable(false);
setDefaultCloseOperation(EXIT_ON_CLOSE);
}
private JLabel getLabel1() {
JLabel l = new JLabel("Seleccione que le gusta");
l.setBounds(10, 5, 180, 30);
return l;
}
private JLabel getLabel2() {
JLabel l = new JLabel("Comer");
l.setBounds(10, 30, 80, 30);
return l;
}
private JLabel getLabel3() {
JLabel l = new JLabel("Dormir");
l.setBounds(10, 50, 80, 30);
return l;
}
private JCheckBox getCheck1() {
check1 = new JCheckBox();
check1.setBounds(80, 30, 20, 20);
check1.setSelected(true);
return check1;
}
private JCheckBox getCheck2() {
check2 = new JCheckBox();
check2.setBounds(80, 53, 20, 20);
return check2;
}
private JLabel getLabel4() {
JLabel l = new JLabel("Genero");
l.setBounds(10, 80, 80, 30);
return l;
}
private JLabel getLabel5() {
JLabel l = new JLabel("Masculino");
l.setBounds(10, 100, 80, 30);
return l;
}
private JLabel getLabel6() {
JLabel l = new JLabel("Femenino");
l.setBounds(10, 115, 80, 30);
return l;
}
private JRadioButton getRadio1() {
radio1 = new JRadioButton();
radio1.setSelected(true);
radio1.setBounds(80, 100, 20, 20);
return radio1;
}
private JRadioButton getRadio2() {
radio2 = new JRadioButton();
radio2.setBounds(80, 120, 20, 20);
return radio2;
}
//Creación del grupo de botones recibe nuestro radiobutton creados
//anteriormente
private void getButtonGroup (JRadioButton radio1, JRadioButton radio2){
//creamos el objeto
ButtonGroup bgroup = new ButtonGroup();
//añadimos al grupo el primer radioButton
bgroup.add(radio1);
//añadimos al grupo el segundo radioButton
bgroup.add(radio2);
}
public static void main(String[] args) {
new Checs();
}
}
Documentación Java JCheckBox: http://docs.oracle.com/javase/8/docs/api/javax/swing/JCheckBox.html
Documentación Java JRadioButton: https://docs.oracle.com/javase/8/docs/api/javax/swing/JRadioButton.html
Documentación Java ButtonGroup: http://docs.oracle.com/javase/8/docs/api/javax/swing/ButtonGroup.html
Conclusión
Todos los elementos que aprendimos anteriormente, son muy utilizados al momento de crear formularios, debido a que brindan muchas facilidades e inclusive en muchos casos se libera de las validaciones.
Suscribirse a:
Entradas
(
Atom
)