Webinar JAVA 01

WEBINAR
EXPERIENCIAS DE PROGRAMACIÓN EN JAVA
Autor: Javier Mariscal Qquellón

jmariscal@seencorp.pe
https://www.linkedin.com/in/javier-mariscal-97a85094
Whastapp: 997596006
¿Copiar y Pegar o reutilizar funcionalidad?
Código claro
Uso de excepciones
Uso excesivo de comentarios // //**
SQL /PLSQL ?
SOAP - REST
GraalVM
GITLAB
3
¿Recursividad?
4
Frameworks
JSF with Primefaces, Spring

JPA with Hibernate (ORM)
Quartz
5
Tools and Others
Netbeans, eclipse, Jdeveloper

Tomee
Oracle DB
Mariadb
MongoDB
6
JAVA
El lenguaje de programación Java es un lenguaje de alto nivel que puede caracterizarse por:
●
Sencillo
●
Orientado a objetos
●
Distribuido
●
Multiprocesos
●
Dinámico
●
Arquitectura Neutral
●
Portable
●
Alto rendimiento
●
Robusto
●
Seguro
©Derechos Reservados
7 Curso Java desde Cero
SEENCORP 2020
Visión general del proceso de desarrollo de
software.
SEENCORP 2020
SEENCORP 2020
La API y la máquina virtual Java aíslan el
programa del hardware subyacente.
La plataforma java tiene 2 componentes:

●
The Java Virtual Machine
●
The Java Application Programming Interface (API)
SEENCORP 2020
¿Qué puedes hacer con la tecnología JAVA?
Java le ofrece las siguientes características:

●
Herramientas de desarrollo.
●
Interfaz de programación de aplicaciones (API).
●
Tecnologías de implementación (Java web start, Java Plug in).
●
Herramientas de interfaz de usuario(JavaFx, Swing, JAVA 2D)
● Bibliotecas de integración. API IDL, API JDBC, JNDI, JAVA RMI,
SEENCORP 2020
Instalación de herramientas
Requisitos
● Instalación de JDK 8
●
Instalación de Netbeans 8.2
SEENCORP 2020
¿Hola Mundo?
SEENCORP 2020
Aprendiendo lenguaje JAVA
●
Concepto de Programación Orientado a Objetos.
●
Conceptos básicos.
●
Clases y Objetos.
●
Anotaciones.
●
Interfaces y Herencia.
● Números y Cadena de Caracteres.
● Genéricos.
● Paquetes.
SEENCORP 2020
Object-Oriented Programming Concepts
What Is an Object? Software objects are often used to model the real-world
objects
What Is a Class?A class is a blueprint or prototype from which objects are

created.
What Is Inheritance?Inheritance provides a powerful and natural mechanism

for organizing and structuring your software
What Is an Interface?When a class implements an interface, it promises to

provide the behavior published by that interface
What Is a Package?A package is a namespace for organizing classes and

interfaces in a logical manner
SEENCORP 2020
What Is an Object?
A software object. A bicycle modeled as a software object.
La agrupación de código en objetos de software individuales proporciona una serie de beneficios, que incluyen:
●
Modularity
●
Information-hiding
●
Code re-use
●
Pluggability and debugging ease
SEENCORP 2020
What Is a Class?
class Bicycle { In object-oriented terms, we say that

int cadence = 0; your bicycle is an instance of the class of
int speed = 0;
int gear = 1;
objects known as bicycles
void changeCadence(int newValue) {
cadence = newValue; class BicycleDemo {
} public static void main(String[] args) {
// Create two different

void changeGear(int newValue) {
// Bicycle objects
gear = newValue;
Bicycle bike1 = new Bicycle();
} Bicycle bike2 = new Bicycle();
void speedUp(int increment) { // Invoke methods on
speed = speed + increment; // those objects

bike1.changeCadence(50);
}
bike1.speedUp(10);
bike1.changeGear(2);
void applyBrakes(int decrement) { bike1.printStates();
speed = speed - decrement;
} bike2.changeCadence(50);
bike2.speedUp(10);
bike2.changeGear(2);
void printStates() {
bike2.changeCadence(40);
System.out.println("cadence:" +
bike2.speedUp(10);
cadence + " speed:" + bike2.changeGear(3);
speed + " gear:" + gear); bike2.printStates();
} }
} }
SEENCORP 2020
What Is Inheritance?
The syntax for creating a subclass is simple. At

