在类Outer的内部再定义一个类Inner，这个Inner就是内部类，Outer则称为外部类。

内部类优点：

    方便的访问外部类中的私有属性，同时，外部类可以也可以方便的访问内部类的私有属性，这样可以避免封装带来的操作结构复杂的问题。

/**
 * 内部类
 * 好处：可以方便的访问外部类中的私有属性。
 *
 */
public class Outer_1 {
	private String infoString = "hello world!";
	class Inner{
		public void print(){
			System.out.println(infoString);
		}
	}
	public void fun(){
		new Inner().print();
	}
	
	
	public static void main(String[] args) {
		new Outer_1().fun();
	}
}

/**
 * 在外部访问内部类
 *
 */
public class Outer_2 {
	private String infoString = "hello world!";
	class Inner{
		public void print(){
			System.out.println(infoString);
		}
	}
	
	public static void main(String[] args) {
		new Outer_2().new Inner().print();
	}
}

内部类的缺点：

    破坏了一个类的基本结构，即类是由属性和方法组成的。

内部类实例讲解：

package base;
/**
 * 递归：自己调自己的方法，（方法内调用本方法）
 * 也叫：迭代循环
 */
public 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{
				this.next.add(newNode);//如果下一个节点不是空，则调用下一个节点的add方法
			}
		}
		public void print(){
			System.out.println(this.data +"\t");
			if(this.next!=null){	//如果下一个节点（next）存在，则继续调用print方法
				this.next.print();
			}
		}
		public boolean search(String data){
			if(data.equals(this.data)){	//如果存在返回true
				return true;
			}else{
				if(this.next!=null){	//如果没有找到，判断下一个节点，如果下一个节点存在，则下一个节点next继续调用search方法
				    return this.next.search(data);
				}else{
					return false;		//下一个节点不存在，则返回false
				}
			}
		}
		public void delete(Node previous,String data){
			if(data.equals(this.data)){	//如果存在改名称，则将下一个节点的引用赋给，前一个节点的next。
				previous.next=this.next;
			}else{
				if(this.next!=null){	//如果不存在，继续判断下一个节点是否存在，如果存在下一个节点。则下一个节点继续调用delete方法
					this.next.delete(this, data);
				}
			}
		}
	}
	
	private Node root;	//根节点。
	public void addNode(String data){
		Node newNode = new Node(data);	//根据有参构造方法创建新节点newNode；
		if(this.root==null){
			this.root = newNode;		//如果根节点为空，，则newNode就作为根节点
		}else{
			this.root.add(newNode);		//否则，调用add方法增加子节点
		}
	}
	
	public void printNode(){
		if(this.root!=null){
			this.root.print();			//如果该节点不为空，则调用print方法
		}
	}
	
	public boolean contains(String data){//判断是否包含该名称
		return this.root.search(data);
	}
	
	public void deleteNode(String data){
		if(this.contains(data)){
			if(this.root.data.equals(data)){//删除节点的原理，就是将下一个节点（对象）赋给上一个节点的next。则本节点就不会被访问到了
				this.root = this.root.next; //找到了，将改对象的next赋值给本对象，将自己替换掉。
			}else{
				this.root.next.delete(this.root, data);//如果没有找到，下一个节点继续调用delete方法查找，注意入参
			}
		}
	}
	
	public static void main(String[] args) {
		Link i = new Link();
		i.addNode("A");
		i.addNode("B");
		i.addNode("C");
		i.addNode("D");
		i.addNode("E");
		System.out.println("==================删除之前==================");
		i.printNode();
		i.deleteNode("C");
		i.deleteNode("D");
		System.out.println("==================删除之后==================");
		i.printNode();
	}
}

结果展示：

==================删除之前==================
A	
B	
C	
D	
E	
==================删除之后==================
A	
B	
E