¡Programando en NetBeans! Adivina el número.

     Bienvenido de nuevo, en esta ocasión crearemos un juego en donde el usuario tendrá que adivinar el número que la computadora "piensa", para esto necesitamos importar librerías, una se Scanner que servira para registrar valores de el usuario, y una llamada Random que nos dará la opción de seleccionar un número aleatorio entre un rango definido.
     Para crear el código primero crearemos un nuevo, proyecto, esta vez lo realizaremos en el main y así entender la lógica, para después ocuparlo con objetos. Nuestro proyecto se llamará AdivinaElNumero. Como se puede ver en el recuadro de la imagen 1 hay dos comandos, los cuales son las librerías que comentaba hace unos momentos y como puedes ver, estas librerías se colocan antes del public class y por supuesto del main.

Imagen 1. Proyecto AdivinaElNumero

     Ahora empezaremos a escribir el código de el juego, como puedes ver es un código muy pequeño. En el recuadro 1 de la imagen 1.1 se crearon dos variables int. En el recuadro 2 creamos un nuevo objeto a partir de la librería Scanner y un nuevo objeto Random a través de la librería Random, después a "x" se le asigno el objeto Random con un intervalo de 1 a 1000. En el recuadro 3 solo imprimimos una instrucción para el juego. Quizás te llame la atención lo que se ve en gris, a esas letras en gris se les llama comentarios y se activan poniendo dos (/) antes de lo que quieras escribir, esto es ignorado por el compilador asi que no te marcara error.

Imagen 1.1.

     En estos pasoS empieza el sentido del juego, pues ocuparemos un do-while (hacer mientras) el cual es todo el recuadro azul de la imagen 1.2, dentro del do-while tenemos asignando a "a" el objeto Scanner creado anteriormente,en el recuadro 2 ocupamos una condición if primero para establecer que si "x" es igual a "a" imprima "acertaste" en el recuadro tres ocupamos el else (si no) y dentro de el un if el cual establece que si "x" es menor a "a" imprima "el número es mas pequeño" y "vuelve a intentarlo, en el recuadro cuatro ocupamos el último else el cual al parecer no tiene condición, pero en si accionará cuando las condiciones anteriores no se cumplan, es decir cuando "x" sea mayor a "a" e imprimirá "el numero es mas grande" y "vuelve a intentarlo". Ahora en el recuadro cinco es donde viene la magia, colocar la condición del while, todo el código anterior (que este dentro del do-while) se repetirá mientras "a" sea diferente de "x"  cuando "a" sea igual a "x" el programa se parará y te dira "acertaste".

Imagen 1.2.

     Y es así como creamos nuestro primer juego, como vez la lógica es muy sencilla, te espero en el siguiente post. Hasta luego.

¡Programando en NetBeans! Plano cartesiano

    En un post anterior hablamos sobre la Geometría Computacional, ahora hablaremos del código base para poder realizar lo anterior, es decir crearemos puntos y lineas.
    En primer lugar tenemos que crear un nuevo proyecto y dos clases, al proyecto lo llamaremos "PlanoCartesiano" y a las clases "Punto" y "Linea".

Imagen 1. Nuevo proyecto.

     Primero nos centraremos en la clase punto. En el recuadro 1 declararemos las propiedades privadas X y Y las cuales hacen referencia a las dos dimensiones manejadas en un plano cartesiano. En el recuadro dos creamos un constructor con dos parámetros de tipo entero, en el recuadro tres inicializamos a X y Y en 0 y en el recuadro cuatro creamos un método que nos devolverá un resultado en cadena.

Imagen 1.1. Declaras propiedades y constructores

     Ahora ocuparemos los metodos get y set (mostrar y modificar).

Imagen 1.2. Métodos get y set.

    Ahora para finalizar esta clase crearemos un método cuadrante el cual tendrá en él un condición if para definir en que cuadrante se encuentra el punto.

Imagen 1.3. Condición if.

     Continuaremos en la clse Linea en donde podremos declarar coordenadas que trazaran una linea imaginaria por ahora, asi como también encontraremos su distancia.
    Primero invocaremos a la clas punto con su constructor con 2 parámetros enteros tal y como se muestra en el recuadro 1, en el recuadro 2 y 3 crearemos dos objetos linea con las clase punto. En el recuadro 4 crearemos un método que realice la operación de distancia el "double" se utiliza como un float pero es para cantidades grandes y en el recuadro 5 haremos un método que nos devuelva un valor en cadena.

