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)