热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

Java成员内部类不能含有static成员(汇总)

文章目录1、为什么内部类中有static成员时内部类也必须声明为static2、JVM的类加载规则:3、成员内部类中为什么不能有静态方法和属性4、静态内部类(publ

文章目录

    • 1、为什么内部类中有static成员时内部类也必须声明为static
    • 2、JVM的类加载规则 :
    • 3、成员内部类中为什么不能有静态方法和属性
    • 4、静态内部类(public static class)和普通内部类(public class)的区别
    • 5、Java中普通内部类为何不能有static属性 却可以有常量
    • 6、java内部类有什么好处?为什么需要内部类?
      • 静态内部类
      • 局部内部类
      • 匿名内部类
    • 7、Java静态内部类(static class)


1、为什么内部类中有static成员时内部类也必须声明为static

        如果A和B类关系紧密,且A类的主要作用是帮助完成B类的实现,这时可将A类作为B类的内部类,两个类可以互相访问各自的私有成员,这样就方便B类的设计,使B类更加自给自足(self contained)。http://www.tanhuanyao.com http:// tanhuanyao.com http://www.bianshayao.com/ http://bianshayao.com/这是我理解的内部类产生的原因,有点类似于C++中的友元类 A类作为B类的内部类,便是B类的一份子,地位上和B类的属性和方法相当,此时A类便有static和非static之分了,这就是为什么只有内部类的类本身才有static的说法的原因。内部类声明为static和普通类的成员为static的含义一样,都是表示被声明为static的东西属于类范畴,不依赖于类的具体对象。如果内部类是非static的,那么这个内部类就依赖于外部类的具体对象,在该内部类中可以调用外部类的非static方法;如果内部类是static的,即该内部类属于外部类的类范畴,不依赖于外部类的具体对象,那么该内部类只能调用外部类的static方法,因为外部类的非static方法依赖于外部类的具体对象。这和普通类中static方法只能访问static的属性和方法的道理是一样的。那么为什么规定内部类中如果出现了static方法,该内部类也必须声明为static呢? 内部类中的static方法表明该方法不依赖于内部类的具体对象,属于内部类的类范畴,假设此时内部类为非static的,那么内部类对象的产生就依赖于外部类对象,有一个外部类对象,才能有一个与之对应的内部类对象,而内部类对象中的static方法不依赖于内部类对象,所以使用该static方法便没有必要创建具体的内部类对象,如果该static方法确有其存在的意义,那就说明该内部类完全没有必要是非static的,java规定这时该内部类必须是static的。

2、JVM的类加载规则 :


  1. static类型的属性和方法,在类加载的时候就会存在于内存中。
  2. 要想使用某个类的static属性和方法,那么这个类必须要加载到JAVA虚拟机中。
  3. 非静态内部类并不随外部类一起加载,只有在实例化外部类之后才会加载。现在考虑这个情况:在外部类并没有实例化,内部类还没有加载,这时候如果调用内部类的静态成员或方法,内部类还没有加载,试图在内存中创建该内部类的静态成员,这明显是矛盾的。所以非静态内部类不能有静态成员变量或静态方法。假设 :在外部类并没有实例化,内部类还没有加载,这时候如果JVM加载静 态成员或方法,内部类还没有加载,因为非静态内部类的加载依赖于实化,而此时却试图在内存中创建该内部类的静态成员,这明显是矛盾的。所以非静态内部类不能有静态成员变量或静态方法。

3、成员内部类中为什么不能有静态方法和属性

非静态内部类不能有静态成员!

成员内部类必须先实例化外部类对象然后再实例化成员内部类;

非static的内部类,在外部类加载的时候,并不会加载它,所以它里面不能有静态变量或者静态方法。

  1. static类型的属性和方法,在类加载的时候就会存在于内存中。
  2. 要使用某个类的static属性或者方法,那么这个类必须要加载到jvm中。
    基于以上两点,可以看出,如果一个非static的内部类如果具有static的属性或者方法,那么就会出现一种情况:内部类未加载,但是却试图在内存中创建static的属性和方法,这当然是错误的。原因:类还不存在,但却希望操作它的属性和方法。

java很多想这类不能共同存在的 一般都与他们的生命周期有关。。。
比如 静态成员和静态方法是随着类的加载而存在的,也就是说内部类的静态属性是随着类的加载的,但是内部类的实例 是创建后才存在的,也就是说其静态属性优先存在于他的类实例的存在 这显然是矛盾的,所以要把内部类设为静态的 这样他们的生命周期就是相同了;

如果内部类没有static的话,就需要实例化内部类才能调用,说明非static的内部类不是自动跟随主类加载的,而是被实例化的时候才会加载。
而static的语义,就是主类能直接通过内部类名来访问内部类中的static方法,而非static的内部类又是不会自动加载的,所以这时候内部类也要static,否则会前后冲突。

4、静态内部类(public static class)和普通内部类(public class)的区别

java中普通的顶级类是不能使用static关键字修饰的。

只有内部类可以使用static修饰,或者不使用staitc关键字修饰。

// 顶层类A不能用static修饰
public class A{// 普通内部类B, 可以不用static修饰public class B{ }// 普通内部类C, 也可以用static修饰public static class C{ }}

1、静态内部类(static修饰的内部类)没有对外部类的引用,所以静态内部类只能访问外部类的静态属性或方法。并且在初始化的时候可以单独存在,例如:

StaticClass staticClass = new StaticClass();

或者:

Users.StaticClass staticClass2 = new Users.StaticClass()

二种方式初始化,建议使用第二种初始化方法,比较清晰。

2、普通内部类有对外部类的引用,所以普通内部类不能独立存在,初始化的时候必须通过外部类的实例。

并且普通内部类可以直接访问外部类的普通属性和函数(包括私有的属性和函数)同时也能访问外部类的静态属性和函数。

普通内部类的实例化如下:

Users.CommonClass commonClass = new Users().new CommonClass();

或者:

Users users = new Users();

Users.CommonClass commonClass2 = users.new CommonClass();

5、Java中普通内部类为何不能有static属性 却可以有常量

public class Outer{int x;class Inner{static int a = 0;//这样写是不合法的.static final int b=0;//这样写是合法的}
}

java类加载顺序,首先加载类,执行static变量初始化,接下来执行对象的创建,如果我们要执行代码中的变量int a 初始化,那么必须先执行加载外部类,再加载内部类,最后初始化静态变量 a ,问题就出在加载内部类上面,我们可以把内部类看成外部类的非静态成员,它的初始化必须在外部类对象创建后以后进行,要加载内部类必须在实例化外部类之后完成 ,java虚拟机要求所有的静态变量必须在对象创建之前完成, 这样便产生了矛盾。

将class Inner看作外部类的非静态成员,它属于对象Outer(即new 出来的Outer()),static int a 属于类Inner 所以先于对象Inner Outer创建出来,矛盾

而java常量放在内存中常量池,它的机制与变量是不同的,编译时,加载常量是不需要加载类的,所以就没有上面那种矛盾。

静态的东西需要在编译时分配内存,而非静态内部类是在实例化的时候才分配内存。所以现在的情况就是有了东西没地方放 static int a 没地方放,因为class Inner还没有实例化

6、java内部类有什么好处?为什么需要内部类?

提起Java内部类(Inner Class)可能很多人不太熟悉,实际上类似的概念在C++里也有,那就是嵌套类(Nested Class),关于这两者的区别与联系,在下文中会有对比。内部类从表面上看,就是在类中又定义了一个类(下文会看到,内部类可以在很多地方定义),而实际上并没有那么简单,乍看上去内部类似乎有些多余,它的用处对于初学者来说可能并不是那么显著,但是随着对它的深入了解,你会发现Java的设计者在内部类身上的确是用心良苦。学会使用内部类,是掌握Java高级编程的一部分,它可以让你更优雅地设计你的程序结构。下面从以下几个方面来介绍:

public interface Contents {int value();
}
public interface Destination {String readLabel();
}
public class Goods {private class Content implements Contents {private int i = 11;public int value() {return i;}}protected class GDestination implements Destination {private String label;private GDestination(String whereTo) {label = whereTo;}public String readLabel() {return label;}}public Destination dest(String s) {return new GDestination(s);}public Contents cont() {return new Content();}
}
class TestGoods {public static void main(String[] args) {Goods p = new Goods();Contents c = p.cont();Destination d = p.dest("Beijing");}
}

在这个例子里类Content和GDestination被定义在了类Goods内部,并且分别有着protected和private修饰符来控制访问级别。Content代表着Goods的内容,而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。在后面的main方法里,直接用 Contents c和Destination d进行操作,你甚至连这两个内部类的名字都没有看见!这样,内部类的第一个好处就体现出来了 隐藏你不想让别人知道的操作,也即封装性
同时,我们也发现了在外部类作用范围之外得到内部类对象的第一个方法,那就是利用其外部类的方法创建并返回。上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢?当然有,其语法格式如下:
outerObject=new outerClass(Constructor Parameters);
outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);
注意在创建非静态内部类对象时,一定要先创建起相应的外部类对象。至于原因,也就引出了我们下一个话题 非静态内部类对象有着指向其外部类对象的引用,对刚才的例子稍作修改:

public class Goods {private int valueRate = 2;private class Content implements Contents {private int i = 11 * valueRate;public int value() {return i;}}protected class GDestination implements Destination {private String label;private GDestination(String whereTo) {label = whereTo;}public String readLabel() {return label;}}public Destination dest(String s) {return new GDestination(s);}public Contents cont() {return new Content();}
}

在这里我们给Goods类增加了一个private成员变量valueRate,意义是货物的价值系数,在内部类Content的方法value()计算价值时把它乘上。我们发现,value()可以访问valueRate,这也是内部类的第二个好处 一个内部类对象可以访问创建它的外部类对象的内容,甚至包括私有变量!这是一个非常有用的特性,为我们在设计时提供了更多的思路和捷径。要想实现这个功能,内部类对象就必须有指向外部类对象的引用。Java编译器在创建内部类对象时,隐式的把其外部类对象的引用也传了进去并一直保存着。这样就使得内部类对象始终可以访问其外部类对象,同时这也是为什么在外部类作用范围之外向要创建内部类对象必须先创建其外部类对象的原因。
有人会问,如果内部类里的一个成员变量与外部类的一个成员变量同名,也即外部类的同名成员变量被屏蔽了,怎么办?没事,Java里用如下格式表达外部类的引用:
outerClass.this
有了它,我们就不怕这种屏蔽的情况了。

静态内部类

和普通的类一样,内部类也可以有静态的。不过和非静态内部类相比, 区别就在于静态内部类没有了指向外部的引用。

这实际上和C++中的嵌套类很相像了,Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上,当然从设计的角度以及以它一些细节来讲还有区别。
除此之外,在任何非静态内部类中,都不能有静态数据,静态方法或者又一个静态内部类(内部类的嵌套可以不止一层)。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。

局部内部类

是的,Java内部类也可以是局部的,它可以定义在一个方法甚至一个代码块之内。

public class Goods1 {public Destination dest(String s) {class GDestination implements Destination {private String label;private GDestination(String whereTo) {label = whereTo;}public String readLabel() {return label;}}return new GDestination(s);}public static void main(String[] args) {Goods1 g = new Goods1();Destination d = g.dest("Beijing");}
}

上面就是这样一个例子。在方法dest中我们定义了一个内部类,最后由这个方法返回这个内部类的对象。如果我们在用一个内部类的时候仅需要创建它的一个对象并创给外部,就可以这样做。当然,定义在方法中的内部类可以使设计多样化,用途绝不仅仅在这一点。
下面有一个更怪的例子:

public class Goods2 {private void internalTracking(boolean b) {if (b) {class TrackingSlip {private String id;TrackingSlip(String s) {id = s;}String getSlip() {return id;}}TrackingSlip ts = new TrackingSlip("slip");String s = ts.getSlip();}}public void track() {internalTracking(true);}public static void main(String[] args) {Goods2 g = new Goods2();g.track();}
}

你不能在if之外创建这个内部类的对象,因为这已经超出了它的作用域。不过在编译的时候,内部类TrackingSlip和其他类一样同时被编译,只不过它由它自己的作用域,超出了这个范围就无效,除此之外它和其他内部类并没有区别。

匿名内部类

java的匿名内部类的语法规则看上去有些古怪,不过如同匿名数组一样,当你只需要创建一个类的对象而且用不上它的名字时,使用内部类可以使代码看上去简洁清楚。它的语法规则是这样的:
new interfacename(){…}; 或 new superclassname(){…};
下面接着前面继续举例子:

public class Goods3 {public Contents cont() {return new Contents() {private int i = 11;public int value() {return i;}};}
}

这里方法cont()使用匿名内部类直接返回了一个实现了接口Contents的类的对象,看上去的确十分简洁。
在java的事件处理的匿名适配器中,匿名内部类被大量的使用。例如在想关闭窗口时加上这样一句代码:

frame.addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){System.exit(0);}
});

