Este es un ejemplo de herencia, la clase ClienteVip que hereda de Cliente:

/**
* ClienteVip
* Clase que muestra la declaración de una clase que extiende a otra:
* es decir muestra la HERENCIA
*
* Para compilar:
*   javac ClienteVip.java
*
* Para ejecutarlo:
*   java ClienteVip
*/
 
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
// Libería necesaria para la clase Date
import java.util.Date;
 
/**
* clase ClienteVip
* Muestra la declaración de ClienteVip, una extensión de la clase Cliente.  
* Es un ejemplo simple de herencia, donde creamos una clase especializada
* que hereda todos los atributos y métodos de la clase padre.
* Para lograrlo debemos añadir la clausula extends en la declaración
* de la clase.
*
* @author Pello Altadill
*/
public class ClienteVip extends Cliente {
    
    // ATRIBUTOS o PROPIEDADES DE LA CLASE extendida:
    public float descuento;
    
    
    // MÉTODOS DE LA CLASE: Constructores, y otras funciones
    /**
    * ClienteVip
    * este es el método constructor, al que se invoca
    * al crear una instancia de la clase
    */
    ClienteVip ()
    {
        // Lamamos al constructor de la clase padre
        super();
        
        System.out.println("Has creado una instancia de ClienteVip");
    }
    
    /**
    * ClienteVip
    * Otro constructor con parámetros.
    * Nos sirve para crear una instancia
    */
    ClienteVip (String nombre, String apellidos, Date nacimiento, int codigo, float descuento)
    {
        // Lamamos al constructor de la clase padre
        super(nombre,apellidos,nacimiento,codigo);
 
        // Establecemos el atributo descuento
        this.descuento = descuento;
 
        System.out.println("Has creado una instancia de ClienteVip");
    }
    
    /**
    * aplicarDescuento
    * Método que aplica el descuento del cliente a un determinado total
    * @return resultado
    */
    public float aplicarDescuento (float precioTotal)
    {
        float resultado = precioTotal * (1-descuento);
        
        return resultado;
    }
    
    /**
    * quitarIVA
    * Método que le quita el IVA al cliente de un total
    *
    */
    public float quitarIVA (float precioTotal)
    {
        float resultado = precioTotal * (0.82F);
        
        return resultado;
    }
    
    /**
    * fichaCliente
    * Método que sobrescribe al de la clase padre Cliente,
    * añadiendo un dato más.
    *
    */
    public void fichaCliente ()
    {
        // al principio hace los mismo que la clase padre.
        super.fichaCliente();
        
        System.out.println("CLIENTE VIP");
        System.out.println("Descuento: " + descuento);
    }
 
    
    /**
    * main
    * Función principal
    * esta función es la que se inicia directamente al ejecutar el programa
    * Y desde ella vamos a crear una instancia de ClienteVip
    */
    public static void main (String args[])
    {
        // Creamos un par de instancias
        ClienteVip unClienteVip = new ClienteVip();
        ClienteVip otroClienteVip = new ClienteVip("Frodo","Bolson", new Date(), 19, 0.10F);
        unClienteVip.codigo = 89;
        
        otroClienteVip.fichaCliente();
 
        System.out.println("Total 109.56 euros, con descuento del " + otroClienteVip.descuento + "%: " + otroClienteVip.aplicarDescuento(109.56F));
                
        unClienteVip.saluda();
    }
}

En las funciones podemos tener un retorno y pueden lanzar excepciones.

/**
* Metodos
* Clase que muestra la declaración de todo tipo de métodos
*
* Para compilar:
*   javac Metodos.java
*
* Para ejecutarlo:
*   java Metodos
*/
 
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
 
/**
* clase Metodos
* Muestra la declaración dedistintos tipos de métodos: constructores,
* métodos con distintos tipos de retorno, métodos que lanzan excepciones,
* métodos estáticos, métodos privados, protegidos y públicos
*
* La clase es un poco absurda pero simplemente trata de mostrar distintos
* tipos de métodos
*
* @author Pello Altadill
*/
public class Metodos {
    
