java内部类的定义与分类示例详解

内部类

基本介绍

一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class),嵌套其他类的类称为外部类(outer class)。是我们类的第五大成员，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系

基本语法：

class Outer{

	class Inner{

	}

}

内部类的分类：

1.定义在外部类局部位置上(比如方法内)：

1）.局部内那类(有类名)

2）.匿名内部类(没有类名,重点);

定义在外部类的成员位置上：

1）成员内部类（没用static 修饰）

2）静态内部类（使用static 修饰）

局部内部类的使用：

局部内部类记住三点会比较好学：

（1）局部内部类定义在方法中/代码块

（2）作用域在方法体或者代码块中

（3）本质仍然是一个类

说明：局部内部类是定义在外部类的局部位置，比如方法中，并且有类名。

1.可以直接访问外部类的所有成员，包含私有的 如下演示

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);//可以直接访问到Outer类中的成员
				f1();//可以直接访问到Outer类中的成员
			}
		}
	}

}

2.不能添加访问修饰符，因为他的地位就是一个局部内部类，局部内部类是不能使用修饰符的，但是可以使用final修饰，因为局部变量也可以使用final

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
        class Inner{//正确写法
			public void k() {
				System.out.println(num);
				f1();
			}
		}
	 	final class Inner{}//正确写法
        public class inner01{}//错误写法
        //总结除final外的任何修饰符，都是错误写法
	}

}

3.作用域：仅仅在定义他的方法或代码块中。

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);
				f1();
			}
		}
        Inner inner =new Inner();//正确写法
	}
    Inner inner =new Inner();//错误写法
	//总结出了方法或者代码块的作用域，都是错误写法因为找不到
}

4.局部内部类—访问—>外部类的成员[访问方式：直接访问]

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);//内部类可以直接访问到外部类的成员
				f1();
			}
		}
	}
}

5.外部类—访问—>局部内部类的成员 访问方式：创建对象，在访问（注意：必须在作用域内）

public class Usb {
	public static void main(String[] args) {
	}
}
class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);
				f1();
			}
		}
        Inner inner=new Inner();//需要创建一个对象才可以访问内部类的成员，还必须时在他的作用域中创建
        inner.k();
	}
}

6.外部其他类–不能访问—>局部内部类（因为 局部内部类地位是一个局部变量）

public class Usb {
	public static void main(String[] args) {
        Inner inner=new Inner();//错误写法
	}
}
class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			public void k() {
				System.out.println(num);
				f1();
			}
		}
	}
}

7.如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

class Outer{
	private int num=99;
	private void f1(){
		System.out.println("真好");
	}
	{
		class Inner{
			private int num=9;
			public void k() {
				System.out.println(Outer.this.num);//类名.this可以找到这个类中的成员 this.可以找到类中的成员
				f1();
			}
		}
		Inner inner=new Inner();
		inner.k();
	}
}

匿名内部类：

匿名内部类的使用（重要）

（1）本质时类（2）内部类（3）该类没有名字（4）同时还时一个对象

说明：匿名内部类时定义在外部类的局部位置，比如方法中并且没有类名（表面没有名字，但是在底层系统还是给分配了名字的）

1.匿名内部类的基本语法

public class Test {
	public static void main(String[] args) {
		temp anonymous=new temp() {
			public void h1() {
				System.out.println("驱羊攻虎");
			}
		};
		anonymous.h1();
		System.out.println(anonymous.getClass());//输出匿名内部类的类名
	}
}
abstract class temp{
	public abstract void h1() ;
}

2.匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义同时他本身也是一个对象，因此从语法上看，他既有定义类的特征，也有创建对象的特征对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。

3.可以直接访问外部类的所有成员，包括私有的

public class Test {
    private static String str="以卵击石";
	public static void main(String[] args) {
		temp anonymous=new temp() {
			public void h1() {
				System.out.println("驱羊攻虎\r"+str);//可以直接访问外部类的所有成员，包括私有的
			}
		};
		anonymous.h1();
		System.out.println(anonymous.getClass());//输出匿名内部类的类名
	}
}
abstract class temp{
	public abstract void h1() ;
}

4.不能添加访问修饰符。因为他的地位就是一个局部变量而已。

5.作用域：匿名内部类与局部内部类一样 仅仅在定义它的方法或代码块中

6.匿名内部类----访问---->外部类成员[访问方式：直接访问]

7.外部其他类—不能访问---->匿名内部类（因为 匿名内部类地位是一个局部变量）

8.如果外部类和匿名内部类的成员重名时，匿名内部类访问的化，默认遵循就近原则，如果想要访问外部类的成员，则可以使用（外部类名.this.成员）去访问 如Test.this.str

成员内部类：

说明：成员内部类是定义在外部类的成员位置，并且没有static修饰

基本用法：

public class InnerClassTest {

    public class InnerClassA {

    }
}

1.可以直接访问外部类的所有成员，包含私有的

2.可以添加任意访问修饰符(public、protected、默认、private), 因为它的地位就事一个成员。

3.作用域：和外部类的其他成员一样，为整个类体，在外部类的成员方法中创建成员内部类对象，在调用方法。

4.成员内部类----访问---->外部类(比如：属性) [访问方式：直接访问]（说明）

5.外部类—>访问---->内部类 (说明) 访问方式：创建对象，在访问

6.外部其他类----访问---->成员内部类

7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就进原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

静态内部类的使用：

说明：静态内部类是定义在外部类的成员位置，并且有static修饰

public class InnerClassTest {

    static class InnerClassA {

    }

}

1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员

2.可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员

3.作用域：同其他成员，为整个类体

4.静态内部类—访问—>外部类（比如：静态属性）[访问方式：直接访问所有静态成员]

5.外部类—访问—>静态内部类 访问方式：创建对象、在访问

6.外部其他类—访问—>静态内部类

7.如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用（外部类名.this.成员）去访问

总结

到此这篇关于java内部类的定义与分类的文章就介绍到这了,更多相关java内部类定义与分类内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！