Introducción a la Programación Orientada a Objetos en Java

UPEL-IPB
Asignatura: Estructuras de Datos y Programación III

Prof.: Julio Castillo
Introducción a la programación
Orientada a Objetos
UPEL-IPB
Recorrido de Aprendizaje
Conceptos Básicos de la Programación Orientada a Objetos ............................................................................................... 3

Abstracción ............................................................................................................................................................ 3
Encapsulación ....................................................................................................................................................... 3
Herencia ................................................................................................................................................................. 4
Polimorfismo .......................................................................................................................................................... 5
Primeros Pasos con Java................................................................................................................................................ 6
¿Qué es un proyecto java? Organización de archivos .java, .class y otros .......................................................................... 6
Verificar la versión de Java en tu equipo ....................................................................................................................... 7
¿Qué necesito para empezar a programar en Java? ....................................................................................................... 8
Conceptos Básicos en Java ............................................................................................................................................ 8
Objetos:.................................................................................................................................................................... 8
Eventos: ................................................................................................................................................................... 8
Clases: ..................................................................................................................................................................... 8
Estado:..................................................................................................................................................................... 8
Comportamiento: ....................................................................................................................................................... 9
Estructura de Código Java: ......................................................................................................................................... 9
Mi Primer Programa En Java: ...................................................................................................................................... 9
Método Main: .......................................................................................................................................................... 10
¿Qué es una Variable? ............................................................................................................................................. 10
¿Cómo declarar variables?........................................................................................................................................ 10
Tipos de variables: ................................................................................................................................................... 10
Variables locales .................................................................................................................................................. 10
Variables de instancia ........................................................................................................................................... 11
Variables estáticas ............................................................................................................................................... 12
Creando constantes ............................................................................................................................................. 13
Datos Primitivos y Objetos ............................................................................................................................................ 15
La clase estándar Scanner ............................................................................................................................................ 16
Mi Primer Código en Java ......................................................................................................................................... 17
Operadores aritméticos ................................................................................................................................................ 18
Operador de asignación (=) ........................................................................................................................................... 18
Operadores relacionales ............................................................................................................................................... 19
UPEL-IPB
Conceptos Básicos de la Programación Orientada a Objetos
Para poder implementar la programación orientada a objetos todos los lenguajes que se basan en esta metodología se
basan en cuatro principios: abstracción, encapsulación, herencia y polimorfismo.
Abstracción:
Una abstracción puede definirse como las características específicas de un objeto, aquellas que lo distinguen de los
demás tipos de objetos y que logran definir límites conceptuales respecto a quien está haciendo dicha abstracción del
objeto
Ejemplo: ¿Qué características podemos abstraer de los automóviles? o ¿Qué características semejantes tienen todos
los automóviles?
Características: Marca, Modelo, Número de chasis, Peso llantas o cauchos, Puertas, Ventanas...
Comportamiento: Acelerar, Frenar, Retroceder...
¿Qué significa que un lenguaje de programación te proporcione más o menos nivel de abstracción?
R. En la medida que un lenguaje de programación te permita simular (o modelar) mejor las situaciones de la vida real,
te proporciona mayor nivel de abstracción.
Encapsulación:
Este concepto consiste en la ocultación de los datos que conforman un objeto, de forma que sólo es posible modificar
los mismos mediante los métodos definidos para dicho objeto.
Ejemplo: De un televisor, el usuario conoce su apariencia y parte de su funcionamiento. Sólo le importa que funcionen
el selector de canales, el video y el audio; no le interesa saber cómo funciona cada una de las partes internas del
aparato, ese detalle sólo le interesan al fabricante y al técnico de servicio.
UPEL-IPB
Existen tres niveles de acceso para el encapsulamiento, los cuales son:
Público (Public): Todos pueden acceder a los datos o métodos de una clase que se definen con este nivel, este es el
nivel más bajo, esto es lo que tú quieres que la parte externa vea.
Protegido (Protected): Podemos decir que estás no son de acceso público, solamente son accesibles dentro de su
clase y por subclases.
Privado (Private): En este nivel se puede declarar miembros accesibles sólo para la propia clase.
Herencia:
La herencia permite compartir automáticamente métodos y datos entre clases, subclases y objetos.". Es una forma de
"sacar factor común" al código que escribimos.
El ejemplo que proponemos es un caso en el que vamos a simular el comportamiento que tendrían los diferentes
integrantes de la selección española de futbol; tanto los Futbolistas como el cuerpo técnico (Entrenadores, Masajistas,
etc…). Para simular este comportamiento vamos a definir tres clases que van a representaran a objetos Futbolista,
Entrenador y Masajista. De cada uno de ellos vamos a necesitar algunos datos que reflejaremos en los atributos y una
serie de acciones que reflejaremos en sus métodos. Estos atributos y métodos los mostramos en el siguiente
diagrama de clases:
Como se puede observar, vemos que en las tres clases tenemos atributos y métodos que son iguales ya que los tres
tienen los atributos id, Nombre, Apellidos y Edad; y los tres tienen los métodos de Viajar y Concentrarse:
UPEL-IPB
Lo que podemos ver en este punto es que estamos escribiendo mucho código repetido ya que las tres clases tienen
métodos y atributos comunes, de ahi y como veremos enseguida, decimos que la herencia consiste en "sacar factor
común" para no escribir código de más, por tanto lo que haremos será crearnos una clase con el "código que es
común a las tres clases" (a esta clase se le denomina en la herencia como "Clase Padre o SuperClase") y el
código que es especifico de cada clase, lo dejaremos en ella, siendo denominadas estas clases como "Clases
Hijas", las cuales heredan de la clase padre todos los atributos y métodos públicos o protegidos. Es muy
importante decir que las clases hijas no van a heredar nunca los atributos y métodos privados de la clase padre,
así que mucho cuidado con esto.
Polimorfismo:
El polimorfismo es un concepto de la programación orientada a objetos que nos permite programar en forma general,
en lugar de hacerlo en forma específica. En general nos sirve para programar objetos con características comunes y
que todos estos compartan la misma superclase en una jerarquía de clases, como si todas fueran objetos de la
superclase. Esto nos simplifica la programación.
UPEL-IPB
Gracias al polimorfismo, cuando se declara la función estacionar() podemos decir que recibe como parámetro un objeto
de la clase "Vehículo" y el compilador me aceptará no solamente vehículos genéricos, sino todos aquellos objetos que
hayamos creado que hereden de la clase Vehículo, es decir; coches, motos, buses, etc. Esa relajación del sistema de
tipos para aceptar una gama de objetos diferente es lo que llamamos polimorfismo.
Primeros Pasos con Java

