在类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