博客

内部类的基本概念

概念：当一个类的的定义出现在另一个类的内部时，这个类被称作内部类（Inner),而这个类所在的类称为外部类（Outer)。

类中可以有的内容有：成员变量，成员方法，构造方法，构造块，代码块，内部类。

内部类的意义

实际意义：当一个类存在的意义是为另一个类服务时，就可以将该类定义在所要服务类的内部，这样可以隐藏该类的具体实现细节，而且内部类可以直接访问外部类的私有成员，而不用外部类再提供公有的set、get方法。

内部类的分类

1. 普通内部类：定义在外部类类体中的非静态类。
2. 静态内部类：定义在外部类类体中的静态类。
3. 局部内部类：定义在外部类成员方法的方法体中的类。
4. 匿名内部类：简单地说是没有名字的内部类。

(1)普通内部类及简单使用

1. 普通内部类中可以有构造方法，成员变量，成员方法等
2. 普通内部类可以用final、abstract关键字修饰
3. 普通内部类可以用private、protect等关键字修饰
4. 普通内部类需要通过外部类来创建对象
5. 内部类中访问与外部类中同名的成员变量或方法时需要使用this关键字
6. 
   普通内部类中的私有成员可以被外部类访问
   
   
   如创建链表时，内部节点类Node的成员可以定义为私有的，且还可以被LinkedList访问。

public class LinkedList<E>{
	private class Node<E>{
		private E element;
		private Node<E> next;
		public Node(E element,Nnode<E> next){
			this.element=element;
			this.next=next;
		}
	}
	private Node<E> first;
	
	public void  Test(){
		if(null!=first)//可以直接访问私有成员element
			System.out.println(first.element);
	}
}

内部类举例：定义外部类NormalOuter与普通内部类Normalnner

//外部类NormalOuter
public class NormalOuter {
    //外部类私有成员变量
    private int num=1;
    //普通内部类NormalInner
    private  class NormalInner{
        private int num=2;
        //私有成员方法print
        private void print(int num){
            
        }
    }
}

可以在普通内部类print()方法中对外部类成员变量num、内部类成员变量num、内部类方法形参num的进行访问，代码修改为

//外部类NormalOuter
public class NormalOuter {
    //私有成员变量
    private int num=1;
    //普通内部类NormalInner
    private  class NormalInner{
        private int num=2;
        //私有成员方法print
        public void print(int num){
            System.out.println("print方法形参num:"+num);//就近原则
            System.out.println("内部类成员变量num:"+this.num);//this代表当前类（内部类）对象的引用
            System.out.println("外部类成员变量num:"+NormalOuter.this.num);//this--外部类对象的引用
        }
    }

    public void test(){
        //创建内部类对象
        NormalInner ni=new NormalInner();
        ni.print(3);
    }
}

在Test类中进行测试

public class NormalTest {
    public static void main(String[] args) {
    	//创建外部类的引用指向该类型的对象
        NormalOuter no=new NormalOuter();
        no.test();
    }
}

结果如下

或者是将内部类Normalnner的访问权限改为public,在main方法中直接创建内部类对象的引用，再通过引用变量调用print方法。如下进行修改。`

//外部类NormalOuter
public class NormalOuter {
    //私有成员变量
    private int num=1;
    //普通内部类NormalInner，修改为public
    public  class NormalInner{
        private int num=2;
        //私有成员方法print
        public void print(int num){
            System.out.println("print方法形参num:"+num);//就近原则
            System.out.println("内部类成员变量num:"+this.num);//this代表当前类（内部类）对象的引用
            System.out.println("外部类成员变量num:"+NormalOuter.this.num);//this--外部类对象的引用
        }
    }
}

public class NormalTest {
    public static void main(String[] args) {
        NormalOuter no=new NormalOuter();
        //由于内部类不是外部类的静态成员，则其属于对象层级，需要通过外部类对象构建
        NormalOuter.NormalInner ni=no.new NormalInner();
        ni.print(3);
    }
}

结果同上

（2）静态内部类

静态内部类：静态内部类简单地可以认为是在普通内部类前加上了static关键字，且由于该内部类因static由对象层级上升到类层级，与静态方法类似的，静态内部类访问外部类成员时只能使用外部类中的静态成员（变量+方法）。

public class StaticOuter {
    //外部类静态成员变量
    private static int num=1;
    //静态内部类
    public static class StaticInner{
        //内部类静态成员变量
        private static int num=2;
        private int cnt=3;
        public void print(int num){
            System.out.println("形参num:"+num);
            System.out.println("内部类cnt:"+cnt);
            System.out.println("内部类静态成员num:"+StaticInner.num);
            System.out.println("外部类静态成员num:"+StaticOuter.num);
        }
    }
}

public class StaticTest {
    public static void main(String[] args) {
    	//声明内部类引用
        StaticOuter.StaticInner si=new StaticOuter.StaticInner();
        si.print(4);
    }
}

结果如下