Una de las características más relevante del lenguaje de programación Java es el hecho de que utiliza una máquina
virtual “Java Virtual Machine” o JVM para la ejecución de los programas.
¿Qué es un proyecto java? Organización de archivos .java, .class y otros

Un proyecto Java podemos considerarlo como una serie de carpetas ordenadas y organizadas de acuerdo con una
lógica para mantener organizado el código. Un proyecto suele constar de archivos .java, archivos .class y
documentación.
Los archivos .java contienen el código fuente (entendible por humanos) que en un momento dado podemos modificar
con un editor de textos y suelen encontrarse en carpetas de nombre src (source).
Los archivos .class contienen el bytecode (no entendible por humanos pero sí por la máquina virtual Java) y suelen
encontrarse en carpetas de nombre bin (binary).
UPEL-IPB
Verificar la versión de Java en tu equipo

En Windows Pulsa la tecla de Windows + R y escribe "cmd". Cuando se ejecute el DOS, escribe java –version. Los
datos de salida que te arrojará será algo como:
En un equipo sin ninguna versión de Java de Sun Microsystems instalada, te arrojará el siguiente mensaje de error:
"java" no se reconoce como un comando interno o externo, programa o archivo por lotes ejecutable.
En Linux Inicia una ventana de terminal y cuando esté abierta digita "java -version".
UPEL-IPB
¿Qué necesito para empezar a programar en Java?

