PAC2 – POO i JavaScript

Alumno: Rubén Mejias Alonso

1.- Explica les principals diferències entre els llenguatges Java i JavaScript. (1 punt)

Java y JavaScript son dos lenguajes de programación diferentes, los cuales y debido al
parecido en su sintaxis tienden a ser confundidos. La principal diferencia entre uno y otro
radica en que Java, es un lenguaje de programación puramente orientado a objetos,
multiplataforma y de propósito general, es decir, se puede implementar en entornos
diferentes como Linux o Windows y ejecutarse en cualquier máquina con sistema operativo.

Por su parte, JavaScript también incorpora los cuatro principios básicos de la POO
(abstracción, encapsulación, herencia y polimorfismo), pero éstos no son necesarios para
utilizarlo. Además, JavaScript se implementa sobre una plataforma web sin necesidad de
utilizar ningún compilador específico.

Las principales diferencias entre Java y JavaScript son:

- Para ejecutar Java, es necesario disponer de un kit de desarrollo y un compilador

llamado Java Virtual Machine (JVM). A partir del código fuente de Java, el JVM genera
un código en formato bytecode binario, independientemente de la plataforma y el sitio
donde vaya a ser ejecutado. Los objetos que se crean en Java, agrupan todo tipo de
datos y funciones en estructuras encapsuladas. Además, se trata de un lenguaje
robusto y con un fuerte tipado, ya que siempre hemos de declarar los tipos de
variables que vamos a utilizar.

- Por su parte, a pesar de incorporar recientemente entre sus funciones los cuatro
principios básicos de la POO (abstracción, encapsulación, herencia y polimorfismo),
JavaScript, nació en entornos basados en lo navegadores y se diseñó con el propósito
de complementar las funciones e interacciones propias de las páginas web creadas con
HTML.

Se trata de un lenguaje incrustado, basado en prototipos e interpretado, es decir, es el

navegador el encargado de interpretarlo una vez que éste carga el documento HTML.
A diferencia de Java, JavaScript ofrece un gran dinamismo y un tipado débil, ya que
por ejemplo, no hace falta declarar el tipo de dato que queremos almacenar dentro de
las variables, además, podemos modificar siempre que queramos la información
almacenada en dicha variable.

2.- Explica amb les teves paraules en que consisteix l’herència i l’abstracció dins del
paradigma de la programació orientada a objectes. (1 punt)

El concepto de herencia se ajusta al objetivo principal que persigue la POO, tratar de

representar en un programa todo aquello que existe en el mundo real. A diferencia de otros
modelos de programación donde los procesos lógicos eran los principales protagonistas a la
hora de ejecutar un programa, con unos datos de entrada, unos procesos intermedios y unos
datos finales de salida, la POO nace como hemos dicho, para crear aplicaciones que simulen
entornos propios del mundo real.

Para lograr este cometido la POO hace uso de un modelo basado en tres conceptos: clases,
objetos y herencia. La herencia es un mecanismo propio de la POO por el cual una nueva
clase (objeto) puede heredar (copiar) de su clase madre, aquellas características que nos
interesen, tanto sus propiedades como sus métodos. Además, siempre podemos añadir
tantas propiedades o métodos como consideremos oportunos en la nueva clase hija. La
misión principal de la herencia es la reutilización del código, ya que con ella conseguimos
especializar a una clase determinada dentro de una clase más general.

El concepto de abstracción es uno de los más importantes para entender el funcionamiento

de la POO. Se trata de realizar un ejercicio mental, mediante el cual podamos simplificar y
extraer las características esenciales de aquellos problemas u objetos de la vida real que
queremos representar en nuestro programa. Debemos ser capaces de distinguir las
características esenciales que hacen que un objeto se diferencie de otro, analizar su
comportamiento y enfocar nuestra visión en su capa externa. Gracias a esta técnica,
podemos definir una interfaz concreta para representar a nuestros objetos.

3.- El propietari d'una empresa, Vivers ElVerd, ens demana un programa per gestionar els
seus treballadors. Les dades que tenim d'ells són: el nom, els cognoms, la data d’alta a
l’empresa i el seu salari sense plusos. Entre els treballadors podem diferenciar entre
venedors i jardiners. Els jardiners a diferencia dels venedors tenen un plus en el seu salari de
200€ en dietes.

Crea les classes que creguis que siguin necessàries amb els seus atributs i els mètodes
necessaris per accedir i actualitzar-los.
(3 punts)

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Ejercicio 3</title>
<script type="text/javascript">

//Definimos clase madre

