Constructores

package com.trifulcas.oop;

// La sintaxis de una clase es muy sencilla 'class'
public class Alumno {
	// Propiedades
	String nombre;
	// 2) Para obligar a dar valor a alguna propiedad
	// El constructor de alumno requiere de un parámetro
	// de tipo String. Esto quiere decir que cuando 
	// cree un objeto alumno le tendré que pasar un nombre
	Alumno(String nombre){
		// ¿Qué es this? This hace referencia al propio objeto
		// Por qué aquí hace falta y en saludo no?
		// Lo uso para diferenciar entre el parámetro y la propiedad
		this.nombre=nombre;
	}
	// Funciones
	void saludo() {
		System.out.println(this.getSaludo() + this.nombre);
		// Sin this también funciona ¿Por qué?
		// Porque Java por defecto busca funciones y propiedades en this
		System.out.println(getSaludo() + nombre);
	}
	String getSaludo() {
		return "Hola que tal ";
	}
}
public class Coche {
	String marca;
	int velocidad=0;
	
	public Coche(String marca) {
		super();
		this.marca = marca;
	}
	void acelerar() {
		System.out.println("brum brum");
		// Lo interesante de las clases es que sus funciones
		// Pueden acceder y modificar las propiedades
		velocidad+=10;
	}
	void frenar() {
		System.out.println("Ñññic");
		
		velocidad-=10;
		if (velocidad<0) {
			velocidad=0;
		}
	}
}


public class Cuadrado {
	// Cada objeto cuadrado tendrá su lado
	double lado;

	// COnstructor: es una función especial que se llama
	// Cuando creamos (instanciamos) el objeto
	// se llama igual que la clase
	// ¿Para qué se usa?
	// 1) Para inicializar valores de mis propiedades
	// 2) Para obligar a dar valor a alguna propiedad
	Cuadrado() {
		lado=1;
	}

	// Todas las funciones devuelven el valor en función
	// de la propiedad de la clase, no como un parámetro
	double area() {
		return lado * lado;
	}

	double perimetro() {
		return lado * 4;
	}

	double diagonal() {
		return Math.sqrt(lado * lado * 2);
	}
}

public static void main(String[] args) {
		// String es la plantilla y cadena es un objeto
		// Cada cadena es una instancia de la clase String
		String cadena = "Hola que tal";
		String otracadena = "Hola que tal";
		String yotracadena = "Hola que tal";
		// Como cada objeto es instancia de la clase String
		// Todos comparten las mismas propiedades y funciones
		System.out.println(cadena.length());
		System.out.println(otracadena.length());
		System.out.println(yotracadena.length());

		// Yo tengo la clase Alumno
		// La clase alumno es una plantilla para crear alumnos
		// La palabra clave new es la que me crea el objeto
		Alumno ana = new Alumno("Ana Pi");
	
		ana.saludo();
		Alumno eva = new Alumno("Eva Pérez");
		
		eva.saludo();
		// juan está declarado pero no he creado ningún objeto
		// Es como si no existiera. No puedo poner juan.nombre="sss"
		Alumno juan;

		Coche seat = new Coche("Seat Panda");
		
		seat.acelerar();
		seat.acelerar();
		System.out.println(seat.velocidad);
		seat.frenar();
		seat.frenar();
		seat.frenar();
		seat.frenar();
		System.out.println(seat.velocidad);
		// Otro coche nuevo
		Coche citroen = new Coche("Citroen");
		
		for (int i = 0; i < 10; i++) {
			citroen.acelerar();
		}
		System.out.println(citroen.velocidad);

		// Esto no tiene sentido:
		// Coche.marca="Seat";
		// Las propiedades se ponen en los objetos, no en la clase
		// Porque la clase es la plantilla
		// Nosotros no usamos el plano de una casa para colgar un cuadro

		// Cada objeto que creamos de la clase cuadrado
		// Encapsula las funciones que nos dan información de su propia
		// clase. No tenemos que pasar esos valores como parámetro
		Cuadrado c1 = new Cuadrado();
		c1.lado = 2;
		System.out.println(c1.area());
		System.out.println(c1.perimetro());
		System.out.println(c1.diagonal());

		System.out.println(cadena.toUpperCase());
		
		// Yo puedo crear un ArrayList con la clase Cuadrado
		// Igual que lo hacía de string o de cualquier otra cosa
		ArrayList<Cuadrado> lista =new ArrayList<>();
		for(int i=1;i<=10;i++) {
			// Creo un objeto
			Cuadrado c=new Cuadrado();
			c.lado=i;
			// Añado a la lista
			lista.add(c);
		}
		// Recorrer esa lista
		for(Cuadrado c:lista) {
			// Imprimir el área
			System.out.println(c.area());
		}
		
		Cuadrado a=new Cuadrado();
		Cuadrado b=new Cuadrado();
		a.lado=1;
		b.lado=1;
		System.out.println(a==b); // false porque no son el mismo objeto
		
		System.out.println("Cuadrado nuevo con constructor");
		Cuadrado nuevo=new Cuadrado();
		System.out.println(nuevo.lado);
	}

Publicado por

Juan Pablo Fuentes

Formador de programación y bases de datos