public static void mostrarInformación(String[][] p) {
        int i, j;
        for (i = 0; i < p.length; i++) {
            for (j = 0; j < p[i].length && p[i][j] != null; j++) {
                System.out.println(p[i][j]+"\t");
            }
            if (p[i][0] != null) {
                System.out.println("");
            }
        }
    }

 
public class MatrisDeStrings {
 
     private static final String[][] NOM_APE = {{"Raul","Salazar",
                                                "Maria","Gonzales",
                                                "Josefina","Petronila",
                                                "Ana",null
                                                }};
 
    public MatrisDeStrings() {
 
        matris(NOM_APE);
    }
 
    public static void matris(final String[][] matris) {
 
        for(int f=0; f<matris.length; f++) {
            for(int c=0; c<matris[f].length; c++) {
                if(Objects.nonNull(matris[f][c])) {
                    System.out.println(matris[f][c]);
                }
            }
        }
 
       //con programacion funcional
       Arrays.stream(NOM_APE)
                .flatMap(Arrays::stream)
                .filter(Objects::nonNull)
                .forEach(System.out::println);
 
    }
 
    public static void main(String ...agrs) {
        new MatrisDeStrings();
    }
}

public static boolean nonNull(Object obj) {
        return obj != null;
    }

private void mostrarMiLista(final LinkedList<Alumno> list) {
 
        // si la lista no esta vacia o tambien if(!(list.size() == 0)) aunque el Sonar(Analizador de codigo estatico) se queja 
        if(!list.isEmpty()) { 
            //old way
            for(int f=0; f<list.size(); f++) {
                System.out.println(list.get(f).getNombre());
                System.out.println(list.get(f).getApellido());
                System.out.println(list.get(f).getLegajo());
            }
 
            //old way 2
            for(Alumno tmp : list) {
                System.out.println(tmp.getNombre());
                System.out.println(tmp.getApellido());
                System.out.println(tmp.getLegajo());
            }
 
            //new way with java-8 foreach mucho más eficiente
            //Que Iterator, una de ellas es menos sobrecarga en la heap
            list.forEach(e -> {
                System.out.println(e.getNombre());
                System.out.println(e.getApellido());
                System.out.println(e.getLegajo());
            });
 
            //Con metodo por referencia
            list.forEach(System.out::println); // invoca a toString() internamente
 
             //con IntStream donde e, el parametro del foreach equivale al index, por eso al hacer get(e) funciona
             IntStream.range(0,list.size())
                    .forEach(e -> {
                        System.out.println(list.get(e).getNombre());
                        System.out.println(list.get(e).getApellido());
                        System.out.println(list.get(e).getLegajo());
                    });
 
        } else {
            System.out.println("Lista Vacia");
            JOptionPane.showMessageDialog(null,"Lista vacia.");
        }
}

 @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("\nAlumno");
        sb.append("\nnombre='").append(nombre).append("\n");
        sb.append(", apellido='").append(apellido).append("\n");
        sb.append(", legajo='").append(legajo).append("\n");
        sb.append("]");
        return sb.toString();
    }

• herencia simple de clases
• Uso de super
• Modificador de acceso protected

package foro; 
import java.lang.Math.*;
import java.util.logging.Logger;
 
/**
 * Clase Calculadora
 */
public class Calculadora {
 
    private String marca;
    private String modelo;
    private String sistemaOperativo;
    private String versionSistemaOperativo;
 
    public static final Logger LOGGER = Logger.getLogger(ProyectoCelular.class.getSimpleName());
 
    public Calculadora() {
        super();
    }
 
    public Calculadora(String marca, String modelo, String sistemaOperativo, String versionSistemaOperativo) {
        this.marca = marca;
        this.modelo = modelo;
        this.sistemaOperativo = sistemaOperativo;
        this.versionSistemaOperativo = versionSistemaOperativo;
    }
 
    /**
     *
     * @param a
     * @param b
     * @return La suma entre a y b
     */
    public float sumar(float a, float b) {
        return a + b;
    }
 
    /**
     *
     * @param a
     * @param b
     * @return La resta entre a y b
     */
    public float restar(float a, float b) {
        return a - b;
    }
 
    /**
     *
     * @param a
     * @param b
     * @return La multiplicación entre a y b
     */
    public double multiplicar(double a, double b) {
        if (a == 0 || b == 0) {
            return 0;
        } else {
            return a * b;
        }
    }
 
    /**
     *
     * @param a
     * @param b
     * @return La división entre a y b
     */
    public double dividir(float a, float b) {
        return a / b;
    }
 
    /**
     *
     * @param n
     * @return El factorial de un numero
     */
    public int factorial(int n) {
        if (n < 1) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }
 
    /**
     * @return the marca
     */
    public String getMarca() {
        return marca;
    }
 
    /**
     * @param marca the marca to set
     */
    public void setMarca(String marca) {
        this.marca = marca;
    }
 
    /**
     * @return the modelo
     */
    public String getModelo() {
        return modelo;
    }
 