    /**
    * Metodos
    * Constructor sin parámetros
    * estos métodos son los únicos que no devuelven algo explicitamente
    */
    Metodos () {
        System.out.println("Has creado instancia");
    }
    
    /**
    * Metodos
    * Constructor con parámetros
    * estos métodos son los únicos que no devuelven algo explicitamente
    */
    Metodos (String opcion) {
        super();
        System.out.println("Opción pasada: " + opcion);
    }
    
    /**
    * estatico
    * Aquellos que tienen la palabra static se consideran Método de clase,  
    * puede ser invocado sin que se cree una instancia
    * de la clase. ver main.
    * De estos métodos solo se crea una copia en memoria, al igual que pasa
    * con los atributos que se declaran static.
    */
    public static void estatico (int veces) {
        for (int i = 0; i < veces;i++) {
            System.out.println("Estático> " + i);
        }
    }
    
    /**
    * saludar
    * Método publico que devuelve un String
    * Si no ponemos nada, se considera público
    * @return String
    */
    String saludar () {
        saludoPrivado();
        return "Hola yo te saludo.";
    }
    
    /**
    * saludoPrivado
    * Método que saca un mensaje por consola.
    * Solo se puede invocar desde dentro de la clase
    */
    private void saludoPrivado () {
        System.out.println("Java rulez");
    }
    
    /**
    * tomarDato
    * Método publico lee un valor por consola y devuelve un entero
    * Puede lanzar dos excepciones
    * @return String
    * @throws IOException, NumberFormatException
    */
    public int tomarDato () throws IOException, NumberFormatException {
            Console c = System.console();
 
        String linea = c.readLine("Dame un número: ");
         
        return Integer.parseInt(linea);
 
    }
    
    /**
    * main
    * Función principal
    * esta función es la que se inicia directamente al ejecutar el programa
    * @throw IOException
    */
    public static void main (String args[]) throws IOException
    {
        // Probamos el método estático. No necesitamos crear instancia!!!
        Metodos.estatico(5);
        
        Metodos pruebaMetodos = new Metodos("hola");
        
        pruebaMetodos.saludar();
        int entero = pruebaMetodos.tomarDato();
        
        
    }
}

Java es una especie de C++ simplificado al que le han quitado la herencia múltiple y los punteros. Como todo lenguaje orientado a objetos utiliza clases, con sus propiedades y métodos. Veamos un par de ejemplos:

Clase Genérica:

/**
* Clases
* Clase que muestra la declaración de una clase
*
* Para compilar:
*   javac Clases.java
*
* Para ejecutarlo:
*   java Clases
*/
 
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
 
/**
* clase Clases
* Clase que muestra la declaración de una clase
*
* @author Pello Altadill
*/
public class Clases {
    
    // ATRIBUTOS de CLASE
    String nombre;
    
    /**
    * Método constructor, se ejecuta al crear una instancia de la clase
    */
    Clases ()
    {
        nombre = "Juan Solo";
        System.out.println("Has creado una instancia de la clase");
    }
    
    /**
    * saludo
    * Un método de la clase que simplemente saca un mensaje
    */
    void saludo ()
    {
        System.out.println("Hola Mundo, soy " + nombre);
    }
    
    /**
    * main
    * Función principal
    * esta función es la que se inicia directamente al ejecutar el programa
    */
    public static void main (String args[])
    {
        // Creamos una INSTANCIA de la clase:
        // es como declarar una variable, pero el tipo es el
        // nombre de la clase
        Clases unaClase = new Clases();
        
        // Con la instancia llamamos a uno de sus métodos
        unaClase.saludo();
    }
}

Clase Cliente:

/**
* Cliente
* Clase que muestra la declaración de una clase
*
* Para compilar:
*   javac Cliente.java
*
* Para ejecutarlo:
*   java Cliente
*/
 
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
// Libería necesaria para la clase Date
import java.util.Date;
 
