Java中内部类也是很有用的比如链表中的使用

一个破坏类结构的存在为什么还会作用，存在即合理，总会有作用的，比如内部类在链表中的表现

首先了解一下内部类
内部类：在一个类内部还有另外一个类，则成为内部类。
定义格式如下：

标识符 class 外部类名称{
      //外部类成员
      标识符 class 内部类名称{
            //内部类成员
      }
}
1、如果一个内部类使用 static 关键字声明，则此内部类就称为外部类，
可以直接通过：外部类.内部类  进行访问。
2、内部类可声明成public和private。当内部类声明为public和private时，对其访问的限制与成员变量和成员方法是一样的。

内部类特点：
缺点：通常类中只有属性和方法，内部类破坏了程序的结构
优点：（只能说是相对而言吧，这个需要对比，实现内部类结构的代码，拆分后代码会变多）
如下样例代码：

//内部类实现的功能
class Outer{									// 定义外部类
	private String info = "hello world" ;		// 定义外部类的私有属性
	class Inner{								// 定义内部类
		public void print(){			 		// 定义内部类的方法
			System.out.println(info) ;			// 直接访问外部类的私有属性	
		}
	};
	public void fun(){						// 定义外部类的方法
		new Inner().print() ;				// 通过内部类的实例化对象调用方法
	}
};
public class InnerClassDemo01{
	public static void main(String args[]){
		new Outer().fun() ;					// 调用外部类的fun()方法
	}
};
############把内部类取出来#############
class Outer{		// 定义外部类
	private String info = "hello world" ;	// 定义外部类的私有属性
	public void fun(){						// 定义外部类的方法
		new Inner(this).print() ;				// 通过内部类的实例化对象调用方法
	}
	public String getInfo(){				// 增加了一个getter方法取得info内容
		return this.info ;	
	}
};
class Inner{	// 定义内部类
	private Outer out = null ;				// 声明Outer对象
	public Inner(Outer out){
		this.out = out ;
	}
	public void print(){				// 定义内部类的方法
		System.out.println(this.out.getInfo()) ;		// 直接访问外部类的私有属性
	}
};
public class InnerClassDemo02{
	public static void main(String args[]){
		new Outer().fun() ;					// 调用外部类的fun()方法
	}
};

使用内部类实现链表类：
代码中有详细的注解

package com;

class Link{                                     //链表的完整类
    class Node{                                 //保存每一个节点，定义为内部类更方便
        private String data;                    //保存节点内容
        private Node next;                      //保存下一个节点
        public Node(String data){
            this.data=data;                     //通过构造方法设置节点内容
        }
        public void add(Node newNode){          //增加新节点
            if(this.next==null){                //如果节点为空，把新节点设置在next的位置上
                this.next=newNode;
            }else{                              //如果不为空，则需要向下继续找next
                this.next.add(newNode);
            }
        }
        public void print(){
            System.out.print(this.data+"\t");  //打印节点内容
            if(this.next!=null){                //如果还有下一个节点继续打印
                this.next.print();              //下一个节点继续打印
            }
        }
        public boolean search(String data){     //内部查找数据
            if(data.equals(this.data)){         //如果查找到数据返回true
                return true;
            }else {                             //向下判断
                if(this.next!=null){            //下一个节点存在就继续查找
                    return this.next.search(data);  //返回下一个查询结果
                }else {
                    return false;               //查询完没找到则返回false
                }
            }
        }

        public void delete(Node previous ,String data){
            if(data.equals(this.data)){         //找到匹配的节点
                previous.next=this.next;        //空出当前节点
            }else{
                if(this.next!=null){            //还有下一个节点
                    this.next.delete(this,data);//继续查找
                }
            }
        }
    }
    private Node root;                          //链表中必然存在的根结点
    public void addNode(String data){           //增加新节点
        Node newNode=new Node(data);            //定义新的节点
        if(this.root==null){                    //如果没有根节点
            this.root=newNode;                  //将第一个节点设置成根节点
        }else{
            this.root.add(newNode);             //通过Node自动安排此节点放的位置
        }
    }
    public void printNode(){                    // 输出链表全部内容
        if(this.root!=null){                    //如果根节点不为空
            this.root.print();                  //调用Node类中的操作
        }
    }
    public boolean contains(String name){
        return this.root.search(name);
    }
    public void deleteNode(String data){        //删除一个节点
        if(this.contains(data)){                //先查询一下是否处在
            if(this.root.data.equals(data)){    //如果内容是根节点
                this.root=this.root.next;       //修改根节点，将第一个节点设置为根节点
            }else {
                this.root.next.delete(root,data);//把下一个节点的前节点和数据一起传进去
            }
        }
    }
}
public class LinkDemo {
    public static void main(String[] args) {
        Link l=new Link();
        l.addNode("123*");
        l.addNode("456*");
        l.addNode("789*");
        System.out.println("链表内容：");
        l.printNode();
        l.deleteNode("456*");
        System.out.println("修改后的链表内容");
        l.printNode();
        System.out.println("查找123*"+l.contains("123*"));

        System.out.println("查找不存在的"+l.contains("111"));
    }
}

内部类应该还有很多用途，只是我还没遇到太多，等遇到了再更新……