// Alias y paso de parámetros: Java pasa siempre por valor, y el valor de una
// variable de objeto es una referencia.

// Recibe una copia de la referencia: llega al mismo objeto y lo modifica.
void heatUp(Thermometer t) {
    t.record(t.current() + 5);
}

// También recibe una copia de la referencia, pero le asigna otro objeto:
// solo cambia el parámetro, no la variable de quien llamó.
void replace(Thermometer t) {
    t = new Thermometer("Cusco", 4.0);
    t.record(-2.0);
}

void main() {
    Thermometer a = new Thermometer("Lima", 18.0);
    Thermometer b = a;              // alias: dos variables, un solo objeto
    b.record(30.0);
    IO.println("a.max() = " + a.max() + "   (a == b: " + (a == b) + ")");

    heatUp(a);
    IO.println("después de heatUp:  " + a.place() + ", actual " + a.current());

    replace(a);
    IO.println("después de replace: " + a.place() + ", actual " + a.current());
}

// Identidad (==) frente a igualdad (equals).
void main() {
    String s1 = "Lima";
    String s2 = "Lima";
    String part = "Li";
    String s3 = part + "ma";        // se arma mientras el programa corre

    IO.println("s1 == s2:      " + (s1 == s2));
    IO.println("s1 == s3:      " + (s1 == s3));
    IO.println("s1.equals(s3): " + s1.equals(s3));

    // Nuestra clase todavía no define equals: hereda el de Object, que usa ==.
    Thermometer t1 = new Thermometer("Lima", 18.0);
    Thermometer t2 = new Thermometer("Lima", 18.0);
    IO.println("t1 == t2:      " + (t1 == t2));
    IO.println("t1.equals(t2): " + t1.equals(t2));
}

// Termina con un NullPointerException a propósito, para leer su mensaje.
void main() {
    Thermometer ok = new Thermometer("Lima", 18.0);
    IO.println(ok.place() + " tiene " + ok.place().length() + " letras");

    Thermometer broken = new Thermometer(null, 18.0);    // nada lo impide (todavía)
    IO.println("lugar: " + broken.place());
    IO.println(broken.place() + " tiene " + broken.place().length() + " letras");
}

// Comparar con == un texto leído del teclado. Pruébenlo con: echo Lima | java -cp build ReadCompare
void main() {
    String city = IO.readln("Ciudad: ");
    IO.println("city == \"Lima\":      " + (city == "Lima"));
    IO.println("city.equals(\"Lima\"): " + city.equals("Lima"));
}

/**
 * Un termómetro que recuerda la temperatura actual y la mínima y la máxima
 * registradas desde que se creó.
 */
public class Thermometer {
    private String place;           // dónde está instalado
    private double current;         // grados Celsius
    private double min;
    private double max;
    private int readings;           // cuántas lecturas lleva, contando la inicial

    /** Crea un termómetro en un lugar, con una primera lectura. */
    public Thermometer(String place, double initial) {
        this.place = place;
        this.current = initial;
        this.min = initial;
        this.max = initial;
        this.readings = 1;
    }

    /** Crea un termómetro sin lugar conocido. */
    public Thermometer(double initial) {
        this("sin lugar", initial);
    }

    /** Crea un termómetro sin lugar conocido que empieza en 0 °C. */
    public Thermometer() {
        this(0.0);
    }

    /** Registra una lectura nueva: cambia la actual y, si hace falta, la mínima o la máxima. */
    public void record(double celsius) {
        current = celsius;
        if (celsius < min) {
            min = celsius;
        }
        if (celsius > max) {
            max = celsius;
        }
        readings++;
    }

    public String place() {
        return place;
    }

    public double current() {
        return current;
    }

    public double min() {
        return min;
    }

    public double max() {
        return max;
    }

    public int readings() {
        return readings;
    }

    /** Diferencia entre la máxima y la mínima registradas. */
    public double range() {
        return max - min;
    }
}

// Crea termómetros con cada constructor y les envía mensajes.
void main() {
    Thermometer lima = new Thermometer("Lima", 18.5);
    lima.record(22.0);
    lima.record(16.0);
    IO.println(lima.place() + ": actual " + lima.current()
            + ", mín " + lima.min() + ", máx " + lima.max()
            + ", " + lima.readings() + " lecturas");

    Thermometer lab = new Thermometer(21.0);    // overloading: otro constructor
    Thermometer fresh = new Thermometer();      // y otro más
    IO.println(lab.place() + ": " + lab.current());
    IO.println(fresh.place() + ": " + fresh.current());

    // Cada objeto tiene su propio estado: registrar en lab no cambia lima.
    lab.record(35.0);
    IO.println("rango de lab: " + lab.range() + ", rango de lima: " + lima.range());
}

// Un error que compila sin advertencias: el parámetro tapa al campo (shadowing).
class BuggyThermometer {
    private double current;

    BuggyThermometer(double current) {
        current = current;          // asigna el parámetro a sí mismo; el campo queda en 0.0
    }

    double current() {
        return current;
    }
}

void main() {
    BuggyThermometer t = new BuggyThermometer(25.0);
    IO.println("esperaba 25.0 y obtuve " + t.current());
}

import static org.junit.jupiter.api.Assertions.assertEquals;

import org.junit.jupiter.api.Test;

// Pruebas de muestra. Cómo escribirlas se ve en la semana 3.
class ThermometerTest {

    @Test
    void firstReadingIsMinAndMax() {
        Thermometer t = new Thermometer("Lima", 18.5);
        assertEquals(18.5, t.min());
        assertEquals(18.5, t.max());
    }

    @Test
    void recordUpdatesMinAndMax() {
        Thermometer t = new Thermometer("Lima", 18.5);
        t.record(22.0);
        t.record(16.0);
        assertEquals(16.0, t.current());
        assertEquals(16.0, t.min());
        assertEquals(22.0, t.max());
        assertEquals(3, t.readings());
    }

    @Test
    void noArgConstructorStartsAtZero() {
        Thermometer t = new Thermometer();
        assertEquals("sin lugar", t.place());
        assertEquals(0.0, t.current());
    }
}

# Semana 2: clases, referencias e identidad.
#   make         compila todo a build/ (con -g, para poder depurar con jdb)
#   make test    corre las demostraciones y las pruebas JUnit
#   make clean   borra build/
JAVAC  = javac
JFLAGS = -Xlint:all -Werror -g
SRC    = $(wildcard *.java)
DEMOS  = ThermometerDemo ShadowBug Aliasing Equality

all: build/.stamp

build/.stamp: $(SRC)
	mkdir -p build
	$(JAVAC) $(JFLAGS) -cp $(JUNIT_JAR) -d build $(SRC)
	touch $@

test: all
	@for d in $(DEMOS); do echo "== $$d"; java -cp build $$d || exit 1; done
	@echo "== ReadCompare (lee Lima de la entrada)"; echo Lima | java -cp build ReadCompare
	@echo "== NullDemo (termina con NullPointerException a propósito)"; ! java -cp build NullDemo
	java -jar $(JUNIT_JAR) execute --class-path build --scan-class-path \
	  --disable-banner --disable-ansi-colors --details=tree

clean:
	rm -rf build

.PHONY: all test clean