/**
* clase Cliente
* Muestra la declaración de una clase que representa un cliente.  
* Una clase se compone de atributos (propiedades) y métodos (funciones)
* La clase representa una entidad y cuando definimos una variable de
* de esa clase
*
* @author Pello Altadill
*/
public class Cliente {
    
    // ATRIBUTOS o PROPIEDADES DE LA CLASE
    public String nombre;
    public String apellidos;
    public Date nacimiento;
    public int codigo;
    
    
    // MÉTODOS DE LA CLASE: Constructores, y otras funciones
    /**
    * Cliente
    * este es el método constructor, al que se invoca
    * al crear una instancia de la clase
    */
    Cliente ()
    {
        System.out.println("Has creado una instancia de Cliente");
    }
    
    /**
    * Cliente
    * Otro constructor con parámetros.
    * Nos sirve para crear una instancia
    */
    Cliente (String nombre, String apellidos, Date nacimiento, int codigo)
    {
        System.out.println("Has creado una instancia de Cliente");
        this.nombre = nombre;
        this.apellidos = apellidos;
        this.nacimiento = nacimiento;
        this.codigo = codigo;
    }
    
    /**
    * nombreCompleto
    * Método que une el nombre y el apellido del Cliente
    * @return resultado
    */
    public String nombreCompleto ()
    {
        String resultado = nombre + " " + apellidos;
        
        return resultado;
    }
    
    /**
    * fichaCliente
    * Método que muestra todos los datos del cliente
    *
    */
    public void fichaCliente ()
    {
        System.out.println("--Ficha del Cliente--");
        System.out.println("Código: " + codigo);
        System.out.println("Nombre completo: " + nombreCompleto());
        System.out.println("Fecha nacimiento: " + nacimiento);
    }
    
    /**
    * saluda
    * Un método que nos muestra un saludo
    */
    public void saluda ()
    {
        System.out.println("Hola mundo desde la clase");
    }
    
    /**
    * main
    * Función principal
    * esta función es la que se inicia directamente al ejecutar el programa
    * Y desde ella vamos a crear una instancia de Cliente
    */
    public static void main (String args[])
    {
        // Creamos un par de instancias
        Cliente unCliente = new Cliente();
        Cliente otroCliente = new Cliente("Darth","Vader", new Date(), 666);
        unCliente.codigo = 89;
        
        otroCliente.fichaCliente();
        
        unCliente.saluda();
    }
}

¿Cómo creamos y accedemos a los elementos de un array de varias dimensiones? Muy fácil. Como en c.

/**
* Matrices
* Clase que muestra la declaración y uso de Arrays de varias dimensiones
* le he llamado Matriz por distinguir, aunque formalmente puede ser los mismo.
*
* Para compilar:
*   javac Matrices.java
*
* Para ejecutarlo:
*   java Matrices
*/
 
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
 
/**
* clase Matrices
* Clase que muestra la declaración y uso de Arrays de dos o más dimensiones
*
*
* @author Pello Altadill
*/
public class Matrices {
    
    /**
    * main
    * Función principal
    * esta función es la que se inicia directamente al ejecutar el programa
    */
    public static void main (String args[])
    {
        // Vamos a definir un array de enteros de dos dimensiones y otro de tres
        int valores[][];
        int [][] dorsales;
        
        // Podemos establecer el tamaño mediante new, y puede ser distinto para cada dimensión:
        // En este caso definimos un array de DIEZ  y TRES elementos  
        int [][] puntos = new int[10][3];
        
        
        // Podemos inicializar los arreglos con valores concretos,
        // lo cual sería una forma de implícita de especificar su tamaño:
        int numeros[][] = {{7,15,42},{69,666,23},{5,87,1},{0,665,-1}};
        
        char letras [][] = {{'a','b','c','d'},{'e','f','g','h'}};
        
        // Podemos crear Matrices de Strings
        String heroes[][] = {{"Gandalf","Trancos"}, {"Haplo","Alfred"},{"Jon Nieve", "Brienne"}};
        
        
        // Podemos alterar valores de un elemento del array
        heroes[0][1] = "Aragorn";
        numeros[1][2] = 24;
        
        // Y por supuesto operar con ellos:
        // al elemento 0 del array heroes le concatenamos algo:
        heroes[2][0] = heroes[2][0] + " lord Comandante";
        
        numeros[3][1]++;
 
        // para recorrer estos arrays con un for, hay que anidar tantos for
        // como dimensiones tenga el array:
        // ATENCIÓN a la forma de acceder al subarray en el segundo FOR    
        System.out.println("Estos son los mayores heroes, por sagas: ");
 
        for (int i = 0;i < heroes.length; i++)
        {
            System.out.println("Saga " + i);
            for (int j = 0; j < heroes[i].length; j++)
            {
                System.out.println("\tEn el índice " + i + "," + j +": " + heroes[i][j]);
            }
        }
        
    }
}