有一点需要注意的是,匿名内部类由于没有名字,所以它没有构造函数(但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类,创建它的时候必须带上这些参数,并在实现的过程中使用super关键字调用相应的内容)。如果你想要初始化它的成员变量,有下面几种方法:
如果是在一个方法的匿名内部类,可以利用这个方法传进你想要的参数,不过记住, 这些参数必须被声明为final 。

将匿名内部类改造成有名字的局部内部类,这样它就可以拥有构造函数了。
在这个匿名内部类中使用初始化代码块。
为什么需要内部类?
java内部类有什么好处?为什么需要内部类?
首先举一个简单的例子,如果你想实现一个接口,但是这个接口中的一个方法和你构想的这个类中的一个方法的名称,参数相同,你应该怎么办?这时候,你可以建一个内部类实现这个接口。由于内部类对外部类的所有内容都是可访问的,所以这样做可以完成所有你直接实现这个接口的功能。
不过你可能要质疑,更改一下方法的不就行了吗?
的确,以此作为设计内部类的理由,实在没有说服力。
真正的原因是这样的,java中的内部类和接口加在一起,可以的解决常被C++程序员抱怨java中存在的一个问题 没有多继承。实际上,C++的多继承设计起来很复杂,而java通过内部类加上接口,可以很好的实现多继承的效果。

