Operador Ternario y Bucle While

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

• Operador ternario

//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: Primero evalúa la condición, despues ejecuta.
  (Ejecuta de 0 a N veces.)

while (expression) {
  statement(s)
}

• Do While: Primero Ejecuta, despues evalúa la condición.
  (Ejecuta de 1 a N veces)

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

Linterna realista

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;
    }
}