the beginning of your class declaration, use the
extends keyword, followed by the name of the
class to inherit from:
class MountainBike extends Bicycle {
// new fields and methods defining

// a mountain bike would go here
SEENCORP 2020
What Is an Interface?
class ACMEBicycle implements Bicycle {
En su forma más común, una int cadence = 0;

int speed = 0;
interfaz es un grupo de métodos int gear = 1;
// The compiler will now require that methods
relacionados con cuerpos vacíos. // changeCadence, changeGear, speedUp, and applyBrakes

// all be implemented. Compilation will fail if those
// methods are missing from this class.
void changeCadence(int newValue) {

cadence = newValue;
}
void changeGear(int newValue) {
interface Bicycle { gear = newValue;

}
// wheel revolutions per minute void speedUp(int increment) {

speed = speed + increment;
void changeCadence(int newValue);
}
void changeGear(int newValue); void applyBrakes(int decrement) {

speed = speed - decrement;
}
void speedUp(int increment);
void printStates() {
System.out.println("cadence:" +
void applyBrakes(int decrement); cadence + " speed:" +
speed + " gear:" + gear);
}
}
}
SEENCORP 2020
What Is a Package?
Un paquete es un espacio de nombres que organiza un conjunto

de clases e interfaces relacionadas
SEENCORP 2020
¿Seguro de lo aprendido?
● Real-world objects contain ___ and ___.

●
A software object's state is stored in ___.
● A software object's behavior is exposed through ___.
● Hiding internal data from the outside world, and accessing it only through publicly exposed methods is known as data
___.
●
A blueprint for a software object is called a ___.
● Common behavior can be defined in a ___ and inherited into a ___ using the ___ keyword.
● A collection of methods with no implementation is called an ___.
● A namespace that organizes classes and interfaces by functionality is called a ___.
● The term API stands for ___?
SEENCORP 2020
Language Basics
●
Variables. tipos de datos básicos (tipos primitivos, cadenas de caracteres y
matrices), valores predeterminados y literales.
●
Operators
●
Expressions, Statements, and Blocks
●
Control Flow Statements
SEENCORP 2020
Language Basics:Variables
●
Instance Variables (Non-Static Fields).Técnicamente hablando, los
objetos almacenan sus estados individuales en "campos no estáticos", es decir,
campos declarados sin la palabra clave estática.
●
Class Variables (Static Fields).esto le dice al compilador que existe
exactamente una copia de esta variable, independientemente de cuántas
veces se haya instanciado la clase.
● Local Variables.las variables locales solo son visibles para los métodos en los
que se declaran; no son accesibles desde el resto de la clase.
●
Parameters.Lo importante para recordar es que los parámetros siempre se
clasifican como "variables", no como "campos"
SEENCORP 2020
¿Como nombrar variables?
●
Variable names are case-sensitive.
●
Al elegir un nombre para sus variables, use palabras completas
en lugar de abreviaturas crípticas.
● Si el nombre que elige consta de una sola palabra, deletree esa
palabra en minúsculas. Si consta de más de una palabra,
escriba en mayúscula la primera letra de cada palabra
subsiguiente

Language Basics:Variables
Primitive Data Types.

todas las variables deben declararse primero antes de que puedan usarse.
int gear = 1;
Tienen valores por defecto cero o false o ‘u\0000’
● byte
● short
● Int
● long
● float
● double
● boolean
● Char
● ¿String ?, No es pero recibe un trato especial.Valor por defecto es nulo
Arrays.
SEENCORP 2020
Variables: Arrays
class ArrayDemo {
Una matriz es un objeto contenedor que public static void main(String[] args) {
// declares an array of integers
contiene un número fijo de valores de un solo

int[] anArray;
// allocates memory for 10 integers
tipo anArray = new int[10];
// initialize first element

anArray[0] = 100;
// initialize second element
anArray[1] = 200;
// and so forth
anArray[2] = 300;
anArray[3] = 400;
anArray[4] = 500;
anArray[5] = 600;
anArray[6] = 700;
anArray[7] = 800;
anArray[8] = 900;
anArray[9] = 1000;
System.out.println("Element at index 0: "

+ anArray[0]);
+ anArray[1]);
+ anArray[2]);
+ anArray[3]);
+ anArray[4]);
+ anArray[5]);
+ anArray[6]);
+ anArray[7]);
+ anArray[8]);
+ anArray[9]);
}
}
SEENCORP 2020
Language Basics:Operators
La regla de precedencia establece que los Operators Precedence

