Respuesta D: El while necesita evaluar una expresión para continuar con el programa;

Respuesta D: Estos return se encuentran invertidos ya que dentro del while se está validando
que cada carácter de la cadena (input) sea diferente al carácter que se encuentra en la
posición opuesta de esta cadena, es decir que dentro del while se está validando que la
palabra No sea palíndroma, por lo cual el retorno debería ser false en lugar de true para así
negar que esta palabra es Palíndroma.
Respuesta C: Porque según el diagrama UML, la subclase “Alternativo” hereda de “Vapor”.

Respuesta 2: Porque una subclase si puede heredar los miembros private de su superclase y
Java solo permite heredar de una sola clase.
Respuesta: La herencia fomenta la reutilización de código, ya que a lo largo de un problema se
pueden encontrar métodos o atributos que deben ser usados de manera constante, por lo que
no tiene sentido perder tiempo redefiniéndolos lo más lógico es reutilizar el código que ya
tenemos definido y para esto nos sirve la herencia. En el caso de la abstracción su ventaja es
que nos beneficia en la arquitectura de un programa al permitirnos predefinir métodos y
obligar a las clases hijas de una clase abstracta a implementar estos métodos.

Respuesta 1: Porque el método abstracto si obliga a las subclases para que lo implementen y a
una clase declarada como final no se le permite heredar.

Respuesta 7: JFrame, JPanel, JButton, JMenu, JMenuBar, JMenuItem.

Respuesta 8:

//Principal

package org.example;
import java.util.Scanner;

public class App {

public static void main(String[] args) {

int id;

String name;

double price;

Producto carrito[] = new Producto[5];

//Objetos para llamar a los metodos de precio según la clasificación del producto.

ProPerecedero perecederos = new ProPerecedero();

ProNoPerecedero noPerecedero = new ProNoPerecedero();

System.out.println("Ingrese la cantidad de productos: ");

Scanner scan = new Scanner(System.in);

int cant = scan.nextInt();

int respuesta; // Esta variable se usa para identificar el producto que el usuario desea.

//Intancias de los objetos que representan los productos del almacen.

ProPerecedero proPerecedero1 = new ProPerecedero(1, "Leche", 2000, 3, true);

ProPerecedero proPerecedero2 = new ProPerecedero(2, "Queso", 1500, 2, true);

ProPerecedero proPerecedero3 = new ProPerecedero(3, "Yogurt", 1800, 6, true);

ProNoPerecedero proNoPerecedero1 = new ProNoPerecedero(4, "Harina", 2500, false);

ProNoPerecedero proNoPerecedero2 = new ProNoPerecedero(5, "Azucar", 2200, false);

//En este switch se identifica el producto que desea el usuario.

for (int i = 0; i < cant; i++) {

System.out.println("Escoja su/sus productos: ");

System.out.println(" 1 = leche \n 2 = Queso \n 3 = Yogurt \n 4 = Harina \n 5 = Azucar ");

respuesta = scan.nextInt();
 switch (respuesta) {

case 1:

carrito[i] = proPerecedero1;

break;

case 2:

carrito[i] = proPerecedero2;

break;

case 3:

carrito[i] = proPerecedero3;

break;

case 4:

carrito[i] = proNoPerecedero1;

break;

case 5:

carrito[i] = proNoPerecedero2;

break;

//Impresion del precio total de los productos de acuerdo a su clasificación

System.out.println("Precio de los perecederos: " + perecederos.productPrice(cant,

carrito));

System.out.println("Precio de los no perecederos: " + noPerecedero.productPrice(cant,

carrito));

//Clase Producto
package org.example;
public abstract class Producto {

int id = 0;

private String name;

private double price;

private int diasCad;

private boolean tipoPerecedero;

public Producto() {

//Constructor para inicializar las variables del producto perecedero

public Producto(int id, String name, double price, int diasCad, boolean tipoPerecedero)

this.setId(id);

this.setName(name);

this.setPrice(price);

this.setDiasCad(diasCad);

this.setTipoPerecedero(tipoPerecedero);

//Constructor para inicializar las variables del producto no perecedero, este no recibe los
dias a caducar.

public Producto(int id, String name, double price, boolean tipoPerecedero)

this.setId(id);

this.setName(name);

this.setPrice(price);

this.setDiasCad(diasCad);

this.setTipoPerecedero(tipoPerecedero);

}
//Encapsulamiento de los atributos de la clase

public int getId() {

return id;

public void setId(int id) {

this.id = id;

public String getName() {

return name;

public void setName(String name) {

this.name = name;

public double getPrice() {

return price;

public void setPrice(double price) {

this.price = price;

public int getDiasCad() {

return diasCad;

public void setDiasCad(int diasCad) {

this.diasCad = diasCad;
 }

public boolean isTipoPerecedero() {

return tipoPerecedero;

public void setTipoPerecedero(boolean tipoPerecedero) {

this.tipoPerecedero = tipoPerecedero;

//Método abstracto para obligar a las subclases "ProPerecedero" y "ProNoPercedero a

implementar un método para obtener el precio"

abstract public double productPrice(int cantProd, Producto carrito[]);

//Metodo para obtener de manera general el precio de todos los productos

static public double productPrices(int cantProd, Producto carrito[])

double total = 0;

for (int i=0; i < cantProd; i++)

total = total + carrito[i].price;

return total;

//Clase del producto perecedero

package org.example;

public class ProPerecedero extends Producto {

 //Constructor vacio para hacer uso de los metodos de esta clase

public ProPerecedero() {

//En este inicializan los atributos que se heredan de la clase "Producto"

public ProPerecedero(int id, String name, double price, int diasCad, boolean tipoPerecedero)
{

super(id, name, price, diasCad, tipoPerecedero);

//Implementación del metodo abstracto de la clase "Producto"

public double productPrice(int cantProd, Producto carrito[]) {

double total = 0;

for (int i = 0; i < cantProd; i++) {

if(carrito[i].isTipoPerecedero() == true )

switch (carrito[i].getDiasCad()) {

case 1:

total = total + (carrito[i].getPrice() * 0.1);

break;

case 2:

total = total + (carrito[i].getPrice() * 0.25);

break;

case 3:

total = total + (carrito[i].getPrice() * 0.5);

break;

default:

total = total + getPrice();

}
 }

return total;

//Clase del producto no perecedero

package org.example;

public class ProNoPerecedero extends Producto {

//Constructor vacio para hacer uso de los metodos de esta clase

public ProNoPerecedero() {

//En este inicializan los atributos que se heredan de la clase "Producto"

public ProNoPerecedero(int id, String name, double price, boolean tipoPerecedero) {

super(id, name, price, tipoPerecedero);

//Implementación del metodo abstracto de la clase "Producto"

public double productPrice(int cantProd, Producto carrito[]) {

double total = 0;

int count = 0;

for (int i = 0; i < cantProd; i++) {

if (carrito[i].isTipoPerecedero() == false) {

total = total + carrito[i].getPrice();

return total;