Documentación de Java
System.out.println(str);
System.out.print(str);
// Ejemplo:
System.out.println("Hola mundo");
// Impresión sin una nueva línea:
System.out.print("Hola mundo. ");
System.out.print("¿Cómo estás?");
// Declarar una variable
int myVarName;
// Inicializar una variable
int myVarName = 5;
// Asignar a una variable existente
myVarName = 10;
// Imprimir una variable
System.out.println(myVarName);
System.out.println("El valor es: " + myValue);
// Los métodos pueden tomar valores, llamados parámetros.
// El siguiente método recibe un parámetro llamado
// 'entrada' y lo imprime.
private void printText(String input)
{
System.out.println(input);
}
// Los métodos también pueden devolver un valor.
// El siguiente método toma un valor,
// le suma dos y lo devuelve.
private int addTwo(int number)
{
return number + 2;
}
// Inicializar un escáner
import java.util.Scanner;
Scanner scanner = new Scanner(System.in);
// Leer una cadena
String str = scanner.nextLine();
// Leer un número entero
int num = scanner.nextInt();
// Leer un doble
double myDouble = scanner.nextDouble();
// Leer un booleano
boolean bool = scanner.nextBoolean();
// Para pedir al usuario que introduzca datos, imprime el mensaje
// y luego pide la entrada. Por ejemplo
System.out.println("¿Cuál es tu nombre? ");
String name = scanner.nextLine();
System.out.println("¿Cuál es tu edad? ");
int age = scanner.nextInt();
// Si se pide una cadena (String) inmediatamente después de pedir
// un int o un double, es necesario limpiar el búfer del Scanner
// primero para capturar el salto de línea extra (\n)
System.out.println("¿Cuál es tu edad? ");
int age = scanner.nextInt();
// Consumir el carácter de nueva línea que queda
scanner.nextLine();
// Luego pedir la cadena (String)
System.out.println("¿Cuál es tu nombre? ");
String name = scanner.nextLine();
// Los operadores de comparación devuelven booleanos (valores true/false)
x == y // ¿es x igual a y?
x != y // x no es igual a y
x > y // x es mayor que y
x >= y // si x es mayor o igual que y
x < y // es x menor que y
x <= y // es x menor o igual que y
// Operadores de comparación en declaraciones if
if (x == y)
{
System.out.println("x e y son iguales");
}
if (x > 5)
{
System.out.println("x es mayor que 5");
}
// Operadores:
+ Suma
- Sustracción
* Multiplicación
/ División
% Módulo (Resto)
() Paréntesis (Para el orden de las operaciones)
// Ejemplos
int z = x + y
int w = x * y;
//Incrementar (añadir uno)
x++
//Disminuye (resta uno)
x--
//Ahortos
x = x + y; x += y;
x = x - y; x -= y;
x = x * y; x *= y;
x = x / y; x /= y;
Números aleatorios
// Genera un número aleatorio de 0 a 1,
// incluyendo el cero, pero sin incluir el 1
double num = Math.random();
// Para generar un int aleatorio en otro
// rango, la fórmula general es
int num = (int)(Math.random() * (numValues) + start);
//Por ejemplo, para generar un int de 15-19 (5 valores)
// sería así
int num = (int)(Math.random() * 5 + 15);
// Un booleano es verdadero o falso
boolean myBoolean = true;
boolean anotherBoolean = false;
System.out.println("¿Pregunta? ");
boolean result = scanner.nextBoolean();
// Operador No
boolean x = !y; // x obtiene lo contrario de y
// Operador And
boolean andExp = x && y;
// Operador or
boolean orExp = x || y;
// ¡Puedes combinar muchos booleanos!
boolean boolExp = x && (y || z);
if (BOOLEAN_EXPRESSION)
{
// código a ejecutar if true
}
if (BOOLEAN_EXPRESSION)
{
// código si es true
}
else
{
// código if false
}
if (x < 0)
{
System.out.println("x es negativo");
}
if (color.equals("red") || color.equals("blue") || color.equals("yellow"))
{
System.out.println("Color primario");
}
else
{
System.out.println("No es un color primario.");
}
// Puedes utilizar else if si tienes varias
// condiciones, pero sólo debe ocurrir una.
if(condición_1)
{
}
else if (condición_2)
{
}
else if (condición_3)
{
}
else
{
}
// Siempre puedes escribirlas usando anidados
// if/else. Por ejemplo
if (condición_1)
{
// este código se ejecuta si la condición 1 es true
}
else
{
// este código se ejecuta si la condición 1 es false
if (condición_2)
{
// este código se ejecuta si la condición 2 es true
}
else
{
// este código se ejecuta si la condición 2 es false
}
}
int COUNT = 5;
for (int i = 0; i < COUNT; i++)
{
/* Repite el código entre los corchetes 5 veces,
* ya que la variable COUNT es 5. */
}
// Imprime los números del 0 al 9
for (int i = 0; i < 10; i++)
{
System.out.println(i);
}
while (expresión boolean)
{
/* Repite el código entre paréntesis while
* 'expresión boolean' es true */
}
// Cuenta atrás de 15 a 10
int i = 15
while (i > 10)
{
System.out.println(i);
i--;
}
// Este es un formato de bucle y medio
while (true)
{
// código
if (expresión boolean)
{
break;
}
}
// Crear un array de tamaño 5
int[] arr = new int[5];
// Crea un array inicializado con valores
int[] arr = {7, 8, 9, 10};
// para acceder a un índice dado de un array
// puedes utilizar la siguiente sintaxis
arr[i]
// por ejemplo, para imprimir el 5º elemento del array:
System.out.println(arr[4])
// ¡recuerda que los arrays empiezan por 0!
// para recorrer un array, puedes utilizar un bucle for estándar
// for loops, dado un array de n elementos arr
for (int i = 0; i < arr.length; i++)
{
System.out.println(arr[i])
}
// esto imprimirá cada elemento de una lista en su propia línea
Ir a la referencia Java completa
Métodos estáticos
// Necesitarás importar Arrays para utilizar estos métodos
import java.util.Arrays;
// Ordena el array dado en orden ascendente
int[] arr = {18, 5, 9, 8, 1, 3}
Arrays.sort(arr) // arr es ahora [1, 3, 5, 8, 9, 18]
// ¡No olvides importar ArrayList!
import java.util.ArrayList;
// Crea una ArrayList general
ArrayList<T> arrList = new ArrayList<T>();
// donde T representa un tipo (Objeto o primitiva)
// Crea una ArrayList de ints y añade algunos.
ArrayList<Integer> arrList = new ArrayList<Integer>();
// Las ArrayList contienen objetos, así que en lugar de utilizar tipos primitivos
// como int, utilizamos sus formas Objeto, como Integer.
arrList.add(1);
arrList.add(2);
arrList.add(3);
arrList.add(4)
// para acceder a un índice dado en un ArrayList
// puedes utilizar la siguiente sintaxis
arrList.get(i);
// esto también se puede guardar en una variable
int arrListElem = arrList.get(2); // arrListElem = 3
// por ejemplo, para imprimir el 3er elemento de la ArrayList:
System.out.println(arrList.get(2))
// Al igual que los arrays, los ArrayList se indexan en 0.
// puedes eliminar de forma similar
arrList.remove(i);
// para recorrer en bucle una ArrayList, puedes utilizar un bucle estándar
// for estándar, dada una ListaArray de n elementos arrList
for (int i = 0; i < arrList.size(); i++)
{
System.out.println(arrList.get(i))
}
// esto imprimirá cada elemento de una lista en su propia línea
// también puedes utilizar un bucle 'foreach
for (Integer i : arrList)
{
System.out.println(i);
}
// para más documentación, consulta la
// documentación oficial de Oracle aquí.
// puedes representar tablas, cuadrículas y matrices
// haz una rejilla 3x4 de ints
int[][] grid = new int[3][4];
// haz una cuadrícula de 3x3 caracteres
char[][] grid = new char[3][3];
// haz una cuadrícula de 10 x 3 cadenas
String[][] grid = new String[10][3];
// inicializa una lista
int[][] grid = {
{1,2,3,4},
{5,6,7,8}
};
// obtener una fila
int[] row = grid[1]
// obtener un elemento
int elem = grid[1][2];
// se utiliza para almacenar las correspondencias entre clave y valor
// crear un mapa
HashMap<String, String> agenda = new HashMap<String, String>();
// poner cosas en el mapa
phonebook.put("Alan Turing", "312-423-1234");
// averigua si una clave está en el mapa
boolean hasKey1 = agenda.containsKey("Alan Turing")
boolean hasKey2 = agenda.containsKey("Karel el Perro");
System.out.println(hasKey1); // se imprimirá true
System.out.println(hasKey2); // se imprimirá false
// obtener cosas de un mapa
String alansNumber = agenda.get("Alan Turing");
// hacer un bucle sobre un mapa
System.out.println("La guía telefónica completa");
ffor(String key: phonebook.keySet())
{
String number = phonebook.get(key);
System.out.println(key + ": " + number);
}
Método principal
// Cualquier clase que ejecutes necesita definir un método principal.
// El método main debe tener la siguiente firma:
public static void main(String[] args)
Ir a la Referencia Java Completa
// La clase Carácter permite manipulaciones avanzadas
// manipulaciones avanzadas de caracteres en java.
// Estos métodos son estáticos, lo que significa que se invocan a nivel de la clase
// nivel de la clase Personaje, en lugar de en un objeto Personaje específico.
// Para utilizar estos métodos, basta con invocarlos en la clase Personaje
// Por ejemplo
static boolean isUpperCase(char ch)
// Uso
Character.isUpperCase('A') // devuelve true
// Métodos
static boolean isUpperCase(char ch)
devuelve true si ch es un carácter en mayúsculas,
false en caso contrario
static boolean isLowerCase(char ch)
devuelve true si ch es un carácter en minúscula,
false en caso contrario
static boolean isDigit(char ch)
devuelve true si ch es un dígito (un número),
false en caso contrario
static boolean isLetter(char ch)
devuelve true si ch es una letra, false en caso contrario
static boolean isLetterOrDigit(char ch)
devuelve true si ch es una letra o un dígito,
false en caso contrario
static boolean isWhitespace(char ch)
devuelve true si ch es un carácter de espacio en blanco
(es decir, espacio o nueva línea), false en caso contrario
static char toUpperCase(char ch)
devuelve la versión en mayúsculas de ch
static char toLowerCase(char ch)
devuelve la versión en minúsculas de ch
// ¡más información en la referencia completa enlazada más arriba!
Ir a la Referencia Java Completa
// La clase Carácter permite manipulaciones avanzadas
// manipulaciones avanzadas de caracteres en java.
// Ejemplos
// isUpperCase
char ch = 'd';
boolean upper = Character.isUpperCase(ch); // upper es false
upper = Character.isUpperCase('D'); // upper es true
upper = Character.isUpperCase(' '); // upper es false
upper = Character.isUpperCase('1'); // upper es false
// isLowerCase
char ch = 'd';
boolean lower = Character.isLowerCase(ch); // lower es true
lower = Character.isLowerCase('D'); // lower es false
lower = Character.isLowerCase(' '); // lower es false
lower = Character.isLowerCase('1'); // lower es false
// Comprueba si es una letra o un dígito
// isLetter, isDigit, isLetterOrDigit
char ch = 'd';
boolean isLetter = Character.isLetter(ch); // isLetter es true
boolean isDigit = Character.isDigit(ch); // isDigit es false
boolean either = Character.isLetterOrDigit(ch); // either es true
isDigit = Character.isDigit(' '); // isDigit es false
isDigit = Character.isDigit('9'); // isDigit es true
either = Character.isLetterOrDigit('9'); // either es true
either = Character.isLetterOrDigit(' '); // either es false
// Comprobación de espacios en blanco como espacio ' ' o nueva línea '\n'
// isEspacio en blanco
char space = ' ';
boolean whiteSpace = Character.isWhitespace(space); // whiteSpace es true
whiteSpace = Character.isWhitespace('\n'); // whiteSpace es true
whiteSpace = Character.isWhitespace('8'); // whiteSpace es false
whiteSpace = Carácter.isWhitespace('A'); // whiteSpace es false
// toUpperCase y toLowerCase
char lowerD = 'd';
char upper = Character.toUpperCase(lowerD); // upper es 'D'
char lower = Character.toLowerCase(upper); // lower es 'd'
// ¡más información en la referencia completa enlazada más arriba!
Ir a la Referencia Java Completa
// La clase Math permite realizar cálculos
// cálculos avanzados en java.
// Estos métodos son estáticos, lo que significa que se llaman a nivel de la clase
// nivel de la clase Math, en lugar de en un objeto Math específico.
// Para utilizar estos métodos, basta con invocarlos en la clase Math
// Por ejemplo
static double abs(double a)
// Uso
double result = Math.abs(-14); // el resultado es 14
// Métodos
static int abs(int a)
static double abs(double a)
devuelve el valor absoluto de a
static long round(double a)
static int(float a)
devuelve el número más cercano, con empates (1,5) redondeando hacia arriba
static int max(int a, int b)
static double max(double a, double b)
devuelve el mayor de dos valores a y b
static int min(int a, int b)
static double min(double a, double b)
devuelve el menor de dos valores a y b
static double pow(double a, double b)
devuelve a elevado a la potencia de b
static double sqrt(double a)
devuelve la raíz cuadrada de a
static double floor(double a)
devuelve el mayor valor menor que
o igual a a
static double ceil(double a)
devuelve el menor valor mayor que
o igual a a
// ¡más información en la referencia completa enlazada más arriba!
Ir a la Referencia Java Completa
// La clase Math permite realizar cálculos
// cálculos avanzados en java.
// Ejemplos
// Valor absoluto
// abs
double val = -5,5
double abs = Math.abs(val); // abs es 5,5
int num = 5
int abs = Math.abs(num); // abs es 5
// round
double x = 1,3
int roundedX = (int) Math.round(x); // 1
double y = 1,5
int roundedY = (int) Math.round(y); // 2
double z = 1,7
int roundedZ = (int) Math.round(z); // 2
// Máximo de dos valores
// max
int max = Math.max(4, 5); // max es 5
max = Math.max(-4, -5); // max es -4
double max = Math.max(3.0, -2.1); // el máximo es 3.0
max = Math.max(-2.2, -10.2); // el máximo es -2.2
// Mínimo de dos valores
// min
int min = Math.min(10, 1); // min es 1
min = Math.min(-10, -11); // min es -11
double min = Math.min(9.4, 11.1); // min es 9.4
min = Math.min(2.2, -9.5); // min es -9.5
// Exponentes (a elevado a la potencia de b)
// pow
double base = 4
double exp = 2
double power = Math.pow(base, exp); // la potencia es 16,0 (4 * 4 = 16)
power = Math.pow(1, 4); // la potencia es 1,0 (1 * 1 * 1 * 1 = 1)
// Raíz cuadrada
// sqrt
double root = Math.sqrt(25); // la raíz es 5,0
root = Math.sqrt(16); // la raíz es 4,0
root = Math.sqrt(root); // la raíz es 2,0
// Suelo -- Mayor valor inferior al parámetro
// floor
double floor = Math.floor(8.323); // suelo es 8.0
floor = Math.floor(-8.323); // el suelo es -9.0
// Techo -- Valor más bajo mayor que el parámetro
// ceil
double ceiling = Math.ceil(8.323); // el techo es 9.0
ceiling = Math.ceil(-8.323); // el techo es -8.0
// ¡más información en la referencia completa enlazada arriba!
Ir a la Referencia Java Completa
// La clase String permite manipulaciones avanzadas
// manipulaciones avanzadas de cadenas en Java.
// Métodos
char charAt(int index)
Devuelve el carácter de la cadena
en el índice especificado.
boolean equals(String other)
devuelve si esta cadena es igual
a otra cadena
boolean equalsIgnoreCase(String other)
devuelve si esta cadena es igual
a otra cadena diferente, ignorando
las diferencias entre mayúsculas y minúsculas
int indexOf(char ch)
devuelve el índice dentro de esta cadena
de la primera aparición del carácter
especificado ch. Si ch no existe en
esta cadena, se devuelve -1
int indexOf(String str)
devuelve el índice dentro de esta cadena
de la primera aparición de la
especificada. Si str no existe
dentro de esta cadena, se devuelve -1
int length()
devuelve la longitud de esta Cadena
String substring(int beginIndex)
devuelve la subcadena de esta cadena
comenzando en el índice de inicio especificado
y terminando al final de la cadena
String substring(int beginIndex, int endIndex)
devuelve la subcadena de esta cadena
que comienza en el índiceInicial especificado
y terminando en el endIndex especificado.
La subcadena incluye el carácter
en beginIndex, pero no incluye
el carácter de endIndex.
boolean startsWith(String str)
devuelve true si esta cadena empieza
con la cadena str especificada,
false en caso contrario
boolean endsWith(String str)
devuelve true si esta cadena termina
con la cadena str especificada,
false en caso contrario
String toLowerCase()
devuelve una nueva cadena que contiene
los mismos caracteres que esta cadena
convertida a minúsculas
String toUpperCase()
devuelve una nueva cadena que contiene
los mismos caracteres que esta cadena
convertida a mayúsculas
// ¡más información en la referencia completa enlazada más arriba!
Ir a la Referencia Java Completa
// La clase String permite manipulaciones avanzadas
// manipulaciones avanzadas de cadenas en Java.
// Ejemplos
// Creación String
String hello = "hola";
String empty = "";
String sentence = "El zorro marrón rápido salta sobre el perro perezoso";
// Acceder a los caracteres de una cadena
// charAt
String str = "¡Hola Mundo!";
char first = str.charAt(0); // first es 'H'
char middle = str.charAt(6); // middle es 'W'
// Comprobación de igualdad
// igual y igualIgnorarCase
String str = "CodeHS";
String lower = "codehs";
boolean isEqual = str.equals("CodeHS"); // isEqual es true
isEqual = str.equals(lower); // isEqual es false
boolean similar = str.equalsIgnoreCase(lower); // similar es true
// Encontrar caracteres y subcadenas
// indexOf
String str = "¡Hola Mundo!";
int index = str.indexOf('H'); // index es 0
index = str.indexOf('o'); // index es 4
index = str.indexOf("Mundo"); // index es 6
index = str.indexOf("Hola"); // index es 0
// Obtener la longitud de una cadena
// length
String str = "Hello";
int length = str.length(); // length es 5
str = "A";
length = str.length(); // length es 1
str = "";
length = str.length(); // length es 0
// Obtener subcadenas de una cadena
// substring
String str = "CodeHS";
String sub = str.substring(4); // sub es "HS"
sub = str.subcadena(1); // sub es "odeHS"
sub = str.substring(1, 4); // sub es "ode"
sub = str.substring(0, 1); // sub es "C"
// Comprobación de los inicios y finales de una Cadena
// empiezaCon y terminaCon
String str = "CodeHS";
boolean codeStart = str.startsWith("Code"); // codeStart es true
boolean hsStart = str.startsWith("HS"); // hsStart false
boolean codeEnd = str.endsWith("Code"); // codeEnd es false
boolean hsEnd = str.endsWith("HS"); // hsEnd es true
// Conversión de mayúsculas y minúsculas de los caracteres de una cadena
// aMayúsculas y a Mayúsculas
String str = "CodeHS";
String hello = "Hello World!";
String lower = str.toLowerCase(); // lower es 'codehs'
String upper = lower.toUpperCase(); // upper es 'CODEHS'
upper = hello.toUpperCase(); // upper es 'HELLO WORLD!'
lower = upper.toLowerCase(); // lower es 'hello world!'
// ¡más información en la referencia completa enlazada más arriba!
// usar extends en Java significa que una clase hereda
// de otra.
// por ejemplo, una clase Jet podría extender a Plane
public class Jet extends Plane
{
// Código específico de Jet
}
// a veces necesitarás llamar a un método de la
// clase de la que has heredado, conocida como clase padre.
super.fly(); // esto llamará al método fly de la clase padre
// Implementar en Java es similar a utilizar un plano.
// una Interfaz da métodos que las clases deben implementar.
public interface Blueprint
{
public String address = "10 Downing Street"
public void printAddress();
}
public class Building implements Blueprint {
// tenemos que declarar un método con la misma
// firma que la interfaz.
public void printAddress()
{
// puedes utilizar las variables de la interfaz como variables estáticas
System.out.println(Blueprint.address));
}
}
// Una clase puede implementar Comparable y luego aprovechar otras
// utilidades para ayudar a ordenar los objetos de la clase (útil para ordenar)
// Compara la instancia actual con el otro objeto y devuelve
// un número que indica el orden. Debe devolver 0 si son
// iguales y un número negativo o positivo dependiendo del ordenamiento
public int compareTo(Object o)
// Para ordenar círculos
public int compareTo(Circle other)
{
double diff = gerRadius() - other.getRadius();
return (int)Math.signum(diff);
}
// Define los métodos que las clases pueden implementar para
// representar una Lista ordenada
// Lista es una interfaz que define firmas de métodos abstractos
// Algunos métodos importantes de la interfaz Lista:
// Devuelve el número de elementos de una lista
int size()
// Añade el elemento dado al final de la lista
boolean add(E elem)
// Añade el elemento dado en el índice especificado, desplaza los siguientes
// elementos siguientes un índice hacia arriba
void add(int index, E elem)
// Devuelve el elemento en el índice especificado
E get(int index)
// Sustituye el elemento en el índice dado por el elem
// proporcionado. Devuelve el elemento antiguo sustituido
E set(int index, E elem)
// Las clases pueden implementar Lista
ArrayList<E> implements Lista<E>
List<String> strList = new ArrayList<String>();
List<MyClass> myList = new ArrayList<MyClass>();
// Cómo utilizar Lista
public void printOddIndices (List<integer> list)
{
// Puedes utilizar métodos como list.add(4), list.size(), etc.
}
// FileReaderExample.java
// Demuestra cómo leer datos de un archivo de texto usando Scanner.
// La entrada/salida de archivos (File I/O) permite que un programa lea datos de un archivo y los imprima en la consola.
// Supongamos que el archivo de texto "data.txt" contiene:
// apple
// banana
// cherry
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class FileReaderExample
{
public static void main(String[] args)
{
try
{
// Crea un objeto File apuntando a "data.txt"
File inputFile = new File("data.txt");
// Crea un Scanner para leer el archivo
Scanner in = new Scanner(inputFile);
// Mientras haya otra línea para leer
// NOTA: también se puede usar in.hasNext() para continuar mientras haya otro valor para leer
while (in.hasNextLine())
{
String line = in.nextLine(); // Lee una línea de texto
System.out.println(line); // Imprime la línea en la consola
}
// Cierra el Scanner para liberar recursos
in.close();
}
catch (IOException e)
{
// Si no se encuentra el archivo o no se puede abrir, muestra un mensaje de error
System.out.println("Archivo no encontrado.");
}
}
}
// Salida esperada:
// apple
// banana
// cherry
// La clase Scanner se usa para leer entradas desde archivos.
// Métodos y Constructor
Scanner(File f)
construye un objeto Scanner que lee desde el archivo especificado
int nextInt()
devuelve el siguiente int leido del archivo o fuente de entrada, si está disponible.
Lanza InputMismatchException si el siguiente valor no es un int válido.
double nextDouble()
devuelve el siguiente double leido del archivo o fuente de entrada.
Lanza InputMismatchException si el siguiente valor no es un double válido.
boolean nextBoolean()
devuelve el siguiente valor boolean (true/false) leido del archivo o fuente de entrada.
Lanza InputMismatchException si el siguiente valor no es un boolean válido.
String nextLine()
devuelve la siguiente línea de texto del archivo o fuente de entrada.
Devuelve una string vacía si se llama inmediatamente después de otro método de Scanner.
String next()
devuelve la siguiente palabra o valor del archivo o fuente de entrada como String.
boolean hasNext()
devuelve true si hay otro valor disponible para leer
boolean hasNextLine()
devuelve true si hay otra línea de texto disponible para leer
void close()
cierra el Scanner para liberar los recursos del sistema
// Supongamos que el archivo "input.txt" contiene:
// 7 true
// 3.14
// Welcome to AP CSA!
import java.io.File;
import java.io.IOException;
import java.util.Scanner;
public class ScannerExample
{
public static void main(String[] args)
{
try
{
// Construye un Scanner para leer del archivo
File inputFile = new File("input.txt");
Scanner in = new Scanner(inputFile);
// Usa diferentes métodos de Scanner para leer cada tipo de entrada
int number = in.nextInt(); // 7
boolean flag = in.nextBoolean(); // true
double pi = in.nextDouble(); // 3.14
in.nextLine(); // consume el salto de línea restante
String message = in.nextLine(); // "Welcome to AP CSA!"
System.out.println("Entero: " + number);
System.out.println("Booleano: " + flag);
System.out.println("Decimal: " + pi);
System.out.println("Mensaje: " + message);
in.close(); // siempre cierra el Scanner al terminar
}
catch (IOException e)
{
System.out.println("Error al leer el archivo.");
}
}
}
// Para hacer un círculo
Circle circle = new Circle(radius);
// Para establecer la posición del centro del círculo
circle.setPosition(x, y);
// Ejemplo, círculo rojo de 50px de radio con centro en (100, 200)
Circle circle = new Circle(50);
circle.setPosition(100, 200);
circle.setColor(Color.rojo);
// Obtener el radio
circle.getRadius(); // devuelve 50
double curRadius = circle.getRadius(); // guardar en variable
// Cambia el radio
circle.setRadius(100);
// Obtener la posición del centro del círculo
double x = circle.getX(); // x es 100
double y = circle.getY(); // y es 200
// Cambia la posición del círculo
double x = getWidth() / 2;
double y = getHeight() / 2;
circle.setPosition(x, y); // el centro del círculo está en el centro de la pantalla
// Añade a la pantalla
add(circle);
// Mueve el círculo dx horizontalmente y dy verticalmente
circle.move(dx, dy);
// Para hacer un rectángulo
Rectangle rect = new Rectangle(width, height);
// Para establecer la posición de la esquina superior izquierda del rectángulo
rect.setPosition(x, y);
// Ejemplo, rectángulo azul de 200x50 con la esquina superior izquierda en (100, 200)
Rectangle rect = new Rectangle(200, 50);
rect.setPosition(100, 200);
rect.setColor(Color.blue);
// Obtén la posición de la esquina superior izquierda del rectángulo
double x = rect.getX(); // x es 100
double y = rect.getY(); // y es 200
// Cambia la posición del rectángulo
double x = getWidth() / 2;
double y = getHeight() / 2;
rect.setPosition(x, y) // la esquina superior izquierda está en el centro de la pantalla
// Añade a la pantalla
add(rect);
// Mueve el rect dx horizontalmente y dy verticalmente
rect.move(dx, dy);
// Para dibujar una línea desde (x1, y1) hasta (x2, y2)
Line line = new Line(x1, y1, x2, y2);
// Establece el color de la línea en verde
line.setColor(Color.green);
// Establece la anchura de la línea en 10 píxeles
line.setLineWidth(10);
// Añade a la pantalla
add(line);
// Cambia el punto inicial de la línea a (x1, y1)
line.setPosition(x1, y1);
// Cambia el punto final de la línea a (x2, y2)
line.setEndpoint(x2, y2);
//Obtén el punto inicial de la línea
double x = line.getX(); // x tiene el mismo valor que x1
double y = line.getY(); // y tiene el mismo valor que y1
//Obtener el punto final de la línea
double endX = line.getEndX(); // x tiene el mismo valor que x2
double endY = line.getEndY(); // y tiene el mismo valor que y2
// Mueve la línea dx horizontalmente y dy verticalmente
line.move(dx, dy);
// Para crear un objeto de texto gráfico
Text txt = new Text(label, font);
// Para establecer la posición de la esquina inferior izquierda del texto
txt.setPosition(x, y);
// Ejemplo
Text txt = new Text("¡Hola, mundo!", "30pt Arial");
txt.setPosition(100, 200);
txt.setColor(Color.blue);
// Cambia lo que dice el texto
txt.setText("¡Adiós!");
// Obtén la posición de la esquina inferior izquierda del texto
double x = txt.getX(); // x es 100
double y = txt.getY(); // y es 200
// Añade a la pantalla
add(txt);
// Mueve el texto dx horizontalmente y dy verticalmente
txt.move(dx, dy);
// Hay muchas constantes de color. Puedes establecer un objeto
// color como
obj.setColor(color);
// Específicamente,
obj.setColor(Color.RED);
// Lista de colores disponibles:
Color.RED
Color.GREEN
Color.BLUE
Color.YELLOW
Color.CYAN
Color.ORANGE
Color.WHITE
Color.BLACK
Color.GRAY
Color.PURPLE
// Otra forma de establecer el color de un objeto es utilizar una
// cadena con el valor hexadecimal del color con setColor.
// Por ejemplo, para establecer el color rosa de un objeto rect:
rect.setColor("#FF66CC");
// Obtén un color aleatorio del aleatorizador
String color = Randomizer.nextColor();
