• 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;
    }

Casi casi lo tiene dog  , recorrer con doble ciclo for como haces con el método suma, porque debes recorrer cada indice, me da aburrimiento máximo llenarla, pero aleatoria nom y así ahorras tiempo en desarrollo, no apto para produccion  

public class Bidimensional {
 
	private double[][] matriz;
	private int	renglones;
	private int columnas;
 	private static final SecureRandom SR = new SecureRandom();
	private static final DecimalFormat TWO_DIGITS = new DecimalFormat("#.##");
 
	public Bidimensional(int renglones, int columnas) { // constructor y pido el ingreso de valores a matrices
		Scanner entrada = new Scanner(System.in);
		this.matriz = new double [renglones][columnas];
 
		for(int i=0 ; i<renglones; i++)
		{
			for(int j=0; j<columnas; j++) {
				matriz[i][j]= Double.valueOf(TWO_DIGITS.format(1 + SR.nextDouble()));
				System.out.print("Ingresar el numero de matriz ["+i+":"+j+"]: ");
				System.out.println(matriz[i][j]);
 
			}
		}
	}
 
	public double[][] suma(Bidimensional m2) // operacion de suma
	{
		for(int i=0; i<2; i++) {
			for(int j=0; j<2; j++)
			{
				matriz[i][j]= matriz[i][j] + m2.matriz[i][j];
			}
		}
 
		return matriz;
	}
 
        public double format(final double num) {
            return Double.valueOf(TWO_DIGITS.format(num).replace(",", "."));
        }
 
 	public static void main(String ...blalba) {
 
		final Bidimensional matris = new Bidimensional(2,2);
		final Bidimensional matris2 = new Bidimensional(2,2);
 
		final double[][] resultado = matris.suma(matris2);
		//Recorrer el Array de doble dimension, con java 8, java 7 usa doble for
		Arrays.stream(resultado)
				.flatMapToDouble(Arrays::stream)
                                .map(this::format)
				.forEach(System.out::println);
 
	}
}

Ingresar el numero de matriz [0:0]: 1.32
Ingresar el numero de matriz [0:1]: 1.8
Ingresar el numero de matriz [1:0]: 1.62
Ingresar el numero de matriz [1:1]: 1.71
Ingresar el numero de matriz [0:0]: 1.53
Ingresar el numero de matriz [0:1]: 1.6
Ingresar el numero de matriz [1:0]: 1.6
Ingresar el numero de matriz [1:1]: 1.57
2.85
3.4
3.22
3.28
 
Process finished with exit code 0

public double[][] suma(Bidimensional m2) // operacion de suma 
{
for(int i=0; i<matriz.length; i++) {
	for(int j=0; j<m2.matriz[i].length; j++)
	{
		matriz[i][j]= matriz[i][j] + m2.matriz[i][j];
	}
} 
    return matriz;
}

for(int i=0; i<matriz.length; i++) {
  for(int j=0; j<matriz[i].length; j++) {
	matriz[i][j]= matriz[i][j] + m2.matriz[i][j];
  }
}

import java.util.logging.Logger;
 
/**
 *
 */
@FunctionalInterface
public interface IPersonal {
 
    Logger LOGGER =Logger.getLogger(IPersonal.class.getSimpleName());
 
    void introducirDatos();
 
    default <T> void mostrar(final T value) {
        System.out.println(value);
    }
 
    /**
     * usar dentro de un metodo estatico
     * @param value
     * @param <T>
     */
    static <T> void mostrar2(final T value) {
        System.out.println(value);
    }
 
    default <T> void log(final T t) {
        LOGGER.severe(t.toString());
    }
 
    /**
     * usar dentro de un metodo estatico
     * @param t
     * @param <T>
     */
    static <T> void log2(final T t) {
        LOGGER.severe(t.toString());
    }
}
 

import java.util.Objects;
import java.util.Scanner;
 
/**
 *
 */
public abstract class AbstractBasePersona implements IPersonal {
 
    protected String nombre;
    protected int edad;
    protected static final Scanner LEER = new Scanner(System.in);
 
    public AbstractBasePersona() {
        this.edad = 0;
        this.nombre = "";
    }
 
    public AbstractBasePersona(final String nombre, final int edad) {
        this.nombre = Objects.requireNonNull(nombre,"Nombre no debe ser null");
        this.edad = Objects.requireNonNull(edad,"Edad no debe ser null");
    }
 
    public String getNombre() {
        return nombre;
    }
 
    public void setNombre(String nombre) {
        this.nombre = nombre;
    }
 
    public int getEdad() {
        return edad;
    }
 
    public void setEdad(int edad) {
        this.edad = edad;
    }
 