7、Java静态内部类(static class)

在一个类中创建另外一个类,叫做成员内部类。这个成员内部类可以静态的(利用static关键字修饰),也可以是非静态的。

一、静态内部类的使用目的。

在定义内部类的时候,在其前面加上一个权限修饰符static。这个内部类就变为了静态内部类。如在进行代码程序测试的时候,如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序的入口,必须具有),那么会出现很多额外的代码。而且最主要的是这段主程序的代码对于Java文件来说,只是一个形式,其本身并不需要这种主方法。但是少了这个主方法又是万万不行的。在这种情况下,就可以将主方法写入到静态内部类中,从而不用为每个Java源文件都设置一个类似的主方法。这对于代码测试是非常有用的。在一些中大型的应用程序开发中,则是一个常用的技术手段。

二、静态内部类的使用限制

将某个内部类定义为静态类,跟将其他类定义为静态类的方法基本相同,引用规则也基本一致。不过其细节方面仍然有很大的不同。具体来说,主要有如下几个地方要引起各位程序开发人员的注意。

一是静态成员(包括静态变量与静态成员)的定义。

在非静态内部类中不可以声明静态成员。如现在在一个student类中定义了一个内部类Age,如果没有将这个类利用static关键字修饰,即没有定义为静态类,那么在这个内部类中如果要利用static关键字来修饰某个成员方法或者成员变量是不允许的。在编译的时候就通不过。故程序开发人员需要注意,只有静态内部类才能够定义静态的成员变量与成员方法。

