[Escriba el subt铆tulo del documento]
Lenguaje de Programaci贸n Orientado a Objetos | 5/12/2014
Lenguaje de Programaci贸n Orientado a Objetos
0
UNIVERSIDAD TÉCNICA DE AMBATO
FACULTAD DE CIENCIAS HUMNAS Y DE LA EDUCACIÓN Carrera: Docencia en Informática Modalidad Presencial Tercer Semestre
Lenguaje de Programación Orientado a Objetos Docente: Ing. Wilma Gavilanes. Estudiante: Zapata Suarez Jhoselyn Ayneth AMBATO – ECUADOR Período: Febrero 2014-Agosto.
Lenguaje de Programación Orientado a Objetos | 5/12/2014
PROGRAMACIÓN II
1
INDICE INTRODUCCIÓN ................................................................................................................................... 1 ¿QUÉ UTILIDAD TIENE ESTE PROGRAMA? .......................................................................................... 1 EXPRESIONES ....................................................................................................................................... 2 OPERADORES....................................................................................................................................... 3 Operadores unarios......................................................................................................................... 4 OPERADORES BINARIOS. ................................................................................................................. 4 PRECEDENCIA DE OPERADORES ...................................................................................................... 4 SENTENCIAS......................................................................................................................................... 5 CONVERSIÓN DE TIPOS ....................................................................................................................... 6 CARACTERÍSTICAS................................................................................................................................ 8 CLASES ................................................................................................................................................. 9 BOOLEAN ....................................................................................................................................... 10 DOUBLE ......................................................................................................................................... 10 FLOAT ............................................................................................................................................ 10 INTEGER......................................................................................................................................... 10
STRING ........................................................................................................................................... 10 CONCEPTO DE INMUTABILIDAD.................................................................................................... 11 STRINGBUFFER .............................................................................................................................. 12 SYSTEM .......................................................................................................................................... 12 ¿QUÉ ES NETBEANS? ......................................................................................................................... 12 BIBLIOTECAS DE JAVA........................................................................................................................ 14 SINTAXIS ............................................................................................................................................ 15 CÓDIGO BÁSICO EN JAVA .................................................................................................................. 15 BIBLIOGRAFÍA. ................................................................................................................................... 20
Lenguaje de Programación Orientado a Objetos | 5/12/2014
MATH............................................................................................................................................. 10
2
INTRODUCCIÓN Java es un lenguaje de programación orientado a objetos, desarrollado por Sun MicroSystems a principios de la década de 1990. Este lenguaje toma la estructura de sintaxis (escritura de código fuente) de C y C++ incorporando un modelo de objetos más simples y eliminando las herramientas de bajo nivel (que suele inducir muchos errores como la manipulación de punteros en C y C++). El surgimiento de Java es propiciado porque en la década de 1980 aparecieron varios lenguajes orientados a objetos y también se realizaron versiones orientadas a objetos (o semi-orientados a objetos) de lenguajes clásicos. Una de las más famosas fue el lenguaje orientado a objetos creado a partir del C tradicional; se le llamó C++ indicando con esa simbología que era un incremento del lenguaje C (en el lenguaje C, como en Java, los símbolos ++ significan incrementar) (Sánchez, 2004). La Programación Orientada a Objetos (POO) permite desarrollar aplicaciones de forma más parecida al pensamiento humano, de hecho simplifica el problema de programación (principalmente en el desarrollo de aplicaciones de código largo) dividiéndolo en objetos, permitiendo centrarse en cada objeto, de esa manera se
Java, su evolución, su filosofía y entornos de desarrollo así como los distintos IDEs (interfaz de entorno de desarrollo) desde consola hasta las aplicaciones móviles haciendo referencia al IDE NetBeans pues este IDE constituye el enfoque sobre el cual se fundamenta este manual.
¿QUÉ UTILIDAD TIENE ESTE PROGRAMA? Existe un gran número de aplicaciones y sitios Web que no funcionan a menos que Java esté instalado, y muchas más que se crean a diario. Java es rápido, seguro y fiable. De portátiles a centros de datos, de consolas de juegos a superequipos científicos, de teléfonos móviles a Internet, Java está en todas partes.
Lenguaje de Programación Orientado a Objetos | 5/12/2014
elimina la complejidad de escribir código largo. En este capítulo se abordará la historia de
1
EXPRESIONES Las expresiones son un conjunto de elementos o tokens junto con literales que son evaluados para devolver un resultado. Los tokens son elemento más pequeño de un programa que es significativo, e interpretado o entendido por el compilador, en java los tokens se dividen en cinco categorías que son: Identificadores: Son las representaciones que se les da a los nombres que se asignan a las variables, clases, paquetes, métodos y constantes en el código de java para que el compilador los identifique y el programador pueda entenderlos. En java los identificadores pueden diferenciar entre mayúsculas o minúsculas por ser case sensitive, por lo que la variable cuyo nombre sea “Mivariable”, no es igual a “mivariable”, ya que java identifica estas como variables diferentes por el case sensitive, también se puede utilizar números, o
abstract
boolean
break
byte
case
catch
char
class
continue
default
do
double
else
extends
false
final
finally
float
for
if
implements
import
instanceof
int
interface
long
native
new
null
package
private
protected
public
return
short
static
super
switch
syncronized
this
Lenguaje de Programación Orientado a Objetos | 5/12/2014
el signo “_” para asignar un identificador.
2
throw
throws
transient
true
try
void
volatile
while
var
rest
byvalue
cast
const
future
generic
goto
inner
operator
outer
Las palabras que se encuentran en negrilla, son palabras claves para java aunque actualmente no se utilicen en la versión de java, pero se pretenden integrar en las siguientes versiones de java. Literales y constantes: Los literales son sintaxis para asignar valores a una variable, es decir el valor que puede tomar una variable, también es un valor constante que puede ser de tipo numérico. Las constantes son variables que tienen un valor fijo y no puede ser modificado en el trascurso de la ejecución del código, estas se declaran por medio de los modificadores final y static.
OPERADORES Los operadores son aquellos que tras realizar una operación devuelven un resultado, estos se puede caracterizar por el número de operadores, el tipo de operandos, y el resultado que generan. Número de operandos. Pueden ser de dos tipos unarios, y binarios. Los unarios son aquellos que solo necesitan de un operando para devolver un valor, mientras que los binarios necesitan de dos o más operandos.
Lenguaje de Programación Orientado a Objetos | 5/12/2014
final static double pi= 3.1416;
3
Operadores unarios. Operador Descripción -
Cambio de signo
!
Operador NOT
~
Complemento a 1
OPERADORES BINARIOS. Operadores
Descripción
+-*/%
Operadores aritméticos
== != < > <= >= Operadores relacionales && || ^
Operadores booleanos
^ << >> >>>
Operadores a nivel de bit
+
Concatenación de cadenas
PRECEDENCIA DE OPERADORES Los operadores son una parte principal en las expresiones, el tipo y forma de uso es
serie de normas, como lo son la precedencia de los operadores. Tipo de operadores
Operadores
Operadores posfijos
[ ] . ( parámetros) expr++ expr--
Operadores unarios
++expr –expr +expr -expr ~ !
Creación o conversión New (tipo) expr Multiplicación
*/%
Suma
+-
Desplazamiento
<< >> >>>
Comparación
< > <= >= instanceof
Igualdad
== !=
AND a nivel bit
&
OR a nivel bit
|
Lenguaje de Programación Orientado a Objetos | 5/12/2014
fundamental a la hora de programas, pero para su uso se tiene que tener en cuenta una
4
XOR a nivel bit
^
AND lógico
&&
OR lógico
||
Condicional
?:
Asignación
= += -= *= /= %= &= ^= |= <<= >>= >>>=
Un ejemplo de la precedencia de los operadores en java podría ser el siguiente, en donde tenemos un código que se encargará de realizar una serie de operaciones aritméticas. int numero1 = 3; int numero2 = 4; int resultado; resultado = numero1 + numero2 * 3; System.out.println (resultado); //esto imprime el valor de 15 según la precedencia de los operadores la multiplicación * tiene mayor prioridad que la suma +, por lo que primero se ejecuta la multiplicación y luego se realiza la suma.
En este caso el resultado cambia ya que primero se evalúan los parámetros que están dentro del paréntesis y luego se evalúa el resto de parámetros. Una de las recomendaciones que da java para el desarrollo es el uso de los paréntesis en las operaciones con más de 3 operandos, así de esta forma el código se hace más legible y se evitan errores al momento de compilar.
SENTENCIAS Las sentencias son una representación de una secuencia de acciones que se realizan en java, la clave fundamental de las sentencias es su punto final que indica que ha finalizado la sentencia y puede continuar con la siguiente, el indicador utilizado es el signo de punto y coma (;). Contamos en java con sentencias que pueden ir desde sentencias de asignación, de bucles, condicionales, y de salto. Las sentencias se conforman comúnmente
Lenguaje de Programación Orientado a Objetos | 5/12/2014
int numero1 = 3; int numero2 = 4; int resultado; resultado = (numero1 + numero2) * 3; System.out.println (resultado); //esto imprime el valor de 21
5
por una instancia, y un operador, un ejemplo es la sentencia de asignación que se conforma por una instancia de una variable, el signo de asignación y una expresión, un ejemplo es: Las sentencias de asignación son aquellas en las que se asigna un valor a una variable o constante. Las sentencias condicionales son las que expresan una condición para definir el flujo de ejecución del programa, entre ellas tenemos if-else y switch. Las sentencias de bucles se encargar de realizar una acción cierta cantidad de tiempo dado, o hasta que se cumpla con una condición, entre ellas tenemos el while, do-while, y for. Las sentencias de salto llevan al compilador a un punto específico del programa o hacia la siguiente sentencia de ejecución, entre ellas tenemos break, continue, y return.
CONVERSIÓN DE TIPOS En algunos casos suele ser necesario convertir un tipo de dato a otro, esto se le conoce como conversión de tipos, modelado, o tipado, así de esta forma poder realizar las operaciones necesarias sobre el valor que se desea convertir. Se debe tener en cuenta el
menor de bit al anterior este tendrá perdida de información, un ejemplo de tipado puede ser un número long que se desea convertir a int, el compilador eliminara los primeros 32bit del long para ajustarlo al int ya que el int es de 32bit y el long de 64. Si la conversión se realiza a un tipo de datos de menos bit a un tipo de datos con mayor bit, la conversión se realiza automáticamente llamada conversión implícita, pero si se realiza de un tipo de datos con mayor bit a menor bit se tiene que realizar una conversión explicita, la cual se realiza con un casting, al usar este método se obliga a realizar la conversión por lo cual puede haber perdida de datos en la conversión. Para realizar una conversión explicita se tiene que poner el tipo de dato que se desea realizar la conversión entre paréntesis, luego el valor o la variable que se desea convertir. Un ejemplo de conversión de tipo explicito puede ser: Int numero1 = 32;
Lenguaje de Programación Orientado a Objetos | 5/12/2014
tipo de dato que se va a convertir, ya que si se convierte un dato que tenga una cantidad
6
byte numero2; numero2 = (byte) numero1; Las siguiente tabla muestra la los tipos de datos que se pueden realizar una conversión implícita desde el dato origen, hasta el dato destino que es el dato en el que se va a convertir. Tipo origen
Tipo destino
byte
double, float, long, int, char, short
short
double, float, long, int
char
double, float, long, int
int
double, float, long
long
double, float
float
double
Los tipos de datos booleanos no pueden ser convertidos a otro tipo de datos, por ningún método mencionado anteriormente. Otro tipo de conversión que no se encuentre en esta tabla desde el origen al destino, tiene que realizarse por medio de una conversión explícita por casting. Cuando se desea realizar una conversión de un tipo string como
dato, la función necesaria se compone de la variable que va almacenar el resultado, y dependiendo de la variable se usa el parámetro que inicia con el tipo de dato a convertir, Integer, Byte, Short, o Long, seguida de punto “. “, el cual indica que se cargarán los atributos del parámetro, en donde cargaremos el parseInt si queremos convertir a interger o parseByte si queremos convertir a byte, o dependiendo del tipo de dato, seguido de paréntesis en donde se agregara el valor de string a convertir. Algunos ejemplos puede ser: int numero1; long numero2; byte numero3; String texto= “2013”; numero1 = Integer.parseInt ( texto ); numero2 = Long.parseLong ( texto); numero3 = Byte.parseByte ( texto );
Lenguaje de Programación Orientado a Objetos | 5/12/2014
origen a otro tipo, es necesario utilizar una función que se encarga de convertir el tipo de
7
esto suele ser usado para realizar una conversión de texto cuando se ingresan valores numéricos por una entrada a java, la cual los detecta como string, así de esta forma puede convertir el texto que se ingresa a un número para realizar operaciones, como una calculadora.
CARACTERÍSTICAS
Lenguaje totalmente orientado a Objetos. Todos los conceptos en los que se apoya esta técnica, encapsulación, herencia, polimorfismo, etc., están presentes en Java.
Disponibilidad de un amplio conjunto de bibliotecas. Como ya se mencionó anteriormente, Java es algo más que un lenguaje. La programación de aplicaciones con Java se basa no solo en el empleo del juego de instrucciones que componen el lenguaje, sino, fundamentalmente, en la posibilidad de utilizar el amplísimo conjunto de clases que Sun pone a disposición del programador y con las cuales es posible realizar prácticamente cualquier tipo de aplicación. Lenguaje simple. Java posee una curva de aprendizaje muy rápida. Resulta relativamente sencillo escribir applets interesantes desde el principio. Todos aquellos familiarizados con C++ encontrarán que Java es más sencillo, ya que se han eliminado ciertas características, como los punteros. Debido a su semejanza con C y C++, y dado que la mayoría de la gente los conoce aunque sea de forma elemental, resulta muy fácil aprender Java. Los programadores experimentados en C++ pueden migrar muy rápidamente a Java y ser productivos en poco tiempo.
Seguro (?). Dada la naturaleza distribuida de Java, donde las applets se bajan desde cualquier punto de la Red, la seguridad se impuso como una necesidad de vital importancia. A nadie le gustaría ejecutar en su ordenador programas con acceso total a su sistema, procedentes de fuentes desconocidas. Así que se implementaron barreras de seguridad en el lenguaje y en el sistema de ejecución en tiempo real.
Lenguaje de Programación Orientado a Objetos | 5/12/2014
8
Portable. La indiferencia a la arquitectura representa sólo una parte de su portabilidad. Además, Java especifica los tamaños de sus tipos de datos básicos y el comportamiento de sus operadores aritméticos, de manera que los programas son iguales en todas las plataformas. Estas dos últimas características se conocen como la Máquina Virtual Java (JVM).
Dinámico. El lenguaje Java y su sistema de ejecución en tiempo real son dinámicos en la fase de enlazado. Las clases sólo se enlazan a medida que son necesitadas. Se pueden enlazar nuevos módulos de código bajo demanda, procedente de fuentes muy variadas, incluso desde la Red. Produce applets. Java puede ser usado para crear dos tipos de programas: aplicaciones independientes y applets. Las aplicaciones independientes se comportan como cualquier otro programa escrito en cualquier lenguaje, como por ejemplo el navegador de Web HotJava, escrito íntegramente en Java. Por su parte, las applets son pequeños programas que aparecen embebidos en las páginas Web, como aparecen los gráficos o el texto, pero con la capacidad de ejecutar acciones muy complejas, como animar imágenes, establecer conexiones de red, presentar menús y cuadros de diálogo para luego emprender acciones, etc.
CLASES En cuanto a lo que respecta a clases, todas
son
casi
imprescindibles
de
conocer, ya que son básicas y por eso están en el paquete java.lang pero vamos a destacar unas cuantas por considerarlas principales.
Lenguaje de Programación Orientado a Objetos | 5/12/2014
9
BOOLEAN La clase Boolean ya la conocemos. Es lo que se llama un wrap o envoltorio, que es una clase que permite manejar los datos equivalentes de tipo primitivo. En este caso la clase Boolean es un wrap del tipo primitivo boolean. Los métodos de esta clase permiten el manejo de los valores primitivos true o false, su modificación o su comparación ya que implementa la interfaz Comparable. DOUBLE Es la clase wrap correspondiente al tipo primitivo double, por lo que lo métodos son muy parecidos a los de la clase Boolean, pero manejando los tipos primitivos para double. Permitiendo obtener, modificar, comparar, etc valores de tipo double. FLOAT Al igual que las anteriores también es un wrap pero para el tipo básico o primitivo float.
Esta es quizás la clase de todos los wrappers más utilizada con diferencia y por tanto maneja tipos primitivos de tipo int. Tiene una gran cantidad de métodos sobre todo para poder convertir el entero a otros tipos como long, float, double, etc. MATH La clase Math tiene una gran cantidad de métodos para poder hacer operaciones matemáticas, como las funciones sin (double a) que calcula el seno del valor a, tan (double a) que calcula la tangente de a, etc. STRING La clase String, quizás hasta más utilizada que la Integer, es una clase que permite la definición y manejo de cadenas de caracteres. Pero un inconveniente posible es que se
Lenguaje de Programación Orientado a Objetos | 5/12/2014
INTEGER
10
define como constante y tras su creación no puede ser cambiada (se dice que es inmutable, como explicaremos más adelante). Por ejemplo si quisiéramos tener una cadena con valores “abc” bastaría con definir una variable de la Clase String de la siguiente manera: String str = "abc"; Esto automáticamente es correcto aunque quizás fuera más formal lo siguiente: char data[] = {'a', 'b', 'c'}; String str = new String(data); La amplia funcionalidad y manejo de String se puede ver en la gran cantidad de métodos que disponemos en esta clase para su manejo, donde podemos hacer comparaciones entre cadenas, comparaciones ignorando mayúsculas (muy útil cuando por ejemplo queremos comparar si la contraseña de un usuario es la correcta), concatenación de cadenas, consulta de carácter en una posición determinada de la cadena, reemplazar
CONCEPTO DE INMUTABILIDAD Veamos el significado de inmutable, que no es precisamente sencillo de explicar. Consideremos que un objeto ocupa un espacio de memoria. Ahora diremos que hay dos tipos de objetos: a) Objetos mutables: son aquellos cuyo espacio de memoria puede ser reemplazado por un contenido definido con posterioridad a la creación del objeto. En este caso, cuando usamos métodos modificadores es el objeto original el que sufre el cambio. b) Objetos inmutables: son aquellos cuyo espacio de memoria permanece ocupado con el objeto tal y como se creó inicialmente. ¿Significa esto que no podemos usar métodos modificadores? No, no significa eso. Significa que cuando usamos métodos modificadores en vez de redefinirse el objeto original, la variable apuntadora pasa a apuntar a un nuevo
Lenguaje de Programación Orientado a Objetos | 5/12/2014
caracteres, convertir a mayúsculas, o minúsculas, etc.
11
objeto que se crea, permaneciendo el original en su espacio de memoria, podemos decir que en algunos casos “inaccesible”, pero estando. En Java, la mayoría de los objetos "esenciales" son inmutables: Long, Integer, Boolean, String, , etc. Un objeto se considera inmutable si su estado no puede cambiarse luego de ser construido. Este comportamiento está ampliamente aceptado como una estrategia robusta para crear código simple y confiable. La inmutabilidad se considera efectiva en aplicaciones concurrentes (hablamos de concurrencia para referirnos a dos tareas que transcurren durante el mismo intervalo de tiempo) donde la mutabilidad (cambiar los objetos su estado), podría dar lugar a que los objetos se corrompieran o llegaran a tener un estado inconsistente. STRINGBUFFER Es una versión mejorada o ampliada de la clase String, ya que permite su modificación después de su creación, es decir, los objetos de tipo StringBuffer son objeto mutables. El método más utilizado de esta clase es insert, que permite insertar cualquier objeto de
SYSTEM Por último la clase System es una de las clases más usuales. Define tres campos err, in y out que respectivamente son la salida estándar de error, entrada estándar y salida estándar. Los métodos para el manejo de estas entradas y salidas estándares de datos son bastante utilizados, al igual que el método currentTimeMillis() que devuelve la fecha actual en milisegundos. También es muy usual el uso del métodogetenv() para acceder a variables de entorno o propiedades del sistema. Cuando se invoca este método, se nos devuelve información sobre el sistema con que estamos trabajando.
¿QUÉ ES NETBEANS?
Lenguaje de Programación Orientado a Objetos | 5/12/2014
cualquier tipo como String a la secuencia de StringBuffer.
12
NetBeans es un proyecto exitoso de código abierto con una gran base de usuarios, una comunidad en constante crecimiento, y con cerca de 100 socios (¡y creciendo!) en todo el mundo. Sun MicroSystems fundó el proyecto de código abierto NetBeans en junio 2000 y continúa siendo el patrocinador principal
de
los
proyectos.
NetBeans IDE es un entorno de desarrollo una
herramienta
para
que
los
programadores puedan escribir, compilar, depurar y ejecutar programas. Está escrito en Java - pero puede servir para cualquier otro lenguaje de programación. Existe además un número importante de módulos para extender el NetBeans IDE. NetBeans IDE es un producto libre y gratuito
En una ventana posterior daremos
nombre
al
proyecto y escogeremos una ubicación en el disco para almacenarlo. También nos dará la opción para crear automáticamente una clase principal, la que hasta ahora hemos llamado Test, y que aquí por defecto se llamará Main. Una vez hecho esto, la ventana de trabajo nos resultará sin duda compleja, pero también familiar: NetBeans nos ofrece un esqueleto de clase Main, que podemos utilizar para hacer nuestra primera prueba. Por defecto, NetBeans compila automáticamente los archivos en el momento en que los grabas (icono del diskette), de forma que únicamente necesitamos
Lenguaje de Programación Orientado a Objetos | 5/12/2014
sin restricciones de uso.
13
utilizar el botón que representa una flecha verde, como el play de un mando a distancia. Verás el resultado de la ejecución en la ventana inferior:
BIBLIOTECAS DE JAVA, que son el resultado de compilar el código fuente desarrollado por quien implementa la JRE, y que ofrecen apoyo para el desarrollo en Java. Algunos ejemplos de estas bibliotecas son:
estructuras de datos como listas, arrays, árboles y conjuntos. - Bibliotecas para análisis de XML. - Seguridad: Bibliotecas de internacionalización y localización. - Bibliotecas de integración, que permiten la comunicación con sistemas externos. Estas bibliotecas incluyen: La API para acceso a bases de datos JDBC (Java DataBase Conectivity). La interfaz JNDI (Java Naming and Directory Interface) para servicios de directorio. RMI (Remote Method Invocation) y CORBA para el desarrollo de aplicaciones distribuidas. - Bibliotecas para la interfaz de usuario, que incluyen: El conjunto de herramientas nativas AWT (Abstract Windowing Toolkit), que ofrece componentes GUI (Graphical User
Lenguaje de Programación Orientado a Objetos | 5/12/2014
- Las bibliotecas centrales, que incluyen una colección de bibliotecas para implementar
14
Interface), mecanismos para usarlos y manejar sus eventos asociados. Las Bibliotecas de Swing, construidas sobre AWT pero ofrecen implementaciones no nativas de los componentes de AWT. - Plugins o conectores que permiten ejecutar applets en los navegadores Web. - Java Web Start, para la distribución de aplicaciones Java a través de Internet. - Documentación y licencia.
SINTAXIS La sintaxis de Java se deriva en gran medida de C++. Pero a diferencia de éste, que combina la sintaxis para programación genérica, estructurada y orientada a objetos, Java fue construido desde el principio para ser completamente orientado a objetos. Todo en Java es un objeto (salvo algunas excepciones), y todo en Java reside en alguna clase (recordemos que una clase es un molde a partir del cual pueden crearse varios objetos).
En lenguaje de programación java, absolutamente todo es un objeto. Así desde el programa principal, las librerías que usemos, y archivos extras que integremos serán clases para crear objetos, un programa básico en java necesita tener las siguientes lineas: La primer linea dice public class HolaMundo es la declaración de la clase: • public especifica el nivel de acceso, esto quiere decir que la clase sera accesible por cualquier elemento. También están los niveles private y protected • class: especifica que es una clase.
Lenguaje de Programación Orientado a Objetos | 5/12/2014
CÓDIGO BÁSICO EN JAVA
15
• HolaMundo: es el nombre de la clase, tomar en cuenta que el nombre del archivo debe ser igual al nombre de la clase que contiene el método (función de clase) principal (main). Deben respetarse mayúsculas y minúsculas. La segunda linea de código public static void main(String[ ] args) es la declaración de el método principal de la aplicación de java: • public: especifica el nivel de acceso a la método, esto quiere decir que es accesible por cualquier método que pueda acceder a la clase de objetos . • static: especifica que la función principal solo sera creada una vez, e invocada desde la clase. • void: dice que el retorno de este método sera de tipo genérico (flujo de bits), convertible a cualquier tipo de dato. • main: nombre del método, para este caso este nombre se reserva para el método principal y sera usado como punto de inicio de la aplicación.
comandos). • System: es una clase estándar java para llamadas al sistema, en esta se encuentras las operaciones básicas de entrada y salida. • out: es una clase declarada dentro de system, y se encarga de manejar las salidas estándar del sistema, por lo general el monitor • println: es un método de la clase out que recoge como argumento el texto que se imprimirá en Pantalla Para poner en marcha todo hay que hacer los siguiente: 1. Editar este código en un archivo de texto el cual debe ser guardado con un nombre como la clase principal, para este caso el archivo se llamara HolaMundo.java.
Lenguaje de Programación Orientado a Objetos | 5/12/2014
• String[ ] args: arreglo de parámetros al programa (en caso que se invoque por linea de
16
2. Luego se debe de compilar el archivo con el comando javac, este creara el archivo HolaMundo.class.
Este
contiene los bytecodes que interpretara el JVM. 3. Por ultimo ejecutamos el archivo con el JVM por medio del
comando
java,
mandandole como parámetro el nombre de la aplicación que se creo en el numeral anterior. Cómo crear una aplicación nueva
Archivo y después pulsaremos en Nuevo proyecto.
queremos realizar. Seleccionaremos la categoría Java y en el panel de la derecha Java Application. Después pulsamos Next.
En la siguiente pantalla se nos preguntará las
por
propiedades
generales
del
proyecto: nombre,
la
carpeta donde lo
Lenguaje de Programación Orientado a Objetos | 5/12/2014
Aparecerá una pantalla en la que tenemos que seleccionar qué tipo de proyecto
17
queremos guardar, si queremos utilizar una carpeta específica para guardar las librerías, si queremos crear una clase principal y si queremos establecerla como proyecto principal. Las opciones de arriba las podéis configurar como queráis, dejad la casilla de las librerías desmarcada, y por último, como vemos en la fotografía, activaremos las dos casillas de la parte inferior. Esto es necesario para que el sistema sepa que lo que vamos a escribir será lo que tenga que ejecutar cuando finalicemos. En el cuadro de texto he escrito “HolaMundo”, que será la aplicación que hayamos creado. Por último pulsamos en Finish.
Ventana de código Todo lo que aparece en color gris claro son comentarios. Es muy importante que nos acostumbremos a realizar comentarios en nuestros programas.
Esto
tiene
muchas
Lenguaje de Programación Orientado a Objetos | 5/12/2014
La ventana de proyectos
18
utilidades como poder recordar mejor en un futuro qué es exactamente lo que hacía este código y también que si otra persona lo ve, pueda entender mejor cómo resuelve el problema nuestro programa. Para hacer un comentario de varias líneas usaremos /* para iniciarlo y */ para finalizarlo. Si vamos a hacer un comentario de una sóla línea podemos comenzarlo por // En la línea 11 definimos la clase holamundo, el cuerpo de la clase queda encerrado entre { y}, cualquier cosa que coloquemos entre esas llaves será el código que pertenezca a la clase holamundo. En la línea 16 se ha iniciado el método principal main. Cuando se ejecuta una aplicación, Java espera que haya un método main, ya que será lo primero que ejecute. Este método define el punto de entrada y salida de la aplicación. La clase define los atributos y métodos comunes a los objetos de ese tipo, pero luego, cada objeto tendrá sus propios valores y compartirán las mismas funciones. Debemos crear una clase antes de poder crear objetos (instancias) de esa clase. Al crear
propiamente dicho. La estructura de una clase es: class [nombre de la clase] { [atributos o variables de la clase] [métodos o funciones de la clase] [main] }
Lenguaje de Programación Orientado a Objetos | 5/12/2014
un objeto de una clase, se dice que se crea una instancia de la clase o un objeto
19
BIBLIOGRAFÍA. http://recursostic.educacion.es/observatorio/web/ca/software/programacion/911monografico-java?start=2 http://es.wikipedia.org/wiki/Java_(lenguaje_de_programaci%C3%B3n) http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_Java/Caracter%C3%ADsticas_del_l enguaje http://www.aprenderaprogramar.com/index.php?option=com_content&view=article&id= 583:el-paquete-javalang-interfaces-clases-string-integer-stringbuffer-concepto-deinmutabilidad-cu00909c&catid=58:curso-lenguaje-programacion-java-nivel-avanzado-
Lenguaje de Programación Orientado a Objetos | 5/12/2014
i&Itemid=180
20