Benützer:
Estructura del Programa Principal
Definition 
Todo programa en java tiene una clase principal que es a su vez el nombre del programa. Se define el la primera linea del código mismo y lleva las palabras
* public (=publico, que se acceda en forma externa) y
* class (=clase, el tipo de programa)
ademas de corchetes:
```
public class nombre_de_mi_programa {
}
```
Dentro del corchete va la instrucción principal que controla la ejecución del programa. Siempre de le denomina main y lleva tres expresiones ante puestas
* public (=publico, que se acceda en forma externa)
* static (=estático o no dinámico, que es fija y única)
* void (=vacía que no retorna ningún valor o expresión)
además de corchetes:
```
public static void main(String[] arg){
}
```
Después de la palabra main va entre paréntesis lo que se denomina los argumentos. En el caso del main estos están estandarizados (no se pueden cambiar) y corresponden a un arreglo de "palabras". Que es un arreglo se reconoce en los paréntesis rectangular "[]" detrás de la palabra String que significa cadena (palabra=cadena de letras). El nombre del arreglo es arg (de argumento) y sus elementos se indican con el paréntesis rectangular y el número del argumento comenzando en cero. De esta forma el primer elemento es arg[0], el segundo arg[1], etc.
ID:(7186, 0)
Ejemplo de Comandos a Ejecutar
Bild
Lo que el programa debe hacer se escribe entre los corchetes del programa main.
Esto puede incluir llamadas a otros programas de modo que el programa main pueda ser corto y la mayor parte de las operaciones realizarse con instructivos definidos en otros archivos.
Un ejemplo simple puede ser usar dos elementos de la lista de argumentos, combinarlos con otro texto y devolver una frase.
En el caso de java se puede definir una nueva palabra indicando la palabra String seguida por la variable que la representa:
```
String texto;
```
donde el punto y coma le indica al sistema que lo que se le quiere comunicar al sistema ha terminado.
Si queremos que la variable texto tenga ya algun significado lo podemos asignar en forma directa con el símbolo igual (=). A modo de ejemplo podríamos asignar el texto "Yo soy":
```
String texto = "Yo soy";
```
Ahora el punto coma va detrás del texto "Yo soy" ya que recién después de asignar dicho texto ha terminado lo que le estamos comunicando al sistema.
Adicionalmente podemos agregar mas textos los que podría haber recibido el programa vía los argumentos. Esto se hace simplemente sumando los nuevos textos. Si empelamos un argumento (el arg[0], ejemplo Juan) para el nombre y el segundo (el arg[1], ejemplo Perez) para el apellido, esto podría ser
```
String texto = "Yo soy"+arg[0]+arg[1];
```
Sin embargo si ponemos a prueba esto obtendremos como resultado:
```
Yo soyJuanPerez
```
dado que no introducimos los espacios en blanco que para el sistema es simplemente otro tipo de caracter. Por ello podemos incluir ahora espacios quedando nuestra asignación:
```
String texto = "Yo soy "+arg[0]+" "+arg[1];
```
y nuestro programa sería
```
public class BasicMain {
public static void main(String[] arg) {
String texto = "Yo soy "+arg[0]+" "+arg[1]
}
}
```
ID:(7187, 0)
Ejemplo de Resultado
Notiz
El programa que hemos escrito genera una frase que incluye nombres que se proveen al programa pero dicha frase. Sin embargo lo generado no es visualizable ya que solo esta en la memoria del programa.
Para poder mostrar lo que el programa realizo tenemos que por ejemplo escribir la frase a la pantalla. Como aun no estamos trabajando con interfaces gráficas (la pantalla a colores) debemos usar lo que se denomina en windows la linea de comando o en linux el terminal. El comando para escribir en dicha interfaces se denomina System.out.println y emplea la nomenclatura
```
System.out.println(text);
```
El comando System.out.println proviene de las rutinas de sistema (System) que en este caso entregan datos al exterior (out) y en particular escriben una linea (println o print line).
Con esta linea nuestra rutina queda como:
ID:(7188, 0)