二是在成员的引用上,有比较大的限制。

一般的非静态内部类,可以随意的访问外部类中的成员变量与成员方法。即使这些成员方法被修饰为private(私有的成员变量或者方法)。因为在其他类中是无法访问被定义为私有的成员变量或方法。但是如果一个内部类被定义为静态的,那么在引用外部类的成员方法或者成员变量的时候,就会有诸多的限制。如不能够从静态内部类的对象中访问外部类的非静态成员(包括成员变量与成员方法)。这是什么意思呢?如果在外部类中定义了两个变量,一个是非静态的变量,一个是静态的变量。静态内部类只能引用外部类中的静态的成员(变量或方法),而不能够访问非静态的变量。对于那些非静态的成员变量与成员方法,在静态内部类中是无法访问的。这就是静态内部类的最大使用限制。在普通的非静态内部类中是没有这个限制的。也正是这个原因,决定了静态内部类只应用在一些特定的场合。其应用范围远远没有像非静态的内部类那样广泛。

三是在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。

通常情况下,在一个类中创建成员内部类的时候,有一个强制性的规定,即内部类的实例一定要绑定在外部类的实例中。也就是说,在创建内部类之前要先在外部类中要利用new关键字来创建这个内部类的对象。如此的话如果从外部类中初始化一个内部类对象,那么内部类对象就会绑定在外部类对象上。也就是说,普通非静态内部类的对象是依附在外部类对象之中的。通常情况下,程序员在定义静态内部类的时候,是不需要定义绑定在外部类的实例上的。也就是说,要在一个外部类中定义一个静态的内部类,不需要利用关键字new来创建内部类的实例。

