文章目录
1 内部类的基本概念
1.1 内部类的定义
内部类： 所谓内部类就是在一个类内部进行其他类结构的嵌套操作。
class Outter{
private String str="加油";
//定义内部类
class Inner{
public void print()
{
System.out.println(str);
}
}
//在外部类中定义一个方法用于产生内部类对象
public void fun()
{
Inner in=new Inner();
in.print();
}
}
public class Test2{
public static void main(String[] args)
{
Outter out=new Outter();
out.fun();
}
}
通过以上代码我们会发现，引入内部类后，程序的结构有些混乱。虽然内部类破坏了程序的结构，但是，内部类可以方便的操作外部类的私有访问。
修改上述代码，要求把内部类拆开到外部，主方法代码不变，也可以实现相同的功能：
class Outter{
private String str="加油";
public String getStr()
{
return str;
}
public void fun() //3.现在由out对象调用了fun()方法
{
Inner in=new Inner(this);//4.this表示当前对象
in.print(); //7.调用方法
}
}
class Inner{
private Outter out;
public Inner(Outter out)//5.Inner.out = main.out
{
this.out = out ; //6.引用传递
}
public void print()
{
System.out.println(out.getStr());//8.执行此方法
}
}
public class Test2{
public static void main(String[] args)
{
Outter out=new Outter(); //1. 实例化Outter类对象
out.fun();//2.调用Outter类方法
}
}
1.2 内部类的优缺点
内部类的优点:
- 内部类与外部类可以方便的访问彼此的私有域（包括私有方法、私有属性）。
- 内部类是另外一种封装，对外部的其他类隐藏。
- 内部类可以实现java的单继承局限。
内部类的缺点:
结构复杂。
范例：使用内部类实现多继承：
class A {
private String name = "A类的私有域";
public String getName() {
return name;
}
}
class B {
private int age = 20;
public int getAge() {
return age;
}
}
class Outter {
private class InnerClassA extends A {
public String name() {
return super.getName();
}
}
private class InnerClassB extends B {
public int age() {
return super.getAge();
}
}
public String name() {
return new InnerClassA().name();
}
public int age() {
return new InnerClassB().age();
}
}
public class Test2 {
public static void main(String[] args) {
Outter outter = new Outter();
System.out.println(outter.name());
System.out.println(outter.age());
}
}
2 创建内部类
2.1 在外部类外部创建非静态内部类
语法： 外部类.内部类 内部类对象 = new 外部类().new 内部类();
举例： Outter.Inner in = new Outter().new Inner();
2.2 在外部类外部创建静态内部类
语法： 外部类.内部类 内部类对象 = new 外部类.内部类();
举例： Outter.Inner in = new Outter.Inner();
2.3 在外部类内部创建内部类语法
在外部类内部创建内部类，就像普通对象一样直接创建Inner in = new Inner();
3 内部类的分类
在Java中内部类主要分为成员内部类、静态内部类、方法内部类、匿名内部类
3.1 成员内部类
成员内部类不存在任何static的变量和方法。
成员内部类是依附外部类的，所以只有创建了外部类才能创建内部类。
3.2 静态内部类
关键字static可以修饰成员变量、方法、代码块、其实还可以修饰内部类，使用static修饰的内部类我们称之为静态内部类，静态内部类和非静态内部类之间存在一个最大的区别，非静态内部类在编译完成之后会隐含的保存着一个引用，该引用是指向创建它的外围类，但是静态类没有。没有这个引用就意味着：
1.静态内部类的创建不需要依赖外部类可以直接创建。
2.静态内部类不可以使用任何外部类的非static类（包括属性和方法），但可以存在自己的成员变量。
class Outter{
private static String str="加油";
static class Inner
{
public void print()
{
//访问外部类的静态属性str
System.out.println(str);
}
}
}
public class Test2{
public static void main(String[] args)
{
//在外部类外部创建静态内部类
Outter.Inner in=new Outter.Inner();
in.print();
}
}
3.3 方法内部类
方法内部类定义在外部类的方法中，方法内部类只能在该方法中被使用，出了该方法就会失效。
1. 方法内部类不允许使用访问权限修饰符（public、private、protected）均不允许。
2. 方法内部类对外部完全隐藏，出了创建这个类的方法可以访问它，其他地方均不能访问。
3. 方法内部类如果想要使用方法形参，该形参必须使用final声明（JDK8形参变为隐式final声明）
class Outter{
private int num;
public void fun(int test)
{
class Inner{
private void f()
{
num++;
System.out.println(num);
System.out.println(test);
}
}
new Inner().f();
}
}
public class Test2{
public static void main(String[] args)
{
Outter out =new Outter();
out.fun(20);
}
}
3.4 匿名内部类
匿名内部类就是一个没有名字的方法内部类，因此特点和方法与方法内部类完全一致，除此之外，还有自己的特点：
1.匿名内部类必须继承一个抽象类或者实现一个接口。
2.匿名内部类没有类名，因此没有构造方法。
interface MyInterface{
void test();
}
class Outter{
private int num;
public void fun(int test)
{
//匿名内部类实现了MyInterface借口
new MyInterface()
{
public void test()
{
System.out.println("匿名内部类！"+test);
}
}.test();
}
}
public class Test2{
public static void main(String[] args)
{
Outter out =new Outter();
out.fun(20);
}
}
4 内部类与外部类的关系
- 对于非静态内部类，内部类的创建依赖外部类的实例对象，在没有外部类实例之前，是无法创建内部类的。
- 内部类是一个相对独立的个体，与外部类没有关系。
- 内部类可以直接访问外部类的元素包括私有域，但是外部类不可以直接访问内部类元素，需要通过内部类的引用间接访问。