Ejercicio: Clase complejo

Crear una clase para trabajar con números complejos.

class Complejo

Tendrán una parte real y una imaginaria, ambas de tipo float. Deben inicializarse en el constructor.

Crearemos las siguientes funciones:

sumar(complejo) ->Suma al número el número complejo que le pasamos

multiplicar(complejo)->Multiplica por el complejo que le pasamos

igual(complejo) -> devuelve true si los números complejos son iguales

Todas estas funciones trabajan con el propio número. Veamos un ejemplo:

$c=new Complejo(2,3);

$d=new Complejo(1,4);

$c->suma($d);

Ahora $c vale (3,7), es decir, la suma de $c y $d. Todas las funciones se aplican al propio objeto.

Además las propiedades deben ser de tipo privado, accederemos a través de setter y getter mágicos.

Crearemos una función mágica tostring que nos pinte el número complejo en su forma acostumbrada (a+bi)

Crearemos también una propiedad virtual de sólo lectura que nos devuelva el valor absoluto del número complejo. El valor absoluto viene definido por la raíz cuadrada de la suma del cuadrado de a y b


class Complejo {

private $real;
private $imaginaria;

function __construct(float $real, float $imaginaria) {
$this->real = $real;
$this->imaginaria = $imaginaria;
}

function sumar(Complejo $complejo) {
$this->real += $complejo->real;
$this->imaginaria += $complejo->imaginaria;
}

function multiplicar(Complejo $complejo) {
$real = $this->real * $complejo->real -
$this->imaginaria * $complejo->imaginaria;
$imaginaria = $this->real * $complejo->imaginaria +
$this->imaginaria * $complejo->real;
$this->real=$real;
$this->imaginaria=$imaginaria;
}

function igual(Complejo $complejo) {
return $this->real == $complejo->real && $this->imaginaria == $complejo->imaginaria;
}

function __get($name) {
if ($name=="absoluto"){
return sqrt($this->real**2+$this->imaginaria**2);
}
if (!property_exists($this, $name)) {
throw new Exception("La propiedad $name no existe");
}
return $this->$name;
}

function __set($name, $value) {
if (!property_exists($this, $name)) {
throw new Exception("La propiedad $name no existe");
}
$this->$name = $value;
}

function __toString() {
return $this->real . " + " . $this->imaginaria . "i";
}

}

¿Un return o varios?

La cosa no está clara:

https://stackoverflow.com/questions/36707/should-a-function-have-only-one-return-statement

Artículo sobre el tema:

https://www.anthonysteele.co.uk/TheSingleReturnLaw

Una buena práctica:

Minimize the number of returns in each routine. It’s harder to understand a routine if, reading it at the bottom, you’re unaware of the possibility that it returned somewhere above.

Use a return when it enhances readability. In certain routines, once you know the answer, you want to return it to the calling routine immediately. If the routine is defined in such a way that it doesn’t require any cleanup, not returning immediately means that you have to write more code.

Escribir en fichero


string docPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
StreamWriter outputFile = new StreamWriter(Path.Combine(docPath, "salida.txt")));
outputFile.WriteLine("Esto es una línea");
outputFile.WriteLine("Esto es otra");
outputFile.Close();

Inyección de dependencia

Las interfaces nos permiten desacoplar las funciones al no depender de una clase, sino de la implementación de un interfaz:

https://anexsoft.com/ejemplo-de-inyeccion-de-dependencias-con-c

Definición:

https://www.freecodecamp.org/news/a-quick-intro-to-dependency-injection-what-it-is-and-when-to-use-it-7578c84fa88f/

https://www.dotnettricks.com/learn/dependencyinjection/implementation-of-dependency-injection-pattern-in-csharp

Gente que está en contra (en ocasiones):

Las ventajas de NO usar inyección de dependencias