https://github.com/zer0m4n/poo-java
Notas de mi aprendizaje en java , las practicas las sacos de ejercidos que veo en internet
https://github.com/zer0m4n/poo-java
espanol ghdesktop ingles java jetbrains learn learning
Last synced: about 2 months ago
JSON representation
Notas de mi aprendizaje en java , las practicas las sacos de ejercidos que veo en internet
- Host: GitHub
- URL: https://github.com/zer0m4n/poo-java
- Owner: Zer0M4n
- License: unlicense
- Created: 2023-06-10T19:34:23.000Z (almost 2 years ago)
- Default Branch: main
- Last Pushed: 2023-07-26T21:18:49.000Z (almost 2 years ago)
- Last Synced: 2025-03-29T03:32:06.302Z (2 months ago)
- Topics: espanol, ghdesktop, ingles, java, jetbrains, learn, learning
- Language: Java
- Homepage:
- Size: 69.3 KB
- Stars: 5
- Watchers: 1
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Programación orientada a objetos(POO)
**Uso del repositorio:** Este repositorio sirve para mostrar mi aprendizaje en java , con notas y ejercicios .
**Que es POO?**
Es una de las paradigmas de programación , este tiene el fin de facilitar programación usando clases y objetos ( y otros conceptos que veré luego)
# Clases y objetos
**Que es una clase ?**
Una clase nos funciona como plantilla que usaremos para facilitarnos la vida, Dentro de la clase se va definir las características de la identidad y sus atributos.
**Que es un objeto?**
Un objeto seria una representación de algo
**Sintaxis de la clase**
```java
//[Modificador de acceso] [Class] [Nombre de la clase] {}
public class Main {
int x = 5;
}
```
**Sintaxis del objeto**
```java
public class Main {
int x = 5;
public static void main(String[] args) {
//[Clase][nombre del objeto] = [new][]Nombre de la clase]
Main myObj = new Main();//Este es el objeto
System.out.println(myObj.x);
//out : 5
}
}
```
**Se puede tener diferentes objetos?**
Claro , lo que cambia en la sintaxis es que el nombre del objeto debe ser diferente
```java
public class Main {
int x = 5;
public static void main(String[] args) {
Main myObj1 = new Main(); // Object 1
Main myObj2 = new Main(); // Object 2
System.out.println(myObj1.x);
System.out.println(myObj2.x);
}
}
//out
//5
//5
```
## Atributos de la clase
**Que es una atributo?** La explicación mas sencilla es que son variables de la clase, así de sencillo
```java
public class Main {
int x = 5;
int y = 3;
}
//Aqui esta clase tiene dos atributos x , y
```
**Como llamamos los atributos?**
Pues muy sencillo , solamente llamaos las varibles usando el objeto
```java
public class Main {
int x = 5;
//LLamar un atributo [Nombre del objeto].[nombre de la variable]
public static void main(String[] args) {
Main myObj = new Main();
System.out.println(myObj.x);
}
}
```
Modificacion de atribtutos'
```java
public class Main {
int x = 10;
public static void main(String[] args) {
Main myObj = new Main();
myObj.x = 25; // x is now 25
System.out.println(myObj.x);
}
}
```
**Que hacer si no quiero que se modifiquen?**
Usamos *~~final~~* para que nos se modifique el acceso
```java
public class Main {
final int x = 10;
public static void main(String[] args) {
Main myObj = new Main();
myObj.x = 25; // will generate an error: cannot assign a value to a final variable
System.out.println(myObj.x);
}
}
```
## Métodos de clase
**Que es un método?** Los métodos son funciones que ejecutan códigos , sirven para separar apartados del programa y se efectúan con el objetos
**Ejemplo**
```java
public class Main {
static void myMethod() {
System.out.println("Hello World!");
}
public static void main(String[] args) {
myMethod();
}
}
// Outputs "Hello World!"
```
# *Metodos Getter y Setter*
Loa métodos ***Getter*** y ***Setter*** Son métodos que permiten el acceso a los atributos de una clase , que están encapsulados de manera privada
**Metodo Getter**
El metodo get("Obtener"): accede a la clase para retornarnos el valor por lo cual la estructura de este metodo debe contener el tipo de valor que vamos a retornar el con ese metodo
**Metodo Setter**
El metodo set("Establecer") nos sirve para asignar un valor a un atributo de nuestra la clase , esto se hace de manera directa con este metodo, como este metodo no retorna nada debe contener la palabra void en su estructura y siempre debe recibir un parametro de entrada
## Tipos de modificadores de acceso?
- **Modificador de acceso prívate:** Este modificador es el mas restrictivo , la unica manera de acceder a los datos es mediante con la clase asociada
- **El modificador por defecto (default):** Cuando no declaramos un modificador de acceso , java asigna el modificador default, este modificador permite accesar los datos de la propia clase, como las clases del mismo paquete
- **Modificador de acceso protected:** Los datos se acceden con la misma clase, clases del mismo paquete y clases heredados
- **Modificador public:** Este es el modificador con mas libertad , podemos acceder los datos donde sea
-
Modificador
La misma clase
Mismo paquete
Subclase
Otro paquete
private
Sí
No
No
No
default
Sí
Sí
No
No
protected
Sí
Sí
Sí/No
No
public
Sí
Sí
Sí
Sí
## Constructores
**Que es un constructor?** Un constructor sirve para inicializar el objeto y establecer sus propiedades y valores predeterminados.
**Sintaxis**
```java
// Create a Main class
public class Main {
int x; // Create a class attribute
// Create a class constructor for the Main class
public Main() {
x = 5; // Set the initial value for the class attribute x
}
public static void main(String[] args) {
Main myObj = new Main(); // Create an object of class Main (This will call the constructor)
System.out.println(myObj.x); // Print the value of x
}
}
// Outputs 5
```
## Herencia y Polimorfismo
**Que es la herencia en POO?** La herencia en poo es cuando "hederemos" Características de una clase a otra, de esta forma nos permite reutilizar atributos y métodos para otras clases
- **Clase Base:** La clase base es la que hereda sus atributos y metodos
- **Clase Derivada:** Esta es la clase que recibe métodos y atributos
Para poder hederar clases tenemos que usar la palabra **extends**
**Sintaxis de la herencia**
```java
class Vehicle {
protected String brand = "Ford"; // Vehicle attribute
public void honk() { // Vehicle method
System.out.println("Tuut, tuut!");
}
}
class Car extends Vehicle {
private String modelName = "Mustang"; // Car attribute
public static void main(String[] args) {
// Create a myCar object
Car myCar = new Car();
// Call the honk() method (from the Vehicle class) on the myCar object
myCar.honk();
// Display the value of the brand attribute (from the Vehicle class) and the value of the modelName from the Car class
System.out.println(myCar.brand + " " + myCar.modelName);
}
}
```
**Que es el polimorfismo en POO?** El polimorfismo es la capacidad de un objeto en ofrecer diferentes respuestas
**Ejemplos de polimorfismo**
```java
class Animal {
public void animalSound() {
System.out.println("The animal makes a sound");
}
}
class Pig extends Animal {
public void animalSound() {
System.out.println("The pig says: wee wee");
}
}
class Dog extends Animal {
public void animalSound() {
System.out.println("The dog says: bow wow");
}
}
class Main {
public static void main(String[] args) {
Animal myAnimal = new Animal(); // Create a Animal object
Animal myPig = new Pig(); // Create a Pig object
Animal myDog = new Dog(); // Create a Dog object
myAnimal.animalSound();
myPig.animalSound();
myDog.animalSound();
}
}
```
## Clases Abstractas
**Clases abstractas:** Es una clase especial que no puede crear objetos , se usa como base para otros clase, solo se usa para heredar
**Métodos abstractos:** Tiene como principal que no tiene cuerpo , solo tiene cuerpo cuando hederemos el método a una clase hija
**Ejemplos de uso de clases abstractas**
```java
// Abstract class
abstract class Animal {
// Abstract method (does not have a body)
public abstract void animalSound();
// Regular method
public void sleep() {
System.out.println("Zzz");
}
}
// Subclass (inherit from Animal)
class Pig extends Animal {
public void animalSound() {
// The body of animalSound() is provided here
System.out.println("The pig says: wee wee");
}
}
class Main {
public static void main(String[] args) {
Pig myPig = new Pig(); // Create a Pig object
myPig.animalSound();
myPig.sleep();
}
}
```
## Interfaces
**Que es?** Una interfaz es una "clase abstracta" completamente que se utiliza para agrupar métodos relacionados con cuerpos vacíos:
**Ejemplo**
```java
// interface
interface Animal {
public void animalSound(); // interface method (does not have a body)
public void run(); // interface method (does not have a body)
}
```
## Excepciones
**Que son las exepciones en java?** Las exepciones son formas que java nos da para controlar errores, son muy utiles para errores previstos y imprevistos
**Tipos de exepciones en java:**
- **Excepciones irrecuperables:** Hijas de **Error**. Son errores de la propia máquina virtual de Java.
- **Excepciones que NO es necesario gestionar:** Hijas de **RunTimeException**. Son excepciones muy comunes, por ejemplo **NullPointerException**,
-
**ArrayIndexOutOfBoundsException**.
- **Excepciones que es necesario gestionar:** Hijas de **Exception**. Todas las demás, por ejemplo **IOException**.
**Ejemplo de exepciones**
```java
public class Main {
public static void main(String[] args) {
try {
int[] myNumbers = {1, 2, 3};
System.out.println(myNumbers[10]);
} catch (Exception e) {
System.out.println("Something went wrong.");
} finally {
System.out.println("The 'try catch' is finished.");
}
}
}
```