Imagen 2. Clase linea.

     Y nuevamente ocuparemos los métodos set y get pero para a y b.

Imagen 2.1 Métodos set y get.

    Así terminamos la clase Linea y ahora sí podemos ir hacia el "main" aquí sólo mandaremos a imprimir a mis puntos, su cuadrante, mi linea y mi distancia.

Imagen 3. Código para imprimir.

Imagen 4. Final código.

     Así termina el proyecto plano.

Imagen 4.1. Resultado del código.

Espero les alla servido, los veo en el siguiente post. Hasta luego.

¡Programando en NetBeans! Reloj

     Hola! en este post realizaremos nuestro segundo programa, ahora crearemos un reloj, será la base, o el inicio para crear un programa para un ciber, es decir, nuestro programa realizara una suma de horas, y realizara un conteo continuo, todo esto lo haremos en una clase para después solo llamarlos al main.
     El primer paso es crear un nuevo proyecto, el cual llamaremos "Reloj", y dentro del mismo proyecto crearemos la clase (si eres nuevo en NetBeans te recomiendo visitar el post anterior), ala cual llamaremos "Hora" quedando de la siguiente manera.

Imagen 1. Nuevo proyecto y pestaña principal (main).

     La clase quedaría así.

Imagen 1.1. Clase Hora.

     Una vez creado nuestro main y nuestra clase empezaremos a escribir el código en la clase. En recuadro 1 de la imagen 1.2 declaramos tres propiedades privadas que rigen el funcionamiento de nuestro reloj, como se puede ver las propiedades son hora, minuto y segundo. En el segundo recuadro creamos el constructor hora, el cual inicializa a nuestras propiedades en 0, pues nuestro reloj debe empezar de 0. En el tercer recuadro vemos el constructor con tres parámetros enteros, también lo podemos llamar modificador de acceso publico pues nos servirá para ingresar a las propiedad privadas declaradas al inicio. en el recuadro 4 creamos un método que nos retorna valores en cadena, es por eso que lleva el "String toString".

Imagen 1.2. Código en la clase.

     Ahora crearemos los métodos "get" (mostrar) y set (modificar) para nuestras propiedades privadas hora, minuto y segundo.

Imagen 1.3. Meet

    En el recuadro 1 de la imagen 1.4 continuaremos creando un método que hará avanzar a nuestro reloj, el cual se llamara avanzar, dentro de él abra una condición "if" (si) que hará el conteo de 59 segundos y el segundo 60 lo regresará a 0, como en los relojs convencionales, esto también lo hará con los minutos y con las horas regresando la hora 23 a 0. En el recuadro dos se crea un método que obligara a incrementar los segundos.

Imagen 1.4. Método avanzar.

    En el recuadro 1 de la imagen 1.5 se crea un método que comparará dos horas, esto con el fin de poder ordenar dos horas para realizar una resta y nos devolverá la diferencia entre dos horas que nosotros elijamos. En el recuadro 2 crearemos un "private static" el cual es un método con solo una copia en toda la clase, este método resta los segundo, minutos y horas de forma ordenada retornandonos un nuevo objeto hora.

Imagen 1.5. Método comparar y Static.

     Por último, dentro de la clase crearemos un método que realice la resta y otro que realice la suma de horas, las dos deberán devolver un resultado, ambos métodos se muestran en los recuadros 1 y 2 respectivamente de la imagen 1.6..

Imagen 1.6. Método suma y resta.

     Una vez creada nuestra clase, regresaremos al "main" para poder inicializar nuestros constructores y métodos así como nuestra clase.
     En el recuadro 1 de la imagen 1.7 creamos nuestros objetos con parámetros y sin. En el recuadro dos simplemente imprimimos nuestros objetos con los parámetros dados. En el 3 invocamos los métodos y en el 4 imprimimos el método invocado que en este caso es un incremento de un segundo en cada objeto.

Imagen 1.7. Creación de objetos e invocación de métodos y constructores.

     En la imagen 1.8 en el recuadro 1 invocamos el método comparar, para después a través de una condición "if" podamos imprimir que hora es la mayo o menor entre dos objetos, en el recuadro 2 invocamos los métodos de suma y se imprimen sus resultados y por ultimo se tiene el avance continuo del reloj en el recuadro 3 el cual se crea a través  de un "do while" (hacer mientras).

