UNIVERSIDAD NACIONAL MAYOR DE SAN MARCOS

(Universidad del Perú, DECANA DE AMÉRICA)

FACULTAD DE INGENIERÍA DE SISTEMAS E INFORMÁTICA

Escuela Profesional de Ingeniería de Sistemas

Algorítmica II

Prof. Lam Zhing Fong

Construcciones del Lenguaje y Clases Básicas

Contenido
Características Generales del Lenguaje................................................................................................................................2
Estructura y miembros de una clase.....................................................................................................................................2
Tipos de datos primitivos y referencias................................................................................................................................2
Tipos...............................................................................................................................................................................2
Valores............................................................................................................................................................................2
Modificadores, Variables, Operadores.................................................................................................................................2
Tipo de Variables............................................................................................................................................................2
Valores por defectos........................................................................................................................................................2
Operadores......................................................................................................................................................................3
Expresiones, sentencias y bloques........................................................................................................................................3
Control de Flujo Básicos......................................................................................................................................................3
De decisión......................................................................................................................................................................4
Repetitiva y ramificación................................................................................................................................................4
Diferencias entre miembros estáticos y de instancia............................................................................................................4
Clases y Objectos, Instanciacion y acceso a miembros........................................................................................................5
Arrays, String, List, Math.....................................................................................................................................................5
Arrays..............................................................................................................................................................................5
Strings.............................................................................................................................................................................6
List..................................................................................................................................................................................6
Math................................................................................................................................................................................6

1
Características Generales del Lenguaje
• Estático
• Fuertemente tipado
• Case sensitive
• WORA
• Uso de garbage collection

Estructura y miembros de una clase.

• Variables Miembros (Campos)
• Métodos
• Clases (anidadas)
• Interfaces
• Constructores
• Inicializadores

Tipos de datos primitivos y referencias.

Tipos
• Primitivos
◦ boolean
◦ byte, short, int, long, char
◦ float, double
• Referencias
◦ Clases: Object, JButton, Boolean, HttpServlet, HolaMundo, etc
◦ Interfaces: List, Comparable, etc.
◦ Arrays: int[], Object[], etc
◦ null

Valores
true, false, 10, 32L, ‘A’, 3.14, 2.7F, Math.PI, etc.
null, new Object(), new Integer(10), etc

Identificar tipo, variable, valores, literales, expresiones, operadores en:

String [] referencias = newString[]{"class", "interface", "array", "null"};

int suma = n * 10;

Modificadores, Variables, Operadores

public static void main(String[] arg) {}
private int a = 10;
public static final MAX_CONT = 20;

Tipo de Variables
• De instancia
• De clase
• Local
• Parámetro

Valores por defectos

false, 0, null. (Aplica para los campos y los elementos de un array inicializado).

2
Operadores

Operador Precedencia
postfix expr++ expr--
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 = += -= *= /= %= &= ^= |= <<= >>= >>>=

Expresiones, sentencias y bloques

Expresión: Construcción que se evalúa a un valor simple. Ej: x + (y / 100 )
Sentencia (Statement): Unidad de ejecución completa.
• De expresión: x + (y / 100 );
• De declaración: double a = 12.5;
• De Control de Flujo: if (x < y) { System.out.println(“...”);}
Bloque:
if (x < y) {
System.out.println(“En un bloque”);
}
else {
System.out.println(“dentro de Otro bloque”);
}

Control de Flujo Básicos.

Decision-making: (if-then, if-then-else, switch)
Looping: (for, while, do-while)
Branching: (break, continue, return)

3
De decisión
if (expresion booleana)
thenPart
else
elsePart
if (numero % 2 == 0) {
System.out.print(“El numero ” + numero + “ es par”);
}else {
System.out.print(“El numero ” + numero + “ es impar”);
}

switch(dia) {
case “Lunes”: //Fall-throw
case “lunes”: numDia = 1; break;
case “Martes”: //Fall-throw
case “martes”: numDia = 2; break;
default: numDia = 0; break;
}

