java声明的作用_变量及函数声明的作用

# 写在开头0 B' z) R! ~6 z' j/ T# Y* _: z

8 `$ K- O9 s2 ~8 {8 v要点1：编译时，必须要有声明。链接时，必须有定义。' J* Q; A1 H9 V  ?/ _- y1 A

% ]! ?5 {7 ]3 V7 R

编译器需要根据声明来进行语法检查，验证使用是否有误

% F! u; G: C+ A3 V

有些语言如C++或是Windows下的调用规范__stdcall等，其中的符号修饰机制，编译时需要根据函数原型来生成符号。

6 R/ ]5 l" `* q, O要点2：如果定义的地方在使用的地方之后，或不在一个文件。那使用之前，是否需要再声明一次？如果需要，有没有必要？

* U( s) ~  V3 _& Z* t8 m9 ?! e" k% s' q& _

C、C++、OC、Java等需要导入头文件的，都是需要的，不过后两者相比做了一些编译器优化，如果定义是在本文件内调用的后面，不用前置声明，会预扫描后面的。4 J* T) Q$ l, Q) n

Swift进行了更多的优化，不需要导入头文件/声明，只要在同一个命名空间中的资源都是共享的，而且默认情况下，项目名称就是命名空间) ~& @4 T) _1 Q. H- d* o

理论上，只要编译器做的工作多，那写代码时，就可以省去这些导入头文件(里都是声明/定义)的工作。但如果手动添加了声明，可以省去编译器一些工作量，不用全局扫描一遍，没发现符号再来报符号未定义错误

: @' K/ `2 d$ U0 F9 N# 声明、定义、初始化

9 z% V3 Q6 `% `) K* A+ ]8 q

! H5 i: ~0 _- o; [8 k! ~4 B8 ]## 定义 参考链接+ m% K2 ]5 H. _: F/ M' f

. V1 V7 y- c+ \1 N变量定义(definition)是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。在程序中，变量有且仅有一个定义。

+ a" h6 p2 F! \格式：数据类型 一个变量名/多个变量名用逗号隔开;8 U5 c7 R* w( ~5 r; G6 e) A0 p不带初始化的定义：带有静态存储持续时间的变量会被隐式初始化为 NULL(所有字节的值都是 0)，其他所有变量的初始值是未定义的。4 k/ z$ H2 ^7 Q! y2 V* p

## 声明& t% T9 Y9 T( ], w

) N$ n# ~7 U/ Y( A5 `8 a6 n变量声明(declaration)是向编译器保证变量以指定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序链接时编译器需要实际的变量定义。5 x+ j# ^' N! w5 x. x6 O% K

变量的声明有两种情况：

# b/ o  t4 c+ r* I4 d" O2 dC4 `. h8 H! N6 h

一种是需要建立存储空间的。格式与变量定义相同。如int i; //声明，也是定义。