    /**
     * @param modelo the modelo to set
     */
    public void setModelo(String modelo) {
        this.modelo = modelo;
    }
 
    /**
     * @return the sistemaOperativo
     */
    public String getSistemaOperativo() {
        return sistemaOperativo;
    }
 
    /**
     * @param sistemaOperativo the sistemaOperativo to set
     */
    public void setSistemaOperativo(String sistemaOperativo) {
        this.sistemaOperativo = sistemaOperativo;
    }
 
    /**
     * @return the versionSistemaOperativo
     */
    public String getVersionSistemaOperativo() {
        return versionSistemaOperativo;
    }
 
    /**
     * @param versionSistemaOperativo the versionSistemaOperativo to set
     */
    public void setVersionSistemaOperativo(String versionSistemaOperativo) {
        this.versionSistemaOperativo = versionSistemaOperativo;
    }
 
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("\nCalculadora");
        sb.append("\nmarca='").append(marca).append("\n");
        sb.append(", modelo='").append(modelo).append("\n");
        sb.append(", sistemaOperativo='").append(sistemaOperativo).append("\n");
        sb.append(", versionSistemaOperativo='").append(versionSistemaOperativo).append("\n");
        return sb.toString();
    }
}
 

package foro;
 
/**
 * Clase Celular
 */
public class Celular extends Calculadora { // extendemos a Calculadora
 
    //private String marca;
    //private String modelo;  // estas dos variables no hacen falta, porque se heredan tambien
    private String  color;
    private double precio;
 
    /**
     * Nuevo constructor vacio
     */
    public Celular() {
        super(); // super invoca al constructor de la clase Calculadora
    }
 
    public Celular(String marca, String modelo, String color, double precio, String sistemaOperativo, String versionSistemaOperativo) {
        /**
         * con este super invocamos al constructor de la clase Calculadora, seteandole los parametros
         * correspondientes chavalina.
         */
        super(marca,modelo, sistemaOperativo,versionSistemaOperativo);
        this.color = color;
        this.precio = precio;
    }
 
    /**
     * @return the marca
     */
    public String getMarca() {
        return marca;
    }
 
    /**
     * @param marca the marca to set
     */
    public void setMarca(String marca) {
        this.marca = marca;
    }
 
    /**
     * @return the modelo
     */
    public String getModelo() {
        return modelo;
    }
 
    /**
     * @param modelo the modelo to set
     */
    public void setModelo(String modelo) {
        this.modelo = modelo;
    }
 
    /**
     * @return the color
     */
    public String getColor() {
        return color;
    }
 
    /**
     * @param color the color to set
     */
    public void setColor(String color) {
        this.color = color;
    }
 
    /**
     * @return the precio
     */
    public double getPrecio() {
        return precio;
    }
 
    /**
     * @param precio the precio to set
     */
    public void setPrecio(double precio) {
        this.precio = precio;
    }
 
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append(super.toString());
        sb.append("\ncolor='").append(color).append("\n");
        sb.append(", precio=").append(precio);
        return sb.toString();
    }
}
 

package foro;
 
 
public class ProyectoCelular {
 
    public static void main(String[] args) {
        // Esto es el main todavia no lo terminé
 
        final Celular celular = new Celular();
        /**
         * Configurando por medio de setters NO-THREAD-SAFE
         */
        celular.setColor("Rojo");
        celular.setMarca("Samsung");
        celular.setModelo("I9300");
        celular.setPrecio(200);
        celular.setSistemaOperativo("Android KitKat");
        celular.setVersionSistemaOperativo("4.4.4");
 
        /**
         * Todos ellos retornan un valor
         * que puedes mostrar con la consola o logger, logger es lo mas correcto
         */
        celular.factorial(2);
        celular.dividir(2,3);
        celular.sumar(2,3);
        celular.restar(5,1);
        celular.multiplicar(5,5);
 
        Calculadora.LOGGER.info(celular.toString());
    }
 
}
 

Estamos en presencia de un constructor telescópico, muchos parámetros a veces difícil de usar, coste de mantenimiento, legibilidad etc, patrón Builder es la solución.

A simple vista pensarías, bueno me creo otro constructor y le añado parámetros, pero vienes de nuevo y añades otro y así, nunca terminara, o este mismo contructor añadirle mas parámetros.

O la típica vía de usar setters, NO-THREAD-SAFE, es decir no Inmutable(Como String, StringBuffer, la api LocalDate del paquete java.time), si usas ese bean en un Thread podrian pasar cosas raras y difíciles de resolver.   tema que, podemos tratar luego.

 

 public Celular(String marca, String modelo, String color, double precio, String sistemaOperativo, String versionSistemaOperativo) {
        /**
         * con este super invocamos al constructor de la clase Calculadora, seteandole los parámetros
         * correspondientes chavalina.
         */
        super(marca,modelo, sistemaOperativo,versionSistemaOperativo);
        this.color = color;
        this.precio = precio;
    }