Orientado a objetos I

Es un estilo de programacion que permite a los desarrolladores agrupar informacion, acciones y/o tareas similares en clases.

Objetos

Es la representacion de algun elemento real en nuestro mundo. Cada objeto contiene atributos el cual crea una diferencia entre otros objetos. Los objetos con atributos similares los clasificamos por clases para englobal estos objectos similares con atributos similares y comportamiento similares.

Clases

Es la definicion de como un objeto debe ser al momento de crearse. En Java todas las clases estan dentro de su propio archivo .java con el mismo nombre de la clase. Una aplicacion de Java es una coleccion de archivos .java el cual ellos interactuan entre ellos mismo. El codigo Java no puede estar fuera de una clase .java .

Metodos

Las funciones el cual definimos dentro de las clases, les llamamos metodo.

Metodo `main`

En Java tenemos desde una sola clase hasta muchas clases interactuando unas con otras, el metodo main es el metodo mas importante dentro de Java, este nos ayuda a definir en cual clases y en donde la aplicacion comienza.

public static void main(String [] args){
   // Start my program here
}

public - Indica quien tiene acceso a nuestro metodo.
static - Indica que el metodo no requiere de algun otro objeto para ejecutarse. e
void - Indica que el metodo no devuelve ningun tipo de valor al terminar la ejecucion del metodo.
main - Es el nombre del metodo.
String [] args - Son los parametros de entrada al metodo.

Crear clases

Para crear una clase en Java necesitamos empezar el archivo con la palabra reservada public class y luego el nombre de la clase. El archivo .java debe de contener el mismo nombre de la clase. Cuando creamos varias clases podemos invocar estas desde cualquier otro archivo siempre y cuando todos los archivos se encuentren en el mismo directorio.

Book.java

public class Book { }

Customer.java

public class Customer { }

Main.java

public class Main {
  public static void main(String args[]) {
    Book book = new Book();
    Customer customer = new Customer();

    System.out.println("This is a instance of " + book.getClass());
    System.out.println("This is a instance of " + customer.getClass());
  }
}

Propiedades

Las variables dentro de una definición de clase se le conocen como propiedades, tambien utilizan el nombre de atributos o campo.

Book.java

public class Book {
  String isbn;
  String title;
  String author;
  boolean available;
}

Main.java

public class Main {
  public static void main(String args[]) {
    Book book = new Book();
    book.isbn = "9785267006323";
    book.title = "1986";
    book.author = "George Orwell";
    book.available = true;

    System.out.println(book.title);
  }
}
//-> "1986"

Configurar valor de propiedades de objeto

book.isbn = "9785267006323";
book.title = "1986";
book.author = "George Orwell";
book.available = true;

Acceso a propiedades de objeto

System.out.println(book.title);

Metodos

Las funciones el cual definimos dentro de las clases, les llamamos metodo.

Book.java

class Book {
  String isbn;
  String title;
  String author;
  int available;

  public boolean getCopy() {
    if(this.available < 1) {
      return false;
    }
    else {
      this.available --;
      return true;
    }
  }
}

Main.java

class Main {
  public static void main(String[] args) {      
    Book book = new Book();
    book.available = 12;

    if(book.getCopy()) {
      System.out.println("Here, your copy.");
    }
    else {
      System.out.println("I am afraind that book is not available.");
    }
  }
}
//-> Here, your copy.

Acceso a propiedades y metodos

Las palabras reservadas tambien la utilizamos con los metodos de una clase, estas palabra especifican la visibilidad o uso de las propiedades y metodos cuando combinamos clases o queremos utilizar propiedades de los objetos creados por la clases.

public

Esta especifica que esa propiedad o metodo no tiene restriccion de uso, puede ser utilizada o llamada de cualquier punto de la aplicacion. Tambien puede ser modificada en cualquier punto.

protected

Esta especifica que la propiedad o metodo puede ser utilizado o modificada exclusivamente dentro de la misma clase el cual fue definida, o clases derivadas de la cual la propiedad fue definida.

private

Esta especifica que la propiedad o metodo puede ser utilizado o modificada exclusivamente dentro de la misma clase el cual fue defenida, no puede ser modificada o usada fuera de la misma clase en la cual se formo.