Tiene unos diez años y dudo que pueda funcionar con el struts actual pero por si alguien quiere echarle un ojo, dejo el enlace:

Bajarse aplicación Struts Mecano

En java los arrays se declaran más o menos como en c. Tenemos estructuras mejores dentro de las utilidades de java.util.*, pero si queremos algo básico y no nos importa que sea rígido podemos declarar arrays así:

/**
* Arrays
* Clase que muestra la declaración y uso de arrays
*
* Para compilar:
*   javac Arrays.java
*
* Para ejecutarlo:
*   java Arrays
*/
 
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
 
/**
* clase Arrays
* Clase que muestra la declaración y uso de arrays. Los arrays
* o arreglos son variables que contienen un conjunto de datos del mismo tipo
* indexados numéricamente desde el 0 en adelante.
*
* NOTA: pueden crearse arrays de elementos del tipo básico: int, float,...
*       y también pueden crearse de clases.
* NOTA2: los arrays en java se definen con un tamaño concreto y no puede
*        alterarse. Si necesitamos elasticidad entonces debemos usar clases
*        como por ejemplo Vector.
*
* @author Pello Altadill
*/
public class Arrays {
    
    /**
    * main
    * Función principal
    * esta función es la que se inicia directamente al ejecutar el programa
    */
    public static void main (String args[])
    {
        // Vamos a definir un array de enteros, todavía sin especificar el tamaño.
        // Lo podemos hacer de dos formas:
        int valores[];
        int [] dorsales;
        
        // Podemos establecer el tamaño mediante new:
        // En este caso definimos un array de DIEZ elementos,  
        // pero ATENCIÓN, los índices irán del 0 al 9.
        int [] puntos = new int[10];
        
        // Si quisieramos crear un array de caracteres que contenga el abecedario
        // lo hariamos así. El abecedario español tiene 28 letras, en el array serán
        // del 0 al 27.
        char abecedario[] = new char[28];
        boolean  verdades[] = new boolean[5];
        
        // Podemos inicializar los arreglos con valores concretos,
        // lo cual sería una forma de implícita de especificar su tamaño:
        int numeros[] = {7,15,42,69,666};
        
        char letras [] = {'a','b','c','d','e','f','g','h'};
        
        // Podemos crear arrays de Strings
        String heroes[] = {"Gandalf", "Haplo", "Jon Nieve", "Vader", "Trancos"};
        
        // para acceder a un elemento del array debemos indicar su índice.
        // el índice es un número entero que va de 0 al tamaño-1 del array
        System.out.println("The number of the beast: " + numeros[4]);
        
        // Podemos alterar valores de un elemento del array
        verdades[0] = false;
        numeros[2] = 23;
        
        // Y por supuesto operar con ellos:
        // al elemento 0 del array heroes le concatenamos algo:
        heroes[0] = heroes[0] + " el gris";
        
        numeros[3] = numeros[2] + 8;
        
        // Vale, ¿que hacemos con el array? Podemos recorrerlo con un for
        // Todo array tiene una propiedad que es length, la cual no da su tamaño
        
        // Por ejemplo, los elementos del array puntos los podemos inicializar  
        // con un valor concreto:
        for (int i = 0;i< puntos.length; i++)
        {
            puntos[i] = 0;
        }
        
        System.out.println("Estos son los mayores heroes: ");
 
        for (int i = 0;i < heroes.length; i++)
        {
            System.out.println("En el índice " + i + ": " + heroes[i]);
        }
        
    }
}