if (args.length > 3) {
System.out.println(“Cantidad de argumento incorrecto.”);
return 1;
}

Repetitiva y ramificación

for (int i = 0; i < args.length; i++) {

switch(i) {
case 0: num1 = Integer.parseInt(args[i]); break;
case 1: num2 = Integer.parseInt(args[i]); break;
case 2: operador = args[i]; break;
default: break;
}
}

for (int i = 0; i < args.length; i++) {

if (i > 2) break;
switch(i){
...
}
}

while (i < arr.length) {

num = arr[i];
i++;
if (num % 2 != 0) continue;
procesar_parte1(num);
procesar_parte2(num);
}

Diferencias entre miembros estáticos y de instancia.

Estáticos (de clase): Math.PI, Math.abs(-10), Integer.MAX_VALUE;
De Instancia: cad.length(), cad.trim()
Nota: Es conveniente expresar num.MAX_VALUE?

4
Clases y Objectos, Instanciacion y acceso a miembros.
class Estudiante extends Persona {
private String codigo;
private List<Curso> cursos;

Estudiante(String apellido, String nombre, String documento, String codigo) {

super(apellido, nombre, documento);
this.codigo = codigo;
cursos = new ArrayList<Curso>();
}

public void inscribirEnCurso(String codigoCurso){

Curso c = Curso.buscarPorCodigo(codigoCurso);
if (c == null)
throw new RuntimeException(“El curso con codigo ”
+ codigoCurso + “ no existe!!”);
cursos.add(c);
}
public void getCursos(){
return cursos;
}
}

Estudiante e1 = new Estudiante(“Perez”, “Juan”, “12345678”, “17001122”);

e1.inscribirEnCurso(‘Java001’);
List<Curso> cursos = e1.getCursos();

Varargs:
inscribirEnCurso(String... codigoCursos)
Otros usos de this? Y super?
Niveles de Acceso
Modificador Class Package Subclass World
public Y Y Y Y
protected Y Y Y N
(sin modif.) Y Y N N
private Y N N N

Arrays, String, List, Math

Arrays

String[] arr = new String[10];

int num = arr.length;
String op1 = arr[0];
arr[0] = “----”;

int [] impares = newint[]{1, 3, 5};

int [] iniConShortCutNoEsArrayLiteral = {1,2,3};

Los Arrays son covariance:

Dog[] dogs = {newDog(), newDog(), newDog()};
Animal[] animals = dogs;
animals[1] = new Cat(); // ArrayStoreException (en runtime)

5
Strings

public final class String extends Object

implements Serializable, Comparable<String>, CharSequence
System.out.println("abc");
String cde = "cde";
System.out.println("abc" + cde);
String c = "abc".substring(2,3);
String d = cde.substring(1, 2);

Métodos Principales:
char charAt(int index)
boolean contains(CharSequence s)
String replaceFirst(String regex,String replacement)
String replaceAll(String regex, String replacement)
String replace(CharSequence target, CharSequence replacement)
String[] split(String regex, int limit)
String[] split(String regex)
static String join(CharSequence delimiter,CharSequence... elements)
static String join(CharSequence delimiter, Iterable<? extends CharSequence>
elements)

Otros:
toLowerCase, toUpperCase, trim, format, etc.

List

public interface List<E>

extends Collection<E>

Metodos de uso frecuentes:

boolean add(E e)
boolean addAll(Collection<? extends E> c)
E get(int index)
E set(int index,E element)
int indexOf(Object o)
List<E> subList(int fromIndex, int toIndex)
boolean contains(Object o)
default void sort(Comparator<? super E> c)

Otros:
void add(int index, E element)
boolean addAll(int index, Collection<? extends E> c)
clear(), containsAll(Collection<?> c), isEmpty(), lastIndexOf(Object),
remove(int), remove(Object), removeAll, etc

Math

public final class Math extends Object

Campos:
E, PI
Métodos:
abs, acos, asin, atan, cbrt, ceil, cos, exp, floor, log, max, min, round,
sin, sqrt, tan, tanh, toRadians, random, etc.