Contenido

1. RESUMEN..................................................................................................................3

2. INTRODUCCIÓN.......................................................................................................3

3. OBJETIVOS................................................................................................................4

4. FUNCIONES...............................................................................................................4

4.1. FUNCIONES VIRTUALES................................................................................4

4.2. FUNCIONES VIRTUALES PURAS..................................................................4

5. OPERADORES...........................................................................................................5

5.1. Operadores asignación.........................................................................................5

5.2. Operadores aritméticos.........................................................................................5

5.3. Operadores aritméticos incrementales o decreméntales......................................6

5.4. Operadores de relación.........................................................................................6

5.5. Operadores lógicos o booleano............................................................................6

5.6. Operadores de Bit.................................................................................................7

6. OPERADORES AMIGOS..........................................................................................7

7. CONCLUSIONES.......................................................................................................7

8. PREGUNTAS..............................................................................................................8

9. BIBLIOGRAFÍA.........................................................................................................9

10. ANEXOS...................................................................................................................10
 1. RESUMEN

Que aplicó correctamente los diversos operadores en el software Dev-C++ debido a que, si

queremos usar un operador amigos, que es aquel que aún cuando no es miembro de una clase

tiene acceso a los miembros de dicha clase, no sería posible porque java solo soporta herencia

simple, en cambio el software C++ es capaz de soportar la herencia múltiple.

Al momento de implementar las funciones virtuales en Dev -C++ tenemos que poner la

palabra reservada “virtual” antes del nombre de la función, en este trabajo veremos las

funciones virtuales y funciones virtuales puras, que las diferencias de las otras funciones

igualando a 0.

2. INTRODUCCIÓN

El momento de aplicar las funciones virtuales nos permite usar unos de los pilares de la

programación orientada a objetos, el polimorfismo, que significa las diferentes formas que

puede tomar, en este caso, la función para cada clase hija.

Cuando determinamos que una función virtual sea pura debemos tener en cuenta lo

siguiente: no debe tener implementación, al hacer eso estamos obligando a que las clases

hijos las definas según sea necesario.

Entre los programas que nos permiten hacer herencia múltiple tenemos: C++, Python,

Eiffel entre otros. Que nos brinda la posibilidad que una clase pueda tomar funcionalidades

de otras clases ejemplo: La clase “Perro” puede heredar de una clase llamada “Mamífero” de

igual manera, que la clase “Mamífero” herede de la clase base “Animal”.

Los operadores al igual que las funciones puede tomar varias formas, es decir, un solo

operador puede funcionar con 2 o más tipos de variables diferentes, ejemplo: Cuando

queremos sumar 1 y 2. Guardamos los valores en 2 variables de tipo int, al momento de

utilizar el operador de aritmético, el resultado sería la suma de 1 y 2, pero también podemos

emplear al operador de aritmético cuando queremos unir 2 cadenas de caracteres.

 3. OBJETIVOS

 Diferencias entre los diversos tipos de operadores

 Aplicar el polimorfismo

 Implementación de las funciones virtuales en las clases derivadas

 Creación de casos para las funciones virtuales y operadores

4. FUNCIONES

4.1. FUNCIONES VIRTUALES

La virtualización de funciones y clases nos permite implementar uno de los pilares

fundamentales de la programación orientada a objetos, el polimorfismo. Además, permite

el ligamento tardío.

4.2. FUNCIONES VIRTUALES PURAS

La función virtual pura es solo una función declarada, en la clase base, más no la

implementación dentro de ella, ya que al definirse como pura, las subclases están

obligadas a implementarla y además no se puede instanciar de la clase que contiene

funciones virtuales puras. En Java se conoce como clase abstracta. Su estructura es:

Donde:

 ‘tipo’ es el tipo de retorno de la función

 ‘nombre_de_funcion’ es el nombre que va a tomar la función

 “=0” es quien designa la función virtual como pura.

 5. OPERADORES

5.1. Operadores asignación

El operador básico que hace referencia a una asignación es el igual (=), también

aparece una forma abreviada para representar una asignación cuando el valor de la

izquierda se repite en la derecha, tal como se muestra en la tabla.

operado
formato Equivalencia
r
+= op1+=op2 op1=op1 + op2

-= op1-=op2 op1=op1 - op2

*= op1*=op2 op1=op1 * op2

/= op1/=op2 op1=op1 / op2

%= op1%=op2 op1=op1 % op2

&= op1&=op2 op1=op1 & op2

|= op1|=op2 op1 =op1 | op2

^= op1^=op2 op1=op1 ^ op2

>>= op1>>=op2 op1 =op1 >> op2

5.2. <<= op1<<=op2 op1= op1 << op2 Operadores

>>>= op1>>>=op2 op1=op1 >>> op2 aritméticos

Todos los operadores

pueden tomar valores de enteros (int) o real (double).

Operador Formato Descripción

+ Op1 + op2 Sumar dos operandos
- Op1 – op2 Restar dos operandos
* Op1 * op2 Multiplicación de dos operandos
/ Op1 / op2 División de dos operandos
% Op1 % op2 Residuo de una división
5.3. Operadores aritméticos incrementales o decreméntales

operador formato descripción

 ++ ++op1 Op1++ Incremento de a uno
Decremento de a uno
-- --op1 Op1--

La posición en la que se pone la variable representa una cosa diferente.

5.4. Operadores de relación

Operador Formato Descripción

> Op1 > op2 Entrega true cuando op1 es mayor que op2
< Op1 < op2 Entrega true cuando op1 es menor que op2
>= Op1 >= op2 Entrega true cuando op1 es mayor igual que op2
<= Op1 <= op2 Entrega true cuando op1 es menor igual que op2
== Op1 == op2 Entrega true cuando op1 es igual que op2
!= Op1 ¡= op2 Entrega true cuando op1 es diferente que op2
Los tipos variables que es aceptado por java es de tipo primitivo, es decir, numérico,

