Estructura del programa Java con ejemplo
i) Estructura del programa Java
ii) Ejemplo de programa Java
—————————————————
i) Estructura del programa Java
1) Sección de documentación
2) Declaración de declaración del paquete
3) Declaración / s de importación
Importamos bibliotecas predefinidas y definidas por el usuario usando la palabra clave “import”
ex:
import java.io – ¡Este sitio web está a la venta! – Recursos e información..Consola;
java – Nombre del proyecto
io – Paquete
Consola – Nombre de clase
import java .io. *;
java – Proyecto
io- paquete
io. *: importa todas las clases del paquete io
———————————————-
4) Declaración de clase
Ex:
Muestra de clase pública {
}
public – Modificador de acceso
clase: palabra clave Java para declarar clase
Muestra – Nombre de clase
—————————————–
5) Método principal (la ejecución del programa Java comienza desde el método principal)
public static void main (String [] args) {
Código…
}
public – Modificador de acceso
Modificador estático sin acceso (use el método principal sin invocar ningún objeto)
object.method ();
object.method (val1, val2);
—————————-
nulo – No devuelve nada
main – Nombre del método
——————————–
(Cadena [] args) – Jyothi
———————————————————-
6) Declaraciones de declaración
Declaramos Variables y Constantes
int a;
a = 10;
int b, c, d;
b = 20, c = 30, d = 40;
int f = 60, g = 70, h = 80;
—————————–
final int y;
y = 100; //Incorrecto
final x = 200; //Correcto
—————————————-
Variables vs. Constantes
int a = 10;
——
——
———
a = 20;
——
—–
a = 10;
—————
int final b = 100;
———-
———-
b = 200; //Incorrecto
———————————————
7) declaraciones normales
System.out.println (“Hola Java”);
Sistema – Clase predefinida
fuera – Objeto
println – Método
“Hola Java” – Mensaje
a + b = d;
——————————–
8) Bloques de código
Condiciones, bucles, métodos …
———————————————
9) Declaración de creación de objetos, etc.
Sintaxis:
ClassName objectName = new ClassName ();
—————————————————
ii) Ejemplo de programa Java
// Nota: Declaramos métodos definidos por el usuario antes del método principal y llamamos a esos métodos después del método principal
Métodos Java
Predefinido
Usuario definido
Métodos no estáticos (método con valor de reajuste, el método no devuelve nada)
Métodos estáticos (Método con valor de reajuste, método no devuelve nada)
—————————————————
// Es un programa de muestra para comprender la sintaxis de Java y la estructura del programa
paquete abcd;
JavaProgram de clase pública {
// Crear un método con parámetros y valor de retorno (método no estático)
public int add (int a, int b) {
resultado int;
resultado = a + b;
resultado de retorno;
}
// Crea un método sin parámetros y no devuelve nada (método no estático)
Comparación pública nula () {
int a = 100, b = 50;
si (a> b) {
System.out.println (“A es un gran número”);
}
más{
System.out.println (“B es un gran número”);
}
}
// Crear un método con parámetros y valor de retorno (método estático)
public static int sub (int a, int b) {
int resultado = ab;
resultado de retorno;
}
// Crea un método sin parámetros y no devuelve nada (método estático)
comparación estática pública vacía2 () {
int a = 100, b = 500;
si (a> b) {
System.out.println (“A es un gran número”);
}
System.out.println (“B es un gran número”);
}
public static void main (String [] args) {
int a; // Declaración variable
a = 10; // Inicialización
int b = 20; // Declaración variable con inicialización
int c, d, e; // Declarando múltiples variables
int f = 40, g = 50, h = 60; // Declarando múltiples variables con inicialización
doble l = 12.3456;
char m = ‘Z’;
booleano x = verdadero;
Cadena y = “Prueba de selenio”;
System.out.println (y); // Pruebas de selenio
System.out.println (l); // 12.3456
System.out.println (“Hola Java”); // Hola Java
int z = a + b;
System.out.println (“El valor de la variable z es:” + z); // El valor de la variable z es: 30
final int abc = 100; // Declarar tipo entero constante
System.out.println (abc); // 100
si (a> b) {
System.out.println (“A es un gran número”);
}
más
{
System.out.println (“B es un gran número”);
} // B es un gran número
grado de char = ‘A’;
switch (grade) {// Decide entre varias alternativas
caso ‘A’:
System.out.println (“Excelente”);
descanso;
caso ‘B’:
System.out.println (“Bueno”);
descanso;
caso ‘C’:
System.out.println (“Mejor”);
descanso;
defecto:
System.out.println (“Calificación inválida”);
}//Excelente
// Imprime de 1 a 5 números excepto el 4to número
para (int i = 1; i <= 5; i ++) {
si (i! = 4) {
System.out.println (i);
}
}
int j = 1;
mientras que (j <= 10) {
System.out.println (j);
j ++;
}
int n = 1;
hacer
{
System.out.println (n);
n ++;
} while (n <= 5);
Herramientas de cadena [] = {“Selenio”, “UFT”, “RFT”, “SilkTest”};
para (Cadena xyz: herramientas) {
System.out.println (xyz);
}
// Crear objeto para acceder / llamar a métodos no estáticos
JavaProgram smriti = nuevo JavaProgram ();
// Llamar a métodos no estáticos
int r = smriti.add (10, 20);
System.out.println (r); // 30
System.out.println (smriti.add (10, 20)); // 30
smriti.Comparison (); // A es un número grande
// Métodos estáticos de clase
int r2 = JavaProgram.sub (18, 11);
System.out.println (r2); // 7
System.out.println (JavaProgram.sub (18, 11)); // 7
JavaProgram.comparison2 (); // B es un número grande
compare2 (); // B es un gran número
}
}
C Programando estructuras de datos
Propósito de la asignación de memoria dinámica:
El proceso de asignación de memoria en tiempo de ejecución se conoce como asignación de memoria dinámica. Aunque C no tiene esta facilidad inherentemente, hay cuatro rutinas de biblioteca que permiten esta función. Muchos lenguajes permiten que un programador especifique un tamaño de matriz en tiempo de ejecución. Dichos lenguajes tienen la capacidad de calcular y asignar durante las ejecuciones, el espacio de memoria requerido por las variables en el programa. Pero C inherentemente no tiene esta facilidad, pero es compatible con las funciones de administración de memoria, que pueden usarse para asignar y liberar memoria durante la ejecución del programa.
La asignación de memoria dinámica es la práctica de asignar ubicaciones de memoria a variables durante la ejecución del programa por solicitud explícita del programador. La asignación dinámica es una característica única de C (entre lenguajes de alto nivel). Nos permite crear tipos de datos y estructuras de cualquier tamaño y longitud para satisfacer las necesidades de nuestros programas dentro del programa.
La principal ventaja de utilizar la asignación dinámica de memoria es evitar el desperdicio de memoria. Esto se debe a que cuando usamos la asignación de memoria estática, se desperdicia mucha memoria porque no se puede utilizar toda la memoria asignada. Por lo tanto, la asignación dinámica de memoria nos ayuda a asignar memoria cuando sea necesario y, por lo tanto, ahorra memoria.
• En la asignación de memoria estática, si asignamos 1000 ubicaciones de memoria como int name [1000]; mientras se ejecuta el programa, solo se puede usar la mitad de esto. El resto no se usa y está inactivo. Es un desperdicio de memoria.
• Si queremos cambiar el tamaño de la matriz en el programa, es posible reeditando el programa. Es un proceso lento.
En la asignación de memoria dinámica, los dos problemas anteriores no ocurrirán porque el espacio de memoria para las variables se asigna solo durante la ejecución. Las siguientes funciones se utilizan en c para fines de gestión de memoria.
malloc: asigna el tamaño de las solicitudes de memoria de bytes y devuelve un puntero al primer byte de espacio asignado
calloc: asigna espacio para una matriz de elementos, los inicializa a cero y devuelve un puntero a la memoria
libre: libera espacio previamente asignado
realloc: modifica el tamaño del espacio previamente asignado.
Malloc, calloc, realloc y gratis:
Función malloc (): esta función se utiliza para asignar un bloque contiguo de memoria en bytes.
Sintaxis:
variable de puntero = (cast-type *) malloc (tamaño);
Dónde,
Variable de puntero: una variable de puntero contiene la ubicación de memoria de otra variable.
Cast-type: tipo de retorno del puntero por malloc () como int.char, etc.
malloc – palabra clave
tamaño: tamaño requerido de la memoria en bytes
La función anterior asigna memoria de tamaño y devuelve la dirección inicial de la memoria a través de la variable de puntero de tipo cast-type. El área asignada no está llena de ceros.
Ejemplo:
yo). y = (int *) malloc (20)
Al ejecutar esta función, se asignan 20 bytes de memoria y la dirección inicial del primer byte se asigna al puntero y del tipo ‘int’.
ii). y = (int *) malloc (10 * sizeof (int);
En la ejecución de esta función se asigna 10 veces el tamaño de un ‘int’, es decir, 10 × 2 = 20 bytes y la dirección inicial del primer byte se asigna al puntero y del tipo ‘int’. Si la asignación es exitosa, devuelve la dirección de inicio más NULL.
Función calloc (): esta función se utiliza para asignar múltiples bloques de memoria contigua. Todos los bloques son del mismo tamaño.
Sintaxis:
variable de puntero = (cast – type *) calloc (n, size);
Dónde,
variable de puntero: una variable de puntero contiene la ubicación de la memoria de otra variable.
Cast-type: tipo del puntero devuelto por calloc () como int. char etc.
calloc – palabra clave
n – número de bloques
tamaño – tamaño requerido de memoria en bytes
Ejemplo:
y = (int *) calloc (3, 10);
En la ejecución, la función asignó 3 bloques de memoria de tamaño 10 bytes y devuelve la dirección inicial del área a través del puntero y de tipo “int”.
Función free (): si ha asignado un bloque de memoria con las funciones malloc (), calloc () o realloc (), entonces necesita liberar la memoria previamente asignada. Sus características principales son
• Esta función se usa para desasignar la memoria previamente asignada usando la función malloc () o calloc ().
• la función libre se usa para devolver el bloque de memoria asignado a la memoria RAM del sistema.
Sintaxis:
libre (ptr);
Ejemplo:
• y = (int *) malloc (10)
• gratis (y)
Función realloc ():
Sintaxis:
void * realloc (void * ptr, size_t new_size);
Realloc es una función que intenta cambiar el tamaño de un bloque de memoria asignado previamente. El nuevo tamaño puede ser mayor o menor. Si el bloque se hace más grande que el contenido anterior, permanece sin cambios y se agrega memoria al final del bloque. Si el tamaño se hace más pequeño, el contenido restante no cambia. Si no se puede cambiar el tamaño del bloque original, realloc intentará asignar un nuevo bloque de memoria y copiará el contenido del bloque anterior. Tenga en cuenta que se devolverá un nuevo puntero (de diferente valor). Debe usar este nuevo valor. Si no se puede reasignar nueva memoria, realloc devuelve NULL. Por lo tanto, para cambiar el tamaño de la memoria asignada al puntero * ip anterior a un bloque de matriz de 50 enteros en lugar de 100, simplemente haga
ip = (int *) realloc (ip, 50);
Clasificación:
La ordenación es un proceso en el que los registros se organizan en orden ascendente o descendente. Por ejemplo, el directorio telefónico contiene los nombres de las personas y los números de teléfono se escriben de acuerdo con los alfabetos ascendentes. Los registros de la lista de estos titulares de teléfonos se ordenarán por el nombre del titular. Al usar este directorio, podemos encontrar fácilmente el número de teléfono de cualquier persona. El método de clasificación tiene una gran importancia en las estructuras de datos.
Por ejemplo, considere los cinco números 5 9 7 4 1
Los números anteriores se pueden ordenar en orden ascendente o descendente.
Orden ascendente (0 a n): 1 4 5 7 9
Orden descendente (nt 0): 9 7 5 4 1
La clasificación se clasifica en los siguientes tipos, que son:
• Ordenamiento de burbuja
• Clasificación de selección
• Ordenación rápida
• Tipo de inserción
• Ordenar fusión
Ordenamiento de burbuja:
Bubble Sort es probablemente uno de los algoritmos de clasificación más antiguos, fáciles, directos e ineficientes. Es el algoritmo introducido como una rutina de clasificación en la mayoría de los cursos introductorios sobre algoritmos. Bubble Sort funciona comparando cada elemento de la lista con el elemento al lado e intercambiándolos si es necesario. Con cada pasada, el más grande de la lista se “burbujea” al final de la lista, mientras que los valores más pequeños se hunden hasta el final. Es similar al tipo de selección, aunque no tan sencillo. En lugar de “seleccionar” los valores máximos, se burbujean a una parte de la lista.
/ * programa para ejemplo de clasificación de burbujas * /
#include
int main ()
{
int s, temp, i, j, a [20];
printf (“Ingrese el número total de elementos:”);
scanf (“% d”, & s);
printf (“Ingrese% d elementos:”, s);
para (i = 0; i scanf (“% d”, y a [i]);
// Algoritmo de clasificación de burbujas
para (i = s-2; i> = 0; i -) {
para (j = 0; j <= i; j ++) {
if (a [j]> a [j + 1]) {
temp = a [j];
a [j] = a [j + 1];
a [j + 1] = temp;
}
}
}
printf (“Después de ordenar:”);
para (i = 0; i printf (“% d”, a [i]);
devuelve 0;
}
Salida:
Ingrese el número total de elementos: 5
Ingrese 5 elementos: 6 2 0 11 9
Después de la clasificación: 0 2 6 9 11
Selección de selección:
La ordenación por selección también se denomina ordenación pushdown. Como su nombre lo indica, el primer elemento de la lista se selecciona y se compara repetidamente con todos y cada uno de los elementos hasta el final. Si se encuentra que cualquier elemento es menor que el elemento seleccionado, estos dos se intercambian. Este procedimiento se repite hasta que se ordena toda la matriz. Es lento y no muy inteligente, porque se compara con todos y cada uno.
/ * programa de demostración del método de selección * /
#include
int main () {
int s, i, j, temp, a [20];
printf (“Ingrese elementos totales:”);
scanf (“% d”, & s);
printf (“Ingrese% d elementos:”, s);
para (i = 0; i scanf (“% d”, y a [i]);
para (i = 0; i para (j = i + 1; j if (a [i]> a [j]) {
temp = a [i];
a [i] = a [j];
a [j] = temp;
}
}
}
printf (“Después de ordenar es:”);
para (i = 0; i printf (“% d”, a [i]);
devuelve 0;
}
Salida:
Ingrese elementos totales: 5
Ingrese 5 elementos: 4 5 0 21 7
La matriz después de ordenar es: 0 4 5 7 21
Ordenación rápida:
Se considera un método rápido para ordenar los elementos. El método también se llama clasificación de intercambio de partición. El método se basa en la técnica de divide y vencerás, es decir, la lista completa se divide en varias particiones y la clasificación se aplica una y otra vez en las particiones.
En este método, la lista se divide en dos, en función de un elemento llamado elemento pivote. Por lo general, el primer elemento considerado elemento pivote. Ahora mueva el elemento pivote a su posición correcta en la lista. Los elementos a la izquierda del pivote son menores que el pivote, mientras que los elementos a la derecha del pivote son mayores que el pivote. El proceso se vuelve a aplicar a cada una de estas particiones. Este proceso continúa hasta que obtengamos la lista ordenada de elementos.
/ * programa para demostración de ordenación rápida * /
#include
voy quicksort (int [10], int, int);
int main () {
int x [20], tamaño, i;
printf (“Ingrese el tamaño de la matriz:”);
scanf (“% d”, y tamaño);
printf (“Ingrese% d elementos:”, tamaño);
para (i = 0; i scanf (“% d”, & x [i]);
clasificación rápida (x, 0, tamaño-1);
printf (“Elementos ordenados:”);
para (i = 0; i printf (“% d”, x [i]);
devuelve 0;
}
void quicksort (int x [10], int first, int last) {
int pivot, j, temp, i;
if (primero <último) {
pivote = primero;
i = primero;
j = último;
mientras que (i while (x [i] <= x [pivote] && i <último)
i ++;
while (x [j]> x [pivote])
j–;
si (i temp = x [i];
x [i] = x [j];
x [j] = temp;
}
}
temp = x [pivote];
x [pivote] = x [j];
x [j] = temp;
clasificación rápida (x, primero, j-1);
clasificación rápida (x, j + 1, último);
}
}
Salida:
Introduzca el tamaño de la matriz: 5
Ingrese 5 elementos: 3 8 0 1 2
Elementos ordenados: 0 1 2 3 8
Tipo de inserción:
La ordenación por inserción es un algoritmo de ordenación simple. En la ordenación por inserción, cada elemento se compara con los elementos anteriores y se inserta antes de su elemento superior. Esto se repetirá hasta que finalice la clasificación.
Suponga que una matriz con n elementos a [1], a [2], ……, a [n] está en la memoria. El algoritmo de ordenación por inserción escanea a de a [1] a a [n], insertando cada elemento a [k] en su posición correcta en el subarreglo previamente ordenado a [1], a [2], …, a [k-1 ]
/ * programa para demostración de ordenación rápida * /
#include
int main () {
int i, j, s, temp, a [20];
printf (“Ingrese elementos totales:”);
scanf (“% d”, & s);
printf (“Ingrese% d elementos:”, s);
para (i = 0; i scanf (“% d”, y a [i]);
para (i = 1; i temp = a [i];
j = i-1;
while ((temp = 0)) {
a [j + 1] = a [j];
j = j-1;
}
a [j + 1] = temp;
}
printf (“Después de ordenar:”);
para (i = 0; i printf (“% d”, a [i]);
devuelve 0;
}
Salida:
Ingrese elementos totales: 5
Ingrese 5 elementos: 3 7 9 0 2
Después de la clasificación: 0 2 3 7 9
Ordenar fusión:
La técnica de combinación de clasificación clasifica un conjunto de valores dado al combinar dos matrices ordenadas en una matriz ordenada más grande. Considere una matriz ordenada, A que contiene elementos p, y la matriz ordenada B, que contiene elementos q. La técnica de combinación de combinación combina los elementos de A y B en una sola matriz ordenada C con elementos p + q. El primer elemento de datos de la matriz A se compara con el primer elemento de datos de la matriz B. Si el primer elemento de datos de A es más pequeño que el primer elemento de datos de B, entonces ese elemento de datos de A se mueve a la matriz, C. Si el elemento de datos de B es más pequeño que el elemento de datos de A, entonces se mueve al conjunto, C. Esta comparación de elementos de datos continúa hasta que uno de los conjuntos finaliza.
/ * programa para la demostración del tipo de fusión * /
#include
#include
vacío mergesort (int a [], int n)
{
int b [50], c, bajo1, alto1, alto2, bajo2;
int i, k, j;
c = 1;
mientras que (c {
bajo1 = 0;
k = 0;
while (bajo1 + c {
bajo2 = bajo1 + c;
alto1 = bajo2-1;
if (bajo2 + c-1 alto2 = bajo2 + c-1;
más
high2 = n-1;
i = bajo1;
j = bajo2;
while (i <= high1 && j <= high2)
{
si (a [i] <= a [j])
b [k ++] = a [i ++];
más
b [k ++] = a [j ++];
}
mientras que (i <= high1)
b [k ++] = a [i ++];
mientras que (j <= high2)
b [k ++] = a [j ++];
bajo1 = alto2 + 1;
}
i = bajo1;
mientras que (k b [k ++] = a [i ++];
para (i = 0; i a [i] = b [i];
c = c * 2;
}
}
principal ()
{
int a [20], i, n;
clrscr ();
printf (“Ingrese el número de elementos \ t:”);
scanf (“% d”, & n);
para (i = 0; i {
printf (“\ n Elemento% d \ t:”, i + 1);
scanf (“% d”, y a [i]);
}
printf (“\ n Array antes de ordenar:”);
para (i = 0; i printf (“% 5d”, a [i]);
mergesort (a, n);
printf (“\ n Matriz después de ordenar:”);
para (i = 0; i printf (“% 5d”, a [i]);
getch ();
devuelve 0;
}
Salida:
Ingrese el número de elementos: 10
Elemento 1: 12
Elemento 2: 54
Elemento 3: 98
Elemento 4: 6566
Elemento 5: 45
Elemento 6:12
Elemento 7: 5
Elemento 8: 1
Elemento 9: 156
Elemento 10:21
Matriz antes de ordenar: 12 54 98 6566 45 12 5 1 156 21
Matriz después de la clasificación: 1 5 12 12 21 45 54 98156 6566