Estas dos sentencias funcionan como en c. Break sirve para salir de una estructura de control como un switch case o de un bucle.

El continue sirve para que el bucle salte a la siguiente vuelta, sin salir del bucle.

Atención al ejemplo y a cómo hacer breaks cuando hay más de un bucle.

/**
* BreakContinue
* Clase que muestra el uso de sentencias Break Continue para
* alterar la ejecución de bucles While, Do-While, o For
*
* Para compilar:
*   javac BreakContinue.java
*
* Para ejecutarlo:
*   java BreakContinue
*/
 
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
 
/**
*  clase BreakContinue
* Clase que muestra el uso de Break y Continue que nos sirven para
* modificar el normal comportamiento de los bucles.
* - Con break se rompe el bucle y se sale de él.
* - Con continue interrumpimos la ejecución actual del bucle y se salta a la siguiente vuelta
*   sin salir del bucle.  
*
*
* @author Pello Altadill
*/
public class BreakContinue {
    
    /**
    * main
    * Función principal
    * esta función es la que se inicia directamente al ejecutar el programa
    */
    public static void main (String args[])
    {
        
        // Declaramos una serie de variables
        int numero, anterior;
        int x,y;
        
        x = 10;
        
        while (x > 0)
        {
            if (x == 5)
            {
                break; // salimos del bucle
            }
            x--;
        }
        
        // Vamos a buscar los números primos
        // que hay del 2 al 20
        for (numero = 2; numero < 20; numero++)
        {
            anterior = numero;
            do
            {
                anterior--;
 
                // En cuanto es divisible, salimos
                if (numero % anterior == 0)
                {
                    break;    
                }
            
            } while(anterior > 2);
            
            // Si se ha llegado hasta el final, es primo
            if (anterior == 2)
            {
                System.out.println(numero + " es un PRIMO");
            }
        }
        
        // Si tenemos dos bucles anidados,  
        // ¿cómo podemos salir de un bucle concreto con break?
        // hay que usar una etiqueta, que es un identificador seguido de
        // dos puntos:
        
        salida:
        
        for(x=1;x<20;x++)
        {
            System.out.println("Bucle principal: " + x);
            
            if (20 % x == 7)
            {    // salimos del bucle principal
                break;
            }
            
            // para salir desde el bucle interno hasta fuera
            // tendremos que usar la etiqueta salida
            for(y=10;y>0;y--)
            {
                System.out.println("Bucle interno: " + y);
                if (20 % y == 4)
                {    // Salimos de este y del bucle principal también
                    // pero hay que especificar la etiqueta de salida
                    break salida;
                }
            }// for2
            
        }// for1
        
    }
}

Se declara igualito que el bucle for de c. Los bucle for se utilizan cuando necesitamos que un número concreto de iteraciones (ej: recorrer un array), ni más ni menos, aunque siempre se puede romper el bucle. A bajo nivel se supone que los bucle for son más rápidos que los while.

/**
* For
* Clase que muestra el uso de un bucle for
*
* Para compilar:
*   javac For.java
*
* Para ejecutarlo:
*   java For
*/
 
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
 
/**
* clase For
* Muestra el uso de un bucle for. Los bucles for sirven para
* ejecutar unas sentencias un número determinado de veces.
* Los bucles while se usan cuando la condición de salida es más incierta,
* o dependemos del valor de alguna variable.
*
* Formato:
*  for (inicio;condición;actualización)
*  {
*    sentencias;  
*  }
* @author Pello Altadill
*/
public class For {
    