Para comenzar a programar en Java se requiere al menos los siguientes elementos Básicos:
1. JDK Java Development Kit es necesario para desarrollar aplicaciones de Java. El JDK necesita más espacio
en el disco porque contiene el JRE junto con varias herramientas de desarrollo.
2. Un editor de código o Entorno de Desarrollo Integrado (IDE)
Conceptos Básicos en Java

Objetos:
Es un elemento distinguible que pertenece a una clase de objetos, y que se caracteriza por tener una serie de
propiedades o atributos (variables) y unos métodos (procedimientos y funciones) asociados. Para instanciar (crear) un
objeto en java seguimos la siguiente notación:
Nombre_De_La_Clase nombre_del_objeto = new Método_Constructor_De_La_Clase()
Eventos:
Son los diversos sucesos o señales que ocurren en nuestro sistema y son detectados y dirigidos a nuestra aplicación,
que en caso necesario ejecutará una acción asociada como respuesta al evento recibido.
Clases:
Las clases pueden definirse como la agrupación o colección de objetos que comparten una estructura común y un
comportamiento común. Por ser un Tipo Abstracto de Datos (TAD) encapsula (se compone de) estados y
comportamientos.
Clase = Categoría = Grupo de Cosas = Plano de Construcción de Objetos
¡Muy Importante! Al momento de guardar nuestro código fuente de las clases el nombre debe ser exactamente igual al
utilizado para nombrar nuestra clase. Y recuerda que en cada archivo fuente en java generalmente se codifica una
sola clase.
Estado:
Son los datos o variables que caracterizan al objeto y cuyos valores en un momento dado indican su estado.
Estado = Atributos = Características = Datos

UPEL-IPB
Para acceder a los atributos de un objeto debemos seguir la siguiente notación:
Nombre_del_Objeto.nombre_Del_Atributo
Comportamiento:
Son las operaciones (acciones o funciones) que se aplican sobre los objetos y que permiten crearlos, cambiar su
estado o consultar el valor de sus atributos.
Comportamiento = Métodos = Acciones = Operaciones
Son los procedimientos y funciones asociados a los objetos y que realizan una operación determinada, al igual los
atributos para acceder a los métodos de un objeto debemos seguir la siguiente notación
Nombre_del_Objeto.nombre_Del_Metodo
Estructura de Código Java:
/*
Fecha:
Versión:
Autor:
*/
public class Programa {
public static void main(String [] args) {
// aquí va el código
}//fin de método main

}//fin de la clase
Mi Primer Programa En Java:

/*
Fecha:
Versión:
Autor:
*/
public class MiPrimerPrograma{
public static void main (String [] args){
double distancia, velocidad, tiempo;
velocidad = 120; // en km/h
tiempo = 2.5; // en horas
distancia = velocidad * tiempo; // 300 km
System.out.println(distancia); // escribe 300 }//fin de método main
}//Fin de la clase MiPrimerPrograma
Explicación del código: Esta pequeña aplicación nos muestra básicamente lo que debe contener al menos nuestras
futuras aplicaciones. En ella observaremos los comentarios multilíneas entre los símbolos /* */ que identifican la fecha
de creación de la aplicación, la versión y el nombre del programador.
UPEL-IPB
Posteriormente se tenemos la cabecera de la clase con el modificador de acceso public, seguido del nombre de la
clase las llavea “{ }” el inicio y fin del ámbito de la clase y de los método, es el equivalente al “begin y end” en
pascal. Dentro de nuestra clase se observa un método estático llamado main que por ahora es suficiente que
sepamos que es la puerta de entrada de los programas y que debe existir una clase que contenga este método. Dentro
de este método se encuentra System.out.println() que es uno de las formas en java que utilizaremos para enviar
mensajes por pantalla.
Método Main:
En JAVA existe un método especial llamado main que será el punto de partida de nuestro programa, dentro de este
método ya se podrán hacer las llamadas a todas las rutinas que compondrán nuestro programa.
¿Qué es una Variable?

Una variable es el nombre dado a una ubicación de memoria. Es la unidad básica de almacenamiento en un programa.
El valor almacenado en una variable se puede cambiar durante la ejecución del programa.
¿Cómo declarar variables?

Podemos declarar las variables en Java de la siguiente manera:
 tipo de dato: tipo de datos que se pueden almacenar en esta variable.