    @Override
    public void introducirDatos() {
        mostrar("Introduce nombre: ");
        nombre = LEER.next();
        //bug scanner
        LEER.nextLine();
        mostrar("Introduce edad");
 
        while(!LEER.hasNextInt()) {
            LEER.next();
            mostrar("Valor invalido!, solo numeros");
        }
        edad = LEER.nextInt();
 
    }
 
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("\nPersona");
        sb.append("\nNombre: ").append(nombre).append("\n");
        sb.append("Edad: ").append(edad);
        return sb.toString();
    }
 
 
}
 
 

public class PersonalDeInformatica extends AbstractBasePersona {
 
    private boolean esDeInformatica;
 
    public PersonalDeInformatica() {
        super();
    }
 
    public PersonalDeInformatica(final String nombre,final int edad, boolean esDeInformatica) {
        super(nombre,edad);
        this.esDeInformatica = esDeInformatica;
    }
 
    @Override
    public void introducirDatos() {
        /**
         * Introducir los datos basicos por defecto, Nombre y Edad
         */
        super.introducirDatos();
 
        // pedimo si es personal de informatica
 
        mostrar("Personal del Informtica ?");
        esDeInformatica = LEER.nextBoolean();
 
        //setemos el tipo de persona
        setEsDeInformatica(esDeInformatica);
    }
 
    public boolean isEsDeInformatica() {
        return esDeInformatica;
    }
 
    public void setEsDeInformatica(boolean esDeInformatica) {
        this.esDeInformatica = esDeInformatica;
    }
 
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append(super.toString());
        sb.append("\nEs de informatica ? ").append(esDeInformatica);
        return sb.toString();
    }
}
 
 

/**
 *
 */
public class PersonalDeLimpieza extends AbstractBasePersona {
 
    private boolean esDeLimpieza; //por defecto la variable de instancia boolean, es false
 
    public PersonalDeLimpieza() {
        super();
    }
 
    public PersonalDeLimpieza(final String nombre, final int edad, final boolean esDeLimpieza) {
        super(nombre,edad);
        this.esDeLimpieza = esDeLimpieza;
    }
 
    public boolean isEsDeLimpieza() {
        return esDeLimpieza;
    }
 
    public void setEsDeLimpieza(boolean esDeLimpieza) {
        this.esDeLimpieza = esDeLimpieza;
    }
 
    @Override
    public void introducirDatos() {
        //invocamo al introducir datos de la superClaseAbstracta
        super.introducirDatos();
 
        // pedimo si es personal de limpieza
 
        mostrar("Personal del limpieza ?");
        esDeLimpieza = LEER.nextBoolean();
 
        //setemos el tipo de persona
        setEsDeLimpieza(esDeLimpieza);
 
    }
 
    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder();
        sb.append(super.toString());
        sb.append("\nPersonal de Limpieza ? ").append(isEsDeLimpieza()).append("\n");
        return sb.toString();
    }
 
}
 
 

import java.util.LinkedList;
 
/**
 *
 */
public class Principal {
 
    private final LinkedList<IPersonal> iPersonalLinkedList = new LinkedList<>();
 
 
    public Principal() {
        init();
    }
 
    private void init() {
 
        final PersonalDeLimpieza personalDeLimpieza = new PersonalDeLimpieza();
        personalDeLimpieza.introducirDatos();
 
        final PersonalDeInformatica personalDeInformatica = new PersonalDeInformatica();
        personalDeInformatica.introducirDatos();
 
        /**
         * Anadimos a todos los objetos que extienden/implementan a IPersonal
         * para procesarlos de manera polimorfica gracias, a que cada uno,
         * sobreEscribe a toString().
         */
        iPersonalLinkedList.add(personalDeLimpieza);
        iPersonalLinkedList.add(personalDeInformatica);
 
        /**
         * Se invocara al metodo toString() de cada Objeto, implicitanmente
         */
        //java 8
        iPersonalLinkedList.forEach(e -> e.mostrar(e));
 
        //java 7
        /*for(IPersonal tmp : iPersonalLinkedList) {
            tmp.mostrar(tmp.toString());
        }*/
 
    }
 
    public static void main(String ...blabla) {
        new Principal();
    }
}
 

Introduce nombre: 
Ana
Introduce edad
14
Personal del limpieza ?
false
Introduce nombre: 
rubn
Introduce edad
30
Personal del Informtica ?
true
 
Persona
Nombre: Ana
Edad: 14
Personal de Limpieza ? false
 
 
Persona
Nombre: rubn
Edad: 30
Es de informatica ? true
 
Process finished with exit code 0
 

Un ejemplo sencillo, luego chekeate el patrón Builder   , y Abstract Generic Builder , con interfaces también (te aseguro que te gustara, y trabajaras mejor con inmutabilidad)