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)

Seguro? no te faltó algo a la hora de declarar la lista de Persona?  

estoy 90% seguro que no probaste el ejemplo, o no hiciste el import bien, que este último no lo creo.

Y eso que lo escribo desde mi Android .

 El operador diamante puede ir vacío también, como con el objeto en el, pero siendo redundante, o sea,

final LinkedList<Persona> lista = new LinkedList<Persona>(); // redundante 

final LinkedList<Persona> list = new LinkedList<>();
list.add(new Persona("Beginner","web",14));
 

package foro;
 
import javax.swing.*;
import javax.swing.border.TitledBorder;
import javax.swing.table.DefaultTableModel;
import java.awt.*;
import java.util.ArrayList;
import java.util.List;
 
/**
 * @Autor rub´n y google
 */
public class JTableAvoidDuplicados extends JFrame {
 
    private final DefaultTableModel defaultTableModel = new DefaultTableModel();
    private final JTable table = new JTable(defaultTableModel);
    private final JScrollPane jScrollPane = new JScrollPane(table);
    private final JButton button = new JButton("Aceptar");
    private final JTextField textField = new JTextField();
 
    public JTableAvoidDuplicados() {
        init();
 
        setSize(500, 100);
        pack();
        setLocationRelativeTo(null);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }
 
    private void init() {
        final JComponent panelNorte = getPanelNorte();
        final JComponent panelSur = getPanelSur();
        panelNorte.add(panelSur, BorderLayout.SOUTH);
        add(panelNorte);
    }
 
    private JComponent getPanelNorte() {
        final JPanel panel = new JPanel();
        panel.setLayout(new BoxLayout(panel, BoxLayout.Y_AXIS));
        final TitledBorder titledBorder = new TitledBorder("PoC duplicados en JTable");
        titledBorder.setTitleFont(new Font(Font.SANS_SERIF,Font.BOLD,16));
        panel.setBorder(titledBorder);
        panel.add(jScrollPane, BorderLayout.NORTH);
        /**
         * Filas de la table
         */
        defaultTableModel.addColumn("Codigo");
        defaultTableModel.addRow(new Object[]{"codigo-0000"});
        defaultTableModel.addRow(new Object[]{"codigo-0001"});
        defaultTableModel.addRow(new Object[]{"codigo-0002"});
        defaultTableModel.addRow(new Object[]{"codigo-0003"});
 
        return panel;
    }
 
    private JComponent getPanelSur() {
        final JPanel panelSur = new JPanel();
        panelSur.setLayout(new BoxLayout(panelSur,BoxLayout.X_AXIS));
        panelSur.setBorder(BorderFactory.createEmptyBorder(10, 0, 5, 0));
        panelSur.add(new JLabel("Introduce codigo: "));
        panelSur.add(Box.createHorizontalStrut(10));
        panelSur.add(textField);
        panelSur.add(Box.createHorizontalStrut(10));
        panelSur.add(button);
        initBehaviour();
        return panelSur;
    }
 
    private void initBehaviour() {
        button.addActionListener(e -> tabla(table, textField));
    }
 
    private void tabla(JTable tabla, JTextField jTextField) {
        String s = "";
        boolean exists = false;
        for (int i = 0; i < tabla.getRowCount(); i++) {
            s = tabla.getValueAt(i, 0).toString().trim();
 
            if (jTextField.getText().equals("")) {
                JOptionPane.showMessageDialog(null, "Introduce un valor");
                break;
            } else if (jTextField.getText().equals(s)) {
                exists = true;
                break;
 
            }
        }
        if (!exists) {
            final DefaultTableModel dd = (DefaultTableModel) tabla.getModel();
            final List<String> lista = new ArrayList<>();
            final String codigo = jTextField.getText();
            if (!codigo.equals("")) {
                lista.add(jTextField.getText());
                dd.addRow(lista.toArray());
            }
        } else {
            JOptionPane.showMessageDialog(null, "Codigo existente.");
        }
    }
 
    public static void main(String... gaga) {
        try {
            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        new Thread(JTableAvoidDuplicados::new).start();
    }
 
}