Foro sobre Java SE > Creación clases heredadas
La clase Cliente es una clase interna de Coche. Ni Coche ni Cliente son heredadas.
Ejemplo de uso de clases internas y heredadas:
JPFileSystemTree hereda de JPTree, y usa tres clases internas, JPFileBrowserExpansion, JPFileSystemActions y WatcherListener.
public class JPFileSystemTree extends JPTree {
private static final long serialVersionUID = -2384982807347926939L;
private transient FileSystemTreeModel fileSystemTreeModel;
private transient final JPopupMenu popupmenuFileSystem;
private transient final EnumMap<JPFileSystemPopupMenu, JMenuItem> menuItemsMap;
private transient Map<Path, UUID> watched = Collections.synchronizedMap(new HashMap<Path, UUID>(20));
private transient DirWatcher dirWatcher = FilesServices.getDirWatcher();
private transient final Lookup.Result<WatcherProcessData> processData = LookupBusServices.getLookupBus().getSubscriber(WatcherProcessData.class, new WatcherListener());
public JPFileSystemTree() {
super();
final JPFileSystemActions fsActions = new JPFileSystemActions();
popupmenuFileSystem = getJPopupMenu();
popupmenuFileSystem.setInvoker(JPFileSystemTree.this);
popupmenuFileSystem.setName("FileSystemPopupmenu");
final ResourceBundle bundle = JPToolsI18NServices.getI18N().getGuiBundle();
final JMenuItem menuOpenFile = new JMenuItem(bundle.getString("ABRIR_ARCHIVO"));
menuOpenFile.setName(JPFileSystemPopupMenu.menuOpenFile.getMenuName());
menuOpenFile.setActionCommand(JPFileSystemPopupMenu.menuOpenFile.getActionCommand());
menuOpenFile.addActionListener(fsActions);
final JMenuItem menuSaveFile = new JMenuItem(bundle.getString("GUARDAR_ARCHIVO"));
menuSaveFile.setName(JPFileSystemPopupMenu.menuSaveFile.getMenuName());
menuSaveFile.setActionCommand(JPFileSystemPopupMenu.menuSaveFile.getActionCommand());
menuSaveFile.addActionListener(fsActions);
final JMenuItem menuDelFile = new JMenuItem(bundle.getString("BORRAR_ARCHIVO"));
menuDelFile.setName(JPFileSystemPopupMenu.menuDelFile.getMenuName());
menuDelFile.setActionCommand(JPFileSystemPopupMenu.menuDelFile.getActionCommand());
menuDelFile.addActionListener(fsActions);
final JMenuItem menuRenFile = new JMenuItem(bundle.getString("RENOMBRAR_ARCHIVO"));
menuRenFile.setName(JPFileSystemPopupMenu.menuRenFile.getMenuName());
menuRenFile.setActionCommand(JPFileSystemPopupMenu.menuRenFile.getActionCommand());
menuRenFile.addActionListener(fsActions);
popupmenuFileSystem.remove(getJPopupMenuItem(JPTreePopupMenu.menuTreeExpand));
popupmenuFileSystem.remove(getJPopupMenuItem(JPTreePopupMenu.menuTreeCollapse));
popupmenuFileSystem.add(menuOpenFile);
popupmenuFileSystem.add(menuSaveFile);
popupmenuFileSystem.add(menuDelFile);
popupmenuFileSystem.add(menuRenFile);
// JPopup EnumMap setup
menuItemsMap = new EnumMap<>(JPFileSystemPopupMenu.class);
menuItemsMap.put(JPFileSystemPopupMenu.menuOpenFile, menuOpenFile);
menuItemsMap.put(JPFileSystemPopupMenu.menuSaveFile, menuSaveFile);
menuItemsMap.put(JPFileSystemPopupMenu.menuDelFile, menuDelFile);
menuItemsMap.put(JPFileSystemPopupMenu.menuRenFile, menuRenFile);
fileSystemTreeModel = new FileSystemTreeModel();
setModel(fileSystemTreeModel);
addTreeExpansionListener(new JPFileBrowserExpansion());
setShowsRootHandles(true);
setCellRenderer(new FileSystemTreeCellRenderer());
}
public FileSystemTreeModel getFileSystemTreeModel() {
return fileSystemTreeModel;
}
public Path getSelectedFile() {
return getSelectedFile(getSelectionPath());
}
public Path getSelectedFile(final TreePath treePath) {
return treePath == null ? null : Paths.get(Objects.toString(treePath.getLastPathComponent()));
}
public List<Path> getSelectedFiles() {
return getSelectedFiles(getSelectionPaths());
}
public List<Path> getSelectedFiles(final TreePath[] treePaths) {
List<Path> files;
if (treePaths != null) {
files = new ArrayList<>(2 * treePaths.length);
for (int i = 0; i < treePaths.length; i++) {
files.add(Paths.get(Objects.toString(treePaths[i].getLastPathComponent())));
}
} else {
files = Collections.emptyList();
}
return files;
}
public JPopupMenu getJPopupFileSystemMenu() {
return popupmenuFileSystem;
}
public JMenuItem getJPFileSystemMenuItem(final JPFileSystemPopupMenu menuItem) {
return menuItemsMap.get(menuItem);
}
public void removeWatched() throws IOException {
for (UUID uuid : watched.values()) {
dirWatcher.removeWatcher(uuid);
}
watched.clear();
}
private class JPFileBrowserExpansion implements TreeExpansionListener {
@Override
public void treeExpanded(final TreeExpansionEvent evt) {
for (Object item : getExpandedTreeNodes()) {
if (!watched.containsKey((Path) item)) {
final UUID uuid = UUID.randomUUID();
watched.put((Path) item, uuid);
try {
dirWatcher.addWatcher(uuid, (Path) item);
} catch (IOException ex) {
JPToolsLogService.getLogger().error(ex.getMessage(), ex.getCause());
}
}
}
fileSystemTreeModel.fireTreeStructureChanged(JPFileSystemTree.this, evt.getPath());
}
@Override
public void treeCollapsed(final TreeExpansionEvent evt) {
final List<Object> listexpanded = getExpandedTreeNodes();
for (Path path : watched.keySet()) {
if (!listexpanded.contains(path)) {
try {
dirWatcher.removeWatcher(watched.remove(path));
} catch (IOException ex) {
JPToolsLogService.getLogger().error(ex.getMessage(), ex.getCause());
}
}
}
fileSystemTreeModel.fireTreeStructureChanged(JPFileSystemTree.this, evt.getPath());
}
}
private class WatcherListener implements LookupListener {
@Override
public void resultChanged(final LookupEvent evt) {
final Collection<? extends WatcherProcessData> items = processData.allInstances();
if (!items.isEmpty()) {
final WatcherProcessData data = items.iterator().next();
final UUID watcherID = data.getWatchID();
if (watcherID != null) {
final Iterator<Entry<Path, UUID>> entrySet = watched.entrySet().iterator();
while (entrySet.hasNext()) {
final Entry<Path, UUID> entry = entrySet.next();
if (entry.getValue().equals(watcherID)) {
fileSystemTreeModel.fireTreeStructureChanged(JPFileSystemTree.this, fileSystemTreeModel.getTreePath(entry.getKey()));
break;
}
}
}
}
}
}
private static class JPFileSystemActions implements ActionListener {
@Override
public void actionPerformed(final ActionEvent evt) {
switch (JPFileSystemPopupMenu.getField(evt.getActionCommand())) {
case menuOpenFile:
break;
case menuSaveFile:
break;
case menuDelFile:
break;
case menuRenFile:
break;
default:
break;
}
}
}
protected void finalize() throws Throwable {
if (!watched.isEmpty()) {
try {
removeWatched();
} finally {
super.finalize();
}
}
super.finalize();
}
}
choces
ufff¡¡¡ Gracias pero tu código de momento se me queda tremendamente grande.
Ya he cogido el concepto de clase interna.
Gracias
hugodepino
Veamos, un amigo y profesional en java me hizo el comentario " ...de que los que venís viciados de otros lenguajes de programación como Basic o Dbase, os cuesta mas..." y me he dado cuenta que tiene toda la razón.
Ha llegado un punto en mis estudios en el que no consigo salir de la clase principal, public static void, y el metodo main. Tengo claro el resto, if, for, while, arrays, excepciones, listas, pilas, variables, etc, etc... pero mi problema es que nada consigue hacerme entender el siguiente caso:
¿Para que sirve una clase heredada?
¿Como se estructura?
¿Y en que situaciones me va a hacer falta utilizarlo?
No le encuentro el sentido a una clase dentro de otra, ¿ no se puede ir saltando de función en función simplemente?, no es cuestión de falta de conocimientos es cuestión de que intentéis metermelo en la cabeza con algún ejemplo gráfico o unas cuantas líneas de código con un simple System.out.println o no se como... pero es imperiosa la necesidad de entenderlo para continuar con mis estudios.
Pasteo un ejercicio que estoy haciendo con el tema de las clases heredadas, por favor no le presteis atención a los this ni a los if ni a las declaraciones de variables, ni nada de eso, lo tengo claro. Que alguien me explique ¿que hace "leches" hace esa clase dentro de otra clase? y que sentido tiene o que parte del libro me he saltado.
Estoy en un punto en el cual no se ni donde empieza la clase principal y solo veo un conglomerado de clases revueltas con funciones sin orden alguno. El ejercicio está sacado de un libro.
Agradecido de antemano
public class Coche {
private final String modelo;
private final String matricula;
private final String color;
private final Cliente cliente;
public Coche(final String modelo, final String matricula, final String color, final String nombre, final String apellidos) {
this.modelo = modelo;
this.matricula = matricula;
this.color = color;
this.cliente = new Cliente(nombre, apellidos);
}
public String getCliente() {
return cliente.datosCliente();
}
public String getDatosCoche() {
return modelo + color + matricula;
}
private static class Cliente {
private final String nombre;
private final String apellidos;
Cliente(final String nombre, final String apellidos) {
this.nombre = nombre;
this.apellidos = apellidos;
}
public String datosCliente() {
return nombre + apellidos;
}
}
public static void main(String[] args) {
Coche coche = new Coche("Renault", "1400BWN", "Blanco", "Moisés", "Perez " Muñoz");
System.out.println(" Datos del coche " + coche.getDatosCoche());
System.out.println(" Datos del cliente " + coche.getCliente());
}
}