Hola Anncode, pregunto, puedo yo simplemente escribir
return (isTurnOnLight) ? false : true;
para retornar en la función?
Conocer a Java como lenguaje de programación
¿Qué es Java?
Versiones de Java y JDK
Las herramientas más usadas de Java
Creando un entorno de desarrollo en Java en Windows
Creando un entorno de desarrollo en Java en Mac
Creando un entorno de desarrollo en Java en Linux
Escribe tu primer Hola Mundo en Java
Etapas de la programación en Java
La JShell de Java
Trabajar con Variables en Java
Variables en Java
Actualizando variables
Convención de Nombres en Java
Técnica de Naming: Camel Case
Tipos de datos numéricos
Tipos de datos char y boolean
Operadores de Asignación, Incremento y Decremento
Operaciones matemáticas
Cast en variables: Estimación y Exactitud
Casteo entre tipos de datos
Archivos .JAR
¡A practicar!
Aplicar condicionales en Java
Sentencia if
Alcance de las variables y Sentencia ELSE
Operadores Lógicos y Expresiones booleanas
Sentencia Switch
Escribir funciones en Java
¿Para qué sirven las funciones?
Implementa Funciones en Java
Java Docs
Javadoc en funciones
Tags Java Docs
Analizar e implementar Ciclos en Java
Bucle do While
Operador Ternario y Bucle While
Bucle For
Break, Continue y Return
Arrays
Declarando Arreglos
Indices y búsqueda de elementos en Arrays
Ciclos For anidados
Continua con el Curso de Programación Orientada a Objetos en Java
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Vamos a crear el algoritmo con la lógica necesaria para encender una lampara, emitir un mensaje y detener las luces en algún momento.
El Bucle While nos ayuda a ejecutar una parte del código mientras una condición se cumpla. Recuerda tener mucho cuidado y asegurarte de que la condición del ciclo while cambie en algún momento, de otra forma, el ciclo no se detendrá nunca y sobrecargarás tu programa:
while (isTurnOnLight) {
printSOS();
}
Los operadores ternarios son otra forma de evaluar condiciones, así como los condicionales IF
y ELSE`:
// Operador Ternario:
isTurnOnLight = (isTurnOnLight) ? false : true;
// IF y ELSE:
if (isTurnOnLight) {
isTurnOnLight = false;
} else {
isTurnOnLight = true;
}
Aportes 101
Preguntas 17
Hola Anncode, pregunto, puedo yo simplemente escribir
return (isTurnOnLight) ? false : true;
para retornar en la función?
Un ejemplo de Operador Ternario
String TipoVehiculo = (NumRuedas>2)? “Auto” : “Moto”;
¡Hola!
Estuve practicando un rato con el operador ternario, y realice una comparación de las lineas de código que nos ahorramos usando este operador.
//Operador Ternario
int age = 19;
int ageMax = 18;
boolean ageVerificationT = age >= ageMax ? true:false;
System.out.println(ageVerificationT);
//Sentencia If Else
int age = 19;
int ageMax = 18;
boolean ageI;
if (age >= ageMax){
ageI = true;
System.out.println(ageI);
}else{
ageI = false;
System.out.println(ageI);
}
¡Saludos!
le agregué el sonido, para darle el efecto de la señal.
En el método para encender y apagar la lampara se puede simplificar a negar el atributo:
public static boolean turnOnOffLight(){
return !isTurnOnLight;
}
Sintáxis del operador ternario:
condicion ? valor_si_se_cumple : valor_si_no_se_cumple
Practica
Tuve un derrame cerebral pero al final lo entendi gracias =D
Me encanta como enseña annCode. Huí de aprender Java por años pero ahora lo estoy disfrutando
Necesite pensarlo varias veces para entender la logica. Para los que como yo… Les dejo mi apuntes
public class While {
static boolean luzEstaPrendida = false; //le decimos que esta apagada al comienzo
public static void main(String[] args) {
prenderApagar();
int intentos = 1;
// si la apagamos, no ejecuta (se ejecuta despues del boolean prenderApagar)
// si la prendemos, ejecuta
while (luzEstaPrendida && intentos <= 10) {
hacerSOS();
intentos++;
}
}
public static void hacerSOS(){
System.out.println("...___...");
}
public static boolean prenderApagar(){
if (luzEstaPrendida){ // Si empiesa prendida -> arriba dice true
luzEstaPrendida = false; // false le dice que se apague
System.out.println("La apagamos");
}else {
luzEstaPrendida = true; // Si empiesa apagada -> arriba dice false
// true le dice que se prenda
System.out.println("La prendimos");
}
return luzEstaPrendida; // me regresa e valor si la apague o la prendi
}
}
📌 Un operador ternario también es conocido como operador terciario, aunque no es correcto.
La estructura del operador ternario ?: es la siguiente: resultado = (condicion)? valor1:valor2; Donde a la variable resultado recibirá el valor1 en el caso de que la condición sea true o bien el valor2 en el caso de que la condición sea false.
public class While {
static boolean isTurnOnLight = false;
public static void main(String[] args) {
turnOnOffLight();
int aux=0;
while (isTurnOnLight&&aux<=10){
printSOS();
aux++;
}
}
/**
* Descripción: imprime el mensaje sos
* */
public static void printSOS(){
System.out.println(". . . _ _ _ . . .");
}
/**
* Descripcion: mediante un operador ternera decide el valor de isTurnOnLight
* @return regresa verdadero o falso según sea el caso.
* */
public static boolean turnOnOffLight(){
isTurnOnLight = (isTurnOnLight)?false:true;
return isTurnOnLight;
}
}
En este caso también se puede tener en cuenta un operador de asignación:
isTurnOnLight = !isTurnOnLight;
Devuelve el contrario del valor actual de la variable, pero esta técnica solo funciona con variables Boonleanas.
A mi condición de salida del While Loop le puse un número aleatorio. Para esto se necesita una clase de Java llamada Random
Random ran = new Random();
Y para generar un número “aleatorio” se usa el método
nextInt(<límite_del_rango>)
Mi condición era que el loop se siguiera ejecutando mientras que “x” no fuera 10. La variable x es el número aleatorio
El while loop queda de la siguiente forma:
while (x != 10){
PrintSOS();
x = ran.nextInt(10) + 1;
System.out.println("x: " + x);
}
Noten que en la variable x, se suma un 1 al número aleatorio generado y esto es porque el rango toma en consideración el número 0. Sin ese " + 1 ", sólo se generarían número del 0 al 9 y nunca se compliría la condición de salida
la señal de S.O.S. escrita es ···/—/···
en morse cada xletra se separa con un slash y se le deja el espacio .para separar cada palabra
Visto en clase
import java.util.Scanner;
public class Main {
static boolean isTurnOnLight ;
public static void main(String[] args) {
int NivelBateria = 10;
Scanner teclado = new Scanner(System.in);
System.out.println("La lampara esta prendida");
String Valor = teclado.nextLine();
boolean valor;
//Ocupamos el operador Terniario
valor = (Valor.equals("si") || Valor.equals("SI") || Valor.equals("Si"))? true: false;
/*
if(Valor.equals("true")){
valor = true;
}else {
valor = false;
}
*/
//llamamaos a la funcion
turnOnOffLight(valor);
if(isTurnOnLight){
do{
printSOS();
NivelBateria--;
}while (NivelBateria != 0);
TipoDato(Valor,valor);
}
}
//Creamos una funcion para validar si la lampara del movil esta prendia o apagada
public static boolean turnOnOffLight (boolean valor) {
//
return isTurnOnLight = (isTurnOnLight)?false:true;
}
//Creamos una funcion para imprimir el mensaje en pantalla
public static void printSOS() {
System.out.println(". . . _ _ _ . . .");
}
public static void TipoDato(String Valor,boolean valor) {
System.out.println("\nEl dato " + Valor + " es de tipo " + ((Object)Valor).getClass().getSimpleName() +
"\nEl tipo de dato " + valor + " es de tipo " + ((Object)valor).getClass().getSimpleName());
}
}
No lo seguí al pie de la letra, pero esta es mi práctica:
public class PracticeBoolean {
static boolean lampStatus = true;
public static void printSos(){
System.out.println("... ___ ...");
}
public static void checkLampStatus(){
lampStatus = (lampStatus)?true:false;
}
public static void main(String [] args){
int i = 1;
while(lampStatus && i <= 10){
checkLampStatus();
printSos();
i++;
}
}
}
Estuve experimentando un poco, y también pude lograr
llegar a esta solución:
public class PracticeBoolean {
static boolean lampStatus = true;
public static void checkLampStatus(){
if (lampStatus){
System.out.println("... ___ ...");
}
}
public static void main(String [] args){
int i = 1;
while(lampStatus && i <= 10){
checkLampStatus();
i++;
}
}
}
Soy aún muy inexperto, y en esta última práctica omito el operador terneario. Ustedes qué opinan?
Simplificando el código
public static boolean turnOnOffLight() {
return isTurnOnLight = !isTurnOnLight;
}
Una forma de simplificar la función turnOnOffLight():
public static boolean turnOnOffLight() {
return isTurnOnLight = !isTurnOnLight;
}
De esta forma estamos cambiando su valor y también obtenemos el nuevo valor
excelente… no sabia lo del operador ternario en Java… me viene de 10 actualizarme
Siento que la experiencia sobre lo pasado en México le trajo algunos recuerdos… Es una de mis profesoras preferidas…!!
Mis anotaciones del código:
import java.util.Scanner;
public class _014_WhileLoop {
static boolean isTurnOnLight=false;
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
turnOffOnLight();
int x=1;
while(isTurnOnLight&&x<=10){
printSOS();
x++;
}
}
public static void printSOS(){
System.out.println(". . . _ _ _ . . .");
}
public static boolean turnOffOnLight(){
isTurnOnLight = (isTurnOnLight)?false:true;
return isTurnOnLight;
}
}
En la función de encender o apagar la linterna no es necesario retornar algo ya que solo buscamos cambiar el estado de la variable de arriba, es decir si está falsa ponerla verdadera y viceversa, por lo tanto la función nos puede quedar así:
public static void turnOnOffFlashlight() {
isFlashlightOn = (isFlashlightOn) ? false : true;
}
public class WhileLoop {
static boolean isTurnOnLight = false;
public static boolean turnOnOffLight(){
//Operador ternario
isTurnOnLight = (isTurnOnLight)?false:true;
return isTurnOnLight;
}
public static void printSOS(){
System.out.println(". . . _ _ _ . . .");
}
public static void main(String[] args) {
turnOnOffLight();
byte i = 1;
while (isTurnOnLight && i<=10){
printSOS();
i++;
}
}
}
Hay una forma más sencilla de escribir la función turnOnOffLight
public static boolean turnOnOffLight() {
return !isTurnOnLight
}
Siempre va a retornar la negación del estado de la lampara.
Tenia una pequena confusion debido a que no entendia porque empezaba en falso y aun asi funcionaba la aplicacion.
Que entendi?, entendi que en el minuto 8:11 Anahi, nos dice que imaginemos que el usuario oprime el boton, esto quiere decir que se le asigna false y comienza a correr el codigo.
Realmente senti que fue una clase donde mas que entender el contexto de una solicitud de ayuda con S.O.S. Realmente, la clase brinda la oportunidad de aprender como con el **OPERADOR TERNARIO ** se cambian boleanos de true a false y de false a true.
Tal vez me equivoque, pero creo que hay un pequeño bug, pues revisando el el código al ejecutarlo con la ternaria así ?true:false, pero dejando la variable inicializada en false, al ejecutar el código, éste no imprime el SOS como lo hizo Anahí y según la condición es que ésta sea true, pero en la ternaria queda como false… en fin… solo un pequeño análisis que hice al replicar pero colocando los valores ternarios al revés… cosas de QA. :hombre_encongiendose_de_hombros:
Si se comenta o elimina la función turnOnOffLight el código sigue funcionando sin problema jaja
Es genial lo del operador terceario, no lo conocia. Cuando usaba una condición if y en ella tenia que asignarle un valor distinto a la misma variable siempre pensaba si se podria hacer de otra forma.
Mi coódigo de la clase:
Buen Ejemplo
<public class WhileLoop {
static boolean isTurnOnLight = false;
public static void main(String[] args) {
turnOnOffLight();
int i = 1;
while (isTurnOnLight && i <= 10){
printSOS();
i++;
}
}
public static void printSOS(){
System.out.println("...___...");
}
public static boolean turnOnOffLight (){
isTurnOnLight = (isTurnOnLight)?false:true;
return isTurnOnLight;
}
}
>
public static boolean turnOnOffLigth(){
isTurnOnOffLigth = !isTurnOnOffLigth;
return isTurnOnOffLigth;
}
Muy buenos los ejemplos.
Comparto mi codigo de esta clase
…
public class whileLoop {
static boolean isTurnTheLight = false;
public static void main(String[] args) {
turnOnOffTheLight();
int i = 1;
while (isTurnTheLight && i<= 10){
printSOS();
i++;
}
}
public static void printSOS ()
{
System.out.println(". . . _ _ _ . . .");
}
public static boolean turnOnOffTheLight()
{
isTurnTheLight = (isTurnTheLight) ? false:true;
return isTurnTheLight;
/* if (isTurnTheLight)
{
isTurnTheLight = false;
}else {
isTurnTheLight = true;
}
return isTurnTheLight ;
}*/
}
}
…
Creo que en esta ocacion, no era que la función tuviera un retorno de tipo boolean, porque en ningun momento se esta utilizando, simplemente esta haciendo un cambio a la variable, pero dentro de la funcion.
Se puede resumir a lo siguiente
public class WhileLoop {
static boolean isOnLight = false;
public static void main(String[] args) {
turnOnOffLight();
while (isOnLight){
helpSOS();
}
}
public static void helpSOS(){
System.out.println("... ___ ...");
}
public static void turnOnOffLight(){
isOnLight = !isOnLight;
}
}
no entiendo el programa de luces. que mal
El editor me marcaba error, la forma en que me funcionó el código es de la siguiente manera:
public static void turnOnOffLight() {
isTurnOnLight = !isTurnOnLight;
}
buen curso
El operador terneario lo hace todo más fácil y nos ayuda a ahorrar lineas de código.
la función también se puede simplificar de esta forma
public static boolean turnOnOffLight(){
return isTurnOnLight = !isTurnOnLight;
}
Comparto mi apunte
//Metodo que responda al touch del usuario para activar la lámpara del celular
public static boolean isIsTurnOffLight(){
//utilizar condicionales con operador ternario
isTurnOnLight = (isTurnOnLight)?false:true;
//forma vista hasta este punto del curso para emplear condicionales a nuestro código.
if(isTurnOnLight ){
isTurnOnLight = false;
}else{
isTurnOnLight = true;
}
return isTurnOnLight;
}
Muy interesante. Con Anahí se aprende mucho 💚
La función turnOnOffLight se puede simplificar aún más con el operador lógico de negación:
public static boolean turnOnOffLight(){
isTurnOnLight = !isTurnOnLight;
return isTurnOnLight;
}
Nunca pude comprender java, con esta profe todo es claro
return (isTurnOnLight) ? false : true;
while (expression) {
statement(s)
}
do {
statement(s)
} while (expression);
Otra forma de cambiar el valor de isTurnOnLight
public static boolean turnOnOffLight() {
isTurnOnLight = !isTurnOnLight;
return isTurnOnLight;
}
Supongo que ahora iremos con el bucle FOR. muy buena manera de explicar.
public class WhileLoop {
static boolean isTurnOnLight = false;
/**
* Descripción: Función que emite diez señales de SOS
*/
public static void main(String[] args) {
turnOnOffLight();
int i = 1;
while (isTurnOnLight && i<=10){
printSOS();
i++;
}
}
/**
* Descripción: Señal SOS
*/
public static void printSOS(){
System.out.println(". . . _ _ _ . . .");
}
/**
* Descripción: Operador ternario que valida si la linterna está encendida
*/
public static boolean turnOnOffLight(){
isTurnOnLight = (isTurnOnLight) ? false : true;
return isTurnOnLight;
}
}```
el operador terneario lo conocia yo como if inline, lo vi en un libro de Java a Fondo by Pablo Augusto SZNAJDLEDER 😃
geniaaal
Nuevo concepto el operador ternario
Excelente lo del operador ternario! 😄
Abreviación de todo el if con el operador ternario. La estructura del operador ternario ?: es la siguiente: resultado = (condicion)?valor1:valor2;
public class WhileLoop {
static boolean isTurnOnLight=false;
public static void main(String[] args) {
isTurnofLight();
int i=1;
while(isTurnOnLight && i<=10){
printsos();
i++;
}
}
public static void printsos(){
System.out.println("..._...");
}
public static boolean isTurnofLight(){
//operador ternario
isTurnOnLight=(isTurnOnLight)? false:true;
return isTurnOnLight;
}
}
lo aplicaré en todo lo que se pueda xd
Con el operador ternario es otra forma de implementar condicionales en el código.
Excelente explicación operador ternario y Bucle While
Yo conocía esta forma abreviada de establecer un condicional ya que se utiliza mucho en los <input> para mostrar valores pero no sabía que tenía su propio termino que es operador ternario, por cierto, estupenda clase ahora sabemos cómo codificar las funciones básicas para solicitar ayuda.
que quiere decir &&= ?
que interesante lo del operador ternario 😮
La estructura del operador ternario ?: es la siguiente:
resultado = (condicion)?valor1:valor2;
Donde a la variable **resultado **recibirá el valor1 en el caso de que la condición sea true o bien el valor2 en el caso de que la condición sea false.
Así, si queremos calcular el mayor de dos números tendremos el siguiente código:
mayor=(x>y)?x:y;
public class WhileLoop{
staticboolean isTurnOnLight = false;
publicstaticvoidmain(String[] args){
int i=1;
turnOnOffLight();
while(isTurnOnLight && i<=10){ // si es true y es menor ejecuta 10 veces
printSOS();
i++;
}
}
publicstaticvoidprintSOS(){
System.out.println(". . . _ _ _ . . .");
}
//Verifica si esta prendido o apagado la luz
publicstaticbooleanturnOnOffLight(){
//isTurnOnLight = (isTurnOnLight) ? false: true;
if(isTurnOnLight){ //Si esta prendido lo apago
isTurnOnLight=false;
}else{ //Si no esta prendido lo prende con "true"
isTurnOnLight=true;
}
return isTurnOnLight;
}
}
https://platzi.com/r/omar-alban-becerra/```
Excelente explicación anahí (y)
Lo acabe de aplicar a unos procesos del trabajo, y se redujeron bastantes lineas! excelente dato!!!
¡Que genial ejemplo para el bucle While, exelente clase!.
Una manera más sencilla que el operador ternario
isTurnOnLight = !isTurnOnLight;
Gracias por la clase, para conectar con la enterio le agregue la opción para que el usuario decida si continuar o detener el proceso
import java.util.Scanner;
public class WhileLoop {
static boolean isTurnOnLight = false;
public static void main(String[] args) {
turnOnOffLight();
int i = 1;
while (isTurnOnLight){
i++;
printSOS();
while (i==10){
i = i -10;
boton();
}
}
}
public static void printSOS(){
System.out.println("...---...");
}
public static boolean turnOnOffLight(){
isTurnOnLight = (isTurnOnLight)?false:true;
return isTurnOnLight;
}
// Esta funcion le pregunta al usuario si quiere volver a ejecutar el proceso o detenarlo
public static void boton(){
int response = 0;
System.out.println("1. Continuar");
System.out.println("2. Detener");
Scanner sc = new Scanner(System.in);
response = Integer.valueOf(sc.nextLine());
switch (response) {
case 1:
isTurnOnLight = true;
break;
case 2:
isTurnOnLight = false;
break;
default:
System.out.println("Error");
boton();
}
}
}```
Genial.
public class WhileLoop {
static boolean isTurnOnLight = false;
public static void main(String[] args) {
isTurnOffLight();
int i = 1;
while(isTurnOnLight && i <= 10){
printSOS();
i++;
}
}
public static void printSOS(){
System.out.println("...___...");
}
public static boolean isTurnOffLight(){
isTurnOnLight = (isTurnOnLight)?false:true;
return isTurnOnLight;
}
}```
Excelente clase.
Fascinante lo del operador ternario.
public class WhileLoop {
static boolean isTurnOnLight = false;
public static void main(String[] args) {
turnOnOffLight();
int i=1;
while (isTurnOnLight && i<=10){
printSOS();
i++;
}
}
public static void printSOS(){
System.out.println("...___...");
}
public static boolean turnOnOffLight(){
isTurnOnLight = (isTurnOnLight)?false:true;
return isTurnOnLight;
}
}```
Buena clase
Por momentos quedo borracho, pero ya luego entiendo y se me pasa
Todo muy claro. Gracias
return !isTurnOnLight```
una forma aún más simple sería retornar la forma negada del contenido de la variable (sólo válido para tipos booleanos).
public static boolean turnOnOffLight(){
return !this.isTurnOnLight;
}
Entiendo que es por motivos académicos, pero he visto en repetidas ocasiones que utilizan el ternario, incluso hasta estructuras condicionales IF-ELSE para retornar TRUE o FALSE cuando esta es la respuesta natural de la condición.
public class While {
static boolean isTurnOnLight = false;
static int amountMessageSent = 0;
public static void main(String[] args) {
handleLight();
while(isTurnOnLight){
printSOS();
handleHelp();
}
}
public static void printSOS(){
/**
*Prints SOS in Morse Code
* And adds to the global var of amount of message sent
* @author Alejandro AS
*/
System.out.println("... ___ ...");
amountMessageSent ++;
}
public static void handleHelp(){
/**
* Handles the global var amountMessageSent
* Prints message when helps arrives and close the cicle
* @author Alejandro AS
*/
if(amountMessageSent == 10){
System.out.println("LA AYUDA LLEGO!!! WIII");
handleLight();
}
}
public static void handleLight(){
/**
* Change the value of the Light of SOS
* @author Alejandro AS
*/
isTurnOnLight=!isTurnOnLight;
}
}
Aunque no es el objetivo de esta clase una forma mas optimizada seria.
return !isTurnOnLight;
De esa manera devuelve siempre el contrario sin tener que comprobar al ser un valor booleano.
Si esta en falso lo contrario es true y al revés, ya que el símbolo ! es la negación de un valor.
Por si les vale para algo 😄
Más simplificado:
Me lo marcó el editor y no sabía como no me había dado cuenta de que se podía hacer así jajajaja
Encontré la forma de hacer una luz más realista usando un for loop
😃
Code:
import java.lang.*;
import java.util.Scanner;
/**
* WhileLoop
*
* Description: program for simulating SOS line
*/
public class WhileLoop {
static boolean lightStatus = false;
public static void main(String[] args) {
byte i = 0;
System.out.printf("Turning lights off for morse code...\n\n 🔦: OFF ⏼ \n\n");
isLightOnOff();
if (lightStatus == false) {
while (i<=10) {
SOS_Signal();
i++;
}
} else {
System.out.printf("ERROR: troubles while turning off light\ntrying again...");
try {
Thread.sleep(500); //milliseconds
isLightOnOff();
} catch (InterruptedException e) {
//TODO: handle exception
;
}
}
}
public static void SOS_Signal() {
char dot = '.';
char underscore = '_';
printSymbol(dot);
printSymbol(underscore);
printSymbol(dot);
System.out.printf("\n");
}
/**
* Description: print a character three times with a pace of 3 seconds
*
* @param symbol the symbol we want to be repeated
* */
public static void printSymbol(char symbol) {
for (byte i = 0; i <= 2; i++) {
try {
System.out.printf("%c", symbol);
Thread.sleep(500);
} catch (InterruptedException e) {
//TODO: handle exception
;
}
}
}
/**
* Description: turn the light off in case it has it on in order to star the secuence
* */
public static boolean isLightOnOff() {
//simplified version with ternary operator
return lightStatus = (lightStatus == true) ? false:false;
/*
* if (lightStatus == true) {
lightStatus = false;
turn light off
} else {
;
}
return lightStatus;
* */
}
}
Output:
Turning lights off for morse code...
🔦: OFF ⏼
...___...
...___...
...___...
...___...
...___...
...___...
...___...
...___...
...___...
...___...
...___...
(NOTA: see que ahoara que lo ves no parece que pasa nada, pero te reto a que corras el program en tu computador, así verás la magia!)
(PS: en mi código las luces tienen que estár apagadas para que pueda iniciar la secuencia, esto porque pues me parece más realista)
Interesante =)
Esto:
isTurnOnLight = (isTurnOnLight) ? false : true;
Puede ser simlpificado a esto:
isTurnOnLight = !isTurnOnLight
El operador ternario es útil cuando queremos asignar un dato a una variable dependiendo de una condición (sin utilizar un if), pero cuando el dato es al final un booleano se pueden usar los operadores lógicos.
public class WhiteLoop {
static boolean isTrunOnLine= false;
public static void main(String[] args) {
turnOff();
int i=1;
while (isTrunOnLine&& i<=5){
printSOS();
i++;
}
}
public static void printSOS(){
System.out.println(". . . _ _ _ . . .");
}
public static boolean turnOff(){
isTrunOnLine=(isTrunOnLine)? false:true;
if (isTrunOnLine==false){
isTrunOnLine=false;
}else{
isTrunOnLine=true;
}
return isTrunOnLine;
}
}```
cool
https://es.wikipedia.org/wiki/SOS
excelente clase!
public class WhileLoop {
static boolean isTurnOnLight = false;
public static void main(String[] args) {
TurnOnOFFLight();
int i = 1;
while (isTurnOnLight && i <=10){
PrintSOS();
i ++;
}
}
public static void PrintSOS(){
System.out.println(" ...___...");
}
public static boolean TurnOnOFFLight(){
//operador terniario, esta sintaxis se usa para cambiar el valor de la variable.
isTurnOnLight = (isTurnOnLight)?false:true;
return isTurnOnLight;
}
}
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?