Imagen 1.8. Imprimir suma y resta y crear condición do-while.

    Es así como finaliza este post esperando te allá servido, gracias y nos vemos en el siguiente post!

¡Programando en NetBeans! Mi primer programa.

     En esta sección nos centraremos a el código de programación en Java, y para tener un buen inicio comenzaremos por imprimir el famosos "Hola mundo", pero antes aprenderemos a crear un nuevo proyecto.
    Nos dirigiremos a la aplicación de NetBeans y en la parte superior izquierda encontraremos una pestaña llamada "file" la cual seleccionaremos y nos desplegará opciones y de ellas seleccionaremos "New Project", tal y como se muestra a continuación.

Imagen 1. Crear nuevo proyecto.

     Nos aparecerá una ventana donde escogeremos el tipo de proyecto a crear (imagen 1.1) donde simplemente dejaremos los predeterminados ("java" en la primer columna y "java application" en la segunda) avanzamos con "next" , nombraremos el proyecto (imagen 1.2.) como Hola_Mundo y lo demás lo dejaremos por defecto y lo crearemos con "Finish"

Imagen 1.1. Escoger tipo de proyecto.

Imagen 1.2. Nombrar proyecto.

     Una vez completado estos pasos nos aparecerá un cuadro de trabajo (Imagen 1.3) en mi caso ya tenia creado el proyecto, lo llame HolaMundo, pero no marcará alguna diferencia, como podemos notar este cuadro de trabajo es el principal, es donde intanciaremos las clases que creemos así como sus métodos, pero para imprimir " Hola Mundo" podemos hacerlo en el main.

Imagen 1.3. Cuadro de trabajo.

     Para imprimir "hola mundo" colocaremos el código -System.out.printl("Hola mundo");- tal como se muestra en la imagen siguiente. El println crea un salto de linea.

Imagen 1.4. Código para imprimir.

     Ejecutaremos y compilaremos el programa para comprobar su funcionamiento. se ejecuta con el botón que tiene una figura de play. 

Imagen 1.5. Compilación.

     Como  podemos observar en el recuadro inferior aparece el mensaje "Hola mundo". ¡Felicidades! Has creado tu primer programa, y aprovechando esto, realizaremos nuestra primera suma y resta creando una clase, Para crear una clase, nos dirigiremos hacia la barra donde tenemos nuestro proyecto, y en la carpeta de "holamundo" (en mi caso) daremos clic derecho y seleccionaremos New--> Java class.

Imagen 1.6. Creación de una clase.

     Nuevamente nos aparecerá un recuadro donde daremos nombre a nuestra clase, en mi caso ya la tenia creada y la llame "Operaciones", damos clic en "Finish" y se creará la clase.

Imagen 1.7. Nombrar clase

     Nos aparecerá un recuadro parecido al principal, pero lo diferenciaremos ya que en la clase no aparecerá el main, recordemos que en la clase creamos las variable, métodos, constructores que intanciaremos en el main. En el recuadro 1 de la Imagen 1.8 declaramos variables de tipo privado, en el recuadro 2 creamos el constructor con dos parámetros que nos servirá también para acceder a las variables de tipo privado y modificar sus valor, en el recuadro 3 y 4 se crean los métodos de suma y resta respectivamente, el "return" nos devuelve un valor que en este caso será entero.

Imagen 1.8. Variables, constructor y métodos.

     Ahora regresaremos a el main donde intanciaremos el objeto que queremos crear. En el recuadro 1 de la imagen 1.9 creamos un nuevo objeto llamado "op", se pone atrás "Operaciones" por que de esa clase o "plantilla" crearemos el objeto, este objeto tiene parámetros de 7 y 3 que acepta nuestro constructor en la clase, los Integer j e i son asignados a guardar el valor retornado de los métodos suma y resta. En los recuadros 2 y 3 simplemente se imprime un texto y el valor obtenido de las operaciones y en el recuadro 4 se repite la misma acción, es asi como creamos nuestro primer programa con una clase.

Imagen 1.9. Instanciar objeto.

Ahora solo ejecutamos el programa y obtenemos...

Imagen 1.10. Programa ejecutado.

     Como puedes ver nos da el valor de la suma y resta del primer objeto y la suma del segundo, es así como hemos creado nuestro primer programa. ¡Bienvenido a Java!