Constructores

Constructor es un tipo de funcion el cual es invocada al momento de una instancia de un objeto, esta funcion es invocada desde la clase y pasada al objeto el cual se esta creando la instancia. Esta funcion es muy similar a los metodos y para usarla solo añadimos un metodo con el mismo nombre de la clase. Los constructores son utilizado para pasar al objeto que estemos iniciando en el momento sus valores por defectos.

Book.java

class Book {
  private String isbn;
  private String title;
  private String author;
  private int available;

  public Book(
    String isbn, 
    String title, 
    String author, 
    int available) {
        this.isbn = isbn;
        this.title = title;
        this.author = author;
        this.available = available;
  }

  public boolean getCopy() {
    if(this.available < 1) {
      return false;
    }
    else {
      this.available --;
      return true;
    }
  }
}

Main.java

class Main {
  public static void main(String[] args) {
    Book book = new Book("1984", "George Orwell", "97852670063", 12);

    if(book.getCopy()) {
      System.out.println("Here, your copy.");
    }
    else {
      System.out.println("I am afraind that book is not available.");
    }
  }
}
//-> Here, your copy.

Encapsulacion (Encapsulation)

Este termino en su forma mas sencillo de definir, significa envolver data dentro de una simple unidad. Encapsulacion es el metodo el cual utilizamos para estructurar nuestras clases. Nuestras clases estan basada en propiedades y metodos, con la encapsulacion podemos organizar propiedades, metodos y definir que tipos de restricciones tienen cada uno de estos elementos de la clase.

Uso y restricciones de encapsulamiento consiste de 3 tipos de permisos por ejemplo: publico, protegido y privado. Estos nos ayuda a evitar errores en el codigo, como otros beneficios.

Getting Setting

Cuando queremos tener acesso a propiedades de un objeto, muchas veces se nos hace complicado hacerlo de manera directa ya que por alguna regla de negocio tenemos que definirla dentro de la clase como propiedades protegida o privada. Proveer metodo publico getter y setter nos proveen la habilidad de acceder a estas propiedades y poder modificarlas aun ellas estando protegidas.

getter Este metodo debe prestar atencion al momento que hacemos una solicitud de alguna propiedad dentro de la clase que no sea publica.
setter No permite efectuar cambio a propiedades el cual tenemos protegidas o privada dentro de nuestra definicion de clases.
Customer.java

class Customer {
  private int id;
  private String firstName;
  private String lastName;
  private String email;

  public Customer(
    int id,
    String firstName,
    String lastName,
    String email) {
      this.id = id;
      this.firstName = firstName;
      this.lastName = lastName;
      this.email = email;
  }

  public String getFirstName() {
    return this.firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getFullName() {
    return this.firstName + " " + this.lastName;
  }
}

Main.java

class Main {
  public static void main(String[] args) {
    Customer customer = new Customer(1, "Steve", "Miller", "[email protected]");

    // Display first name.
    System.out.println(customer.getFirstName());
    //-> Steve

    // Get full name
    System.out.println(customer.getFullName());
    //-> Steve Miller

    // Set first name
    customer.setFirstName("Johnny");

    // Get full name
    System.out.println(customer.getFullName());
    //-> Johnny Miller
  }
}

Propiedade o metodo estatico (Static)

Metodos o propiedades estatica nos permite de definir propiedades o funciones dentro de clases el cual podemos utilizar o acceder sin tener que instanciar la clase en algun objeto. Para definir propiedades o metodos estaticos usamos la palabra reservada static.

Counter.java

class Counter {
  static int count;
  public void increment() {
    count++;
  }

  public void decrement() {
    count--;
  }
}

Main.java

class Main {
  public static void main(String[] args) {
    Counter c1 = new Counter();
    Counter c2 = new Counter();

    c1.increment();
    c2.increment();

    System.out.println(c1.count);
    //-> 2
    System.out.println(c2.count);
    //-> 2

    c1.decrement();
    System.out.println(c2.count);
    //-> 1
  }
}

Herencia (Inheritance)

Herencias nos permite expandir nuestras clases a otras el cual son clases descendientes o hijos. Las clases padres pueden pasar a otras clases descendientes propiedades y metodos publicos como protegidas, no privada. Para expandir nuestras clases utilizamos conjunto a la clase hijo la palabra reservada extends.

Person.java

class Person {
  protected String firstName;
  protected String lastName;