 nombre_variable: nombre dado a la variable.
 valor: es el valor inicial almacenado en la variable.
Tipos de variables:
Hay tres tipos de variables en Java:
1. Variables locales
2. Variables de instancia
3. Variables estáticas
Ahora aprendamos sobre cada una de estas variables en detalle.
Variables locales
Una variable definida dentro de un bloque, método o constructor se llama variable local.
Estas variables se crean cuando el bloque ingresado o método se llama y destruye después de salir del bloque o
cuando la llamada regresa del método.
El alcance de estas variables solo existe dentro del bloque en el que se declara la variable, es decir, podemos acceder
a estas variables solo dentro de ese bloque.
UPEL-IPB
public class Estudiante

{
public void edadEstudiante()
{ //variable local age
int age = 0;
age = age + 5;
System.out.println("La edad del estudiante es : " + age);
}//fin de método edadEstudiante
public static void main(String args[])

{
//Instanciamos un objeto de la clase Estudiante
//Usando la notación: Nombre_De_La_Clase nombre_del_objeto = new Método_Constructor_De_La_Clase()
Estudiante unEstudiante= new Estudiante ();

unEstudiante.edadEstudiante ();
}//fin de la clase
Variables de instancia
Las variables de instancia son variables no estáticas y se declaran en una clase fuera de cualquier método, constructor
o bloque.
Como las variables de instancia se declaran en una clase, estas variables se crean cuando un objeto de la clase se
crea y se destruye cuando se destruye el objeto.
A diferencia de las variables locales, podemos usar modificadores de acceso para variables de instancia. Si no
especificamos ningún especificador de acceso, se utilizará el especificador de acceso predeterminado.
Ejemplo: Crearemos 2 Clases en Archivos .java independientes.
Primera Clase: Points.java
import java.io.*;
public class Points
{
//Estas variables son variables de instancia. Se ha utilizado el modificador de acceso protected
//Estas variables están en una clase y no están dentro de ninguna función/método
protected int ingPoints;
protected int matPoints;
protected int filPoints;
}//fin de la clase
UPEL-IPB
Segunda Clase: PointsDemo.java
public class PointsDemo

{
{ //primer objeto
//Instanciamos un objeto de la clase Points
//Usando la notación: Nombre_De_La_Clase nombre_del_objeto = new Método_Constructor_De_La_Clase
Points obj1 = new Points();

obj1.ingPoints = 50;
obj1.matPoints = 80;
obj1.filPoints = 90;
//segundo objeto
//Instanciamos un objeto de la clase Points
Points obj2 = new Points();

obj2.ingPoints = 80;
obj2.matPoints = 60;
obj2.filPoints = 85;
//mostrando puntos para el primer objeto

System.out.println("Puntos para el primer objeto:");
System.out.println(obj1.ingPoints);
System.out.println(obj1.matPoints);
System.out.println(obj1.filPoints);
//mostrando puntos para el segundo objeto

System.out.println("Puntos para el segundo objeto:");
System.out.println(obj2.ingPoints);
System.out.println(obj2.matPoints);
System.out.println(obj2.filPoints);
}//fin de la clase
Variables estáticas
Las variables estáticas también se conocen como variables de clase.
Estas variables se declaran de forma similar a las variables de instancia, la diferencia es que las variables estáticas se
declaran utilizando la palabra clave static dentro de una clase fuera de cualquier constructor o bloque de métodos.
A diferencia de las variables de instancia, solo podemos tener una copia de una variable estática por clase,
independientemente de cuántos objetos creemos.
Las variables estáticas se crean al inicio de la ejecución del programa y se destruyen automáticamente cuando finaliza
la ejecución.
UPEL-IPB
Para acceder a variables estáticas, no necesitamos crear ningún objeto de esa clase, simplemente podemos acceder a
la variable como:
nombre_clase.nombre_variable;
Ejemplo:
import java.io.*;
public class Emp {
// Salario como variable estática

public static double salario;
public static String nombre = "Alex";
}//fin de la clase
public class EmpDemo

{
public static void main(String args[]) {
//acceder a la variable estática sin objeto
Emp.salario = 1000;
System.out.println(Emp.nombre + " tiene un salario promedio de: " + Emp.salario);
}//fin de la clase
Creando constantes
La palabra clave “final” es un modificador que se puede usar al declarar variables para evitar cualquier cambio
posterior en los valores que inicialmente se les asignaron.
Esto es útil cuando se almacena un valor fijo en un programa para evitar que se altere accidentalmente.
Las variables creadas para almacenar valores fijos de esta manera se conocen como “constantes“, y es convencional
nombrar constantes con todos los caracteres en mayúsculas, para distinguirlas de las variables regulares. Los
programas que intentan cambiar un valor constante no se compilarán, y el compilador javac generará un mensaje de
error.
UPEL-IPB
Ejemplo:
public class Constantes

{
public static void main ( String[] args ) {
//inicializamos tres constantes enteras
final int CONSTANTE1 = 6 ;
//declaramos variables regulares del tipo int

int td,pat,fg,total;
//Inicializamos las variables regulares

td = 4*CONSTANTE1;
pat = 3*CONSTANTE2;
fg = 2*CONSTANTE3;
total = (td+pat+fg) ;
System.out.println("Resultado: " + total);
//Nota: El carácter * significa una multiplicación.

}//fin de la clase
UPEL-IPB
Datos Primitivos y Objetos

Los datos primitivos son solo valores únicos; ellos no tienen capacidades especiales. Lo datos tipo Objetos son
denominados wrapper y son objetos que poseen métodos para operar sobre ellos y sobre los datos primitivos.
UPEL-IPB
Ejemplo:
/*
Fecha:
Versión:
Autor:
*/
public class TipoDeDatosJava
{
// Programa Java para demostrar tipos de datos primitivos

{
char a = 'G';
// El tipo de datos enteros es generalmente

// utilizado para valores numéricos
int i=89;
// byte y short para enteros cortos

byte b = 4;
short s = 56;
// por defecto, el valor de la fracción es double en Java

double d = 4.355453532;
// para float use 'f' como sufijo

float f = 4.7333434f;
System.out.println("char: " + a);

System.out.println("integer: " + i);
System.out.println("byte: " + b);
System.out.println("short: " + s);
System.out.println("float: " + f);
System.out.println("double: " + d);
} //fin de método main
}//Fin de la clase
La clase estándar Scanner

La clase Scanner de Java provee métodos para leer valores de entrada de varios tipos y está localizada en el
paquete java.util. Los valores de entrada pueden venir de varias fuentes, incluyendo valores que se entren por el
teclado o datos almacenados en un archivo.
Para utilizar esa clase tenemos que crear primero un objeto de ella para poder invocar sus métodos. La siguiente
declaración crea un objeto de la clase Scanner que lee valores de entrada del teclado.
Scanner teclado = new Scanner(System.in);

UPEL-IPB
El propósito de pasar a System.in como argumento es conectar o establecer una relación entre el objeto tipo
Scanner, con nombre teclado en la declaración anterior, y el objeto System.in, que representa el sistema estándar
de entrada de información en Java. Si no se indica lo contrario, el teclado es, por omisión, el sistema estándar de
entrada de información en Java.
Luego que se tenga un objeto de la clase Scanner asociado al sistema estándar de entrada System.in, llamamos, por
ejemplo, su método nextInt para entrar un valor del tipo int. Para entrar otros valores de otros tipos de datos primitivos,
se usan los métodos correspondientes como nextByte o nextDouble.
Mi Primer Código en Java

/*
Programa Ejemplo de Java: Calcula y muestra el perímetro y área de
un rectángulo, dados la longitud y anchura del rectángulo.
Archivo: RectanguloPA.java
*/
import java.util.Scanner; //también se puede escribir import java.util.*;
public class RectanguloPA { // comienza clase RectanguloPA
public static void main (String[] args) {// comienza método main
//Instanciamos un objeto de la clase Scanner
Scanner teclado = new Scanner (System.in);

System.out.println("Esta aplicacion solicita la longitud y anchura de un rectangulo.");
System.out.println("Luego, calcula y muestra su perimetro y area.");
System.out.println();
System.out.print("Entre la longitud del rectangulo: ");
double longitud = teclado.nextDouble();
System.out.print("Entre la anchura del rectangulo: ");
double anchura = teclado.nextDouble();
double perimetro = 2*longitud + 2*anchura;
double area = longitud * anchura;
System.out.println();
System.out.println("El perimetro del rectangulo es: " +
perimetro + " unidades.");
System.out.println("El area del rectangulo es: " + area + "
unidades cuadradas.");
}// termina método main
}// termina clase RectanguloPA
UPEL-IPB
Operadores aritméticos
Se utilizan para realizar operaciones aritméticas simples en tipos de datos primitivos.
*: Multiplicación
/: División
%: Modulo
+: Adición
–: Resta
Ejemplo:
// Programa Java para ilustrar

// operadores aritméticos
public class Operadores
{
public static void main(String[] args)
{
int a = 20, b = 10, c = 0, d = 20, e = 40, f = 30;
String x = "Thank", y = "You";
// Operador + y -
System.out.println("a + b = "+(a + b));
System.out.println("a - b = "+(a - b));
// El operador + si se usa con strings

// concatena las cadenas dadas.
System.out.println("x + y = "+x + y);
// Operador * y /
System.out.println("a * b = "+(a * b));
System.out.println("a / b = "+(a / b));
// operador de módulo da el resto

// de dividir el primer operando con el segundo
System.out.println("a % b = "+(a % b));
// si el denominador es 0 en la división
// System.out.println(a/c);
// lanzaría una java.lang.ArithmeticException
}//Fin de método main
}//Fin de clase
Operador de asignación (=)

+ = , para sumar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
= , para restar el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
* = , para multiplicar el operando izquierdo con el operando derecho y luego asignándolo a la variable de la izquierda.
/ = , para dividir el operando izquierdo con el operando derecho y luego asignarlo a la variable de la izquierda.
^ = , para aumentar la potencia del operando izquierdo al operando derecho y asignarlo a la variable de la izquierda.
% = , para asignar el módulo del operando izquierdo con el operando derecho y luego asignarlo a la variable de la
izquierda.
UPEL-IPB

// Operadores de Asignación
public class OperadoresAsig
{
{
int a = 20, b = 10, c, d, e = 10, f = 4, g = 9;
// operador de asignación simple

c = b;
System.out.println("Valor de c = " + c);
// Esta siguiente declaración arrojaría una exception

// porque el valor del operando derecho debe ser inicializado
// antes de la asignación, entonces el programa no
// compila.
// c = d;
// operadores de asignación simples

a = a + 1;
b = b - 1;
e = e * 2;
f = f / 2;
System.out.println("a,b,e,f (usando operadores simples)= " +
a + "," + b + "," + e + "," + f);
a = a - 1;
b = b + 1;
e = e / 2;
f = f * 2;
// operados de asignación compuestos/cortos

a += 1;
b -= 1;
e *= 2;
f /= 2;
System.out.println("a,b,e,f (usando operadores cortos)= " +
a + "," + b + "," + e + "," + f);
}//Fin de método main
}//Fin de clase
Operadores relacionales
Estos operadores se utilizan para verificar relaciones como igualdad, mayor que, menor que. Devuelven el resultado
booleano después de la comparación y se usan ampliamente en las instrucciones de bucle, así como en las sentencias
condicionales if/else. El formato general es, variable operador_relacion valor
UPEL-IPB
Algunos de los operadores relacionales son:
==, Igual a: devuelve verdadero si el valor del lado izquierdo es igual al lado derecho.
! =, No igual a: devuelve verdadero si el valor del lado izquierdo no es igual al lado derecho.
<, menos que: el resultado verdadero si el valor del lado izquierdo es inferior al del lado derecho.
<=, menor o igual que: devuelve verdadero si el valor del lado izquierdo es menor o igual que el lado derecho.
>, Mayor que: devuelve verdadero si el valor del lado izquierdo es mayor que el lado derecho.
> =, Mayor que o igual a: regresa verdadero si el valor del lado izquierdo es mayor o igual que el lado derecho.
Ejemplo:
// operadores relacionales
public class OperRelacionales
{
{
int a = 20, b = 10;
String x = "Thank", y = "Thank";
int ar[] = { 1, 2, 3 };
int br[] = { 1, 2, 3 };
boolean condicion = true;
//varios operadores condicionales

System.out.println("a == b :" + (a == b));
System.out.println("a < b :" + (a < b));
System.out.println("a <= b :" + (a <= b));
System.out.println("a > b :" + (a > b));
System.out.println("a >= b :" + (a >= b));
System.out.println("a != b :" + (a != b));
// Los Arrays no se pueden comparar con

// operadores relacionales porque los objetos
// almacenan referencias, mas no el valor
System.out.println("x == y : " + (ar == br));
System.out.println("condicion==true :" + (condicion == true));

}//finde metodo main
}//fin de la clase

Introducción a la Programación Orientada a Objetos en Java

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Introducción a la Programación Orientada a Objetos en Java

Cargado por

Copyright:

Formatos disponibles

UPEL-IPB

Asignatura: Estructuras de Datos y Programación III

Conceptos Básicos de la Programación Orientada a Objetos ............................................................................................... 3

Conceptos Básicos de la Programación Orientada a Objetos

Comportamiento: Acelerar, Frenar, Retroceder...

Existen tres niveles de acceso para el encapsulamiento, los cuales son:

Primeros Pasos con Java

¿Qué es un proyecto java? Organización de archivos .java, .class y otros

Verificar la versión de Java en tu equipo

¿Qué necesito para empezar a programar en Java?

Conceptos Básicos en Java

Nombre_De_La_Clase nombre_del_objeto = new Método_Constructor_De_La_Clase()

Clase = Categoría = Grupo de Cosas = Plano de Construcción de Objetos

Estado = Atributos = Características = Datos

Para acceder a los atributos de un objeto debemos seguir la siguiente notación:

Comportamiento = Métodos = Acciones = Operaciones

}//fin de método main

Mi Primer Programa En Java:

}//Fin de la clase MiPrimerPrograma

¿Qué es una Variable?

¿Cómo declarar variables?

