编译单元域
private,public,protected,默认不写（firendly)
1、Class类的访问权限：
public：可以供所有的类访问。
默认：默认可以称为friendly但是，java语言中是没有friendly这个修饰符的，这样称呼应该是来源于c++。默认的访问权限是包级访问权限。
即如果写了一个类没有写访问权限修饰符，那么就是默认的访问权限，同一个包下的类都可以访问到，即使可以实例化该类
（当然如果这个类不具有实例化的能力除外，比如该类没有提供public的构造函数）。
说明：
1、每个编译单元（类文件）都仅能有一个public class
2、public class的名称（包含大小写）必须和其类文件同名。
3、一个类文件(*.java)中可以不存在public class。
这种形式的存在的场景：如果我们在某个包内撰写一个class，仅仅是为了配合同包内的其他类工作，而且
我们不想再为了撰写说明文档给客户（不一定是现实意义的客户，可能是调用这个类的类）看而伤脑筋，而且有可能过一段时间之后
有可能会彻底改变原有的做法，并完全舍弃旧版本，以全新的版本代替。
4、class不可以是private和protected。
5、如果不希望那个任何产生某个class的对象，可以将该类得所有构造函数设置成private。但是即使这样也可以生成该类的对象，就是class的static的成员（属性和方法）可以办到。
2、类成员变量的访问权限：
public：紧接public的属性任何类都可以访问到。可以直接使用ClassName.propertyName。但是从类的封装性上来考虑将一个类的属性定义成public一般很少使用，
在定义静态常量的时候通畅会这样定义。如：public static final int PAGE_SIZE=10;
private：只有类本身内部的方法可以访问类的private属性，当然内部类也可以访问其外部类的private成员的。（属性和方法）
默认（friendly）：包级可见，同一个包内的类可以访问到这个属性，可以直接使用className.propertyName来访问，但是从类的封装性特性来说很少这样使用类的属性的。
protected：关键字所处理的是所谓“继承”的观念。对于同一包的其他类，protected＝默认，对于不同包的类，如果存在继承关系，而baseClass存在protected属性，则可以被其自继承，而不同包的其他类
则不能访问类的protected属性。
3、类的成员方法的访问权限：
其从语法角度来讲，这些访问权限控制符作用于类的方法和作用于类的属性上的效果是一样的。
public：所有类可见。
pirvate：只有同一类内部的方法可见，在有就是内部类也可以访问到。
默认（friendly）：包内可见。
protected:继承可见。
4、访问权限存在的理由
1、“让使用者无法碰触到他们不该碰触的东西。”这些东西仅供类的内部机制使用。将某些成员声明成private，对于使用者来说可以说是一种服务，
因为这样使用者可以知道哪些是他关注的哪些是不重要的，不需要关注，如此历来对于使用来说降低了对使用对象认识的难度。
2、（最终要的理由）让程序设计者可以更动class内部运作方式，而无须担心波及到客户端程序。
5、java的“访问权限修饰符”赋予classes开发者极具有价值的控制能力。身为classes开发者，如果你的任何改变可以完全不干扰你的使用者，
你便可以安心改变你的底层实现，因为客户端程序员无法访问class的这一部分。
通过今天学习访问权限的问题了解到，接口或者抽象等等策略所谓的“实现隐藏”其根本原因并不是说为了隐藏实现的代码和思路，而是降低使用者的使用难度，以及从维护角度来说可见范围的控制给程序维护带来了极大的安全性。
❷ 在java中，什么是编译单元。如何根据编译单元创建类库，又如何使用这个类库。
猪哥解答：
c领域倒是有编译单元的说法，java 中没有听说。
类库吗，功能类集合，就是一组类放一起来实现某个功能。不要太去追概念性的东西，什么白猫黑猫，能抓老鼠才是好猫。
类库举例：人、购物车、超市、商品，人去超市购买商品，道具是购物车，那我要准备几个类
人.java，购物车.java，超市.java，商品.java，这几个类通过人这个拥有各种动作行为(方法)的类联系到一起，实现了人推车在超市中买商品的购物动作。
那么我这也就是一个类库，多个类集中到一起，为了实现人购买商品这个功能。
❸ java中import的作用
import的作用就是导入静态成员，导入接口类型。
拓展资料
java中import的作用详解：
一、java以这样两种方式导入包中的任何一个public的类和接口(只有public类和接口才能被导入)。
三、java.lang包是自动导入的。java编译器会忽略这些冗余导入声明(rendant import declarations)。即使像这样 import java.util.ArrayList; import java.util。
❹ C++中指针作用域
作用域是对于标识符而言的，是限制编译器在某一个范围内能够找到某个标识符。而指针指向的对象本身和标识符无关，只和指针的值和类型有关。因此只引用要被指向的变量对应的标识符能够在指针作用域中访问，就可以指向这个变量。
例如
static int a = 1;
extern int b;
int g()
{
int d = 1;
}
int f()
{
int c = 1;
int* p1 = &a; //静态变量为编译单元（源文件）作用域，合法；
int* p2 = &b; //外部变量为全局作用域，合法；
int* p3 = &c; //函数内的局部作用域，合法；
int* p4 = &d; //非法，在全局作用域、编译单元、f()作用域中均找不到d的声明。
}
int main()
{
return 0;
}
====
[原创回答团]
❺ 我们经常看到书上面说的 某某变量的内存单元是编译器在编译时候分配的 是什么意思
所谓在编译期间分配空间指的是静态分配空间（相对于用new动态申请空间），如全局变量或静态变量（包括一些复杂类型的常量），它们所需要的空间大小可以
明确计算出来，并且不会再改变，因此它们可以直接存放在可执行文件的特定的节里（而且包含初始化的值），程序运行时也是直接将这个节加载到特定的段中，不
必在程序运行期间用额外的代码来产生这些变量。
其实在运行期间再看“变量”这个概念就不再具备编译期间那么多的属性了（诸如名称，类型，作用
域，生存期等等），对应的只是一块内存（只有首址和大小），
所以在运行期间动态申请的空间，是需要额外的代码维护，以确保不同变量不会混用内存。比如写new表示有一块内存已经被占用了，其它变量就不能再用它了；
写delete表示这块内存自由了，可以被其它变量使用了。（通常我们都是通过变量来使用内存的，就编码而言变量是给内存块起了个名字，用以区分彼此）
内存申请和释放时机很重要，过早会丢失数据，过迟会耗费内存。特定情况下编译器可以帮我们完成这项复杂的工作（增加额外的代码维护内存空间，实
现申请和释 放）。从这个意义上讲，局部自动变量也是由编译器负责分配空间的。进一步讲，内存管理用到了我们常常挂在嘴边的堆和栈这两种数据结构。
最后对于“编译器分配空间”这种不严谨的说法，你可以理解成编译期间它为你规划好了这些变量的内存使用方案，这个方案写到可执行文件里面了（该文件中包含若干并非出自你大脑衍生的代码），直到程序运行时才真正拿出来执行。
❻ 定义c/c++全局变量/常量几种方法的区别
在讨论全局变量之前我们先要明白几个基本的概念： 1. 编译单元(模块)： 在ide开发工具大行其道的今天，对于编译的一些概念很多人已经不再清楚了，很多程序员最怕的就是处理连接错误(link error) 因为它不像编译错误那样可以给出你程序错误的具体位置，你常常对这种错误感到懊恼，但是如果你经常使用gcc，makefile等工具在linux或者嵌入式下做开发工作的话，那么你可能非常的理解编译与连接的区别！当在vc这样的开发工具上编写完代码，点击编译按钮准备生成exe文件时，vc其实做了两步工作，第一步，将每个.cpp(.c)和相应.h文件编译成obj文件；第二步，将工程中所有的obj文件进行link生成最终的.exe文件，那么错误就有可能在两个地方产生，一个是编译时的错误，这个主要是语法错误，另一个是连接错误，主要是重复定义变量等。我们所说的编译单元就是指在编译阶段生成的每个obj文件，一个obj文件就是一个编译单元，也就是说一个cpp(.c)和它相应的.h文件共同组成了一个编译单元，一个工程由很多个编译单元组成，每个obj文件里包含了变量存储的相对地址等 。 2. 声明与定义的区别 函数或变量在声明时，并没有给它实际的物理内存空间，它有时候可以保证你的程序编译通过，但是当函数或变量定义的时候，它就在内存中有了实际的物理空间，如果你在编译模块中引用的外部变量没有在整个工程中任何一个地方定义的话， 那么即使它在编译时可以通过，在连接时也会报错，因为程序在内存中找不到这个变量！你也可以这样理解，对同一个变量或函数的声明可以有多次，而定义只能有一次! 3. extern的作用 extern有两个作用，第一个 当它与" c" 一起连用时，如: extern " c" void fun(int a int b) 则告诉编译器在编译fun这个函数名时按着c的规则去翻译相应的函数名而不是c++的， c++的规则在翻译这个函数名时会把fun这个名字变得面目全非，可能是fun abc_int_int#$也可能是别的，这要看编译器的" 脾气" 了(不同的编译器采用的方法不一样)，为什么这么做呢，因为c++支持函数的重载啊，在这里不去过多的论述这个问题，如果你有兴趣可以去网上搜索，相信你可以得到满意的解释! 当extern不与" c" 在一起修饰变量或函数时，如在头文件中: extern int g_int 它的作用就是声明函数或全局变量的作用范围的关键字，其声明的函数和变量可以在本模块活其他模块中使用，记住它是一个声明不是定义!也就是说b模块(编译单元)要是引用模块(编译单元)a中定义的全局变量或函数时，它只要包含a模块的头文件即可 在编译阶段，模块b虽然找不到该函数或变量，但它不会报错，它会在连接时从模块a生成的目标代码中找到此函数。 如果你对以上几个概念已经非常明白的话，那么让我们一起来看以下几种全局变量/常量的使用区别: 1. 用extern修饰的全局变量 以上已经说了extern的作用，下面我们来举个例子 如: 在test1.h中有下列声明: #ifndef test1h #define test1h extern char g_str[] // 声明全局变量g_str void fun1() #endif 在test1.cpp中 #include " test1.h" char g_str[] = " 123456" // 定义全局变量g_str void fun1() { cout < < g_str < < endl } 以上是test1模块， 它的编译和连接都可以通过 如果我们还有test2模块也想使用g_str 只需要在原文件中引用就可以了 #include " test1.h" void fun2() { cout < < g_str < < endl } 以上test1和test2可以同时编译连接通过，如果你感兴趣的话可以用ultraedit打开test1.obj 你可以在里面着" 123456" 这个字符串 但是你却不能在test2.obj里面找到，这是因为g_str是整个工程的全局变量，在内存中只存在一份 test2.obj这个编译单元不需要再有一份了，不然会在连接时报告重复定义这个错误! 有些人喜欢把全局变量的声明和定义放在一起，这样可以防止忘记了定义，如把上面test1.h改为 extern char g_str[] = " 123456" // 这个时候相当于没有extern 然后把test1.cpp中的g_str的定义去掉 这个时候再编译连接test1和test2两个模块时，会报连接错误，这是因为你把全局变量g_str的定义放在了头文件之后，test1.cpp这个模块包含了test1.h所以定义了一次g_str 而 test2.cpp也包含了test1.h所以再一次定义了g_str 这个时候连接器在连接test1和test2时发现两个g_str。如果你非要把g_str的定义放在test1.h中的话，那么就把test2的代码中#include " test1.h" 去掉换成: extern char g_str[] void fun2() { cout < < g_str < < endl } 这个时候编译器就知道g_str是引自于外部的一个编译模块了，不会在本模块中再重复定义一个出来，但是我想说这样做非常糟糕，因为你由于无法在test2.cpp中使用#include " test1.h" 那么test1.h中声明的其他函数你也无法使用了，除非也用都用extern修饰，这样的话你光声明的函数就要一大串，而且头文件的作用就是要给外部提供接口使用的，所以请记住， 只在头文件中做声明，真理总是这么简单。 2. 用static修饰的全局变量 首先，我要告诉你static与extern是一对“水火不容”的家伙，也就是说extern和static不能同时修饰一个变量； 其次，static修饰的全局变量声明与定义同时进行，也就是说当你在头文件中使用static声明了全局变量后，它也同时被定义了； 最后，static修饰全局变量的作用域只能是本身的编译单元，也就是说它的“全局”只对本编译单元有效，其他编译单元则看不到它。一般定义static全局变量时，都把它放在原文件中而不是头文件，这样就不会给其他模块造成不必要的信息污染，同样记住这个原则吧！ 如: test1.h: #ifndef test1h #define test1h static char g_str[] = " 123456" void fun1() #endif test1.cpp: #include " test1.h" void fun1() { cout < < g_str < < endl } test2.cpp #include " test1.h" void fun2() { cout < < g_str < < endl } 以上两个编译单元可以连接成功 当你打开test1.obj时，你可以在它里面找到字符串" 123456" 同时你也可以在test2.obj中找到它们，它们之所以可以连接成功而没有报重复定义的错误是因为虽然它们有相同的内容，但是存储的物理地址并不一样，就像是两个不同变量赋了相同的值一样，而这两个变量分别作用于它们各自的编译单元。 也许你比较较真，自己偷偷的跟踪调试上面的代码 结果你发现两个编译单元（test1 test2）的g_str的内存地址相同，于是你下结论static修饰的变量也可以作用于其他模块，但是我要告诉你，那是你的编译器在欺骗你，大多数编译器都对代码都有优化功能，以达到生成的目标程序更节省内存，执行效率更高，当编译器在连接各个编译单元的时候，它会把相同内容的内存只拷贝一份，比如上面的" 123456" 位于两个编译单元中的变量都是同样的内容，那么在连接的时候它在内存中就只会存在一份了，如果你把上面的代码改成下面的样子，你马上就可以拆穿编译器的谎言: test1.cpp: #include " test1.h" void fun1() { g_str[0] = ' ' a' ' cout < < g_str < < endl } test2.cpp #include " test1.h" void fun2() { cout < < g_str < < endl } void main() { fun1() // a23456 fun2() // 123456 } 这个时候你在跟踪代码时，就会发现两个编译单元中的g_str地址并不相同，因为你在一处修改了它，所以编译器被强行的恢复内存的原貌，在内存中存在了两份拷贝给两个模块中的变量使用。 正是因为static有以上的特性，所以一般定义static全局变量时，都把它放在原文件中而不是头文件，这样就不会给其他模块造成不必要的信息污染，同样记住这个原则吧！
❼ JAVA问题:什么叫做一个编译单元
当一个c或cpp文件在编译时，预处理器首先递归包含头文件，
形成一个含有所有
必要信息的单个源文件，这个源文件就是一个编译单元。
这个编译单元会被编译成为一个与cpp
文件名同名的目标文件
。
连接程序把不同编译单元中产生的符号联系起来，构成一个可执行程序。
❽ 在java程序中什么条件下要用import语句什么时候不用
当需要使用其他包中的类的时候，需要使用import语句。
例如：import org.springframework.core.task.TaskExecutor;
其他包的类一般情况就是，你正在使用的类需要调用别人类里面的方法。
比如：
import java.util.ArrayList;
import java.util.List;
public class Test1 {
List<String> list=new ArrayList<String>();
}
里面调用了import java.util包下面的ArrayList和List，
当然也可以调用自己封装好的包，方法是一样的，
上面两句import也可以写成：import java.util.*；
❾ 在C/C++中，什么叫编译单元
可以这样的理解：
编译单元
当一个c或cpp文件在编译时，预处理器首先递归包含头文件，
形成一个含有所有 必要信息的单个源文件，这个源文件就是一个编译单元。
这个编译单元会被编译成为一个与cpp 文件名同名的目标文件 。
连接程序把不同编译单元中产生的符号联系起来，构成一个可执行程序。
❿ C位域 编译器问题
位段（或称“位域”，Bit field）为一种数据结构，可以把数据以位元的形式紧凑的储存，并允许程序员对此结构的位元进行操作。这种数据结构的好处：
可以使数据单元节省储存空间，当程序需要成千上万个数据单元时，这种方法就显得尤为重要。
位段可以很方便的访问一个整数值的部分内容从而可以简化程序源代码。
而位域这种数据结构的缺点在于，其内存分配与内存对齐的实现方式依赖于具体的机器和系统，在不同的平台可能有不同的结果，这导致了位段在本质上是不可移植的。