从以上的分析中可以看出,静态内部类与非静态的内部类还是有很大的不同的。一般程序开发人员可以这么理解,非静态的内部类对象隐式地在外部类中保存了一个引用,指向创建它的外部类对象。

牢记两个差别:

一、如是否可以创建静态的成员方法与成员变量(静态内部类可以创建静态的成员,而非静态的内部类不可以)

二、对于访问外部类的成员的限制(静态内部类只可以访问外部类中的静态成员变量与成员方法,而非静态的内部类即可以访问所有的外部类成员方法与成员变量)。

这两个差异是静态内部类与非静态外部类最大的差异,也是静态内部类之所以存在的原因。了解了这个差异之后,程序开发人员还需要知道,在什么情况下该使用静态内部类。如在程序测试的时候,为了避免在各个Java源文件中书写主方法的代码,可以将主方法写入到静态内部类中,以减少代码的书写量,让代码更加的简洁。

总 之,静态内部类在Java语言中是一个很特殊的类,跟普通的静态类以及非静态的内部类都有很大的差异。作为程序开发人员,必须要知道他们之间的差异,并在 实际工作中在合适的地方采用合适的类。不过总的来说,静态内部类的使用频率并不是很高。但是在有一些场合,如果没有这个内部静态类的话,可能会起到事倍功半的反面效果。

非静态内部类实例:

package common.lang;public class Student {private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}public class Child{private String name1;private int age1;public String getName1() {return name1;}public void setName1(String name1) {this.name1 = name1;}public int getAge1() {System.out.println(age);return age1;}public void setAge1(int age1) {this.age1 = age1;}}public static void main(String[] args) {Student s = new Student();s.setAge(12);s.setName("yao");Child c = s.new Child();System.out.println(c.getAge1());}
}

静态内部类实例:

package common.lang;public class Student {private String name;private static int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public static int getAge() {return age;}public static void setAge(int age) {Student.age = age;}public static class Child{private String name1;private int age1;public String getName1() {return name1;}public void setName1(String name1) {this.name1 = name1;}public int getAge1() {System.out.println(age);return age1;}public void setAge1(int age1) {this.age1 = age1;}}public static void main(String[] args) {Student s = new Student();Child c = new Child();}
}