En el siguiente post crearemos un reloj a partir de clases. Hasta luego.

Geometría Computacional

     Quizás te preguntes a qué se refiere la geometría computacional sin darte cuenta que es la base de todos los diseños e interfaces que tenemos, así como para el diseño de muchos objetos los cuales son asistidos por computadora.
     La geometría computacional funciona a través del uso de objetos geométricos creados por conjuntos de segmentos y puntos definidos en un plano cartesiano "imaginario". El plano utilizado contiene dos dimensiones pues así es mas fácil visualizarlo y solucionarlo.
    Para entender mejor esto, lo explicaremos a detalle y comenzaremos definiendo un segmento linea.
    Un segmento linea es la unión de dos puntos diferentes lo cuales podemos llamar P1 y P2, estos puntos tienen un conjunto de coordenadas donde P1 se define por (X1, Y1) y P2 esta definido por (X2, Y2), Estos dos puntos forman el segmento llamado p1p2. Esto puede causar confusión entre un segmento y una linea, pues en una linea s pueden definir los puntos P1 y P2 pero la diferencia es que una linea es una recta infinita en el plano cartesiano y un segmento es una recta acotada, es decir tiene un inicio y un fin los cuales son los puntos P1 Y P2. En un segemento también se puede saber en que dirección va nuestro segmento, esto se define por el orden en que definiremos el segmento, es decir si el segmento lo llamamos p1p2 la dirección será del punto p1 hacia el punto p2 y si lo llamamos p2p1 la dirección será de p2 a p1, al definir su dirección podemos llamar al segmento "vector".

Imagen 1

     Una vez comprendido que es un segmento, debemos pasar a las intersecciones de estos, pues así podremos formar figuras geométricas y para comprobarlo matemáticamente (sin necesidad de un plano cartesiano) realizaremos lo siguiente. Imaginemos dos vectores V1 y V2 partiendo del origen tal y como se muestra en la imagen siguiente.

Imagen 2

     Gráficamente notamos que los vectores solo se unen en el origen, pero en sus puntos terminales no, pero computacionalmente esto sería mas difícil de visualizar así que tenemos que encontrarlo matemáticamente, y para eso debemos realizar determinantes o producto cruzado, los datos que ocuparemos serán los del punto p2 y el punto p3 que se encuentran en la imagen 2.

     

Imagen 2.1. Uso de determinante.

     Al realizar esta operación nos devolverá dos resultados, la multiplicación de (X1)*(Y2)=R1 y (X2)*(Y1)=R2, estos dos resultados se pondrán en la siguiente operación. R1 - R2 = +- Rf. Es importante saber que la operación anterior se realizara de manera algebraica, es decir que R1 y R2 respetaran sus signos obtenidos en la operación de determinantes de tal manera que el signo (-) presente en la operación debe influir con la leyes de signos. 

Imagen 2.2. Paso dos de la determinante.

     En el resultado Rf lo que nos importará es el signo obtenido pues si tenemos un signo (-) se interpreta que los puntos de los extremos de nuestros segmentos se cruzan y si el signo es (+) los puntos extremos de los segmentos no se tocan. El número obtenido es el área total si formáramos una figura con otro punto, pero eso es otro tema.

Imagen 2.3. Resultado final de la determinante.

     Para entender mejor lo anterior, mostraremos un ejemplo con valores numéricos. Tenemos dos segmentos, ambos partiendo del origen, el segmento 1 tiene las coordenadas "(0,0),(5,4)", el segmento 2 tiene las coordenadas (0,0),(3,8). Gráficamente se vería de la siguiente forma.

Imagen 3.1. Gráfica de los segmentos.

     Aplicando la formula de determinantes explicada anteriormente quedaría de la siguiente forma.

Imagen 3.2. Aplicación de determinantes.

     El resultado final de la determinante para la operación algebraica anteriormente explicada queda así.

Imagen 3.2. Paso 2 de la determinante.

     Recuerda que el signo (-) en este caso se obtuvo por la ley de signos al multiplicar el signo de 12 por el signo (-) de la fórmula. El resultado final queda así.

Imagen 3.3. Resultado.

     Así se comprueba matemáticamente que los segmentos no se cruzan en sus extremos por el signo (+).

     Ahora, si tenemos dos segmentos que no empiezan en el origen, pero comparten un punto en común, la comprobación se realizaría de igual forma que el caso anterior, solo que se realiza un paso previo.