1 _( ^7 u8 w/ K& p4 N/ J6 `( @- Q% _

一种是不需要建立存储空间的，通过使用extern关键字声明变量名而不定义它。

- W- ]. @, d' U( U例如：extern int a; //声明，不是定义。说明变量a是在别的文件中定义的，这里只是在声明(数据类型、名称存在)

" u/ o% z0 q; C## 初始化

" |% R4 z) B# W7 _$ }; p6 D$ h) r  D2 I

初始化(Initialization)是指为数据对象或变量赋初值的做法。用于进行初始化的程序结构则称为初始化器或初始化列表。在C/C99/C++中，初始化器是声明器的可选部分，它由一个'='以及其后的一个表达式(或含有多个以','隔开的带圆括号表达式的单一列表)所组成。

: w4 S' W6 ~3 X: z* z4 E在定义变量之后，系统为变量分配的空间内存储的值是不确定的，所以需要对这个空间进行初始化，以确保程序的安全性和确定性

8 i- I7 X! E8 t6 f: Y& S## 注意：

. F. K: z1 ^+ ^6 n8 T) x

; K6 r- g9 z& F- h. m4 v* P9 F当extern声明的变量右侧手动写有初始化式时，就会被当成定义。

4 e9 e$ [5 s& ^0 B3 X0 R4 U6 J, A4 U  w+ S0 H) B0 s+ a

只有当extern声明位于函数外部时，才可以被初始化。不过也有warning# p! `4 K2 T4 V; H

extern就失去了它本身的意义，如果其他文件有同名的变量定义，那会报重定义的错误( N1 F+ L5 _2 p6 _$ p2 s# 为什么使用前要加声明？ —— 为了完成编译T& \' r0 P4 @$ s. I

+ Y. l1 g5 G8 }+ X. v借用函数原型中维基百科的原话：函数原型被广泛应用于C、C++ 语言程序代码的上下文中，通过在头文件中放置函数的前向声明来允许将代码拆分为多个翻译单元。即编译器可以单独编译目标文件的这部分内容，然后由链接器组合成可执行文件或库。, ~4 D7 O) W- _9 n: ~2 }( r0 p

( A3 f" g' W% N6 N

编译器需要根据声明来进行语法检查，验证使用是否有误: l+ O. i! ?, z

有些语言如C++或是Windows下的调用规范__stdcall等，其中的符号修饰机制，编译时需要根据函数原型来生成符号。

7 e: q8 Z, {- i5 @那为什么C、C++中，都在一个文件，只是定义在使用之后，还需要提前声明？而OC Java中就不用？5 P* H! i7 A/ L' a2 Y, M9 b( H

3 a2 Z  [8 s/ L- O  H) J

编译器优化了，会扫描完头文件中声明的、本文件从头到尾声明/定义的，找不到再报错9 `' ?" ~5 Y0 t' ?* H" g

C纯粹是历史原因，C出来的时候编译机制是自上而下的扫描，编译器还做不到预扫描，后来就约定俗成了。知乎

, P+ `1 a7 e8 Z, U8 c5 X- d

C可不可以做？可以，但不好做，如果是只向后扫描完整个文件还好。那如果扫描完所有可能存在的地方(因为C中全是函数，都是全局通用的，所以所有文件都有可能是定义函数/变量处)，那编译器工作量就太大了

% t$ F. t) Q* o0 Q- x1 ^为什么Swift中就不用导入头文件？

3 m0 `5 i! p- ESwift进行了相关的一些优化，只要在同一个命名空间中的资源都是共享的，而且默认情况下，项目名称就是命名空间

p: X; i5 j) i7 f4 k0 f' [1 U* Q: d# L+ y- ?) }: e

编译器进一步优化，全局搜定义/实现，搜到自动补全。

6 N( ~4 A( Z5 e$ k0 x## 使用前先添加声明的好处：

5 ^: B+ c+ u- r# x0 x) H( ^6 X9 _

9 N% v4 I. u3 ~, @$ r) `

缩小编译器的压力，不用全局去查找外部符号(本文件内未定义的符号)的定义处。只从导入的头文件中取查找声明(对比变量的使用，语法检查是否有误)即可. f* y) C. Z8 w( V: o

不全局搜索，反向推导行不？涉及到隐式类型转换，或者变长常数之类的，不太能精确推导出来。

Y& S# V6 t( m2 U) a# 记录一个我自己的误区：头文件的作用% ]0 x% t) _& V$ W- c- q* \

6 V8 Z+ `2 H( E/ p  g( m6 h# h

## 头文件和源文件的区别

' Q+ z4 m; l& G1 n- A2 `' Y# S1 z

头文件和源文件在本质上没有任何区别。 只不过一般：0 S+ |- D3 ?3 m* W2 p

0 }7 C# H5 F" B( i6 G$ f

后缀为 .h 的文件是头文件，内含函数声明、宏定义、结构体定义等内容。$ ?- P; Q( b* d$ H- y, H+ k

后缀为 .c .m .cpp 的文件是源文件，内含函数实现，变量定义等内容。

! {8 [9 \* s* t! ]2 i; q% H, s; J

而且是什么后缀也没有关系，只不过编译器会默认对某些后缀的文件采取某些动作。这样分开写成两个文件是一个良好的编程风格。" }! `  B$ V0 y4 y之前，一直以为是根据导入的头文件，递归编译同名的源文件.m，没被导入过的头文件，其.m文件就不被编译。前两天突然一细想：那如果就是不导入头文件，通过动态创建对象调用的方法呢，crash？好好的类找不到了？

. N* |+ [' ]3 i4 Q; R' ~$ z8 {头文件的作用就是放置一些可重复被各源文件导入的代码：一般是类、函数的声明，变量、宏的声明或定义。

7 F" [. N8 z) ^% T预处理阶段：处理#include指令，将每个源文件内，#include后的文件(一般是头文件)内的内容复制过来，替换#include指令，是递归的。将h文件中所有的内容全部扫描进这个当前的源文件中，形成一个.i文件5 ?; H" K; R+ z! g2 C) p

编译器在编译时是以源文件为单位进行的(每个源文件都会编译)，也就是说如果你的项目中一个C文件都没有，那么你的项目将无法编译，连接器是以目标文件为单位，它将一个或多个目标文件进行函数与变量的重定位，生成最终的可执行文件，在PC上的程序开发，一般都有一个main函数，这是各个编译器的约定。

0 c! e7 ?: w, J% \1 c每个源文件都参与编译链接？那无用代码怎么办，编译过程中的中间代码优化环节，会做相关的优化删除工作。

2 k# ~) ?$ u" k## 头文件是必须的吗？

% ^% N% E$ y; _( q( z6 I/ a; W& S( r, U! m5 p. e5 b

不是，C语言中不是，OC中也不是随便创建类时都自动创建.h。

3 o& A8 e! v5 k4 v) a% H' q* V; {* L' j

如果确定这个类不会被别人使用(那创建类还有啥意义？当然，也可以动态使用，根据类名、方法名来调用。闲的，这个问题没意义，只是强调一下头文件的作用(绝大部分场景，是方便让其他文件导入声明))，完全可以将.h中对类的声明挪到.m中，然后将.h删除。+ C! v( a4 S& H( t3 s5 V  ^

就算本文件内有函数、变量、宏需要导出给其他文件，也不是必须要头文件。头文件只是方便一次导入多个声明，且方便被复用。如果不想用，自己在每个用到的文件中一个一个写声明也可以的。不是必须要通过导入头文件才能使用外文件的函数/变量等的8 g, }' ^! N/ N8 e: I5 R: l& `即头文件不是必须的：

! R$ _4 X! |& {5 D& U7 \& H2 k# ]- c( m0 m! P3 Z

无函数/变量等需要导出给其他文件使用时，不需要创建头文件

$ i( y$ x$ P1 M: F) c9 p

有函数/变量等需要导出给其他文件使用时，也不是必须要有头文件才行，自己手写一堆声明即可。(头文件就是一堆公用声明/定义的集合)

9 e/ b. a% u- q! W: g& n## 一个源文件对应一个头文件吗？

: d0 Z$ k6 p* r0 m# u1 E$ ~# o2 J4 j2 Q" u, a6 [

当然不是。

% m6 L  s* x% m- j; k* T1 ?4 ~0 s1 M' q! ?5 a) C; X9 E, i

在C语言中，常见几个.c文件对应一个.h文件，因为很多都是内部函数，只能对外暴露的函数才需要放到头文件中让人使用# M' D$ h, t- U3 R8 M

在面向对象中，都是以对象为单位来定义、使用，将该对象的对外保护的属性、方法的声明放到头文件中。: ]. }+ x. m5 V" n& b6 K: C

- @3 [  k% ~' K! Z' |: i. @

而且在面向对象中，偶尔也能看到一个头文件中存放了多个强关联类的声明(一导入这个头文件，就导入了多个类的声明)。7 d! {# w$ a6 y2 X

为了在导入的时候，避免不必要的代码导入，如果不是真的强关联，一般都是一个类对应一个源文件、一个头文件。

& |/ {; p: H) f4 b0 p7 e' }& _) P0 R5 i+ s% j8 A6 B) [/ u( v: H& H" _

Java吧 收集整理 java论坛 www.java8.com