operadores de mayor nivel se ejecuten postfix expr++ expr--
primero. unary ++expr --expr +expr -expr ~ !
multiplicative */%
additive +-
shift << >> >>>
relational < > <= >= instanceof
equality == !=
bitwise AND &
bitwise exclusive ^
OR
bitwise inclusive OR |
logical AND &&
logical OR ||
ternary ?:
assignment = += -= *= /= %= &= ^= |= <<= >>=
>>>=
SEENCORP 2020
class ArithmeticDemo {
Assignment, Arithmetic, and public static void main (String[] args) {
Unary Operators int result = 1 + 2;

// result is now 3
System.out.println("1 + 2 = " + result);
int original_result = result;
Operator Description result = result - 1;

// result is now 2
System.out.println(original_result + " - 1 = " + result);
+ Additive operator (also used for original_result = result;
String concatenation) result = result * 2;
- Subtraction operator // result is now 4

System.out.println(original_result + " * 2 = " + result);
original_result = result;
* Multiplication operator
result = result / 2;
/ Division operator // result is now 2
System.out.println(original_result + " / 2 = " + result);
% Remainder operator original_result = result;
result = result + 8;
// result is now 10
System.out.println(original_result + " + 8 = " + result);
original_result = result;
result = result % 7;
// result is now 3
System.out.println(original_result + " % 7 = " + result);
}
}
SEENCORP 2020
The Unary Operators class UnaryDemo {
public static void main(String[] args) {
Operator Description int result = +1;

// result is now 1
+ Unary plus operator; indicates positive
System.out.println(result);
value (numbers are positive without this,
however) result--;
// result is now 0
- Unary minus operator; negates an System.out.println(result);
expression
result++;
++ Increment operator; increments a value // result is now 1
by 1 System.out.println(result);
-- Decrement operator; decrements a

result = -result;
value by 1 // result is now -1
! Logical complement operator; inverts System.out.println(result);
the value of a boolean boolean success = false;

// false
System.out.println(success);
// true
System.out.println(!success);
}
}
SEENCORP 2020
The Equality and Relational Operators class ComparisonDemo {
== equal to public static void main(String[] args){
!= not equal to int value1 = 1;

int value2 = 2;
> greater than if(value1 == value2)
>= greater than or equal to System.out.println("value1 == value2");
if(value1 != value2)
< less than System.out.println("value1 != value2");
<= less than or equal to if(value1 > value2)
System.out.println("value1 > value2");
if(value1 < value2)
The Conditional Operators System.out.println("value1 < value2");
if(value1 <= value2)
Estos operadores exhiben un comportamiento de "cortocircuito", lo que
System.out.println("value1 <= value2");
significa que el segundo operando se evalúa solo si es necesario.
}
&& Conditional-AND }
|| Conditional-OR
class ConditionalDemo1 {
public static void main(String[] args){

int value1 = 1;
int value2 = 2;
if((value1 == 1) && (value2 == 2))
System.out.println("value1 is 1 AND value2 is 2");
if((value1 == 1) || (value2 == 1))
System.out.println("value1 is 1 OR value2 is 1");
}
}
SEENCORP 2020
The Type Comparison Operator instanceof class InstanceofDemo {

Puede usarlo para probar si un objeto es una instancia de una clase,
una instancia de una subclase o una instancia de una clase que
Parent obj1 = new Parent();
implementa una interfaz particular.
Parent obj2 = new Child();
System.out.println("obj1 instanceof Parent: "

+ (obj1 instanceof Parent));
System.out.println("obj1 instanceof Child: "
+ (obj1 instanceof Child));
System.out.println("obj1 instanceof MyInterface: "
+ (obj1 instanceof MyInterface));
System.out.println("obj2 instanceof Parent: "
+ (obj2 instanceof Parent));
System.out.println("obj2 instanceof Child: "
+ (obj2 instanceof Child));
System.out.println("obj2 instanceof MyInterface: "
+ (obj2 instanceof MyInterface));
}
}
class Parent {}
class Child extends Parent implements MyInterface {}
interface MyInterface {}
SEENCORP 2020
Language Basics:Expressions, Statements, and
Blocks
// expression
Expressions:es una construcción compuesta de variables, int cadence = 0;
operadores e invocaciones de métodos, que se evalúa en un soloanArray[0] = 100;
valor. (evitar expresiones ambiguas, ejemplo; x + y / 100 System.out.println("Element 1 at index 0: " + anArray[0]);
recomendación x + (y/100) o (x+y)/100 int result = 1 + 2; // result is now 3

if (value1 == value2)
Statements:Una declaración forma una unidad completa de System.out.println("value1 == value2");
ejecución, terminan en ;
// assignment statement
●
declaration statement aValue = 8933.234;
// increment statement
●
control flow statements aValue++;
// method invocation statement
Blocks:A block is a group of zero or more statements between System.out.println("Hello World!");
balanced braces and can be used anywhere a single statement is // object creation statement
Bicycle myBike = new Bicycle();
allowed.
// declaration statement
double aValue = 8933.234;
class BlockDemo {
boolean condition = true;
if (condition) { // begin block 1
System.out.println("Condition is true.");
} // end block one
else { // begin block 2
System.out.println("Condition is false.");
} // end block 2
}
}
SEENCORP 2020
Language Basics:Control Flow Statements
Las declaraciones de flujo de control dividen el

flujo de ejecución empleando la toma de
decisiones, el bucle y la ramificación, lo que
permite que su programa ejecute
condicionalmente bloques de código
particulares.
Esta sección describe las declaraciones de toma

