1. JAVA中局部内部类和匿名内部类的特点和作用是什么
Java 内部类
分四种：成员内部类、局部内部类、静态内部类和匿名内部类。
1、成员内部类： 即作为外部类的一个成员存在，与外部类的属性、方法并列。
注意：成员内部类中不能定义静态变量,但可以访问外部类的所有成员。
public class Outer{
private static int i = 1;
private int j=10;
private int k=20;
public static void outer_f1(){
//do more something
}
public void out_f2(){
//do more something
}
//成员内部类
class Inner{
//static int inner_i =100; //内部类中不允许定义静态变量
int j=100;//内部类中外部类的实例变量可以共存
int inner_i=1;
void inner_f1(){
System.out.println(i);//外部类的变量如果和内部类的变量没有同名的，则可以直接用变量名访问外部类的变量
System.out.println(j);//在内部类中访问内部类自己的变量直接用变量名
System.out.println(this.j);//也可以在内部类中用"this.变量名"来访问内部类变量
//访问外部类中与内部类同名的实例变量可用"外部类名.this.变量名"。
System.out.println(k);//外部类的变量如果和内部类的变量没有同名的，则可以直接用变量名访问外部类的变量
outer_f1();
outer_f2();
}
}
//外部类的非静态方法访问成员内部类
public void outer_f3(){
Inner inner = new Inner();
inner.inner_f1();
}
//外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样
public static void outer_f4(){
//step1 建立外部类对象
Outer out = new Outer();
//***step2 根据外部类对象建立内部类对象***
Inner inner=out.new Inner();
//step3 访问内部类的方法
inner.inner_f1();
}
public static void main(String[] args){
outer_f4();
}
}
成员内部类的优点：
⑴ 内部类作为外部类的成员，可以访问外部类的私有成员或属性。（即使将外部类声明为PRIVATE，但是对于处于其内部的内部类还是可见的。）
⑵ 用内部类定义在外部类中不可访问的属性。这样就在外部类中实现了比外部类的private还要小的访问权限。
注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。
2、局部内部类： 即在方法中定义的内部类，与局部变量类似，在局部内部类前不加修饰符public或private，其范围为定义它的代码块。
注意：局部内部类中不可定义静态变量，可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的。
public class Outer {
private int s = 100;
private int out_i = 1;
public void f(final int k){
final int s = 200;
int i = 1;
final int j = 10;
class Inner{ //定义在方法内部
int s = 300;//可以定义与外部类同名的变量
//static int m = 20;//不可以定义静态变量
Inner(int k){
inner_f(k);
}
int inner_i = 100;
void inner_f(int k){
System.out.println(out_i);//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
System.out.println(k);//*****可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的*****
// System.out.println(i);
System.out.println(s);//如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
System.out.println(this.s);//用"this.变量名" 访问的也是内部类变量
System.out.println(Outer.this.s);//用外部"外部类类名.this.变量名" 访问的是外部类变量
}
}
new Inner(k);
}
public static void main(String[] args) {
//访问局部内部类必须先有外部类对象
Outer out = new Outer();
out.f(3);
}
}
注意：
在类外不可直接生成局部内部类（保证局部内部类对外是不可见的）。要想使用局部内部类时需要生成对象，对象调用方法，在方法中才能调用其局部内部类。通过内部类和接口达到一个强制的弱耦合，用局部内部类来实现接口，并在方法中返回接口类型，使局部内部类不可见，屏蔽实现类的可见性。
3、静态内部类： 静态内部类定义在类中，任何方法外，用static定义。
注意：静态内部类中可以定义静态或者非静态的成员
public class Outer {
private static int i = 1;
private int j = 10;
public static void outer_f1(){
}
public void outer_f2(){
}
// 静态内部类可以用public,protected,private修饰
// 静态内部类中可以定义静态或者非静态的成员
static class Inner{
static int inner_i = 100;
int inner_j = 200;
static void inner_f1(){
System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员
outer_f1();//包括静态变量和静态方法
}
void inner_f2(){
// System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员
// outer_f2();//包括非静态变量和非静态方法
}
}
public void outer_f3(){
// 外部类访问内部类的静态成员：内部类.静态成员
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部类访问内部类的非静态成员:实例化内部类即可
Inner inner = new Inner();
inner.inner_f2();
}
public static void main(String[] args) {
new Outer().outer_f3();
}
}
注意：*******生成（new）一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：
Outer.Inner in=new Outer.Inner()；
而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类。静态内部类不可用private来进行定义。*******
例子：
对于两个类，拥有相同的方法：
class People
{
run();
}
class Machine{
run();
}
此时有一个robot类：
class Robot extends People implement Machine.
此时run()不可直接实现。
注意：当类与接口（或者是接口与接口）发生方法命名冲突的时候，此时必须使用内部类来实现。用接口不能完全地实现多继承，用接口配合内部类才能实现真正的多继承。
4、匿名内部类
匿名内部类是一种特殊的局部内部类，它是通过匿名类实现接口。
IA被定义为接口。
IA I=new IA(){};
匿名内部类的特点：
1，一个类用于继承其他类或是实现接口，并不需要增加额外的方法，只是对继承方法的事先或是覆盖。
2，只是为了获得一个对象实例，不需要知道其实际类型。
3，类名没有意义，也就是不需要使用到。
public class Outer {
private static int i = 1;
private int j = 10;
public static void outer_f1(){
}
public void outer_f2(){
}
// 静态内部类可以用public,protected,private修饰
// 静态内部类中可以定义静态或者非静态的成员
static class Inner{
static int inner_i = 100;
int inner_j = 200;
static void inner_f1(){
System.out.println("Outer.i"+i);//静态内部类只能访问外部类的静态成员
outer_f1();//包括静态变量和静态方法
}
void inner_f2(){
// System.out.println("Outer.i"+j);//静态内部类不能访问外部类的非静态成员
// outer_f2();//包括非静态变量和非静态方法
}
}
public void outer_f3(){
// 外部类访问内部类的静态成员：内部类.静态成员
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部类访问内部类的非静态成员:实例化内部类即可
Inner inner = new Inner();
inner.inner_f2();
}
public static void main(String[] args) {
new Outer().outer_f3();
}
}
注：一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类，没有类名，根据多态，我们使用其父类名。因他是局部内部类，那么局部内部类的所有限制都对其生效。匿名内部类是唯一一种无构造方法类。大部分匿名内部类是用于接口回调用的。匿名内部类在编译的时候由系统自动起名Out$1.class。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。因匿名内部类无构造方法，所以其使用范围非常的有限。当需要多个对象时使用局部内部类，因此局部内部类的应用相对比较多。匿名内部类中不能定义构造方法。如果一个对象编译时的类型是接口，那么其运行的类型为实现这个接口的类。
________________________________________________________________________________
内部类总结：
1.首先，把内部类作为外部类的一个特殊的成员来看待，因此它有类成员的封闭等级：private ,protected,默认(friendly),public
它有类成员的修饰符: static,final,abstract
2.非静态内部类nested inner class,内部类隐含有一个外部类的指针this,因此，它可以访问外部类的一切资源（当然包括private）
外部类访问内部类的成员，先要取得内部类的对象,并且取决于内部类成员的封装等级。
非静态内部类不能包含任何static成员.
3.静态内部类：static inner class,不再包含外部类的this指针，并且在外部类装载时初始化.
静态内部类能包含static或非static成员.
静态内部类只能访问外部类static成员.
外部类访问静态内部类的成员，循一般类法规。对于static成员，用类名.成员即可访问，对于非static成员，只能
用对象.成员进行访问
4.对于方法中的内部类或块中内部类只能访问块中或方法中的final变量。
类成员有两种static , non-static，同样内部类也有这两种
non-static 内部类的实例，必须在外部类的方法中创建或通过外部类的实例来创建(OuterClassInstanceName.new innerClassName(ConstructorParameter)),并且可直接访问外部类的信息,外部类对象可通过OuterClassName.this来引用
static 内部类的实例, 直接创建即可，没有对外部类实例的引用。
内部类不管static还是non-static都有对外部类的引用
non-static 内部类不允许有static成员
方法中的内部类只允许访问方法中的final局部变量和方法的final参数列表，所以说方法中的内部类和内部类没什麽区别。但方法中的内部类不能在方法以外访问，方法中不可以有static内部类
匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数
匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递
2. c语言如果用指针去使用变量，和直接使用变量有什么不同。
指针是C语言中的一个重要概念，也是C语言的一个重要特色。正确而灵活的运用它，可以有效地表示复杂的数据结构；能动态分配内存；方便地使用字符串；有效而方便地使用数组；在调用函数时能获得一个以上的结果；能直接处理内存单元地址等……——《C程序设计（第三版）》
你在举例的时候说的直接引用数据的时候是几乎没有区别的，数组其实也相当于一种指针的应用，只不过是规定好了的。但比如用在排序上，同样是排序（从大到小）数据1和2，不用指针：
#include
void main()
{
int a,b;
scanf("%d %d",&a,&b);
if(a<b)
{
a=a+b;
b=a-b;
a=a-b;
}
}
原来输入的时候是a=1，b=2，程序运行完是a=2，b=1；
而如果运用指针：
#include
void main()
{
int *p1,*p2,*p,a,b;
scanf("%d %d",&a,&b);
p1=&a;
p2=&b;
if(a<b)
{
p1=&b;
p2=&a;
}
}
排序完成后，p1指向较大的数2，p2指向较小的数1，而a仍然等于1，b=2，它们的值是不变的。如果在另外的程序中同样调用了这两个变量，用指针就不会对其产生影响，这就是指针作用的一个方面。指针还有很多其它方面的作用，这也是c语言的一个特色，建议你好好地学一下，很有用的。
3. 自动化测试时需要使用python，请问如何理解python中的全局变量和局部变量
提供理解供参考：
简单点来说：
1、在python中，全局变量可以直接访问，而局部变量只能在定义的块（如函数体）内部或是通过函数访问。
2、同名的变量，会优先使用局部变量。
为更好理解，示例代码如下：
3、可以在函数体内部，使用 global来字义一个全局变量，在使用之前这个全局变量必须初始化。
4. C语言中直接访问数据方式和间接访问数据方式区别
直接访问数据和间接访问数据 直接访问数据是指通过变量名直接使用变量数据，我们以前编写的程序，都是用这种方式访问数据。例如： int i; scanf("%d",&i); printf("%d",i); 间接访问数据是指通过指针变量去访问其他变量数据，这是C语言中大量使
5. C程序设计中什么是直接访问和间接访问，访问是什么意思
（1）直接访问：
int a=0;
a=a+1;
这种就属于直接访问变量a这个名字就是你给这块内存取的名字，取a的值的时候就是直接从内存中取出值来
（2）间接访问：
int a=0;
int *p=&a;
*p = (*p)+1;
这种就属于间接访问，p变量的这块内存中存的是a的地址，通过p内存中的地址找到这块内存，取出里边的值，就是间接访问
6. c++为何要用指针指针有何好处
指针就是地址，另外还有指针变量，也就是存放地址的变量。
指针是存放内存地址的，使编程更容易实现数据的出去和计算。
平时使用的别的变量（指的指针变量以外的变量），就是用变量名字代表了它所在的空间，本质还是到这个地址去访问；而用指针变量访问，就是直接访问这个空间了，因此更高效。
7. 13)在C语言中，对变量的访问方式是（ ）
文件的打开(fopen函数)
fopen函数用来打开一个文件，其调用的一般形式为：
文件指针名=fopen(文件名,使用文件方式);
其中，
“文件指针名”必须是被说明为FILE 类型的指针变量；
“文件名”是被打开文件的文件名；
“使用文件方式”是指文件的类型和操作要求。
“文件名”是字符串常量或字符串数组。
例如：
FILE *fp；
fp=("file a","r");
其意义是在当前目录下打开文件file a，只允许进行“读”操作，并使fp指向该文件。
又如：
FILE *fphzk
fphzk=("c:\\hzk16","rb")
其意义是打开C驱动器磁盘的根目录下的文件hzk16，这是一个二进制文件，只允许按二进制方式进行读操作。两个反斜线“\\ ”中的第一个表示转义字符，第二个表示根目录。
使用文件的方式共有12种，下面给出了它们的符号和意义。
文件使用方式 意义
“rt” 只读打开一个文本文件，只允许读数据
“wt” 只写打开或建立一个文本文件，只允许写数据
“at” 追加打开一个文本文件，并在文件末尾写数据
“rb” 只读打开一个二进制文件，只允许读数据
“wb” 只写打开或建立一个二进制文件，只允许写数据
“ab” 追加打开一个二进制文件，并在文件末尾写数据
“rt+” 读写打开一个文本文件，允许读和写
“wt+” 读写打开或建立一个文本文件，允许读写
“at+” 读写打开一个文本文件，允许读，或在文件末追加数据
“rb+” 读写打开一个二进制文件，允许读和写
“wb+” 读写打开或建立一个二进制文件，允许读和写
“ab+” 读写打开一个二进制文件，允许读，或在文件末追加数据
对于文件使用方式有以下几点说明：
1) 文件使用方式由r,w,a,t,b，+六个字符拼成，各字符的含义是：
r(read): 读
w(write): 写
a(append): 追加
t(text): 文本文件，可省略不写
b(banary): 二进制文件
+: 读和写
2) 凡用“r”打开一个文件时，该文件必须已经存在，且只能从该文件读出。
3) 用“w”打开的文件只能向该文件写入。若打开的文件不存在，则以指定的文件名建立该文件，若打开的文件已经存在，则将该文件删去，重建一个新文件。
4) 若要向一个已存在的文件追加新的信息，只能用“a”方式打开文件。但此时该文件必须是存在的，否则将会出错。
5) 在打开一个文件时，如果出错，fopen将返回一个空指针值NULL。在程序中可以用这一信息来判别是否完成打开文件的工作，并作相应的处理。因此常用以下程序段打开文件：
6) if((fp=fopen("c:\\hzk16","rb")==NULL)
{
printf("\nerror on open c:\\hzk16 file!");
getch();
exit(1);
}
这段程序的意义是，如果返回的指针为空，表示不能打开C盘根目录下的hzk16文件，则给出提示信息“error on open c:\ hzk16 file!”，下一行getch()的功能是从键盘输入一个字符，但不在屏幕上显示。在这里，该行的作用是等待，只有当用户从键盘敲任一键时，程序才继续执行，因此用户可利用这个等待时间阅读出错提示。敲键后执行exit(1)退出程序。
7) 把一个文本文件读入内存时，要将ASCII码转换成二进制码，而把文件以文本方式写入磁盘时，也要把二进制码转换成ASCII码，因此文本文件的读写要花费较多的转换时间。对二进制文件的读写不存在这种转换。
8) 标准输入文件(键盘)，标准输出文件(显示器)，标准出错输出(出错信息)是由系统打开的，可直接使用。
13.1.2 文件关闭函数（fclose函数）
文件一旦使用完毕，应用关闭文件函数把文件关闭，以避免文件的数据丢失等错误。
fclose函数调用的一般形式是：
fclose(文件指针)；
例如：
fclose(fp);
正常完成关闭文件操作时，fclose函数返回值为0。如返回非零值则表示有错误发生。
13.2 文件的读写
对文件的读和写是最常用的文件操作。在C语言中提供了多种文件读写的函数：
•字符读写函数 ：fgetc和fputc
•字符串读写函数：fgets和fputs
•数据块读写函数：freed和fwrite
•格式化读写函数：fscanf和fprinf
使用以上函数都要求包含头文件stdio.h。
8. 关于两个程序同时运行，不同程序的变量的内存地址一样该怎么理解
变量是局部的，而且非malloc变量，因此是固定的，之所以在不同进程间也一样，应该是操作系统做了一次内存映射的，看到的这个地址只是相对于程序其实内存地址的相对地址。实际地址应该要在加上程序的起始地址才对。
fun1(int *p1){ //子程序fun1里形式参数为指针，获得一个内存地址。
*p1=1; //将指针所指向的内容赋予1
}
fun2(int *p2){
*p2=3;
}
main
{ int a;
printf("%d,%d",fun1(&a),fun2(&a)); //fun1,fun2分别获得变量a 的地址并对a进行修改
}
输出结果为:
1,3
两个子程序都是获得一个变量的内存地址
(8)直接访问就是直接利用变量扩展阅读：
如果内存变量和字段同名，直接使用变量访问是字段，要访问内存变量应该在变量名前加上“m．”，如有一个字段名为XB，有一个名为XB的内存变量，则要给该内存变量给值8，可使用的语言为：M.XB=8
可使用SAVE TO命名把内存变量保存到内存变量文件中，也可使用RESTORE命令把内存变量文件中的内存变量及值恢复到内存中。
SAVE TO命令的格式如下：
SAVE TO FileName[ALL LIKE Skeleton|ALL EXCEPT Skeleton]
格式中的FileName为内存变量的文件名，默认的扩展名为.MEM，Skeleton用来指定一类变量，可在其中使用“*”和“？”通配符，通配符的含义与文件名通配符基本一致。
9. 概念帝请进，c语言，关于直接访问和间接访问的问题
我来打个比方吧：
a. 直接访问某个地址，就相当于你知道某个物品放在某个抽屉里，然后你去那个抽屉，然后访问你的物品。
b. 间接访问就是，你知道某个抽屉放着一个纸条，纸条写着：某某物品存放于某某另外一个抽屉。
这样的话
a里面的抽屉，就是变量，
b里面存放纸条的抽屉，就是指针，指针的值，就是那个纸条，纸条指向另外一个抽屉（变量），另外一个抽屉存放的东西，就是一个变量的值。
10. c语言用指针比较快是不是因为直接访问寻找变量需要的时间比较多 而指针直接从地址访问就不用寻址费时了
用指针不是减少了寻址的时间，是省略了计算地址的步骤，要做的工作少了，所以说速度快。
用指针比较快，这个概念有点过时了。现在的编译器，代码优化的效率是很高的，在设定高优化级别的情况下，两者几乎没有差别。另一方面，使用指针编程相对复杂，更容易导致潜在的错误，就软件工程的角度来看，牺牲可靠性来换取速度的小量提升（甚至速度没有提升）是划算的。
结论，减少指针的使用，使用索引就很好。要想提升执行速度，编译的时候把优先级别设的高一点就可以了。