  public String getFirstName() {
    return this.firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getFullName() {
    return this.firstName + " " + this.lastName;
  }
}

Customer.java

import java.util.Optional;

class Customer extends Person {
  private static int lastId = 0;
  private int id;
  private String email;

  public Customer(
    int id,
    String firstName,
    String lastName,
    String email) {
      if(Optional.ofNullable(id).orElse(0).intValue() == 0) {
        lastId++;
        this.id = lastId;
      }
      else {
        this.id = id;
        if(id > lastId) {
          lastId = id;
        }
      }
      this.firstName = firstName;
      this.lastName = lastName;
      this.email = email;
  }

  public static int getLastId() {
    return lastId;
  }

  public int getId() {
    return this.id; 
  }

  public String getEmail() {
    return this.email;
  }

  public void setEmail(String email) {
    this.email = email;
  }
}

Main.java

class Main {
  public static void main(String[] args) {
    Customer customer1 = new Customer(3, "John", "Doe", "[email protected]");
    System.out.println(customer1.getId());
    //-> 3

    Customer customer2 = new Customer(0, "Mary", "Poppins", "[email protected]");
    System.out.println(customer2.getId());
    //-> 4

    System.out.println(customer2.getFullName());
    //-> Mary Poppins

    customer2.setFirstName("Jenny");
    System.out.println(customer2.getFullName());
    //-> Jenny Poppins

    Customer customer3 = new Customer(7, "James", "Kahwa", "[email protected]");
    System.out.println(customer3.getId());
    //-> 7
  }
}

Método de anulación (Overriding method)

Anulación de método es simplemente reemplazar un método pariente de una clase por una nueva en la clase descendiente.

Pops.java

class Pops {
  public int age = 30;

  public void sayHi() {
    System.out.println("Hi, I am pops.");
  }
}

Child.java

class Child extends Pops {
  public int age = 7;

  public void sayHi() {
    System.out.println("Hi, I am child my age is " + age + " year olds. My Pops ages is " + super.age + ".");
  }
}

Main.java

class Main {
  public static void main(String[] args) {
    Pops pops = new Pops();
    Child child = new Child();

    pops.sayHi();
    //-> Hi, I am pops.

    child.sayHi();
    //-> Hi, I am child my age is 7 year olds. My Pops ages is 30.
  }
}

Clases Abstracta (Abstract Class)

Clase abstracta nos permite aislar un elemento de su contexto. Es un tipo de clase el cual no podemos instanciar, pero podemos usarla como clase modelo a unas clases descendiente. Siempre deben heredarse.

Book.java

class Book {
  private String isbn;
  private String title;
  private String author;
  private int available;

  public Book(
    String isbn, 
    String title, 
    String author, 
    int available) {
      this.isbn = isbn;
      this.title = title;
      this.author = author;
      this.available = available;
  }

  public boolean getCopy() {
    if(this.available < 1) {
      return false;
    }
    else {
      this.available --;
      return true;
    }
  }

  public String getIsbn() {
    return this.isbn;
  }

  public String getTitle() {
    return this.title;
  }

  public int isAvailable() {
    return this.available;
  }

  public void addCopy() {
    this.available++;
  }
}

Person.java

class Person {
  protected String firstName;
  protected String lastName;

  public String getFirstName() {
    return this.firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return this.lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }

  public String getFullName() {
    return this.firstName + " " + this.lastName;
  }
}

Customer.java

abstract class Customer extends Person {
  protected static int lastId = 0;
  protected int id;
  protected String email;
  public static int getLastId() {
    return lastId;
  }

  public int getId() {
   return this.id; 
  }

  public String getEmail() {
    return this.email;
  }

  public void setEmail(String email) {
    this.email = email;
  }