Imagen 4. Segundo caso.

    El paso previo es aplicar esta fórmula (p2-p1) x (p4-p3), recordemos que en estos caso el símbolo (x) hace referencia a determinantes o producto cruzado. Si analizamos la imagen, nos daremos cuenta que p1 seria el mismo punto p3 pues comparten este punto quedando la ecuación de la siguiente manera: (p2-p1) x (p4-p1). Realizando las operaciones indicadas los resultados son (3,0) x (1,3). Teniendo estos valores podemos aplicar la determinante explicada en el caso uno (cuando los segmentos parten del origen) y así obtener el resultado.

     En el caso tres nos centraremos más al análisis pues por simple inspección determinaremos si los segmentos se cruzan o no dependiendo del signo que decretemos. Éste caso se ocupa cuando los segmentos no tienen un punto en común. Imaginemos que tenemos estos segmentos en el plano.

Imagen 5. Tercer caso.

     En este caso haremos 4 análisis, el primero es analizar a el segmento AB con respecto al punto C y al punto D, los otros dos análisis serán  del segmento CD con respecto a los puntos A y B. Para determinar los signos se trazan segmentos imaginarios y dependiendo de la inclinación hacia la derecha (-) o izquierda (+) se determinarán los signos.

    Primero analizaremos el segmento AB respecto a C, si trazamos una linea imaginaria del punto A a C encontraremos un segmento con una leve inclinación hacia la izquierda por lo cual determinamos que el signo sera (+), ahora del segmento AB con respecto al punto D trazaremos un segmento imaginario del punto A al B obteniendo una dirección hacia la derecha determinando que el signo sera (-). Para el segmento CD realizaremos lo mismo, primero analizaremos CD con respecto al punto A, trazamos un segmento imaginario de C a A y tenemos una inclinación hacia la derecha determinando que tiene signo (-) y ahora analizaremos el mismo segmento con respecto a B y obtenemos un signo (+).

     Los segmentos se cruzarán siempre y cuando el analisis (1 y 2) y (3 y 4) sean signos diferentes.

Imagen 5.1. Primer análisis.

Imagen 5.2. Segundo análisis.

Imagen 5.4. Tercer análisis.

Imagen 5.5 Cuarto análisis.

      Para este caso tenemos que el análisis 1 y 2 tienen signos diferentes (+) y (-) respectivamente y el análisis 3 y 4 también tienen signos diferentes (-) y (+) por lo tanto los segmentos sí se cruzan.

     El cuarto caso se utiliza para saber si un punto esta sobre un segmento o entre un segmento. Imaginemos el siguiente conjunto de coordenadas.

Imagen 6. Cuarto caso.

     Para este caso solo se verifica si se cumple la siguiente condición: min(XA,XB) <= XC <= Max (XA,XB) &&  min(YA,YB) <= XC <= Max (YA,YB). Donde min (XA, XB)  y  (YA, YB) son los puntos mas pequeños en las cordenadas de X y Y respectivamente para el segmento AB. Max (XA,XB) y  Max (YA,YB) son los puntos de X y Y respectivamente del segmento AB. 

    Estos 4 casos son los principios de la Geometría Computacional. Hasta luego!

¡Para programar en NetBeans! Sobrecarga.

     Hola de nuevo a este es mi quinto post sobre programación en Java. Te invito a revisar los 4 anteriores para así poder entender bien el tema de "sobrecarga".

     Si has leído mis post´s anteriores y en especial el post de tipos de datos, recordaras que tenemos un ejemplo de un objeto nómina, de nuevo lo ocuparemos para este tema. Nuevamente hago la invitación para que revises los post´s anteriores.

     Supongamos que tenemos un objeto nómina de una empresa de 10 empleados, y para modificar las variables (las cuales son privadas) del objeto, tenemos que utilizar modificadores de acceso de orden publico, esto con el fin de tener 10 objetos diferentes (10 nóminas) de la misma clase (nómina de la empresa). Resultaría confuso y laborioso crear e invocar un método de acceso con identificación diferente para cada objeto nómina, por lo tanto resulta muy útil tener el mismo nombre de un método pero con diferente lista de parámetros (diferentes tipos de datos) y a esto se le denomina "sobrecarga de parámetros".

     Para lograrlo, Java o bueno, el compilador debe poder asimilar qué método le corresponde a cada objeto y para esto se debe ayudar al compilador, dándole pistas que pueda asociar con los objetos. Estas pistas pueden ser el orden de los parámetros, el número de parámetros, su tipo de datos. Es decir puedo tener dos parámetro con el mismo nombre, pero simplemente cambiando el orden de estos parámetros, Java podrá identificar que son para diferente objeto. A esto se le denomina "signatura del método". En palabras mas técnicas, el compilador usa las signaturas de los métodos para acoplar o asignar cada invocación a el objeto apropiado.

     Estas mismas características y usos de la sobrecarga son aplicables para los constructores. 

     Con este 5 post "¡Para programar en NetBeans!", es posible empezar a programar físicamente en NetBeans, pero eso lo veremos en el siguiente post donde quizás será más explicito cada tema y se darán ejemplos de la teoría. No dejes de visitar mi blog y deja tus cometarios.

     Hasta luego.