 tipo de dato: tipo de datos que se pueden almacenar en esta variable.

Ahora aprendamos sobre cada una de estas variables en detalle.

public class Estudiante

public static void main(String args[])

Estudiante unEstudiante= new Estudiante ();

Ejemplo: Crearemos 2 Clases en Archivos .java independientes.

Primera Clase: Points.java

Segunda Clase: PointsDemo.java

public class PointsDemo

Points obj1 = new Points();

Points obj2 = new Points();

//mostrando puntos para el primer objeto

//mostrando puntos para el segundo objeto

// Salario como variable estática

public class EmpDemo

public class Constantes

//declaramos variables regulares del tipo int

//Inicializamos las variables regulares

//Nota: El carácter * significa una multiplicación.

Datos Primitivos y Objetos

public static void main(String args[])

// El tipo de datos enteros es generalmente

// byte y short para enteros cortos

// por defecto, el valor de la fracción es double en Java

// para float use 'f' como sufijo

System.out.println("char: " + a);

La clase estándar Scanner

Scanner teclado = new Scanner(System.in);

Mi Primer Código en Java

Scanner teclado = new Scanner (System.in);

Se utilizan para realizar operaciones aritméticas simples en tipos de datos primitivos.

// Programa Java para ilustrar

// El operador + si se usa con strings

// operador de módulo da el resto

Operador de asignación (=)

// Programa Java para ilustrar

// operador de asignación simple

// Esta siguiente declaración arrojaría una exception

// operadores de asignación simples

// operados de asignación compuestos/cortos

Algunos de los operadores relacionales son: