public class Menú {
public static void main(String[] args){
Interfaz i=new Interfaz();
System.out.println("¡Hola, bienvenido al programa de creación de peronajes!");
i.main();
}
}
---------------------------------------------------------------------------------------------------------------------------
import java. util.Scanner;
import Datos.Datos;
import Lógica.Lógica;
public class Interfaz {
public void main(){
Scanner kai=new Scanner(System.in);
Lógica l=new Lógica();
Datos d= new Datos();
System.out.println("Hola, ¿quieres crear tu personaje?");
System.out.println("<1> Si" );
System.out.println("<2> No");
int opc= kai.nextInt();
switch(opc){
case 1:
l.Crear();
l.Acciones();
break;
case 2:
System.out.println("¡Oh!, parece que no vamos poder jugar hoy");
}
}
}
---------------------------------------------------------------------------------------------------------------------------
package Lógica;
import Datos.Datos;
import java.util.Scanner;
public class Lógica {
Scanner kai= new Scanner(System.in);
Datos d=new Datos();
public void Crear(){
System.out.println("¡Tu personaje ha sido creado!");
System.out.println("Ingresa el nombre del personaje");
d.setNombre(kai.next());
System.out.println("Ingresa el apellido del personaje");
d.setApellido(kai.next());
System.out.println("Ingresa la edad del personaje");
d.setEdad(kai.nextInt());
System.out.println("Describeme un poco tu personaje");
d.setPersonalidad(kai.next());//Preguntar cómo hacer que sea una oraón y no solo una palabra
System.out.println("Ingresa la estatura del personaje");
d.setEstatura(kai.nextDouble());
System.out.println("Selecciona el sexo de tu personaje");
System.out.println("<1> Femenino");
System.out.println("<2> Masculino");
int opc69= kai.nextInt();
switch(opc69){
case 1: d.setSexo("Femenino");
break;
case 2: d.setSexo("Masculino");
}
}
public void Acciones(){
boolean again=true;
while (again==true){
System.out.println("Selecciona qué deseas hacer ahora");
System.out.println("<1> Bailar");
System.out.println("<2> Caminar");
System.out.println("<3> Hablar");
System.out.println("<4> Mostrar Personaje");
System.out.println("<5> Salir");
int opc3= kai.nextInt();
switch(opc3){
case 1:
Bailar();
break;
case 2:
Caminar();
break;
case 3 :
break;
case 4:
Mostrar();
break;
case 5 :System.out.println("¡Muchas gracias por jugar!, espero nos veamos de nuevo");
again=false;
break;
default: System.out.println("Ingresa alguna opción válida" );
}
}
}
public void Mostrar(){
System.out.println("El nombre de tu personaje es: "+ d.getNombre());
System.out.println("El apellido de tu personaje es: "+ d.getApellido());
System.out.println("La edad de tu personaje es: "+ d.getEdad());
System.out.println("La estatura de tu personaje es: "+d.getEstatura());
System.out.println("El género de tu personaje es "+ d.getSexo());
System.out.println("Su personalidad es: "+ d.getPersonalidad());
}
public void Hablar(){
}
public void Caminar(){
System.out.println(d.getNombre()+" está caminando\n¿Quieres que siga caminando?");
System.out.println("<1> Si");
System.out.println("<2> No");
int opc6=kai.nextInt();
switch(opc6){
case 1:
System.out.println(d.getNombre()+" está caminando\n¿Quieres que siga caminando?");
System.out.println("<1> Si");
System.out.println("<2> No");
int opc47=kai.nextInt();
switch(opc47){
case 1:System.out.println(d.getNombre()+" está caminando\n¿Quieres que siga caminando?");
System.out.println("<1> Si");
System.out.println("<2> No");
int opc78=kai.nextInt();
switch(opc78){
case 1: System.out.println(d.getNombre()+" está caminando\n"+d.getNombre()+" se pierde en el horizonte sin dejar de caminar.");
break;
case 2: System.out.println(d.getNombre()+" se ha detenido, igual ya estaba cansado de caminar");
break;
}
break;
case 2: System.out.println(d.getNombre()+ "se ha detenido, pero quería caminar más.");
break;
default:System.out.println("Escribe alguna de las opciones");
}
case 2: System.out.println(d.getNombre()+ "se ha detenido, pero quería caminar más.");
break;
default:System.out.println("Escribe alguna de las opciones");
}
}
public void Bailar(){
System.out.println(d.getNombre()+" está bailando reguetón");
System.out.println(d.getNombre()+" se ha emocionado.");
System.out.println("¡Oh no!, "+ d.getNombre()+" está siendo infectado por el virus incurable de guisus declaratus");
System.out.println("...");
System.out.println("Selecciona qué deseas hacer:");
System.out.println("<1> Detenerlo");
System.out.println("<2> Dejarlo");
int opc4= kai. nextInt();
switch (opc4){
case 1: System.out.println("Has salvado a "+d.getApellido()+" de ser víctima de los efectos radioactivos del reguetón");
break;
case 2: System.out.println("¡No creo que esta sea una buena idea!");
System.out.println("");
System.out.println(d.getNombre()+" èztAá ézcRívìEmDdo Ázhi");
System.out.println("ZzëlétsíòNnä khé kïérèz äsÉr:");
System.out.println("<1> Detenerlo");
System.out.println("<2> Dejarlo");
int opc2= kai.nextInt();
switch(opc2){
case 1: System.out.println( "¡Has salvado a"+ d.getNombre()+" de un daño cerebral demasiado grave!, \nDesafortunadamente ha quedado con graves secuelas que lenguaje que requerirán años de apoyo emocional y lectura avanzada a la que quizá no sobreviva dadas las circunstancias. \nQuizá debas disponer de un lavado cerebral.");
case 2:
if (d.getEdad()<18){
System.out.println(d.getNombre()+" tan solo tiene "+ d.getEdad()+" no sé si deba estar haciendo esto");
System.out.println("¡Oh no!, " + d.getNombre()+ " se hace llamar \"Nalgas miadas\" ");
}
else{
System.out.println("Sé que " + d.getNombre()+ " tiene ya "+ d.getEdad()+ ", pero no creo que lo que está haciendo sea legal ");
System.out.print("¡Oh no!, " +d.getNombre());
NombreR();
System.out.println(" se ha cambiado el nombre a "+ d.getNombre() );
System.out.println("¡Me parece que el virus se ha estado extendiendo mientras la dignidad de "+ d.getNombre()+ " baja poco a poco!");
System.out.println("¡Oh no!, debes seleccionar qué hacer:");
System.out.println("<1> Detener esta horrible escena");
System.out.println("<2> Seguir con el sadismo");
int opc54=kai.nextInt();
switch(opc54){
case 1 : System.out.println("Desafortunadamente es demasiado tarde para salvar a "+d.getNombre()+ "...\n Ahora padece de ñerous poutous...\n Te apuñala por la espalda y mueres.");
System.exit(0);
break;
case 2: System.out.println("¿Contento?, "+d.getNombre()+"Ha conocido una pareja de su estirpe y se ha ido a asaltar gente y rombar celulares");
}
}
}
}
}
public void NombreR(){
int Ran;
Ran=(int)Math.random()*(1-4)+4;
if(d.equals("Femenino")){
if (Ran==1){
d.setNombre("Shirley Zurleidy" );
}
else{
if(Ran==2){
d.setNombre("Marylin Faizuly");
}
else{
if(Ran==3){
d.setNombre("Yumilei");
}
else{
if (Ran==4){
d.setNombre("Jacinta");
}
}
}
}
}
else{
if(Ran==1){
d.setNombre("Brayatan");
}
else{
if(Ran==2){
d.setNombre("Kevin");
}
else{
if (Ran==3){
d.setNombre("Irvin");
}
else{
if (Ran==4){
d.setNombre("Edwin");
}
}
}
}
}
}
}
---------------------------------------------------------------------------------------------------------------------------
package Datos;
public class Datos {
private String Nombre;
private int Edad;
private double Estatura;
private String Apellido;
private String Personalidad;
private String Sexo;
public Datos(){
this.Nombre=Nombre;
this.Edad=Edad;
this. Estatura=Estatura;
this.Apellido=Apellido;
this.Personalidad=Personalidad;
this.Sexo=Sexo;
}
public String getSexo() {
return Sexo;
}
public void setSexo(String sexo) {
Sexo = sexo;
}
public String getNombre() {
return Nombre;
}
public void setNombre(String nombre) {
Nombre = nombre;
}
public int getEdad() {
return Edad;
}
public void setEdad(int edad) {
Edad = edad;
}
public double getEstatura() {
return Estatura;
}
public void setEstatura(double estatura) {
Estatura = estatura;
}
public String getApellido() {
return Apellido;
}
public void setApellido(String apellido) {
Apellido = apellido;
}
public String getPersonalidad() {
return Personalidad;
}
public void setPersonalidad(String personalidad) {
Personalidad = personalidad;
}
}
Eso es todo
viernes, 16 de septiembre de 2016
lunes, 12 de septiembre de 2016
Programación en capas
Ejemplo
public class Datos {
private String Sabor;
private String Crocante;
private String Tipo;
public Datos() {
Sabor="";
Crocante="";
Tipo="";
}
public String getSabor() {
return Sabor;
}
public void setSabor(String sabor) {
Sabor = sabor;
}
public String getCrocante() {
return Crocante;
}
public void setCrocante(String crocante) {
Crocante = crocante;
}
public String getTipo() {
return Tipo;
}
public void setTipo(String tipo) {
Tipo = tipo;
}
}
-----------------------------------------------------------------------------------------------------------------
import java.util.Scanner;
public class Lógica {
Scanner kai= new Scanner(System.in);
Datos dat=new Datos();
public void Sabor(){
System.out.println("Escoge el sabor de helado que quieres");
System.out.println("<1> Fresa");
System.out.println("<2> Chocolate");
System.out.println("<3> Mandarina-Limón");
int opc=kai.nextInt();
switch(opc){
case 1: System.out.println("Ha escogido el helado de fresa");
dat.setSabor("fresa");
break;
case 2:System.out.println("Ha escogido el helado de chocolate");
dat.setSabor("chocolate");
break;
case 3:System.out.println("Ha escogido el helado de Mandarina-Limón");
dat.setSabor("mandarina-limón");
break;
default: System.out.println("No has escogido ninguna de las opciones válidas");
}
System.out.println("Escoge el crocante que quieres");
System.out.println("<1> Barquillos");
System.out.println("<2> Pepitas de colores");
System.out.println("<3> Uvas pasas");
int opc2=kai.nextInt();
switch(opc2){
case 1: System.out.println("Ha escogido barquillos");
dat.setCrocante("barquillos");
break;
case 2:System.out.println("Ha escogido pepitas de colores");
dat.setCrocante("pepitas de colores");
break;
case 3:System.out.println("Ha escogido uvas pasas");
dat.setCrocante("uvas pasas");
break;
default: System.out.println("No has escogido ninguna de las opciones válidas");
}
System.out.println("Escoge el tipo de helado que quieres");
System.out.println("<1> Canastilla");
System.out.println("<2> Sencillo");
System.out.println("<3> Especial");
int opc3=kai.nextInt();
switch(opc3){
case 1: System.out.println("Ha escogido la Canastilla");
dat.setTipo("canastilla");
break;
case 2:System.out.println("Ha escogido el helado sencillo");
dat.setTipo("sencillo");
break;
case 3:System.out.println("Ha escogido el helado especial");
dat.setTipo("especial");
break;
default: System.out.println("No has escogido ninguna de las opciones válidas");
}
System.out.println("Ya está listo tu helado de "+dat.getSabor()+" con crocante "+dat.getCrocante()+" de tipo "+dat.getTipo()+".\n Recógelo en la caja y no olvides pagar.");
}
}
--------------------------------------------------------------------------------------------------------------------
import java.util.Scanner;
public class Visualización {
public static void main(String[]args){
Scanner kai= new Scanner(System.in);
Datos dat=new Datos();
Lógica log= new Lógica();
System.out.println("¡Bienvenido a la heladería!");
log.Sabor();
}
}
viernes, 9 de septiembre de 2016
Ejercicio 3 : Interfaces 1
public interface PuedeNadar {
public void Nadar();
}
public void Nadar();
}
-------------------------------------
public interface PuedeVolar {
public void Volar();
}
-------------------------------------
public interface PuedeCaminar {
public void Caminar();
}
-------------------------------------
public abstract class Mamífero implements PuedeCaminar{//Como no se puede generalizar entre mamíferos se le pone abstracto para no implementarlo aquí
public abstract void Caminar();
public abstract void Nadar();
}
-------------------------------------
public abstract class Aves implements PuedeVolar, PuedeCaminar{
public abstract void Volar();
public abstract void Caminar();
}
public abstract void Volar();
public abstract void Caminar();
}
---------------------------------------------------------------------------------------------------------------
public class Avestruz extends Aves implements PuedeCaminar{
public void Caminar() {
System.out.println("El avestruz está caminando, preparándose para correr");
}
public void Volar(){
System.out.println("El avestruz es un ave que no puede volar, pero si puede correr");
}
}
---------------------------------------------------------------------------------------------------------------
public class Murciélago extends Mamífero implements PuedeVolar{
public void Caminar() {
System.out.println("¡Oh no!, parece que es un murciélago vampiro ! º - º !\n(⊙_◎)\n ....¡Y está caminando! (✖╭╮✖) ");
}
public void Volar() {
System.out.println("El murciélago está volando, ¡por suerte es un comefruta!(｡◕‿◕｡) ");
}
public void Nadar() {
}
}
--------------------------------------------------------------------------------------------------------------------------
public abstract class Felino extends Mamífero {
public abstract void Caminar();
public abstract void Nadar();
}
public abstract void Caminar();
public abstract void Nadar();
}
--------------------------------------------------------------------------------------------------------------------------
public class Gato extends Felino {
public void Nadar() {
System.out.println("¡El gato está nadando!");
}
public void Caminar() {
System.out.println("El gato está caminando");
}
}
--------------------------------------------------------------------------------------------------------------------------
public class Loro extends Aves implements PuedeCaminar{
public void Caminar() {
System.out.println("El loro está caminando");
}
public void Volar(){
System.out.println("El loro está volando");
}
}
--------------------------------------------------------------------------------------------------------------------------
public class Tigre extends Felino {
public void Nadar() {
System.out.println("¡El tigre está nadando!");
}
public void Caminar() {
System.out.println("El tigre está caminando");
}
}
--------------------------------------------------------------------------------------------------------------------------
import java.util.Scanner;
public class RumAnimal {
public static void main(String[]args){
Gato g=new Gato();
Loro l=new Loro();
Avestruz a=new Avestruz();
Murciélago m=new Murciélago();
Tigre t=new Tigre();
Scanner sc=new Scanner(System.in);
System.out.println("¡Hola!, bienvenido al menú de los animales, por favor selecciona una de las siguientes opciones:");
System.out.println("<1> Avestruz");
System.out.println("<2> Loro");
System.out.println("<3> Gato");
System.out.println("<4> Murciélago");
System.out.println("<5> Tigre");
int opc= sc.nextInt();
switch(opc){
case 1: System.out.println("Has escogido la avestruz, ahora selecciona qué deseas que haga:");
System.out.println("<1> Caminar");
System.out.println("<2> Volar");
int opc2=sc.nextInt();
switch(opc2){
case 1 : a.Caminar();
break;
case 2: a.Volar();
break;
}
break;
case 2: System.out.println("Has escogido el loro, ahora selecciona qué deseas que haga:");
System.out.println("<1> Caminar");
System.out.println("<2> Volar");
int opc3=sc.nextInt();
switch(opc3){
case 1 : l.Caminar();
break;
case 2: l.Volar();
break;
}
break;
case 3: System.out.println("Has escogido el gato, ahora selecciona qué deseas que haga:");
System.out.println("<1> Nadar");
System.out.println("<2> Caminar");
int opc4=sc.nextInt();
switch(opc4){
case 1 : g.Nadar();
break;
case 2: g.Caminar();
break;
}
break;
case 4: System.out.println("Has escogido el murciélago, ahora selecciona qué deseas que haga:");
System.out.println("<1> Caminar");
System.out.println("<2> Volar");
int opc5=sc.nextInt();
switch(opc5){
case 1 : m.Caminar();
break;
case 2: m.Volar();
break;
}
break;
case 5: System.out.println("Has escogido el tigre, ahora selecciona qué deseas que haga:");
System.out.println("<1> Caminar");
System.out.println("<2> Nadar");
int opc6=sc.nextInt();
switch(opc6){
case 1 : t.Caminar();
break;
case 2: t.Nadar();
break;
}
break;
default: System.out.println("Has escogido una opción errónea.");
}
}
}
martes, 6 de septiembre de 2016
Relaciones entre clases
RELACIONES ENTRE CLASES
Karem Valentina Pinto Fuentes
En cuanto a relaciones entre clases nos referimos a los tipos de comunicación
que puede haber tanto entre ellas como entre sus objetos.
La comunicación entre clase solo puede llevarse a cabo a través de la
parte pública de las clases, es decir, las partes declaradas como package.
También se encuentra el tipo protegido o “protected” que permite la interacción
entre las clases herederas y la súper clase por medio de atributos o métodos
que solo estas pueden ver.
Existen grandes grupos de relaciones entre clases:
· Relaciones de generalización/especialización:
Este es el tipo más básico de relación y ocurre cuando hay una super
clase que es la generalización de algo y las subclases la especialización de
eso mismo. Como en el caso de la clase principal Empleado de la cual se heredan
las clases Asalariado, Por comisión y Por horas, lo cual, cabe aclarar es un tipo
de herencia múltiple, en caso de que solo se heredara una clase sería simple.
Código
public class Empleado(){
}
public class Asalariado extends Empleado(){
}
public class Porcomisión extends Empleado (){
}
public class Porhoras extends Empleado (){
}
·
Comunicación por
asociación:
Este tipo de comunicación simplemente señala la relación entre
clases, pueden funcionar en ambos sentidos.
Código
Contiene dos tipos especiales, agrupación y la composición.
1. Agrupación: Es cuando una clase forma parte de otra. Varias clases compuestas
pueden tener las mismas asociaciones de agregación o varias asociaciones de
agregación distintas, además borrar el compuesto no quiere decir la eliminación
de los componentes.
Código
public class
Empresa(){
private [] int
clientes;
public
void addCliente(Cliente cliente){
}
}
public class Cliente(){
private String nombre;
private String teléfono;
}
2. Composición: Es un tipo de relación dependiente en donde una clase se conforma de
clases más pequeñas. Significa usar objetos dentro de otros objetos.
Código
·
Relación de dependencia,
también llamada relación de uso : Cuando la inicialización de una clase depende
de otra, en este caso si la clase de la que se depende es eliminada la otra
también desaparece. Un claro ejemplo de esto puede ser la dependencia que hay
entre un carro y una gasolinera, pues sin la última el primero dejaría de
funcionar.
Código
Bibliografía
Suscribirse a:
Entradas (Atom)