¡Para programar en Neatbeans! Constructores.

     Una vez entendido los temas de objetos y métodos pasaremos a entender lo que es un constructor. Un objeto necesita ayuda para poder incializar su clase, con inicailizar nos referimos a crear valores que cumplan con las características que nuestras variables requieren. Los constructores son parecidos a los métodos pero se diferencian en que los constructores no pueden devolver un valor, simplemente son como un complemento para hacer valer las variables. Otra característica de los constructores es que debe ser identificados con el mismo nombre de la clase, 

     No es necesario crear un constructor para cada clase, pues todas las clases traen un constructor por "defecto" es decir, no tiene parámetros y tampoco tiene función simplemente Java crea este constructor por estructura, pero no tendrá ningún efecto sobre el objeto.

¡Para programar en NetBeans! Modificadores de acceso.

    Anteriormente hice un post sobre los tipos de datos, si eres nuevo en la programación con Java te recomiendo visitar mis post anteriores (Identificadores y Tipos de datos) para así familiarizarte un poco más con Java y entender qué son los modificadores de acceso.
    Antes de explicar qué es un modificador de acceso, hablaremos un poco sobre la encapsulación. Sabemos que un objeto es definido por su clase, y la clase esta conformada por los métodos y los datos primitivos. Una característica del objeto, es que sus datos primitivos solo pueden ser modificados dentro de él, es decir que el objeto debe delimitar sus fronteras con el resto de el programa haciendo imposible que a través del código externo a la clase se cambien valores declarados dentro de ella. Los únicos que tienen acceso a estos datos primitivos son los métodos pertenecientes al objeto, por lo tanto la única forma de interactuar con las variables de un objeto es a través de los métodos que por decirlo de alguna forma, definen los "servicios" que el objeto puede realizar a través de sus variables. Entonces ¿cómo podemos encapsular una clase y cómo accederíamos a ella?
    Para esto tenemos los modificadores de acceso, un modificador de acceso es una palabra reservada de Java para realizar funciones ya establecidas por Java.
    Los modificadores de acceso controlan la entrada a las propiedades de una clase, Existen dos modificadores principales "public" y "private" y pueden aplicarse a los métodos y datos primitivos de una clase. Cuando las propiedades de una clase son "public (acceso publico)" podemos modificar y/o ver sus valores desde fuera del objeto, Si es "private" (acceso privado)" solo se pueden ver y/o modificar dentro del objeto.
    Para acceder a propiedades "private" se necesitan métodos de acceso de orden "public" para asi poder interactuar con las variables que deseamos modificar. También existen métodos de acceso "private" estos solo sirven como soporte de otros métodos de la clase. Toda clase debe proporcionar métodos públicos para que el código externo pueda ocupar el objeto como se desee, el diseño de los métodos públicos debe ser muy detallado para que solo se cambien variables apropiadas.
    En el siguiente post explicaremos una función parecida a los métodos de acceso, los "constructores" te invito a visitar mi siguiente post para saber más acerca de ellos.
    Hasta luego.