function Trabajador (nombre, apellidos, fecha, salario){

//Propiedades públicas. Gracias a la palabra reservada .this, estas propiedades seran accesibles
desde cualquier parte del programa, instancias incluidas
this.nombre = nombre;
this.apellidos = apellidos;
this.fecha = fecha;
this.salario = salario;

//Métodos públicos. Con ellos permitimos que otras partes del programa puedan utilizarlos.
//Métodos para obtener el nombre, apellidos, fecha de alta y salario sin plus del trabajador.

this.getNombre = function(){
return nombre;
}

this.getApellidos = function(){
return apellidos;
 }

this.getFecha = function(){
return fecha;
}

this.getSalario = function(){
return salario;
}

this.muestraInfo = function (){

alert ("Nombre del trabajador: " + this.nombre + "\n\nApellidos: " + this.apellidos +
"\n\nFecha de alta: " + this.fecha);
}

this.muestraSalario = function (){

alert ("Salario del trabajador: " + this.salario);
}

//Definimos la clase hija vendedor

function Vendedor (nombre, apellidos, fecha, salario){

//Con el método call() se llama al constructor de la clase Trabajador. Utilizamos .this para heredar los
parametros definidos en la clase madre Trabajador

Trabajador.call(this, nombre, apellidos, fecha, salario);

//Definimos la clase hija jardinero

function Jardinero (nombre, apellidos, fecha, salario){

//Métodos
Trabajador.call(this, nombre, apellidos, fecha, salario);
this.calcularSalario = function (){
this.salario = salario ;
dietas = 200;
total = salario + dietas;
alert ("Salario del trabajador incuyendo dietas: " + total);
}

</script>
</head>

<body>
</body>
</html>

4.- Partint de l’exercici anterior afegeix on calgui els mètodes:

a) “calcularSalari()” que calculi i retorni el salari final (plus inclòs si s'escau) del
treballador.
b) “mostraInfo()” que mostri en un alert totes les dades del treballador tret del salari.
c) “mostraSalari()” que mostri el salari final del treballador en un alert.

Crea una instancia per a cada tipus de treballador i crida els dos últims mètodes creats.
(2 punt)

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Ejercicio 3</title>
<script type="text/javascript">

//Definimos clase madre

function Trabajador (nombre, apellidos, fecha, salario){

//Propiedades públicas. Con la palabra reservada .this, estas propiedades seran accesibles
desde cualquier parte del programa.

this.nombre = nombre;
this.apellidos = apellidos;
this.fecha = fecha;
this.salario = salario;

//Métodos públicos. Con ellos permitimos que otras partes del programa puedan utilizarlos.
//Métodos para obtener el nombre, apellidos, fecha de alta y salario sin plus del trabajador.

this.getNombre = function(){
return nombre;
}

this.getApellidos = function(){
return apellidos;
}

this.getFecha = function(){
return fecha;
}

this.getSalario = function(){
return salario;
}

this.muestraInfo = function (){

alert ("Nombre del trabajador: " + this.nombre + "\n\nApellidos: " + this.apellidos +
"\n\nFecha de alta: " + this.fecha);
}

this.muestraSalario = function (){

alert ("Salario del trabajador: " + this.salario);
}
}

//Definimos la clase hija vendedor

function Vendedor (nombre, apellidos, fecha, salario){

//Con el método call() se llama al constructor de la clase Trabajador. Utilizamos .this para
heredar los parametros definidos en la clase madre Trabajador

Trabajador.call(this, nombre, apellidos, fecha, salario);

}
// Creamos una instancia nueva del tipo Trabajador en el prototipo de la clase vendedor. Ahora
podemos acceder a las propiedades públicas de la clase Trabajador en cualquiera de las instancias de
la clase Vendedor que creemos.

Vendedor.prototype = new Trabajador ();

//Definimos un nuevo vendedor

var vendedor = new Vendedor ("Juan","Rodriguez Moreno","22 de Mayo de 1998", 1000)

//Métodos para mostrar la información y el sueldo sin dietas

vendedor.muestraInfo();
vendedor.muestraSalario();

//Definimos la clase hija jardinero

function Jardinero (nombre, apellidos, fecha, salario){

Trabajador.call(this, nombre, apellidos, fecha, salario);
this.calcularSalario = function (){
this.salario = salario ;
dietas = 200;
total = salario + dietas;
alert ("Salario del trabajador incuyendo dietas: " + total);
}

}
// Creamos una instancia nueva de la clase Trabajador

Jardinero.prototype = new Trabajador ();

var jardinero = new Jardinero ("Pedro","Mendez Ortega","5 de Agosto de 2011", 1000)

//Métodos para mostrar la información y el sueldo con dietas

jardinero.muestraInfo();
jardinero.calcularSalario();

</script>
</head>
<body>
</body>
</html>
5.- Crea un script on l'usuari introdueix una cadena de text sobre la que realitzarà les
següents accions, mostrant al final el resultat a la pàgina HTML :
• Sol·licitarà la introducció d’una paraula i ens dirà quantes vegades apareix a la cadena de
text introduïda anteriorment.
• Ens mostrarà un resum de tots els caràcters que conté la cadena de text i el nombre de
vegades que apareixen.
• Tornarà el nombre de paraules de la cadena.
• Canviarà a majúscula la primera lletra de cada paraula.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"

"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title>Documento sin título</title>
<script type="text/javascript">

// Solicitamos al ususario la entrada del texto para analizar y la palabra que deseamos encontrar
var cadena = prompt("INTRODUZCA UN TEXTO : ");
var palabra = prompt ("Introduzca la palabra que desea encontrar: ")

//FUNCIÓN PARA CONTAR LAS REPETICIONES DE TEXTO EN LA CADENA

function Caracteres (){
/* CONTAR CARÁCTERES:
Convertimos la cadena de texto en un array mediante la funcion split(), pasándole como
separador el parámetro sin espacio "".
Así el array estará compuesto sólo por carácteres. */
arrayChar = cadena.split("");
contarChar = arrayChar.length ; // PROPIEDADES DEL STRING. Contamos los carácteres de la
cadena array con la propiedad .length

repes = 0; //Iniciamos el contador a 0 para contar el número de repeticiones

posicion = cadena.indexOf(palabra); // con indexOf buscamos desde el principio de la cadena

el carácter que le pasamos como parámetro
posicion2 = cadena.lastIndexOf(palabra); // con lastIndexOf hacemos lo mismo pero la
búsqueda comienza por el final de la cadena
posicion2 = contarChar - posicion2 ; // posición final del último carácter

//Iniciamos el bucle para recorrere los arrays

while (contarChar >= posicion2) {
posicion = cadena.indexOf(palabra); //punto para modificar
posicion++; //Avanzamos en el array

cadena = cadena.substring(posicion); //con substring() devolvemos la porción de texto

indicada en el parámetro
contarChar -= posicion; // creamos una nueva posición
repes++; // incrementamos en 1 el contador
}

// ESCRIBIMOS LOS RESULTADOS OBTENIDOS

if (posicion >= 0) {
document.write ("La palabra: " + palabra + " se repite " + repes + " veces.");
document.write("<br />");
document.write("<br />");
 }
else {
document.write ("La palabra: " + palabra + " no se encuetra en el texto.");
document.write("<br />");
document.write("<br />");

//FUNCIÓN PARA MOSTRAR EL NÚMERO DE CARÁCTERES DEL TEXTO

function numCaracteres (){
arrayNumChar = cadena.split("");
contarNumChar = arrayNumChar.length ;

repeticion=0;
for(i=0; i < contarNumChar; i++){
if(contarNumChar.charAt(i) == 2){ //Con el método charAt(), conseguimos
extraer los carácteres indicados en el parámetro
//Si la condición anterior se repite, se añade una unidad a la variable donde guardamos
las repeticiones totales.
repeticion++;
}
}
// ESCRIBIMOS LOS RESULTADOS OBTENIDOS
if (contarNumChar >= 0) {
document.write ("El carácter: " + contarNumChar + " se repite " + repeticion + "
veces.");
document.write("<br />");
document.write("<br />");

}
else {
alert ("No hay carácteres en el texto introducido.");

}
}

//FUNCIÓN PARA CONTAR PALABRAS

function numPalabras (){

// Creamos un array mediante la funcion split(), pasandole como separador el parámetro
espacio " " y así poder aislar cada palabra
arrayPalabras = cadena.split(" ");
contarPalabras = arrayPalabras.length; // PROPIEDADES DEL STRING. Contamos los carácteres
de la cadena array con la propiedad .length

document.write ("El texto anterior contiene: " + contarPalabras + " palabras. "); // mostramos
el resultado en un alert
document.write("<br />");
document.write("<br />");

//FUNCIÓN PARA CAMBIAR LA PRIMERA LETRA DE CADA PALABRA POR UNA MAYÚSCULA
function Mayuscula(cadena) {

arrayMayuscula = cadena.split(" ");

salida = []; // utilizamos la propiedad para crear arrays [ ].Así podremos conocer los argumentos que
pasaremos al llamar a la función

for (var i = 0; i < arrayMayuscula.length; i++) { //recorremos el array

/*Utilizamos el método replace(),el cual nos sirve para substituir el texto indicado por el que
queramos. Este método admite dos parámetros, con el primer parámetro
indicamos el texto que queremos substituir y con el segundo parámetro, introducimos el texto
deseado:

1-) arrayMayuscula[i].charAt(0): en el primer parámetro indicamos la posición del elemento en

el array y con charAt retornamos el carácter indicado entre paréntesis. En
este caso el primero de cada palabra.

2-) arrayMayuscula[i].charAt(0).toUpperCase(): en el segundo parámetro con el método

toUpperCase convertimos el carácter indicado en mayúscula */

salida[i] = arrayMayuscula[i].replace(arrayMayuscula[i].charAt(0),
arrayMayuscula[i].charAt(0).toUpperCase() );

}
//Escribimos los resultados
// El método join() convierte el array obtenido en una nueva cadena, además podemos
especificar la separación de los nuevos elementos usando su parámetro, en nuestro caso
queremos palabras separadas (" ")
document.write("Cambiamos la primera letra por una mayúscula: <br />" + salida.join(" "));
document.write("<br />");
document.write("<br />");

Caracteres ();
numPalabras ();
Mayuscula(cadena);

</script>
</head>

<body>
</body>
</html>