内部类和静态嵌套类_Java_ThinkSAAS
内部类和静态嵌套类
内部类和静态嵌套类
术语规范:按照官方文档，定义在外部类(封装类)内部的类称之为nested class，根据是否被static关键字修饰又分为两类：static nested classes 和 inner classes。
class OuterClass {
static class StaticNestedClass {}
class InnerClass {}
使用嵌套类的好处在于:
当某个类为旁类专用时，将其写成嵌套类能使得代码结构更紧凑。
嵌套类增加了封装性
内部类和静态嵌套类的不同根源来自于static，最大区别在于访问外部类成员的权限。
1.静态嵌套类
static修饰符使得嵌套类对象成为外部类的静态成员，与外部类直接关联。
这样静态嵌套类作为一个静态成员，仅能访问外部类的静态成员，因为外部类中的非静态成员与外部类对象相关，静态嵌套类就不能访问他们，这使得静态嵌套类的功能变的很弱，可用之处很少。
另外因为静态嵌套类是依附于外部类而非外部类对象的，所以不同的外部类对象共享一个静态嵌套类，这一点与内部类不同，可以用来包装main方法。
静态嵌套类的声明示例:
OuterClass.StaticNestedClass nestedObject =
new OuterClass.StaticNestedClass();
没有static修饰意味着一个内部类是和外部类对象关联的，也可以说一个内部类对象存在于外部类对象中，是外部类对象的一个成员，因此内部类对象可以访问外部类对象的全部成员，包括私有成员。
因为内部类依赖于外部类对象而存在，所以不能定义任何静态成员。
内部类对象可以访问外部类的所有成员变量，包括私有成员，这是Java闭包的原理;
因为内部类隐含对外部类的引用，所以外部类就不能被JVM的垃圾回收机制自动垃圾回收。
不同的外部类对象之间没有公共的内部类对象成员。
内部类的声明示例:
OuterClass.InnerClass innerObject = new OuterObject().new InnerClass();
3.变量遮蔽Shadowing
嵌套类和封装类以及局部方法区的变量作用域有重叠，如果有同名变量将发生变量遮蔽。
public class ShadowTest {
public int x = 0;
class FirstLevel {
public int x = 1;
void methodInFirstLevel(int x) {
System.out.println("x ="+ x);
System.out.println("this.x ="+ this.x);
System.out.println("ShadowTest.this.x ="+ ShadowTest.this.x);
public static void main(String... args) {
ShadowTest st = new ShadowTest();
ShadowTest.FirstLevel fl = st.new FirstLevel();
fl.methodInFirstLevel(23);
注意这里对3种不同变量的引用方式,结果如下
x = 23 //1. 局部变量
this.x = 1 //2.内部类变量
ShadowTest.this.x = 0 //3.外部类变量
内部类中this指针指向内部类自己，ShadowTest.this则指向外部类对象;
不加修饰的变量，将执行就近匹配原则；如果名称相同将发生变量遮蔽效应；为了防止隐患，内部类引用外部类对象时应使用第三种方法。
PHP开发框架
开发工具/编程工具
服务器环境
ThinkSAAS商业授权：
ThinkSAAS为用户提供有偿个性定制开发服务
ThinkSAAS将为商业授权用户提供二次开发指导和技术支持
让ThinkSAAS更好，把建议拿来。
开发客服微信&Java入门：深入理解嵌套类和内部类
秒后自动跳转到登录页
(奖励5下载豆)
快捷登录：
举报类型：
不规范：上传重复资源
不规范：标题与实际内容不符
不规范：资源无法下载或使用
其他不规范行为
违规：资源涉及侵权
违规：含有危害国家安全等内容
违规：含有反动/色情等内容
违规：广告内容
详细原因：
任何违反下载中心规定的资源，欢迎Down友监督举报，第一举报人可获5-10下载豆奖励。
视频课程推荐
Java入门：深入理解嵌套类和内部类
上传时间：
技术分类：
资源评价：
（3位用户参与评价）
已被下载&25&次
Java入门：深入理解嵌套类和内部类，详细请下载查看。
本资料共包含以下附件：
Java入门：深入理解嵌套类和内部类.zip
51CTO下载中心常见问题：
1.如何获得下载豆？
1)上传资料
2)评论资料
3)每天在首页签到领取
4)购买VIP会员服务，无需下载豆下载资源
5)更多途径：点击此处
2.如何删除自己的资料？
下载资料意味着您已同意遵守以下协议：
1.资料的所有权益归上传用户所有
2.未经权益所有人同意，不得将资料中的内容挪作商业或盈利用途
3.51CTO下载中心仅提供资料交流平台，并不对任何资料负责
4.本站资料中如有侵权或不适当内容，请邮件与我们联系（）
5.本站不保证资源的准确性、安全性和完整性, 同时也不承担用户因使用这些资料对自己和他人造成任何形式的伤害或损失
下载1785次
下载1135次
下载1547次
下载1617次
下载1485次
相关专题推荐
本专题收录Java经典编程的实例源码，
在国内的开发语言中，java凭借这简单
本套视频教程是韩顺平老师，循序渐进
北京圣思园张龙（风中叶）老师的Java
讲述Arm嵌入式Linux系统下的C语言编程
这段视频是从尚学堂科技的教学课堂上
本套视频共78集，是由郝斌老师根据多
本视频专题共180集涵盖了C语言概述中
本视频专题共107集涵盖了Java概述、数
由传智播客毕向东老师讲解的Java基础
本专题为spring视频教程，共31集。教
本专题为C语言黑客编程系列视频教程，
本专题为韩顺平讲解的Java从入门到精
本专题为Java Web项目开发案例精粹视
SSH为struts+spring+hibernate的一个
本专题为疯狂Java李刚老师讲解的Stru
意见或建议：
联系方式：
您已提交成功！感谢您的宝贵意见，我们会尽快处理您现在的位置：&&&&&&&&&&&&文章内容
快捷导航：
Java入门:深入理解嵌套类和内部类
来源：考试大&&&【考试大：中国教育考试第一门户】&&&日
　　一、什么是嵌套类及内部类？　　可以在一个类的内部定义另一个类，这种类称为嵌套类（nested classes），它有两种类型：静态嵌套类和非静态嵌套类。静态嵌套类使用很少，最重要的是非静态嵌套类，也即是被称作为内部类（inner）。嵌套类从JDK1.1开始引入。其中inner类又可分为三种：　　其一、在一个类（外部类）中直接定义的内部类；　　其二、在一个方法（外部类的方法）中定义的内部类；　　其三、匿名内部类。　　下面，我将说明这几种嵌套类的使用及注意事项。　　二、静态嵌套类　　如下所示代码为定义一个静态嵌套类，　　public class StaticTest { 　　private static String name = "javaJohn";　　private String id = "X001";　　static class Person{　　private String address = "swjtu,chenDu,China";　　public String mail = "";//内部类公有成员　　public void display(){　　//System.out.println(id);//不能直接访问外部类的非静态成员　　System.out.println(name);//只能直接访问外部类的静态成员　　System.out.println("Inner "+address);//访问本内部类成员。　　}　　}　　public void printInfo(){　　Person person = new Person();　　person.display();　　//System.out.println(mail);//不可访问　　//System.out.println(address);//不可访问　　System.out.println(person.address);//可以访问内部类的私有成员　　System.out.println(person.mail);//可以访问内部类的公有成员　　　　}　　public static void main(String[] args) {　　StaticTest staticTest = new StaticTest();　　staticTest.printInfo();　　}　　}　　在静态嵌套类内部，不能访问外部类的非静态成员，这是由Java语法中"静态方法不能直接访问非静态成员"所限定。若想访问外部类的变量，必须通过其它方法解决，由于这个原因，静态嵌套类使用很少。注意，外部类访问内部类的的成员有些特别，不能直接访问，但可以通过内部类来访问，这是因为静态嵌套内的所有成员和方法默认为静态的了。同时注意，内部静态类Person只在类StaticTest 范围内可见，若在其它类中引用或初始化，均是错误的。　　三、在外部类中定义内部类　　如下所示代码为在外部类中定义两个内部类及它们的调用关系：　　public class Outer{ 　　int outer_x = 100;　　class Inner{　　public int y = 10;　　private int z = 9;　　int m = 5;　　public void display(){　　System.out.println("display outer_x:"+ outer_x);　　}　　private void display2(){　　System.out.println("display outer_x:"+ outer_x);　　}　　}　　void test(){　　Inner inner = new Inner();　　inner.display();　　inner.display2();　　//System.out.println("Inner y:" + y);//不能访问内部内变量　　System.out.println("Inner y:" + inner.y);//可以访问　　System.out.println("Inner z:" + inner.z);//可以访问　　System.out.println("Inner m:" + inner.m);//可以访问　　InnerTwo innerTwo = new InnerTwo();　　innerTwo.show();　　}　　class InnerTwo{　　Inner innerx = new Inner();　　public void show(){　　//System.out.println(y);//不可访问Innter的y成员　　//System.out.println(Inner.y);//不可直接访问Inner的任何成员和方法　　innerx.display();//可以访问　　innerx.display2();//可以访问　　System.out.println(innerx.y);//可以访问　　System.out.println(innerx.z);//可以访问　　System.out.println(innerx.m);//可以访问　　}　　}　　public static void main(String args[]){　　Outer outer = new Outer();　　outer.test();　　}　　}　　以上代码需要说明有，对于内部类，通常在定义类的class关键字前不加public 或 private等限制符，若加了没有任何影响，同时好像这些限定符对内部类的变量和方法也没有影响（？）。另外，就是要注意，内部类Inner及InnterTwo只在类Outer的作用域内是可知的，如果类Outer外的任何代码尝试初始化类Inner或使用它，编译就不会通过。同时，内部类的变量成员只在内部内内部可见，若外部类或同层次的内部类需要访问，需采用示例程序中的方法，不可直接访问内部类的变量。
来源:考试大-
责编:zj&&&
模板不存在，请添加模板后再生成！E:\wwwroot\www_233_com\Templets\three\Templets\soft\small\cont_b_st.htm
暂无跟贴,欢迎您发表意见
考试大Java认证评论排行
1.&&评论4条
2.&&评论2条
3.&&评论2条
4.&&评论2条
5.&&评论1条
6.&&评论1条
12345678910
12345678910
123456SCJP考试题310-025(第二套)19-50/1477SCJP考试题310-025(第二套)51-91/147
12345678910java 内部类 -
- ITeye技术网站
博客分类：
Java语言允许在类中再定义类，这种在其它类内部定义的类就叫内部类。内部类又分为：常规内部类、局部内部类、匿名内部类和静态嵌套类四种。我们内部类的知识在Android手机开发中经常用到。
一、常规内部类
所谓常规内部类，或者说内部类，指的就是除去后面三种之外的内部类（这算什么解释。。。）
先写一个最简单的内部类的例子，大家感觉一下：
public class Outer {
public class Inner{
编译一下，我们看到目录中出现了两个class文件，其中有一个文件名叫做Outer$Inner.class，带了一个$符号，这个特点让我们很容易的认出来这是内部类编译后的class文件。
再写一个稍微复杂一点的内部类：
public class Outer {
private int x=1;
public Outer(){
System.out.println("Outer initial");
public class Inner{
public Inner(){
System.out.println("Inner initial");
private int x=2;
void add(){
System.out.println(x);
System.out.println(this.x);
System.out.println(Outer.this.x);
public static void main(String[] args){
Inner inner = new Outer().new Inner();
inner.add();
我们编译以后，运行一下看看：
在上面的例子里我们可以清晰的看到：
内部类就像一个实例成员一样存在于外部类中。
内部类可以访问外部类的所有成员就想访问自己的成员一样没有限制。
内部类中的this指的是内部类的实例对象本身，如果要用外部类的实例对象就可以用类名.this的方式获得。
内部类对象中不能有静态成员，原因很简单，内部类的实例对象是外部类实例对象的一个成员。
下面我们再小结一下内部类的创建方法：
在外部类的内部，可以用 Inner inner = new Inner(); 方法直接创建
在外部类外部，必须先创建外部类实例，然后再创建内部类实例，除了上面 Inner inner = new Outer().new Inner()的写法以外，还有 Outer outer = new Outer(); Inner inner = outer.new Inner();的写法
二、局部内部类
我们也可以把类定义在方法内部，这时候我们称这个类叫局部内部类。
我们再看一个例子：
public class Outer {
public void doSomething(){
final int y=2;
class Inner{
void print(){
System.out.println(x);
System.out.println(this.x);
System.out.println(Outer.this.x);
System.out.println(y);
Inner inner = new Inner();
inner.print();
public static void main(String[] args){
Outer outer = new Outer();
outer.doSomething();
运行程序，查看结果：
我们通过上面这里例子也可以看到下面几点：
局部内部类的地位和方法内的局部变量的位置类似，因此不能修饰局部变量的修饰符也不能修饰局部内部类，譬如public、private、protected、static、transient等
局部内部类只能在声明的方法内是可见的，因此定义局部内部类之后，想用的话就要在方法内直接实例化，记住这里顺序不能反了，一定是要先声明后使用，否则编译器会说找不到。
局部内部类不能访问定义它的方法内的局部变量，除非这个变量被定义为final 。
是不是有点不好理解？关于为什么用final修饰以后就可以用了，我打算专门在番外篇里专门写一篇博客给你讲清楚，先记住吧。
三、匿名内部类
当我们把内部类的定义和声明写到一起时，就不用给这个类起个类名而是直接使用了，这种形式的内部类根本就没有类名，因此我们叫它匿名内部类。
我们再看一个有趣的例子：
public class Dog {
public interface Pet {
public void beFriendly();
public void play();
public static void main(String[] args){
Pet dog = new Pet(){
public void beFriendly() {
System.out.println("蹭蹭你^_^");
public void play() {
System.out.println("把飞盘叼给你，逼你把飞盘丢出去，然后它再捡回来让你继续扔，连续500次^_^");
dog.beFriendly();
dog.play();
编译和运行程序，查看结果：
竟然编译和运行都很正常，我们知道抽象类和接口肯定无法实例化的，因此刚才的例子肯定有点意思：
第一匿名内部类可以是个接口，这个没什么好奇怪的哈。
第12行到第21行是一个语句，就是定义了一个对象，因此21行大括号后面有个分号。
匿名内部类用 new Pet(){ … } 的方式把声明类的过程和创建类的实例的过程合二为一。
匿名内部类可以是某个类的继承子类也可以是某个接口的实现类。
好吧我们再看一个例子，方法参数内的匿名内部类：
public class Dog {
static abstract class Ball {
abstract String getName();
void play(Ball b){
System.out.println(b.getName());
public static void main(String[] args){
Dog dog = new Dog();
dog.play(new Ball(){
String getName() {
return "qiu qiu";
编译和运行以后的截图我就不给你了，返回值就是“qiu qiu”。
从第14行到第18行是一句话，就是执行一个play方法，而这个方法的参数就由一个匿名内部类的实例来提供。
四、静态嵌套类
为了让你感觉舒服一些，我们也把最简单的内部类放在最后讲。
当一个内部类前面用static修饰时，我们称之为静态嵌套类或者说静态内部类。
上面的例子里其实我们已经看到过静态嵌套类了，下面我们再举一个例子：
public class Outer {
static int x =1;
static class Nest {
void print(){
System.out.println("Nest "+x);
public static void main(String[] args){
Outer.Nest nest = new Outer.Nest();
nest.print();
因为静态嵌套类和其他静态方法一样只能访问其它静态的成员，而不能访问实例成员。因此静态嵌套类和外部类（封装类）之间的联系就很少了，他们之间可能也就是命名空间上的一些关联。上面例子中你需要注意的就是静态嵌套类的声明方法 new Outer.Nest() 连续写了两个类名，以至于我们都怀疑前面的Outer是个包名了，好在包名一般都小写的，要不还真分不清……
再强调一遍，内部类在Android中应用的非常多，理解和使用好显得蛮重要。好了，本讲就到这里。
如何应用Java的静态内部类
/oop/787330.html
在上一小节我们讨论了内部类，即在一个类中包含有另外一个或者多个类（见本书12.3.3小节）。与内部类相似，静态内部类指在一个类的内部包含有另外一个或者多个静态类。例如：
public class OuterClass {
static class StaticInnerClass1 {
//内部静态类
//只可以访问OuterClass的静态成员
//StaticInnerClass结束
static class StaticInnerClassN {
//更多静态内部类
//只可以访问OuterClass的静态成员
//StaticInnerClassN结束
//OuterClass结束
与一般内部类不同，在静态代码中不能够使用this操作，所以在静态内部类中只可以访问外部类的静态变量和静态方法。使用静态内部类的目的和使用内部类相同。如果一个内部类不依赖于其外部类的实例变量，或与实例变量无关，则选择应用静态内部类。
如下例子演示怎样使用静态内部类：
///完整程序存在本书配套资源目录Ch12名为StaticInnerClassTest.java
public class StaticInnerClassTest {
public static void main( String args[] ) {
OuterClass2 outer = new OuterClass2();
OuterClass2.StaticInnerClass.innerMethod();
//调用静态内部类的静态方法
OuterClass2.outerMethod();
//创建静态内部类对象
OuterClass2.StaticInnerClass staticInner = new OuterClass2.StaticInnerClass();
int num = staticInner.innerMethod2();
//调用静态内部类实例方法
class OuterClass2 {
private double x = 0.0;
//内部静态类不可以访问外部类实
static private int n = 10;
//外部类静态变量
static void outerMethod() {
//外部类静态方法
System.out.println("from OuterClass...");
void outerMethod2() {
System.out.println("from OuterClass’ instance method2()...");
static class StaticInnerClass {
//静态内部类
static private int m = 5;
//静态内部类静态变量
static void innerMethod() {
//静态内部类静态方法
//只可以访问外部类静态变量
System.out.println("from InnerClass sum = " + sum);
outerMethod();
//只可以调用外部类静态方法
int innerMethod2() {
outerMethod();
System.out.println("from InnerMethod2() n = " + n);
//静态内部类结束
//外部类结束
如同不用创建对象就可调用静态方法一样，上例静态内部类中的静态方法利用：
OuterClass2.StaticInnerClass.innerMethod(); //静态内部类调用其静态方法
来调用。注意，可以在静态内部类的方法中，直接访问外部类的静态变量n和调用静态方法outerMethod()。但不允许访问外部类的实例变量x以及实例方法outerMethod2()。
静态内部类中也可以提供实例方法，如：
static class StaticInnerClass {
int innerMethod2() {
//只可访问外部类静态变量
outerMethod();
//只可调用外部类静态方法
System.out.println("from InnerMethod2() n = " + n);
//静态内部类结束
静态内部类的实例方法中亦只允许访问外部类的静态成员。
可以使用下列语法格式创建一个静态内部类对象并且调用其实例方法，以及静态方法：
OuterClass2.StaticInnerClass staticInner = new OuterClass2.StaticInner Class();
//创建静态内部类对象
int num = staticInner.innerMethod2();
//调用实例方法
staticInner.innerMethod();
//调用其静态方法
package Chapter10;
public class StaticInternal {
private static String name = "\"聂庆亮\"";
public static void setStatic(String n) {
System.out.println("[现在访问的是外部类的静态方法!]");
static class InnerClass_2 {
String address,
long phoneN
static void getStatic() {
System.out.println("[访问外部类的静态变量] name = " + name);
setStatic("尹继平");
public void setString(String address, String mail) {
System.out.println("1.静态内部类的带String型参数的非静态主法");
this.address =
this.mail =
public void setInt(long phoneNum, int qq) {
System.out.println("2.静态内部类的带int型参数的非静态主法!");
this.phoneNum = phoneN
public void setValue() {
InnerClass_2.getStatic();
InnerClass_2 inner = new InnerClass_2();
inner.setString("北京昌平区沙河镇", "");
inner.setInt(, );
System.out.println("\n外部类访问静态内部类的结果如下：");
System.out.println("姓名：" + this.name);
System.out.println("住址：" + inner.address);
System.out.println("联系电话" + inner.phoneNum);
System.out.println("E-mail：" + inner.mail);
System.out.println("QQ号码：" + inner.qq);
public static void main(String[] args) {
StaticInternal sin = new StaticInternal();
sin.setValue();
Java内部类与静态内部类
定义在一个类内部的类叫内部类，包含内部类的类称为外部类。内部类可以声明public、protected、private等访问限制，可以声明为abstract的供其他内部类或外部类继承与扩展，或者声明为static、final的，也可以实现特定的接口。外部类按常规的类访问方式使用内部类，唯一的差别是外部类可以访问内部类的所有方法与属性，包括私有方法与属性。
(1)创建实例
OutClass.InnerClass obj = outClassInstance.new InnerClass(); //注意是外部类实例.new，内部类
AAA.StaticInner in = new AAA.StaticInner();//注意是外部类本身，静态内部类
(2)内部类中的this
内部类中的this与其他类一样是指的本身。创建内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件，可理解为内部类链接到外部类。 用外部类创建内部类对象时，此内部类对象会秘密的捕获一个指向外部类的引用，于是，可以通过这个引用来访问外围类的成员。
(3)外部类访问内部类
内部类类似外部类的属性，因此访问内部类对象时总是需要一个创建好的外部类对象。内部类对象通过‘外部类名.this.xxx’的形式访问外部类的属性与方法。如：System.out.println("Print in inner Outer.index=" + pouter.this.index);System.out.println("Print in inner Inner.index=" + this.index);
（4）内部类向上转型
内部类也可以和普通类一样拥有向上转型的特性。将内部类向上转型为基类型，尤其是接口时，内部类就有了用武之地。如果内部类是private的，只可以被它的外部类问，从而完全隐藏实现的细节。
（5）方法内的类
方法内创建的类（注意方法中也能定义类），不能加访问修饰符。另外，方法内部的类也不是在调用方法时才会创建的，它们一样也被事先编译了。
（6）静态内部类
定义静态内部类：在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。
通常称为嵌套类，当内部类是static时，意味着：
[1]要创建嵌套类的对象，并不需要其外围类的对象；
[2]不能从嵌套类的对象中访问非静态的外围类对象（不能够从静态内部类的对象中访问外部类的非静态成员）；
嵌套类与普通的内部类还有一个区别：普通内部类的字段的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有static数据和static字段，也不能包含嵌套类。但是在嵌套类里可以包含所有这些东西。也就是说，在非静态内部类中不可以声明静态成员，只有将某个内部类修饰为静态类，然后才能够在这个类中定义静态的成员变量与成员方法。
另外，在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。普通非静态内部类的对象是依附在外部类对象之中的，要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。静态类和方法只属于类本身，并不属于该类的对象，更不属于其他外部类的对象。
（7）内部类标识符
每个类会产生一个.class文件，文件名即为类名。同样，内部类也会产生这么一个.class文件，但是它的名称却不是内部类的类名，而是有着严格的限制：外围类的名字，加上$,再加上内部类名字。
（8）为何要用内部类？
1. 内部类一般只为其外部类使用；
2. 内部类提供了某种进入外部类的窗户；
3. 也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外部类是否已经继承了某个接口。因此，内部类使多重继承的解决方案变得更加完整。
talentluke
浏览: 268283 次
来自: 深圳
core Java中有一段：Vector类对自己的所有可修改方 ...
基本上明白了.但执行顺是否应该是/etc/profile -& ...
各自有各自的场景吧楼主不要太激进了
写的不错，赞一个
楼主善于思考这点是很不错的. 点赞.最近在面试的时候我遇到了让 ...面试题（35）
内部类是类中类（内部类不为同一包的其他类可见，具有很好的封装性），分为静态内部类，成员内部类，局部内部类以及匿名内部类；局部内部类写在方法里面；用到最多的就是匿名内部类，例子如下：
首先定义一个接口：Interface A{ public void method();}
然后 A a = new A(){public void method{ System.out.println(&hehe!&);}}
上面表达式等号右边就是一个匿名内部类，事实上它是一个没有名称的接口A的实现类。
1. 静态的内部类称为嵌套类，嵌套类不能直接引用外部类的non-static属性和方法，创建嵌套类对象时不依赖外部类对象；
2. 静态内部类没有了指向外部的引用，和C++的嵌套类很相像了，Java内部类和C++嵌套类最大的不用在于是否具有指向外部引用这点；
3. 在任何非静态内部类中，都不能有静态数据、静态方法或者又一个静态内部类（也就是不止一层），然后静态内部类可以拥有这一切。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：19063次
排名：千里之外
原创：58篇