¡Para programar en NetBeans! Tipos de datos.

     En mi post anterior, expliqué qué son y cómo funcionan los identificadores, pues en mi opinión es un concepto básico de la programación en el lenguaje Java. A pesar de ser un concepto básico, algunas palabras como clase u objetos tienden a ser extrañas para los nuevos en el mundo de la programación, por ello he creado el siguiente post sobre "Los tipos de datos".
    Java es un lenguaje de programación orientado a objetos... pero, ¿a qué se refiere esto? En java "objeto" hace referencia a un conjunto de "datos primitivos" los cuales están interactuando entre sí para lograr un objetivo más complejo. Los "datos primitivos" tienen valores básicos y elementales para cumplir el objetivo de nuestro programa estos valores básicos y elementales pueden ser números y caracteres.
    Un ejemplo de objeto puede ser, un objeto de nómina, en el cual están registrados o almacenados datos primitivos de valor numérico como las percepciones y las deducciones.
    En parte los datos primitivos definen al objeto, pero lo que le da razón de ser es la "clase", en palabras simples, una "clase" es una plantilla para hacer objetos, pues la "clase" almacena los tipos de datos primitivos y los métodos. Los métodos son las operaciones que pueden llevarse a cabo dentro de los objetos. Con esto tenemos una interacción entre datos primitivos y métodos, los cuales forman la clase, la cual define al objeto.
     Regresando a el ejemplo del objeto nómina, con los datos percepciones y deducciones, no nos bastaría para decir que ese objeto es una nómina, entonces agregamos los métodos, es decir las operaciones que se realizaran dentro del objeto nomina, con estos dos aspectos formamos la clase, con la cual podremos definir al objeto nomina.
     Entonces ¿para que nos sirve la clase? Si recordamos, una clase es una plantilla para crear objetos, por lo tanto, cuando hemos definido una clase, podremos crear con ella múltiples objetos. Por ejemplo, en el objeto nomina podemos crear nominas independientes, es decir la nomina de Juan, Pedro, María, etc. pues todas las nominas tienen datos primitivos (con distinto valor numérico) y realizan los mismo métodos (operaciones), dando lugar al resultado objeto nómina, con la diferencia de que los valores numéricos serán diferentes para cada nómina.
     Esto crea la definición de encapsulación y se refiere a que cada objeto, en este caso, cada nómina protege y gestiona su propia información, dando lugar a nuestro siguiente tema, "Modificadores de acceso".
     Te invito a visitar el post "¡Para programar en NetBeans! Modificadores de acceso." para aprender más de la programación en Java.
     Hasta luego.

¡Para programar en Netbeans! Identificadores

     Como recordaremos, NetBeans es un entorno de desarrollo libre, principalmente para el lenguaje de programación en Java. 

     Para empezar a programar en Java debemos entender qué es un identificador. La palabra "identificar" según la RAE significa: "Dar los datos personales para ser reconocido". Entonces, los identificadores en Java, son los nombres que asignamos a una variable, una clase o un objeto, esto con el fin de poder reconocerlos a lo largo de nuestro programa, pero existen algunas reglas para su uso.

• No tienen un máximo de longitud. Puedes ponerle el nombre que quieras (a excepción de las palabras reservadas) sin importar el número de letras, pero no es muy recomendable exagerar en esto, solo pon un nombre que sea de acuerdo a lo que vallas a utilizar.
• No pueden ser palabras reservadas. Las palabras reservadas son las que Java ya a establecido para algunas funciones especificas, es por eso que no pueden ser ocupadas como identificadores.

Imagen 1. Palabras reservadas en Java.

• No aceptan espacios en blanco. Aunque puedes exagerar en la identificación de alguna variable, clase, objeto, etc., no puedes ocupar el espacio para separar tus palabras pero puedes hacer esto: "DistanciaPunto" para diferenciar entre palabras.
• Son sensitivos a las mayúsculas y minúsculas. Java puede interpretar que "DisTanCia", es diferente a "Distancia" y tomarlos como identificadores diferentes.
• Para declarar clases, el primer carácter va en mayúscula. Por ejemplo para declarar la clase "punto" sera así "public class Punto".
• Para declarar atributos, objetos o métodos el primer carácter va en minúscula, en caso de ser dos palabras la siguiente empezara en mayúscula.
• También es valido crear un identificador empezando con un guion bajo ( _ ). Ejemplo: "public class _Punto"

    Estas son las reglas de los identificadores. Si eres nuevo en programación te resultara confuso las palabras clase, objeto, o los ejemplos y para que entiendas a que se refieren te invito a visitar mi post "¡Para programar en NetBeans! Tipos de datos".

    Hasta luego.