carácter y booleanos; teniendo como resultado un valor de tipo booleano.

7 == 38 false (booleano) “a” ¡= “k” true (booleano)

5.5. Operadores lógicos o booleano

Operador formato Descripción

&& Op1 && op2 Y lógico, si los dos son verdaderos, devuelve true
|| op1 | | op2 O lógico, si uno de ellos es verdadero entrega true
! ! op1 Conocido como negación lógica, invierte el valor
Antes hemos visto la comparación entre iguales tipos de variables que además tienen

que ser primitivos, pero en este caso la comparación se hará entre datos tipos booleanos.

5.6. Operadores de Bit

Los operadores de bits solo actúan sobre int, long, byte, short o char.

Operado
Formato Descripción
r
>> Op1 >> op2 Desplaza a op1 , op2 bits a la derecha
<< Op1 << op2 Desplaza a op1, op2 bits a la izquierda
>>> Op1 >>> op2 Desplaza a op1, op2 bits a la derecha, pero sin signo
& Op1 & op2 Realiza un AND a nivel de bits
 Op1 op2 Realiza un OR a nivel de bits
^ Op1 ^ op2 Realiza un XOR a nivel de bits
~ ~ op1 Realiza el complemento de op1 a nivel de bits
 6. OPERADORES AMIGOS

Los operadores amigo tienden a ser o no miembro de una clase, pero a pesar de estar o no

incluida tiene permitido el acceso a los miembros de dicha clase.

Se utiliza en una clase, mayormente para sobrecargas con los operadores +, <<, >>; el

operador friend sirve para que un operador o función que no es miembro de una clase pueda

acceder a los miembros públicos, privados o protegidos dentro de la clase específica, para lo

cual tendremos que declarar a dicho operador o función como amigo (friend), tal como se

muestra en el ejemplo

7. CONCLUSIONES

Un solo tipo de operador puede trabajar con diferentes tipos de variables, como es el caso

de int, double, string. Pero si ingresas int debe salir int, java no reconoce la unión de un int

con un string, por ello, para poder diferencias entre esos tipos de variables necesitamos poner

para el caso de string, comillas (““), seguido el signo + y el valor int. Quedando como

resultado la línea de texto que puso y el valor que asigno a la variable, ejemplo:

System.out.println(“El valor de X es: “+ valor1);

El polimorfismo permite alterar la implementación que se tiene en una función virtual en

la clase base, debido a que una acción puede ser ejecutada de diferente manera, ejemplo: la

función “comer”, debido a que el nombre es genérico ya que no todos comemos de igual

manera. Para ello se tendría que crear la función virtual en la clase base, en ya en la clase

derivada poder especificar la acción de comer.

Para diferenciar entre los tipos de funciones debemos tener en cuenta la implementación,

las funciones virtuales pueden tener implementación, pero en las clases derivadas puede ser

modificada, en cambio, una función virtual pura nunca debe ser implementada en la clase

base, eso obligaba a ser implementada en la clase hija.

 8. PREGUNTAS

• ¿Cuál es la diferencia entre una función virtual y una función normal?

Al momento de ser llamada una función normal se llama primero a la clase padre, por

ejemplo, si en la clase padre tienes una función llamada Area(), lo que realmente se está

llamando es esa función con su implementación, en cambio, en una función virtual, el

método Area() al ser llamando en la clase main, se estará mandando la función de la clase

derivada.

• ¿Qué sucede cuando tenemos una función virtual pura?

Cuando en la clase tenemos una función virtual pura, se dice entonces que es una clase

abstracta, la cual tiene una característica importante, no se puede crear objetos en la clase,

y también solo debe ser usada como una base para que otras clases puedan heredarlo.

Todas las subclases tienen que definirse obligatoriamente para que el código pueda

compilar.

• ¿Cuáles son las diferencias entre un método abstracto en Java y una función virtual en

C ++?

Una función virtual tiene implementación en la clase base, pero una clase abstracta no

tiene. En java, la clase abstracta se crea mediante el método abstracto, usando la palabra

clave abstracta, pero en c ++ la clase abstracta se crea utilizando la función virtual pura.

Sólo una clase abstracta puede tener un método abstracto, cualquier clase puede tener

un método virtual.

9. BIBLIOGRAFÍA

El Lenguaje de Programación JavaTM. (s.f.). Obtenido de

http://www.academia.edu/14898353/El_lenguaje_de_Programaci%C3%B3n_Java

Programación ATS. (7 de Agosto de 2017). 76.Programación en Java || POO || Clases y metodos

Abstractos. Obtenido de https://www.youtube.com/watch?v=J2aXYUA1h20
Programando en {JAVA}. (8 de Junio de 2011). Obtenido de
https://palomaitor.wordpress.com/category/unidad-2/

Sobrecarga de operadores. (22 de Febrero de 2012). Obtenido de http://p-o-o-

itsav.blogspot.com/2012/02/27-sobrecarga-de-operadores.html

SOFTWARE JAOR. (9 de Octubre de 2016). Curso de C++ 78 Funciones Amigas. Obtenido de

https://www.youtube.com/watch?v=DB_2hIJ1CXc&index=125&list=PLJy7--
EGFrT15b9KujZz0zjaerAZECvl0

SOFTWARE JAOR. (10 de Octubre de 2016). Curso de C++ 86 SobreCarga Operadores. Obtenido de
https://www.youtube.com/watch?v=44buxUsu9j4

WIKILIBROS. (s.f.). Obtenido de https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B

%2B/Sobrecarga_de_Operadores

10. ANEXOS