个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
25
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章java反射超详细讲解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.
java反射机制是在程序的运行过程中，对于任何一个类，都能够知道它的所有属性和方法；对于任意一个对象，都能够知道它的任意属性和方法，这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制.
java反射机制主要提供以下这几个功能:
class类，class类也是一个实实在在的类，存在于jdk的java.lang包中。class类的实例表示java应用运行时的类(class ans enum)或接口(interface and annotation)（每个java类运行时都在jvm里表现为一个class对象，可通过类名.class、类型.getclass()、class.forname("类名")等方法获取class对象）。数组同样也被映射为为class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 class 对象。基本类型boolean，byte，char，short，int，long，float，double和关键字void同样表现为 class 对象.
到这我们也就可以得出以下几点信息:
1.类加载机制流程 。
2.类的加载 。
注：详细的类加载内容，看jvm板块.
在类加载的时候，jvm会创建一个class对象。class对象可以说是反射中最常见的.
获取class对象的方式的主要三种:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public
class
demo1main1 {
public
static
void
main(string[] args)
throws
exception {
//获取class对象的三种对象
system.out.println(
"根据类名：\t"
+ user.
class
);
system.out.println(
"根据对象：\t"
+
new
user().getclass());
system.out.println(
"根据全限定类名：\t"
+
class
.forname(
"demo1.user"
));
//常用的方法
class
<user> userclass = user.
class
;
system.out.println(
"获取全限定类名：\t"
+ userclass.getname());
system.out.println(
"获取类名：\t"
+ userclass.getsimplename());
system.out.println(
"实例化：\t"
+ userclass.newinstance());
}
}
|
输出结果:
|
1
2
3
4
5
6
|
根据类名：
class
demo1.user
根据对象：
class
demo1.user
根据全限定类名：
class
demo1.user
获取全限定类名： demo1.user
获取类名： user
实例化： user{name=
'init'
, age=
0
}
|
再来看看class类的方法:
tosting()|
1
2
3
4
|
public
string tostring() {
return
(isinterface() ?
"interface "
: (isprimitive() ?
""
:
"class "
))
+ getname();
}
|
tostring()方法能够将对象转换为字符串，tostring()首先判断class类型是否是接口类型，也就是说普通类和接口都能用class对象表示，然后在判断是否是基本数据类型，这里判断的都是基本数据类型和包装类，还有void类型.
getname()获取类的全限定名称。（包括包名）即类的完整名称.
1.如果是引用类型。比如 string.class.getname()→java.lang.string 。
2.如果是基本数据类型。比如 byte.class.getname()→byte 。
3.如果是数组类型。比如 new object[3].getclass().getname()→[ljava.lang.object,
getsimplename()获取类名（不包括包名）.
getcanonicalname()获取全限定的类名(包括包名).
togenericstring()返回类的全限定名称，而且包括类的修饰符和类型参数信息.
forname()根据类名获得一个class对象的引用，这个方法会使类对象进行初始化.
例如：class t = class.forname("java.lang.thread")就能够初始化一个thread线程对象.
在java中，一共有三种获取类实例的方式:
1.class.forname(java.lang.thread) 。
2.thread.class 。
3.thread.getclass() 。
newinstance()创建一个类的实例，代表着这个类的对象。上面forname()方法对类进行初始化，newinstance方法对类进行实例化。使用该方法创建的类，必须带有无参的构造器.
getclassloader()获取类加载器对象.
getinterfaces()获取当前类实现的类或是接口，可能是多个，所以返回的是class数组.
isinterface()判断class对象是否是表示一个接口.
getfields()获得某个类的所有的公共（public）的字段，包括继承自父类的所有公共字段。 类似的还有getmethods和getconstructors.
getdeclaredfields获得某个类的自己声明的字段，即包括public、private和proteced，默认但是不包括父类声明的任何字段。类似的还有getdeclaredmethods和getdeclaredconstructors.
getname、getcanonicalname与getsimplename的区别:
getsimplename：只获取类名.getname：类的全限定名，jvm中class的表示，可以用于动态加载class对象，例如class.forname。getcanonicalname：返回更容易理解的表示，主要用于输出（tostring）或log打印，大多数情况下和getname一样，但是在内部类、数组等类型的表示形式就不同了。例子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
package
com.cry;
public
class
test {
private
class
inner{
}
public
static
void
main(string[] args)
throws
classnotfoundexception {
//普通类
system.out.println(test.
class
.getsimplename());
//test
system.out.println(test.
class
.getname());
//com.cry.test
system.out.println(test.
class
.getcanonicalname());
//com.cry.test
//内部类
system.out.println(inner.
class
.getsimplename());
//inner
system.out.println(inner.
class
.getname());
//com.cry.test$inner
system.out.println(inner.
class
.getcanonicalname());
//com.cry.test.inner
//数组
system.out.println(args.getclass().getsimplename());
//string[]
system.out.println(args.getclass().getname());
//[ljava.lang.string;
system.out.println(args.getclass().getcanonicalname());
//java.lang.string[]
//我们不能用getcanonicalname去加载类对象，必须用getname
//class.forname(inner.class.getcanonicalname()); 报错
class
.forname(inner.
class
.getname());
}
}
|
constructor类存在于反射包(java.lang.reflect)中，反映的是class 对象所表示的类的构造方法.
获取constructor对象是通过class类中的方法获取的，class类与constructor相关的主要方法如下:
。
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| constructor | getconstructor(class<?>… parametertypes) | 返回指定参数类型、具有public访问权限的构造函数对象 |
| constructor<?>[] | getconstructors() | 返回所有具有public访问权限的构造函数的constructor对象数组 |
| constructor | getdeclaredconstructor(class<?>… parametertypes) | 返回指定参数类型、所有声明的（包括private）构造函数对象 |
| constructor<?>[] | getdeclaredconstructors() | 返回所有声明的（包括private）构造函数对象 |
| t | newinstance() | 调用无参构造器创建此 class 对象所表示的类的一个新实例。 |
。
栗子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
|
public
class
constructiontest
implements
serializable {
public
static
void
main(string[] args)
throws
exception {
class
<?> clazz =
null
;
//获取class对象的引用
clazz =
class
.forname(
"com.example.javabase.user"
);
//第一种方法，实例化默认构造方法，user必须无参构造函数,否则将抛异常
user user = (user) clazz.newinstance();
user.setage(
20
);
user.setname(
"jack"
);
system.out.println(user);
system.out.println(
"--------------------------------------------"
);
//获取带string参数的public构造函数
constructor cs1 =clazz.getconstructor(string.
class
);
//创建user
user user1= (user) cs1.newinstance(
"hiway"
);
user1.setage(
22
);
system.out.println(
"user1:"
+user1.tostring());
system.out.println(
"--------------------------------------------"
);
//取得指定带int和string参数构造函数,该方法是私有构造private
constructor cs2=clazz.getdeclaredconstructor(
int
.
class
,string.
class
);
//由于是private必须设置可访问
cs2.setaccessible(
true
);
//创建user对象
user user2= (user) cs2.newinstance(
25
,
"hiway2"
);
system.out.println(
"user2:"
+user2.tostring());
system.out.println(
"--------------------------------------------"
);
//获取所有构造包含private
constructor<?> cons[] = clazz.getdeclaredconstructors();
// 查看每个构造方法需要的参数
for
(
int
i =
0
; i < cons.length; i++) {
//获取构造函数参数类型
class
<?> clazzs[] = cons[i].getparametertypes();
system.out.println(
"构造函数["
+i+
"]:"
+cons[i].tostring() );
system.out.print(
"参数类型["
+i+
"]:("
);
for
(
int
j =
0
; j < clazzs.length; j++) {
if
(j == clazzs.length -
1
)
system.out.print(clazzs[j].getname());
else
system.out.print(clazzs[j].getname() +
","
);
}
system.out.println(
")"
);
}
}
}
class
user {
private
int
age;
private
string name;
public
user() {
super
();
}
public
user(string name) {
super
();
this
.name = name;
}
/**
* 私有构造
* @param age
* @param name
*/
private
user(
int
age, string name) {
super
();
this
.age = age;
this
.name = name;
}
public
int
getage() {
return
age;
}
public
void
setage(
int
age) {
this
.age = age;
}
public
string getname() {
return
name;
}
public
void
setname(string name) {
this
.name = name;
}
@override
public
string tostring() {
return
"user{"
+
"age="
+ age +
", name='"
+ name + '\
''
+
'}'
;
}
}
|
输出结果:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
user{age=
20
, name=
'jack'
}
--------------------------------------------
user1:user{age=
22
, name=
'hiway'
}
--------------------------------------------
user2:user{age=
25
, name=
'hiway2'
}
--------------------------------------------
构造函数[
0
]:
private
com.example.javabase.user(
int
,java.lang.string)
参数类型[
0
]:(
int
,java.lang.string)
构造函数[
1
]:
public
com.example.javabase.user(java.lang.string)
参数类型[
1
]:(java.lang.string)
构造函数[
2
]:
public
com.example.javabase.user()
参数类型[
2
]:()
|
关于constructor类本身一些常用方法如下(仅部分，其他可查api):
。
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| class | getdeclaringclass() | 返回 class 对象，该对象表示声明由此 constructor 对象表示的构造方法的类,其实就是返回真实类型（不包含参数） |
| type[] | getgenericparametertypes() | 按照声明顺序返回一组 type 对象，返回的就是 constructor对象构造函数的形参类型。 |
| string | getname() | 以字符串形式返回此构造方法的名称。 |
| class<?>[] | getparametertypes() | 按照声明顺序返回一组 class 对象，即返回constructor 对象所表示构造方法的形参类型 |
| t | newinstance(object… initargs) | 使用此 constructor对象表示的构造函数来创建新实例 |
| string | togenericstring() | 返回描述此 constructor 的字符串，其中包括类型参数。 |
。
栗子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
constructor cs3 = clazz.getdeclaredconstructor(
int
.
class
,string.
class
);
system.out.println(
"-----getdeclaringclass-----"
);
class
uclazz=cs3.getdeclaringclass();
//constructor对象表示的构造方法的类
system.out.println(
"构造方法的类:"
+uclazz.getname());
system.out.println(
"-----getgenericparametertypes-----"
);
//对象表示此 constructor 对象所表示的方法的形参类型
type[] tps=cs3.getgenericparametertypes();
for
(type tp:tps) {
system.out.println(
"参数名称tp:"
+tp);
}
system.out.println(
"-----getparametertypes-----"
);
//获取构造函数参数类型
class
<?> clazzs[] = cs3.getparametertypes();
for
(
class
claz:clazzs) {
system.out.println(
"参数名称:"
+claz.getname());
}
system.out.println(
"-----getname-----"
);
//以字符串形式返回此构造方法的名称
system.out.println(
"getname:"
+cs3.getname());
system.out.println(
"-----getogenericstring-----"
);
//返回描述此 constructor 的字符串，其中包括类型参数。
system.out.println(
"getogenericstring():"
+cs3.togenericstring());
|
输出结果:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
-----getdeclaringclass-----
构造方法的类:com.example.javabase.user
-----getgenericparametertypes-----
参数名称tp:
int
参数名称tp:
class
java.lang.string
-----getparametertypes-----
参数名称:
int
参数名称:java.lang.string
-----getname-----
getname:com.example.javabase.user
-----getogenericstring-----
getogenericstring():
private
com.example.javabase.user(
int
,java.lang.string)
|
2.3field类及其用法 。
field 提供有关类或接口的单个字段的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）字段或实例字段.
同样的道理，我们可以通过class类的提供的方法来获取代表字段信息的field对象，class类与field对象相关方法如下:
。
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| field | getdeclaredfield(string name) | 获取指定name名称的(包含private修饰的)字段，不包括继承的字段 |
| field[] | getdeclaredfield() | 获取class对象所表示的类或接口的所有(包含private修饰的)字段,不包括继承的字段 |
| field | getfield(string name) | 获取指定name名称、具有public修饰的字段，包含继承字段 |
| field[] | getfield() | 获取修饰符为public的字段，包含继承字段 |
。
栗子:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
public
class
reflectfield {
public
static
void
main(string[] args)
throws
classnotfoundexception, nosuchfieldexception {
class
<?> clazz =
class
.forname(
"reflect.student"
);
//获取指定字段名称的field类,注意字段修饰符必须为public而且存在该字段,
// 否则抛nosuchfieldexception
field field = clazz.getfield(
"age"
);
system.out.println(
"field:"
+field);
//获取所有修饰符为public的字段,包含父类字段,注意修饰符为public才会获取
field fields[] = clazz.getfields();
for
(field f:fields) {
system.out.println(
"f:"
+f.getdeclaringclass());
}
system.out.println(
"================getdeclaredfields===================="
);
//获取当前类所字段(包含private字段),注意不包含父类的字段
field fields2[] = clazz.getdeclaredfields();
for
(field f:fields2) {
system.out.println(
"f2:"
+f.getdeclaringclass());
}
//获取指定字段名称的field类,可以是任意修饰符的自动,注意不包含父类的字段
field field2 = clazz.getdeclaredfield(
"desc"
);
system.out.println(
"field2:"
+field2);
}
}
class
person{
public
int
age;
public
string name;
//省略set和get方法
}
class
student
extends
person{
public
string desc;
private
int
score;
//省略set和get方法
}
输出结果:
field:
public
int
reflect.person.age
f:
public
java.lang.string reflect.student.desc
f:
public
int
reflect.person.age
f:
public
java.lang.string reflect.person.name
================getdeclaredfields====================
f2:
public
java.lang.string reflect.student.desc
f2:
private
int
reflect.student.score
field2:
public
java.lang.string reflect.student.desc
|
上述方法需要注意的是，如果我们不期望获取其父类的字段，则需使用class类的getdeclaredfield/getdeclaredfields方法来获取字段即可，倘若需要连带获取到父类的字段，那么请使用class类的getfield/getfields，但是也只能获取到public修饰的的字段，无法获取父类的私有字段。下面将通过field类本身的方法对指定类属性赋值，代码演示如下:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
|
//获取class对象引用
class
<?> clazz =
class
.forname(
"reflect.student"
);
student st= (student) clazz.newinstance();
//获取父类public字段并赋值
field agefield = clazz.getfield(
"age"
);
agefield.set(st,
18
);
field namefield = clazz.getfield(
"name"
);
namefield.set(st,
"lily"
);
//只获取当前类的字段,不获取父类的字段
field descfield = clazz.getdeclaredfield(
"desc"
);
descfield.set(st,
"i am student"
);
field scorefield = clazz.getdeclaredfield(
"score"
);
//设置可访问，score是private的
scorefield.setaccessible(
true
);
scorefield.set(st,
88
);
system.out.println(st.tostring());
//输出结果：student{age=18, name='lily ,desc='i am student', score=88}
//获取字段值
system.out.println(scorefield.get(st));
// 88
|
其中的set(object obj, object value) 方法是field类本身的方法，用于设置字段的值，而get(object obj)则是获取字段的值，当然关于field类还有其他常用的方法如下:
。
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| void | set(object obj, object value) | 将指定对象变量上此 field 对象表示的字段设置为指定的新值。 |
| object | get(object obj) | 返回指定对象上此 field 表示的字段的值 |
| class<?> | gettype() | 返回一个 class 对象，它标识了此field 对象所表示字段的声明类型。 |
| boolean | isenumconstant() | 如果此字段表示枚举类型的元素则返回 true；否则返回 false |
| string | togenericstring() | 返回一个描述此 field（包括其一般类型）的字符串 |
| string | getname() | 返回此 field 对象表示的字段的名称 |
| class<?> | getdeclaringclass() | 返回表示类或接口的 class 对象，该类或接口声明由此 field 对象表示的字段 |
| void | setaccessible(boolean flag) | 将此对象的 accessible 标志设置为指示的布尔值,即设置其可访问性 |
。
上述方法可能是较为常用的，事实上在设置值的方法上，field类还提供了专门针对基本数据类型的方法，如setint()/getint()、setboolean()/getboolean、setchar()/getchar()等等方法，这里就不全部列出了，需要时查api文档即可。需要特别注意的是被final关键字修饰的field字段是安全的，在运行时可以接收任何修改，但最终其实际值是不会发生改变的.
method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息，所反映的方法可能是类方法或实例方法（包括抽象方法）.
下面是class类获取method对象相关的方法:
。
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| method | getdeclaredmethod(string name, class<?>… parametertypes) | 返回一个指定参数的method对象，该对象反映此 class 对象所表示的类或接口的指定已声明方法。 |
| method[] | getdeclaredmethod | 返回 method 对象的一个数组，这些对象反映此 class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。 |
| method | getmethod(string name, class<?>… parametertypes) | 返回一个 method 对象，它反映此 class 对象所表示的类或接口的指定公共成员方法。 |
| method[] | getmethods() | 返回一个包含某些 method 对象的数组，这些对象反映此 class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共成员方法。 |
。
在通过getmethods方法获取method对象时，会把父类的方法也获取到，如上的输出结果，把object类的方法都打印出来了。而getdeclaredmethod/getdeclaredmethods方法都只能获取当前类的方法。我们在使用时根据情况选择即可。下面将演示通过method对象调用指定类的方法:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
class
clazz =
class
.forname(
"reflect.circle"
);
//创建对象
circle circle = (circle) clazz.newinstance();
//获取指定参数的方法对象method
method method = clazz.getmethod(
"draw"
,
int
.
class
,string.
class
);
//通过method对象的invoke(object obj,object... args)方法调用
method.invoke(circle,
15
,
"圈圈"
);
//对私有无参方法的操作
method method1 = clazz.getdeclaredmethod(
"drawcircle"
);
//修改私有方法的访问标识
method1.setaccessible(
true
);
method1.invoke(circle);
//对有返回值得方法操作
method method2 =clazz.getdeclaredmethod(
"getallcount"
);
integer count = (integer) method2.invoke(circle);
system.out.println(
"count:"
+count);
|
输出结果:
|
1
2
3
|
draw 圈圈,count=
15
drawcircle
count:
100
|
在上述代码中调用方法，使用了method类的invoke(object obj,object… args) 第一个参数代表调用的对象，第二个参数传递的调用方法的参数。这样就完成了类方法的动态调用.
。
| 方法返回值 | 方法名称 | 方法说明 |
|---|---|---|
| object | invoke(object obj, object… args) | 对带有指定参数的指定对象调用由此 method 对象表示的底层方法。 |
| class<?> | getreturntype() | 返回一个 class 对象，该对象描述了此 method 对象所表示的方法的正式返回类型，即方法的返回类型 |
| type | getgenericreturntype() | 返回表示由此 method 对象所表示方法的正式返回类型的 type 对象，也是方法的返回类型。 |
| class<?>[] | getparametertypes() | 按照声明顺序返回 class 对象的数组，这些对象描述了此 method 对象所表示的方法的形参类型。即返回方法的参数类型组成的数组 |
| type[] | getgenericparametertypes() | 按照声明顺序返回 type 对象的数组，这些对象描述了此 method 对象所表示的方法的形参类型的，也是返回方法的参数类型 |
| string | getname() | 以 string 形式返回此 method 对象表示的方法名称，即返回方法的名称 |
| boolean | isvarargs() | 判断方法是否带可变参数，如果将此方法声明为带有可变数量的参数，则返回 true；否则，返回 false。 |
| string | togenericstring() | 返回描述此 method 的字符串，包括类型参数。 |
。
getreturntype方法/getgenericreturntype方法都是获取method对象表示的方法的返回类型，只不过前者返回的class类型后者返回的type(前面已分析过)，type就是一个接口而已，在java8中新增一个默认的方法实现，返回的就参数类型信息 。
|
1
2
3
4
5
6
|
public
interface
type {
//1.8新增
default
string gettypename() {
return
tostring();
}
}
|
而getparametertypes/getgenericparametertypes也是同样的道理，都是获取method对象所表示的方法的参数类型，其他方法与前面的field和constructor是类似的.
到此这篇关于java反射超详细讲解的文章就介绍到这了,更多相关java反射内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。
原文链接：https://blog.csdn.net/qq_45966440/article/details/119758723 。
最后此篇关于java反射超详细讲解的文章就讲到这里了,如果你想了解更多关于java反射超详细讲解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
25
4
0
目录 进程 其他相关概念 创建线程的两种方式 为什么使用start（）方法而不直接使用run（）方法 start（）方法底层
CURL状态码列表 状态码 状态原因 解释 0 正常访问
ODBC连接类函数 odbc_connect函数：打开一个ODBC连接 odbc_close函数：关闭一个已经打开的ODBC连接 odbc_close_all函数：关闭所有已经打开的ODBC连
作为标题，如何计算从纪元1900到现在使用boost的持续时间？ 编辑:很抱歉以前的问题太短。我将再次描述我的问题。 我有关于将生日另存为整数的问题。我创建了四个函数，用法如下: ptime转换为整数
前言 在Java中，有一个常被忽略 但 非常重要的关键字Synchronized今天，我将详细讲解 Java关键字Synchronized的所有知识，希望你们会喜欢 目录 1. 定义 J
详细 JVM 垃圾收集日志的时间戳是收集的开始还是结束？ 2016-08-09T21:04:19.756-0400: 224890.317: [GC Desired survivor size 167
我在“Master-Detail”概念上苦苦挣扎，除了一点点(但很重要)的细微差别外，几乎所有东西都按预期工作。我应该在 Storyboard上更改什么以在详细信息 View (屏幕截图底部的右上角)
我希望能够显示表格的详细 View ，但不推送新屏幕，而只显示表格所在的详细 View 。 设置它的最佳方式是什么......如果真的可行的话？ ---------------------------
我在我的博客中为我的帖子使用了详细 View ，每篇帖子都有评论，所以我想对它们进行分页，但我不知道该怎么做，因为我请求了帖子模型。我知道如何在功能 View 中执行此操作，但不知道如何在详细 Vie
在下面的代码中，与 pm 对齐，该行是否会 move 整个内存并将其分配给 pm，或者它只会 move p 指向的内存而不是整个数组？ int main() { int*
1·下载 https://dev.mysql.com/downloads/mysql/ 2·安装服务 1)管理员运行cmd 2)D: 3)cd D:\mysql
今天以前一直用的SQL Server 2005做开发，偶尔也用MySQL，现入手公司项目，用到SQL Server 2008,于是乎必须安装它，免得出现其他很纠结的小问题，现将自己安装图解分享如下：
1. crontab命令选项 复制代码 代码如下: #crontab -u <-l, -r, -e> -u指定一个用
我们有一个 WPF 应用程序，它有一个主窗口/详细信息窗口，两者都是 WPF 数据网格。当您在上部数据网格中选择一行时，详细信息将显示在下部数据网格中。我想知道从 UI 的角度来看是否有任何关于如何处
在可视化 Perforce 客户端 (p4v) 中有一个选项: 显示文件操作的 p4 命令输出 启用后，在日志 Pane 中，我可以看到这样的详细日志记录: p4 sync /Users/az/ftp
在其他服务器上设置测试环境后，在几个API调用中出现错误。 99％肯定这是MySQL的事情，但是返回的错误根本没有帮助: global name 'sys' is not defined" 我已经导入
我正在维护一个通用的 iOS 应用程序，其开发已开始于 iOS 6。我正在为 iOS 7 更新 UI。现在我遇到了应用程序的 iPad 部分的奇怪问题。这部分遵循使用 UISplitViewContr
我希望我能正确描述这种情况。当它发生时很容易在屏幕上看到，但很难用语言解释，但我会尽力而为。 我有一个带有固定主视图 (UITableView) 和两个详细 View 之一的 UISplitViewC
我尝试在 eclipse 和 intelliJ 参数中使用垃圾收集记录器来配置简单的测试程序。尝试了不同类型的配置，但尚未创建日志文件。 -XX:+PrintGCDetails -XX:+PrintG
正如您所知，.cap 文件中的 java 小程序的输出文件格式必须通过智能卡读卡器/写卡器(如 ACR122 或任何其他读卡器)部署到 java 卡，而且我相信 java 卡与 java 卡之间的部署
我是一名优秀的程序员,十分优秀！