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語言用指針比較快是不是因為直接訪問尋找變數需要的時間比較多 而指針直接從地址訪問就不用定址費時了
用指針不是減少了定址的時間，是省略了計算地址的步驟，要做的工作少了，所以說速度快。
用指針比較快，這個概念有點過時了。現在的編譯器，代碼優化的效率是很高的，在設定高優化級別的情況下，兩者幾乎沒有差別。另一方面，使用指針編程相對復雜，更容易導致潛在的錯誤，就軟體工程的角度來看，犧牲可靠性來換取速度的小量提升（甚至速度沒有提升）是劃算的。
結論，減少指針的使用，使用索引就很好。要想提升執行速度，編譯的時候把優先順序別設的高一點就可以了。