Java内部类

什么是内部类？
内部类：顾名思义是被嵌套定义在JAVA类中的一种类，在JAVA中内部类又可以分为静态内部类和非静态内部类，非静态内部类又包含成员内部类、局部内部类和匿名内部类。

内部类的访问修饰有:public 、private 、protected、static

/*
*内部类就是对类的一个封装，外部对象无法访问，或者说同一个包下的求它类不可见，可以通过实现一个方法提供对该内部类的访问，一般使用private修饰。
*成员内部类
*/

public class Test {
        private int age;
        private String name;

        public Test(int age, String name) {
            this.age = age;
            this.name = name;
        }
    public class InnerClass{//成员内部类，和普通类成员一样的定义
        private double weight;

        public InnerClass(double weight) {
            this.weight = weight;
        }
        public void toString()
        {
            System.out.println("Name: "+getName()+" Age:"+getAge()+" Weight:"+weight);
        }
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Test() {
    }
}

编译后含有将会产生一个Test.class 以及一个Test$InnerClass.class,
实例化这样的类时，内部类有特殊的实例化方式，非静态内部类需要依赖于外部类的对象。

public class Main {
    public static void main(String[] args) {
        Test test=new Test(18,"liming");
        Test.InnerClass inner=test.new InnerClass(55.5);
    }
}

局部内部类也就是定义在方法作用域内的类，调用时只能作用在方法作用域内，类似于一个局部变量

/*
*局部内部类（方法内部类）
*类的作用域仅限于方法作用域
*/
public void Parts()
{//jdk1.8
	final String x="Thank you";
	class Inner
	{
		public void print()
		{//jdk1.7及以前如果在局部内部类类内部访问方法中的非finanl变量将导致编译出错，只能对final 变量进行修改。
		System.out.println(x+" Are you ok?");
		}
	}
	Inner inner=new Inner();
	inner.print();
}

静态内部类，与静态成员一样可以在类实例化前调用，但静态内部类仅能访问外部类的静态成员，这和静态方法只能调用静态变量是一样的防止变量不存在。

/*
*静态内部类可以有静态方法和静态变量
*/
public class Test{
public static class Inner{
            private int x;
            private int y;

            public Inner(int x, int y) {
                this.x = x;
                this.y = y;
            }

            @Override
            public String toString() {
                return "x=" + x +
                        ", y=" + y ;
            }
        }
        }

匿名内部类：没有实际名字的内部类，由于没有名字所以匿名内部类也就没有构造方法
匿名内部类分为以下 几种情况：
1、继承式匿名内部类

class Test{
abstract class Abs{
	public abstract void func();
}
public void print()
{
	/*没有命名类，编译文件会产生外部类名+$+编号。class,如Test$1.class*/
	Abs abs=new Abs(){
	
	public void func()
	{
	System.out.println("Called");
	}
};
	}
}

2、接口式匿名内部类

class Test{
	interface Ibs{
	public void func();
	}
	public void print()
	{
		Ibs ibs=new Ibs(){
			public void func()
			{
				System.out.println("Are you ok");
			}
		};
	}
}

3、参数式匿名内部类

class Test{
	interface Ibs{
	public void func();
	}
	public void Calling(Ibs ibs)
	{
		ibs.func();
	}
}

class Main
{
	public static void main(String [] args)
	{
		Test A=new Test();
		A.Calling(new Ibs(){
			public void func()
			{
			System.out.println("Are you ok?");
			}
	});
	}
}

匿名内部类是莫得修饰符的（名字都莫得），不能定义静态成员与方法，同样的匿名内部类是局部的需要注意其作用域。