de decisiones (if-then, if-then-else, switch), las
declaraciones de bucle (for, while, do-while) y
las declaraciones de ramificación (break,
continue, return)
SEENCORP 2020
Control Flow Statements:The if-then and if-
then-else Statements
●
The if-then Statement
●
The if-then-else Statement class IfElseDemo {
void applyBrakes() {
// the "if" clause: bicycle must be moving
int testscore = 76;
if (isMoving){
// the "then" clause: decrease current speed char grade;
currentSpeed--;
} if (testscore >= 90) {
} grade = 'A';
– OR
} else if (testscore >= 80) {
grade = 'B';
// same as above, but without braces
} else if (testscore >= 70) {
if (isMoving) grade = 'C';
currentSpeed--; } else if (testscore >= 60) {
} grade = 'D';
} else {
grade = 'F';
if (isMoving) {
}
currentSpeed--;
} else {
System.out.println("Grade = " + grade);
System.err.println("The bicycle has already stopped!"); }
} }
}
SEENCORP 2020
Control Flow Statements:The switch
Statement
public class SwitchDemo {
int month = 8;
funciona con tipos enumerados (discutidos en Tipos de enumeración), la String monthString;
clase String y algunas clases especiales que envuelven ciertos tipos switch (month) {
case 1: monthString = "January";
primitivos: Carácter, Byte, Corto e Entero (discutido en Números y cadenas). break;
case 2: monthString = "February";
break;
--Equialente al switch case 3: monthString = "March";
break;
int month = 8;
case 4: monthString = "April";
if (month == 1) { break;
case 5: monthString = "May";
System.out.println("January"); break;
} else if (month == 2) { case 6: monthString = "June";

break;
System.out.println("February"); case 7: monthString = "July";
break;
} case 8: monthString = "August";
break;
case 9: monthString = "September";
break;
case 10: monthString = "October";
break;
case 11: monthString = "November";
break;
case 12: monthString = "December";
break;
default: monthString = "Invalid month";
break;
}
System.out.println(monthString);
}
}
SEENCORP 2020
Control Flow Statements:The while and do-
while Statements
La sentencia while ejecuta continuamente un bloque de class WhileDemo {
sentencias mientras una condición particular es public static void main(String[] args){
verdadera. Su sintaxis se puede expresar como: int count = 1;
while (count < 11) {
while (expression) {
System.out.println("Count is: " + count);
statement(s) count++;
} }
}
}
do {
statement(s)
class DoWhileDemo {
} while (expression);
int count = 1;
La diferencia entre do-while y while es que do-while do {
evalúa su expresión en la parte inferior del bucle en lugar System.out.println("Count is: " + count);
de en la parte superior. Por lo tanto, las declaraciones count++;
dentro del bloque do siempre se ejecutan al menos una } while (count < 11);
vez, }
}
SEENCORP 2020
Control Flow Statements:The for Statement
La instrucción for proporciona una forma class ForDemo {

compacta de iterar sobre un rango de valores
for(int i=1; i<11; i++){
System.out.println("Count is: " + i);
}
for (initialization; termination; increment) {
}
statement(s) }
}
–- Otra forma
class EnhancedForDemo {
int[] numbers =
{1,2,3,4,5,6,7,8,9,10};
for (int item : numbers) {
System.out.println("Count is: " + item);
}
}
}
SEENCORP 2020
Control Flow Statements:Branching
Statements
class BreakWithLabelDemo {
Ramificaciones public static void main(String[] args) {
● The break Statement:The break statement has two int[][] arrayOfInts = {
forms: labeled and unlabeled { 32, 87, 3, 589 },

{ 12, 1076, 2000, 8 },
● The continue Statement };

{ 622, 127, 77, 955 }
int searchfor = 12;

● The return Statement
int i;
int j = 0;
boolean foundIt = false;
search:
for (i = 0; i < arrayOfInts.length; i++) {
for (j = 0; j < arrayOfInts[i].length;
j++) {
if (arrayOfInts[i][j] == searchfor) {
foundIt = true;
break search;
}
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at " + i + ", " + j);
} else {
System.out.println(searchfor + " not in the array");
}
}
}
SEENCORP 2020
Statements
class BreakWithLabelDemo {
Ramificaciones public static void main(String[] args) {
int[][] arrayOfInts = {
●
The break Statement:The break { 32, 87, 3, 589 },
{ 12, 1076, 2000, 8 },
statement has two forms: labeled and };

{ 622, 127, 77, 955 }
unlabeled int searchfor = 12;
int i;
int j = 0;
search:
for (i = 0; i < arrayOfInts.length; i++) {
for (j = 0; j < arrayOfInts[i].length;
j++) {
if (arrayOfInts[i][j] == searchfor) {
foundIt = true;
break search;
}
}
}
if (foundIt) {
System.out.println("Found " + searchfor + " at " + i + ", " + j);
} else {
System.out.println(searchfor + " not in the array");
}
}
}
SEENCORP 2020
Statements
Ramificaciones class ContinueDemo {

●
The continue Statement:La instrucción continue public static void main(String[] args) {
omite la iteración actual de un ciclo for, while o
do-while String searchMe = "peter piper picked a " + "peck of pickled peppers";
int max = searchMe.length();
int numPs = 0;
for (int i = 0; i < max; i++) {

// interested only in p's
if (searchMe.charAt(i) != 'p')
continue;
// process p's
numPs++;
}
System.out.println("Found " + numPs + " p's in the string.");
}
}
SEENCORP 2020
Statements
Ramificaciones class ContinueWithLabelDemo {

●
The continue Statement:
String searchMe = "Look for a substring in me";
String substring = "sub";
int max = searchMe.length() -

substring.length();
test:
for (int i = 0; i <= max; i++) {
int n = substring.length();
int j = i;
int k = 0;
while (n-- != 0) {
if (searchMe.charAt(j++) != substring.charAt(k++)) {
continue test;
}
}
foundIt = true;
break test;
}
System.out.println(foundIt ? "Found it" : "Didn't find it");
}
}
SEENCORP 2020
Statements
Ramificaciones
● The return Statement
La instrucción return sale del método actual y el flujo de control vuelve al lugar
donde se invocó el método. La declaración return tiene dos formas: una que
devuelve un valor y otra que no.
return ++count;
return;
SEENCORP 2020
Classes and Objects
●
Classes
●
Declaración de clases.
●
Declaración de variables.
●
Definición de métodos
●
Proporcionar Constructores de Clases
●
Pasar información a un método o constructor
●
Objects
●
Creación de objetos
●
Uso de objetos.
●
Mas sobre Clases
●
Retornar un valor de de un métodoto
●
Usando la palabra “this”
●
Control de acceso a miembros de clase (static, final)
●
Inialización de Campos
●
Classes Anidadas
●
Clases internas
●
Clases locales
●
Clases anonimas
●
Expresiones Lambda
SEENCORP 2020
Classes and Objects:Classes
●
Declaring Classes: public class Bicycle {
class MyClass {
// the Bicycle class has
// field, constructor, and // three fields
public int cadence;
// method declarations public int gear;
} public int speed;
class MyClass extends MySuperClass implements YourInterface { // the Bicycle class has
// field, constructor, and // one constructor

public Bicycle(int startCadence, int startSpeed, int startGear) {
// method declarations gear = startGear;
cadence = startCadence;
}
speed = startSpeed;
}
In general, class declarations can include these components, in order:
// the Bicycle class has
// four methods
public void setCadence(int newValue) {
●
Modifiers such as public, private, and a number of others that you will cadence = newValue;
encounter later. }
●
The class name, with the initial letter capitalized by convention. public void setGear(int newValue) {
gear = newValue;
●
The name of the class's parent (superclass), if any, preceded by the }
keyword extends. A class can only extend (subclass) one parent. public void applyBrake(int decrement) {
speed -= decrement;
●
A comma-separated list of interfaces implemented by the class, if any, }
preceded by the keyword implements. A class can implement more
than one interface. public void speedUp(int increment) {
speed += increment;
●
The class body, surrounded by braces, {}. }
SEENCORP 2020
Ejemplo de código:
Declaring Member Variables
Hay varios tipos de variables:
● Variables miembro en una clase: se denominan campos. public int cadence;
● Variables en un método o bloque de código: se public int gear;
denominan variables locales. public int speed;
● Variables en las declaraciones de métodos: se

denominan parámetros.
Las declaraciones de campo se componen de tres

componentes, en orden:
● Cero o más modificadores, como público o privado.
● El tipo de campo.
● El nombre del campo.
SEENCORP 2020
public class Bicycle {
private int cadence;

private int gear;
Modificadores de acceso private int speed;
●
public modifier: the field is accessible from all classes.
●
private modifier:the field is accessible only within its own class. gear = startGear;
speed = startSpeed;
}
Cuando hablado de Encapsulación es común hacer que los campos
sean privados. Esto significa que solo se puede acceder public int getCadence() {
return cadence;
directamente desde la clase de bicicletas. Sin embargo, todavía
}
necesitamos acceso a estos valores. Esto se puede hacer
indirectamente agregando métodos públicos que obtengan los public void setCadence(int newValue) {
valores de campo para nosotros cadence = newValue;

}
public int getGear() {

Types return gear;
}
Todas las variables deben tener un tipo. Puede usar tipos primitivos
como int, float, boolean, etc. O puede usar tipos de referencia, como public void setGear(int newValue) {
cadenas, matrices u objetos. gear = newValue;

}
Variable Names
public int getSpeed() {
●
la primera letra del nombre de una clase debe estar en mayúscula y return speed;
}
●
la primera (o única) palabra en el nombre de un método debería ser
un verbo. public void applyBrake(int decrement) {
speed -= decrement;
}
public void speedUp(int increment) {

speed += increment;
46 Curso Java desde Cero }
}
SEENCORP 2020
public double calculateAnswer(double wingSpan, int numberOfEngines,

Definición de Método double length, double grossTons) {
De manera más general, las declaraciones de métodos tienen seis //do the calculation here
componentes: }
●
Modificadores, como públicos, privados y otros. // Overloading Methods
public class DataArtist {
●
El tipo de retorno: el tipo de datos del valor devuelto por el método, o
...
nulo si el método no devuelve un valor.
public void draw(String s) {
●
El nombre del método: las reglas para los nombres de campo se aplican ...
también a los nombres de los métodos. }
●
La lista de parámetros entre paréntesis: una lista delimitada por comas public void draw(int i) {
de parámetros de entrada, precedida por sus tipos de datos, encerrada ...
entre paréntesis, (). Si no hay parámetros, debe usar paréntesis vacíos. }
●
Una lista de excepciones. public void draw(double f) {
...
●
El cuerpo del método, encerrado entre llaves, el código del método,
}
incluida la declaración de variables locales.
public void draw(int i, double f) {
Nombrar un Método ...
Por convención, los nombres de los métodos deben ser un verbo en }
minúsculas o un nombre de varias palabras que comience con un verbo en }
minúsculas, seguido de adjetivos, sustantivos, etc.
Sobrecarga de Métodos
Esto significa que los métodos dentro de una clase pueden tener el mismo
nombre si tienen listas de parámetros diferentes
SEENCORP 2020
Creando constructores de Clases gear = startGear;

Una clase contiene constructores que son invocados al crear objetos de speed = startSpeed;
las clases. }
// Pasar información a un Método o un Constructor
Pasar información a un Método o un Constructor public double computePayment(
double loanAmt,
Parameter Types double rate,
double futureValue,
Arbitrary Number of Arguments int numPeriods) {
Parameter Names double interest = rate / 100.0;

double partial1 = Math.pow((1 + interest),
- numPeriods);
double denominator = (1 - partial1) / interest;
double answer = (-loanAmt / denominator)
- ((futureValue * partial1) / denominator);
return answer;
}
// Arbitrary Number of Arguments
public Polygon polygonFrom(Point... corners) {
int numberOfSides = corners.length;
double squareOfSide1, lengthOfSide1;
squareOfSide1 = (corners[1].x - corners[0].x)
* (corners[1].x - corners[0].x)
+ (corners[1].y - corners[0].y)
* (corners[1].y - corners[0].y);
lengthOfSide1 = Math.sqrt(squareOfSide1);
// more method body code follows that creates and returns a

// polygon connecting the Points
}
48 Experiencias de programación en Java
SEENCORP 2020
public class PassPrimitiveByValue {
Passing Primitive Data Type Arguments

Los argumentos primitivos, como un int o un doble, se pasan a

int x = 3;
los métodos por valor. Esto significa que cualquier cambio en
los valores de los parámetros solo existe dentro del alcance del // invoke passMethod() with
// x as argument
método. Cuando el método regresa, los parámetros passMethod(x);
desaparecen y cualquier cambio en ellos se pierde
// print x to see if its
Passing Reference Data Type Arguments // value has changed
System.out.println("After invoking passMethod, x = " + x);
Los parámetros de tipo de datos de referencia, como los
}
objetos, también se pasan a los métodos por valor. Esto
significa que cuando el método regresa, la referencia pasada // change parameter in passMethod()
aún hace referencia al mismo objeto que antes. Sin embargo, public static void passMethod(int p) {
p = 10;
los valores de los campos del objeto se pueden cambiar en el }
método, si tienen el nivel de acceso adecuado. }
public void moveCircle(Circle circle, int deltaX, int deltaY) {

// code to move origin of circle to x+deltaX, y+deltaY
circle.setX(circle.getX() + deltaX);
circle.setY(circle.getY() + deltaY);
// code to assign a new reference to circle

circle = new Circle(0, 0);
}
SEENCORP 2020
Classes and Objects:Objects
Creando objetos
● Declaración: asocia un nombre de variable con un tipo de objeto.
●
Instanciación: la palabra new es un operador de Java que crea el
objeto.
● Inicialización: al nuevo operador le sigue una llamada a un
constructor, que inicializa el nuevo objeto.
Declarando una variable para referirse a un objeto
Instanciar una clase
El nuevo operador crea una instancia de una clase asignando
memoria para un nuevo objeto y devolviendo una referencia a esa
memoria. El nuevo operador también invoca el constructor de
objetos.
Inicializando un objeto
Referenciando campos de un objeto.
El código que está fuera de la clase del objeto debe usar una
referencia o expresión de objeto, seguida del operador de punto (.),
Seguido de un nombre de campo simple.
Llamada a métodos de un Objeto.
SEENCORP 2020
For example, the Point class was written like this
Retornando un valor de un Método.
Returning a Class or Interface public class Point {
public int x = 0;
Usando la palabra this: public int y = 0;
●
Dentro de un método de instancia o un //constructor
public Point(int a, int b) {
constructor, esta es una referencia al objeto x = a;
. }
y = b;
●
Desde dentro de un constructor, también }
but it could have been written like this:
puede usar la palabra clave this para llamar
a otro constructor en la misma clase. public class Point {
public int x = 0;
Hacerlo se llama invocación explícita del public int y = 0;
constructor.
//constructor
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
SEENCORP 2020
Control de acceso de un miembro de una

Access Levels
clase.
Modifier Class Package Subclass World
● Use el nivel de acceso más restrictivo public Y Y Y Y
que tenga sentido para un miembro en protected Y Y Y N
particular. Use privado a menos que no Y Y N N
tenga una buena razón para no hacerlo. modifier
private Y N N N
● Evite los campos públicos excepto las
constantes.
SEENCORP 2020
Campos y Métodos Estáticos public class Bicycle {
private int cadence;

El lenguaje de programación Java admite métodos
private int gear;
estáticos, así como variables estáticas. Los métodos
private int speed;
estáticos, que tienen el modificador estático en sus
declaraciones, deben invocarse con el nombre de la
clase, sin la necesidad de crear una instancia de la clase // add an instance variable for the object ID
Constantes private int id;
El modificador estático, en combinación con el

modificador final, también se utiliza para definir // add a class variable for the
constantes. // number of Bicycle objects instantiated
Por convención, los nombres de los valores constantes se private static int numberOfBicycles = 0;
escriben en mayúsculas. …
Si el nombre se compone de más de una palabra, las public static int getNumberOfBicycles() {
palabras están separadas por un guión bajo (_). return numberOfBicycles;
}
static final double PI = 3.141592653589793;
SEENCORP 2020
Inicializando Campos public class BedAndBreakfast {
Inicializando bloque Estático.

// initialize to 10
Un bloque de inicialización estática es un bloque public static int capacity = 10;
normal de código encerrado entre llaves, {}, y precedido
por la palabra clave estática // initialize to false
Inicializando Miembre de Instancia. private boolean full = false;

}
Hay dos alternativas al uso de un constructor para
inicializar variables de instancia: bloques inicializadores
y métodos finales.
class Whatever {
public static varType myVar = initializeClassVariable();
private static varType initializeClassVariable() {
// initialization code goes here

}
}
SEENCORP 2020
Clases Anidadas class OuterClass {

●
Las clases anidadas que se declaran estáticas se ...
denominan clases anidadas estáticas. class NestedClass {
●
Las clases anidadas no estáticas se denominan clases ...
internas. }
Cuando Utilizar }
●
si una clase es útil solo para otra clase
●
Aumenta la encapsulacion.
class OuterClass {
●
Puede conducir a un código más fácil de leer y mantener
...
Static Nested Classes
static class StaticNestedClass {
OuterClass.StaticNestedClass nestedObject =
...
new OuterClass.StaticNestedClass();
}
Inner Classes class InnerClass {
OuterClass.InnerClass innerObject = outerObject.new ...
InnerClass(); }
}
SEENCORP 2020
Shadowing public class ShadowTest {
Serialization
public int x = 0;
Serializar un objeto significa convertir su estado en una
secuencia de bytes para que la secuencia de bytes se pueda class FirstLevel {
revertir en una copia del objeto. Un objeto Java es
serializable si su clase o cualquiera de sus superclases public int x = 1;
implementa la interfaz java.io.Serializable o su subinterfaz,
java.io.Externalizable. La deserialización es el proceso de void methodInFirstLevel(int x) {
convertir la forma serializada de un objeto en una copia del System.out.println("x = " + x);
System.out.println("this.x = " + this.x);
objeto.
System.out.println("ShadowTest.this.x = " + ShadowTest.this.x);
}
}
public static void main(String... args) {

ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
}
}
SEENCORP 2020
Clases Locales HelloWorld frenchGreeting = new HelloWorld() {

Las clases locales son clases que se definen en un bloque, que String name = "tout le monde";
es un grupo de cero o más declaraciones entre llaves
balanceadas. Normalmente se encuentran clases locales public void greet() {
definidas en el cuerpo de un método.
greetSomeone("tout le monde");
Clases Anonimas
}
Las clases anónimas le permiten hacer su código más conciso.
Le permiten declarar e instanciar una clase al mismo tiempo. public void greetSomeone(String someone) {
Son como las clases locales, excepto que no tienen un nombre.
Úselos si necesita usar una clase local solo una vez. name = someone;
La expresión de clase anónima consta de lo siguiente: System.out.println("Salut " + name);

●
Operador new }
● El nombre de una interfaz para implementar o una clase para
};
extender.
●
Paréntesis que contienen los argumentos de un constructor,
al igual que una expresión de creación de instancia de clase
normal.
●
Un cuerpo, que es un cuerpo de declaración de clase.
SEENCORP 2020
Lambda Expressions public enum Day {

Las expresiones Lambda le permiten para tratar SUNDAY, MONDAY, TUESDAY, WEDNESDAY,
la funcionalidad como argumento de método o el
código como datos. THURSDAY, FRIDAY, SATURDAY
}
Enum Types
Un tipo de enumeración es un tipo de datos
especial que permite que una variable sea un
conjunto de constantes predefinidas
SEENCORP 2020
Anotaciones
Las anotaciones, una forma de metadatos,

proporcionan datos sobre un programa que no
forma parte del programa en sí.
Son usadas en:
●
Información para el compilador.
●
Procesamiento en tiempo de compilación y tiempo
de implementación: las herramientas de software
pueden procesar información de anotaciones para
generar código, archivos XML, etc.
● Procesamiento en tiempo de ejecución: algunas
anotaciones están disponibles para ser
examinadas en tiempo de ejecución.
SEENCORP 2020
SEENCORP 2020
SEENCORP 2020
SEENCORP 2020
CREANDO MANTENIMIENTO CON JAVA SWING+BASE DE DATOS
23/05/2020 5 a 6 pm INGRESO LIBRE

Www.seencorp.pe
Inscríbase al Whastapp: 997596006
JAVA SWING
Creación Especializada de Aplicaciones de Escritorio

Www.seencorp.pe
INICIO LUNES 1 DE JUNIO
L,M,V 6 – 7 PM
JAVA DESDE CERO

Www.seencorp.pe
INICIO JUEVES 28 DE MAYO
M,J,S 5 – 6 PM

Webinar JAVA 01

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Webinar JAVA 01

Cargado por

Copyright:

Formatos disponibles

WEBINAR

EXPERIENCIAS DE PROGRAMACIÓN EN JAVA

Autor: Javier Mariscal Qquellón

JSF with Primefaces, Spring

Netbeans, eclipse, Jdeveloper

La plataforma java tiene 2 componentes:

Java le ofrece las siguientes características:

What Is a Class?A class is a blueprint or prototype from which objects are

What Is Inheritance?Inheritance provides a powerful and natural mechanism

What Is an Interface?When a class implements an interface, it promises to

What Is a Package?A package is a namespace for organizing classes and

A software object. A bicycle modeled as a software object.

class Bicycle { In object-oriented terms, we say that

// Create two different

void speedUp(int increment) { // Invoke methods on

speed = speed + increment; // those objects

The syntax for creating a subclass is simple. At

class MountainBike extends Bicycle {

// new fields and methods defining

class ACMEBicycle implements Bicycle {

En su forma más común, una int cadence = 0;

interfaz es un grupo de métodos int gear = 1;

// The compiler will now require that methods

relacionados con cuerpos vacíos. // changeCadence, changeGear, speedUp, and applyBrakes

void changeCadence(int newValue) {

void changeGear(int newValue) {

interface Bicycle { gear = newValue;

// wheel revolutions per minute void speedUp(int increment) {

void changeGear(int newValue); void applyBrakes(int decrement) {

Un paquete es un espacio de nombres que organiza un conjunto

● Real-world objects contain ___ and ___.

24 Curso Java desde Cero

Primitive Data Types.

contiene un número fijo de valores de un solo

// allocates memory for 10 integers

tipo anArray = new int[10];

// initialize first element

System.out.println("Element at index 0: "

La regla de precedencia establece que los Operators Precedence

Assignment, Arithmetic, and public static void main (String[] args) {

Unary Operators int result = 1 + 2;

Operator Description result = result - 1;

String concatenation) result = result * 2;

- Subtraction operator // result is now 4

% Remainder operator original_result = result;

The Unary Operators class UnaryDemo {

public static void main(String[] args) {

Operator Description int result = +1;

-- Decrement operator; decrements a

! Logical complement operator; inverts System.out.println(result);

the value of a boolean boolean success = false;

The Equality and Relational Operators class ComparisonDemo {

== equal to public static void main(String[] args){

!= not equal to int value1 = 1;

public static void main(String[] args){

The Type Comparison Operator instanceof class InstanceofDemo {

System.out.println("obj1 instanceof Parent: "

recomendación x + (y/100) o (x+y)/100 int result = 1 + 2; // result is now 3

Las declaraciones de flujo de control dividen el

Esta sección describe las declaraciones de toma

} else if (month == 2) { case 6: monthString = "June";

La sentencia while ejecuta continuamente un bloque de class WhileDemo {

La instrucción for proporciona una forma class ForDemo {

● The break Statement:The break statement has two int[][] arrayOfInts = {

● Real-world objects contain _ and _.