    /**
    * main
    * Función principal
    * esta función es la que se inicia directamente al ejecutar el programa
    */
    public static void main (String args[])
    {
        // Vamos a dar 10 vueltas.
        // En los bucles for solemos usar un número como índice
        // del bucle.
        int i,j,k;
        
        i = j = k = 0;
        
        // Vamos a dar 10 vueltas: dentro del for  
        // - Primero iniciamos: i=0;
        // - Luego ponemos la condición de salida: i>0
        // - Luego ponemos la actualiación
        for (i=0; i<10; i++)
        {
            System.out.println("Dentro del bucle 1 : " + i);
        }
        
        // podemos inicializar la variable dentro del for
        // pero ojo, el ámbito de z solo será el bucle for.
        for (int z = 10; z>0; z--)
        {
            System.out.println("Dentro del bucle 2 : " + z);
        }
        
        // Podemos usar más de una variable usando la ,
        for (j=0, k=20; j<10 && k>0; j++, k=k-2)
        {
            System.out.println("Dentro del bucle 3 : " + j + " , " + k);
        }
 
        // El bucle infinito:
        // for (;;)        
    }
}

Esto es lo mismo que en c. El bucle do while es una iteración que al menos se ejecuta una vez.

/**
* DoWhile
* Clase que muestra los bucles while
*
* Para compilar:
*   javac DoWhile.java
*
* Para ejecutarlo:
*   java DoWhile
*/
 
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
 
/**
* clase DoWhile
* Muestra el uso de bucles do while. Este tipo de bucles
* es como el while, repiten unas sentencias mientras una condición sea verdadera
* pero en su caso la primera iteración sucede siempre ya que la condición se comprueba
* al final.
* Formato:
*        do
*        {
*         sentencias;
*        } while();
*
* @author Pello Altadill
*/
public class DoWhile {
    
    /**
    * main
    * Función principal
    * esta función es la que se inicia directamente al ejecutar el programa
    */
    public static void main (String args[])
    {
        // Vamos a comprobar si un número es primo
        // para eso hay que verificar que solo es divisible
        // por si misma o por 1.
        int numero, anterior;
        
        // Les asignamos a las dos
        numero = anterior = 7;
        
        // para guardar el resultado
        boolean esPrimo = true;  
        
        // Ejecutamos el do-while
        do
        {
            anterior--;
 
            if (numero % anterior == 0)
            {
                esPrimo = false;    
            }
            
        } while(anterior > 2 && esPrimo);
        
        // Mostramos el resultado
        if (esPrimo)
        {
            System.out.println("Este numero: " + numero + " es primo");
        }
        else
        {
            System.out.println("Este numero: " + numero + " NO es primo");
        }
    
    }
}

Los bucles se hacen igual que en c. Vamos a ver un ejemplo con el bucle while:

/**
* While
* Clase que muestra los bucles while
*
* Para compilar:
*   javac While.java
*
* Para ejecutarlo:
*   java While
*/
 
// Librería necesaria para trabajar con la entrada/salida
import java.io.*;
 
/**
* clase While
* Muestra el uso de bucles while. Este tipo de bucles
* repiten unas sentencias mientras una condición sea verdadera.
* El final no será previsible.
* Formato:
*  while (true)        
*  {
*     sentencias;
*  }
*
* @author Pello Altadill
*/
public class While {
    
    /**
    * main
    * Función principal
    * esta función es la que se inicia directamente al ejecutar el programa
    */
    public static void main (String args[])
    {
        // Vamos a usar un contador
        int contador = 10;
        
        // Ejecutamos el bucle mientras contador sea mayor que 0
        while (contador > 0)
        {
            System.out.println("Dentro del bucle " + contador);
            // y vamos decrementando
            contador--;
        }
        
        // Vamos a hacer otra prueba
        contador = 10;
        System.out.println("El siguiente bucle:");
        
        // Atención: podemos actualizar la variable en la propia condición
        while (contador-- > 0)
        {
            System.out.println("Dentro del bucle " + contador);
        }
 
        // el bucle infinito: simplemente poniendo en la condición true
        //while (true)        
        // {
        //   sentencias;
        // }
    }
}