码迷,mamicode.com
首页 > 编程语言 > 详细

Java内部类

时间:2020-05-31 13:19:59      阅读:59      评论:0      收藏:0      [点我收藏+]

标签:程序   情况   权限   匿名内部类   外部   定义   people   turn   实例   

内部类

通常情况

一个 Java 文件中只有一个主类,也就意味着下面这样是错误的:

// 编译器会报错,一个 java 文件中只能有一个被 public 修饰的类,并且该类的类名与 java 文件名一致(Outer.java)
public class Outer{
}
public class Other{
}

将第二个类的 public 权限修饰符删除,就可以在 java 文件中定义多个类
并且每个类都可以被访问到

内部类的结构

内部类,顾名思义,就是 java 一个类中定义另一个类,如下所示:

public class Outer{
	class Inter{
	}
}

创建内部类

内部类在实例化的时候偷偷保留了指向外部类的引用。因此在创建内部类对象的同时,必须先创建外部类对象(静态内部类除外)

  • 通过外部类中的方法得到内部类
public class Outer{
	public Inter inter() {
		return new Inter();
	}
	class Inter{
	}
	public static void main(String[] args) {
		Outer outer = new Outer();
		Inter inter = outer.inter();
	}
}
  • 内部类对象通过 外部类对象的 .new 方法创建
public class Outer{
	class Inter{
	}
	public static void main(String[] args) {
		// 通俗易懂的创建方式
		Outer outer = new Outer();
		Outer.Inter inter0 = outer.new Inter();
		// 一次创建完毕
		Inter inter1 = new Outer().new Inter();
		Outer.Inter inter2 = new Outer().new Inter();
	}
}

内部类对象通过 外部类.this 方法得到父类

public class Outer{
	class Inter{
		Outer getOuter() {
			return Outer.this;
		}
	}
	public static void main(String[] args) {
		Outer outer1 = new Outer();
		Outer.Inter inter = outer1.new Inter();
		Outer outer2 = inter.getOuter();
		// 两个对象是同一个
		System.out.println(outer1 == outer2);	// true
	}
}

内部类的特点

内部类默认可以访问外部类中所有的成员

public class Outer{
	Object[] items = new Object[2];
	private int index = 0;
	class Inter{
		public void add(String s) {
			// 在Inter类中,可以访问到外部的private成员变量
			if (index<items.length) items[index++]=s;; 
		}
	}
	public static void main(String[] args) {
		Outer outer = new Outer();
		Outer.Inter inter = outer.new Inter();
		inter.add("元素一");
		inter.add("元素二");
		System.out.println(outer.items[1]);	// print:元素二
	}
}

内部类与向上转型

将内部类声明为private或者protected。同时,在创建内部类实例对象的时候,通过内部类的父接口来声明对象变量,这样一来,客户端程序员就只能访问接口中定义的公共方法。因而实现了对接口实现过程代码的隐藏。

public class Outer{
	public Inter inter() {
		return new Inter();
	}
	interface People{
		void speak();
	}
	class Inter implements People{
		public void speak() {
			System.out.println("这是接口中的一个方法");
		}
		public void sleep(){
		}
	}
	public static void main(String[] args) {
		// 程序员无法访问到内部类实现的接口以外的方法
		Outer outer = new Outer();
		People inter = outer.inter();
		inter.speak();
		// inter.sleep()	访问不到
	}
}

在方法中和作用域内的内部类

内部类可以在方法里面或者在任意的作用域中定义内部类。

匿名内部类

看起来就像创建类对象的时候,同时在这里插入该类的定义。

用的比较多的: new 接口(){ 接口的实现 },这样就不用再定义具体的一个实现类了

public class Outer{
    // 接口
	interface Inter{
		void speak();
	}
	public Inter inter() {
        // 返回的时候,将接口实现
		return new Inter(){
			public void speak() {
				System.out.println("hello");
			}
		};
	}
}

嵌套类(静态内部类)

使用 static 修饰的内部类就是嵌套类了。内部类不依赖于外部类对象,没有 .this方法,普通内部类中不能有static方法或成员和嵌套类。而嵌套类里边可以有static方法和成员,也可以继续嵌套一个类

public class Outer{
	static class Inter{
		static String des = "静态成员变量";
		static void speak() {
			System.out.println("静态方法");
		}
		static class InterInter{
			static {
				String des = "嵌套类中的嵌套类";
			}
		}
	}
	public static void main(String[] args) {
		Inter.speak();
	}
}
  • 接口内部的嵌套类
    接口中的类都会被声明为public,static。可以通过在接口内部写一个嵌套类,并且在这个嵌套类中创建公共代码

每个类中测试的时候都需要主方法,但是你可以在一个嵌套类中定义一个main方法,这样外部类在解析这个嵌套类的时候会执行其中的静态main方法,从而外部类不用特意写个主方法了

  • 无论嵌套多少层都没事,嵌套类总能访问外部类的成员(无论其访问修饰符是什么),最里层的嵌套类可以访问外层的所有成员

为什么使用内部类

每个内部类都能独立地继承一个(接口的)实现,所以无论外围类是否及经济成了某个(接口的)实现,对于内部类都没有影响

  • 可以解决多重继承问题
  • (闭包与回调)通过内部类提供闭包的功能是优良的解决方案,他比指针更灵活、更安全。

闭包(closure)是一个可调用的对象,他记录了一些信息,这些信息来自创建它的作用域。

  • 内部类和控制框架
    每个内部类都可以独立地实现一个action
    内部类可以很容易访问外围类的任意成员

Java内部类

标签:程序   情况   权限   匿名内部类   外部   定义   people   turn   实例   

原文地址:https://www.cnblogs.com/llf7/p/12996847.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!