推荐阅读
  • 本文介绍了Perl的测试框架Test::Base,它是一个数据驱动的测试框架,可以自动进行单元测试,省去手工编写测试程序的麻烦。与Test::More完全兼容,使用方法简单。以plural函数为例,展示了Test::Base的使用方法。 ... [详细]
  • Nginx使用(server参数配置)
    本文介绍了Nginx的使用,重点讲解了server参数配置,包括端口号、主机名、根目录等内容。同时,还介绍了Nginx的反向代理功能。 ... [详细]
  • 拥抱Android Design Support Library新变化(导航视图、悬浮ActionBar)
    转载请注明明桑AndroidAndroid5.0Loollipop作为Android最重要的版本之一,为我们带来了全新的界面风格和设计语言。看起来很受欢迎࿰ ... [详细]
  • 微软头条实习生分享深度学习自学指南
    本文介绍了一位微软头条实习生自学深度学习的经验分享,包括学习资源推荐、重要基础知识的学习要点等。作者强调了学好Python和数学基础的重要性,并提供了一些建议。 ... [详细]
  • 本文分享了一个关于在C#中使用异步代码的问题,作者在控制台中运行时代码正常工作,但在Windows窗体中却无法正常工作。作者尝试搜索局域网上的主机,但在窗体中计数器没有减少。文章提供了相关的代码和解决思路。 ... [详细]
  • android listview OnItemClickListener失效原因
    最近在做listview时发现OnItemClickListener失效的问题,经过查找发现是因为button的原因。不仅listitem中存在button会影响OnItemClickListener事件的失效,还会导致单击后listview每个item的背景改变,使得item中的所有有关焦点的事件都失效。本文给出了一个范例来说明这种情况,并提供了解决方法。 ... [详细]
  • 本文介绍了Redis的基础数据结构string的应用场景,并以面试的形式进行问答讲解,帮助读者更好地理解和应用Redis。同时,描述了一位面试者的心理状态和面试官的行为。 ... [详细]
  • Java容器中的compareto方法排序原理解析
    本文从源码解析Java容器中的compareto方法的排序原理,讲解了在使用数组存储数据时的限制以及存储效率的问题。同时提到了Redis的五大数据结构和list、set等知识点,回忆了作者大学时代的Java学习经历。文章以作者做的思维导图作为目录,展示了整个讲解过程。 ... [详细]
  • 本文介绍了C++中省略号类型和参数个数不确定函数参数的使用方法,并提供了一个范例。通过宏定义的方式,可以方便地处理不定参数的情况。文章中给出了具体的代码实现,并对代码进行了解释和说明。这对于需要处理不定参数的情况的程序员来说,是一个很有用的参考资料。 ... [详细]
  • 如何用UE4制作2D游戏文档——计算篇
    篇首语:本文由编程笔记#小编为大家整理,主要介绍了如何用UE4制作2D游戏文档——计算篇相关的知识,希望对你有一定的参考价值。 ... [详细]
  • 计算机存储系统的层次结构及其优势
    本文介绍了计算机存储系统的层次结构,包括高速缓存、主存储器和辅助存储器三个层次。通过分层存储数据可以提高程序的执行效率。计算机存储系统的层次结构将各种不同存储容量、存取速度和价格的存储器有机组合成整体,形成可寻址存储空间比主存储器空间大得多的存储整体。由于辅助存储器容量大、价格低,使得整体存储系统的平均价格降低。同时,高速缓存的存取速度可以和CPU的工作速度相匹配,进一步提高程序执行效率。 ... [详细]
  • 本文介绍了计算机网络的定义和通信流程,包括客户端编译文件、二进制转换、三层路由设备等。同时,还介绍了计算机网络中常用的关键词,如MAC地址和IP地址。 ... [详细]
  • 本文介绍了作者在开发过程中遇到的问题,即播放框架内容安全策略设置不起作用的错误。作者通过使用编译时依赖注入的方式解决了这个问题,并分享了解决方案。文章详细描述了问题的出现情况、错误输出内容以及解决方案的具体步骤。如果你也遇到了类似的问题,本文可能对你有一定的参考价值。 ... [详细]
  • 本文探讨了C语言中指针的应用与价值,指针在C语言中具有灵活性和可变性,通过指针可以操作系统内存和控制外部I/O端口。文章介绍了指针变量和指针的指向变量的含义和用法,以及判断变量数据类型和指向变量或成员变量的类型的方法。还讨论了指针访问数组元素和下标法数组元素的等价关系,以及指针作为函数参数可以改变主调函数变量的值的特点。此外,文章还提到了指针在动态存储分配、链表创建和相关操作中的应用,以及类成员指针与外部变量的区分方法。通过本文的阐述,读者可以更好地理解和应用C语言中的指针。 ... [详细]
  • 从零学Java(10)之方法详解,喷打野你真的没我6!
    本文介绍了从零学Java系列中的第10篇文章,详解了Java中的方法。同时讨论了打野过程中喷打野的影响,以及金色打野刀对经济的增加和线上队友经济的影响。指出喷打野会导致线上经济的消减和影响队伍的团结。 ... [详细]
author-avatar
feng2502863897
这个家伙很懒,什么也没留下!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有