  // Abstract method
  public abstract double getMonthlyFee();
  public abstract int getAmountToBorrow();
  public abstract String getType();
}

Basic.java

import java.util.Optional;

class Basic extends Customer {
  public Basic(
    int id,
    String firstName,
    String lastName,
    String email) {
      if(Optional.ofNullable(id).orElse(0).intValue() == 0) {
        lastId++;
        this.id = lastId;
      }
      else {
        this.id = id;
        if(id > lastId) {
          lastId = id;
        }
      }
      this.firstName = firstName;
      this.lastName = lastName;
      this.email = email;
  }

  public double getMonthlyFee() {
    return 5.0;
  }

  public int getAmountToBorrow() {
    return 3;
  }

  public String getType() {
    return "Basic";
  }
}

Premium.java

import java.util.Optional;

class Premium extends Customer {
  public Premium(
    int id,
    String firstName,
    String lastName,
    String email) {
      if(Optional.ofNullable(id).orElse(0).intValue() == 0) {
        lastId++;
        this.id = lastId;
      }
      else {
        this.id = id;
        if(id > lastId) {
          lastId = id;
        }
      }
      this.firstName = firstName;
      this.lastName = lastName;
      this.email = email;
  }

  public double getMonthlyFee() {
    return 10.0;
  }

  public int getAmountToBorrow() {
    return 10;
  }

  public String getType() {
    return "Premium";
  }
}

Main.java

class Main {

  public String checkIfValid(Customer customer, Book[] books) {
    String valid = (customer.getAmountToBorrow() >= books.length) 
      ? "Yes you can!"
      : "No you cannot!";
    return valid;
  }

  public static void main(String[] args) {
    // Define self
    Main self = new Main();

    // Define books
    Book[] booksList1 = new Book[6];
    booksList1[0] = new Book("9785267006323", "Ready Player One", "Ernest Cline", 10);
    booksList1[1] = new Book("9785267006322", "The Sun and Her Flowers", "Rupi Kaur", 10);
    booksList1[2] = new Book("9785267896322", "The Secret Lives of Color", "Kassia St Clair", 10);
    booksList1[3] = new Book("9785234606321", "Don't Make Me Think", "Steve Krug", 10);
    booksList1[4] = new Book("9734967006324", "Clean Architecture", "Robert Martin", 10);
    booksList1[5] = new Book("9757817006329", "Modular Web Design", "Nathan Curtis", 10);

    Book[] booksList2 = new Book[2];
    booksList1[0] = new Book("9785267006323", "Ready Player One", "Ernest Cline", 10);
    booksList1[1] = new Book("9785267006322", "The Sun and Her Flowers", "Rupi Kaur", 10);

    // Define customer
       Customer customer1 = new Basic(5, "John", "Doe", "[email protected]");
    String validCustomer1 = self.checkIfValid(customer1, booksList1);
    System.out.println(validCustomer1);
    //-> No you cannot!

    Customer customer2 = new Premium(6, "Steve", "Rhills", "[email protected]");
    String validCustomer2 = self.checkIfValid(customer2, booksList1);
    System.out.println(validCustomer2);
    //-> Yes you can!

    Customer customer3 = new Premium(7, "Mary", "Nath", "[email protected]");
    String validCustomer3 = self.checkIfValid(customer3, booksList2);
    System.out.println(validCustomer3);
    //-> Yes you can!
  }
}

Orientado a objetos I

Orientado a objetos I

Objetos

Clases

Metodos

Metodo `main`

Crear clases

Propiedades

Configurar valor de propiedades de objeto

Acceso a propiedades de objeto

Metodos

Acceso a propiedades y metodos

Constructores

Encapsulacion (Encapsulation)

Getting Setting

Propiedade o metodo estatico (Static)

Herencia (Inheritance)

Método de anulación (Overriding method)

Clases Abstracta (Abstract Class)

results matching ""

No results matching ""

Orientado a objetos I

Objetos

Clases

Metodos

Metodo main

Crear clases

Propiedades

Configurar valor de propiedades de objeto

Acceso a propiedades de objeto

Metodos

Acceso a propiedades y metodos

Constructores

Encapsulacion (Encapsulation)

Getting Setting

Propiedade o metodo estatico (Static)

Herencia (Inheritance)

Método de anulación (Overriding method)

Clases Abstracta (Abstract Class)

results matching ""

No results matching ""

Metodo `main`