編譯器會給匿名類一個名字嗎

⑴ c＋＋，我發現一個問題。匿名命名空間裡面的變數怎麼引用啊他沒有空間名啊啊啊啊，怎麼引用

在本文件中，直接使用。
在其他文件中無法使用。

當定義一個命名空間時，可以忽略這個命名空間的名稱：
namespce {
char c;
int i;
double d;
}
編譯器在內蘆枝部會為這個命名空間生成一個唯一的名字，而且還會為這個匿名的命名空間生成一條using指令。所以上面的代碼在效果上等同於：
namespace __UNIQUE_NAME_ {
char c;
int i;
double d;
}
using namespace __UNIQUE_NAME_;

在匿謹喚名命名空間中聲明的名稱也將被編譯器轉換，與編譯器為這個匿名命名空間生祥嘩凱成的唯一內部名稱(即這里的__UNIQUE_NAME_)綁定在一起。還有一點很重要，就是這些名稱具有internal鏈接屬性，這和聲明為static的全局名稱的鏈接屬性是相同的，即名稱的作用域被限制在當前文件中，無法通過在另外的文件中使用extern聲明來進行鏈接。如果不提倡使用全局static聲明一個名稱擁有internal鏈接屬性，則匿名命名空間可以作為一種更好的達到相同效果的方法。

注意:命名空間都是具有external 連接屬性的,只是匿名的命名空間產生的__UNIQUE_NAME__在別的文件中無法得到,這個唯一的名字是不可見的.

C++ 新的標准中提倡使用匿名命名空間,而不推薦使用static,因為static用在不同的地方,涵義不同,容易造成混淆.另外,static不能修飾class。

⑵ t=new Thread(new Runnable(){主體}) Thread是匿名類嗎java

是
t=new Thread(new Runnable(){主體})

表示Thread接收一個實現Runnable介面的類作為參數；
但 new Runnable() 在java語法上不成立，因為介面不能被實例化
改成new Runnable(){主體} 表示一個實現了Runnable介面的類唯攜凳，這個類和傳統的類定義不一樣
如class A implements Runnable(){主體} 不一樣，它沒有類名
因此叫做匿名類（全稱是匿名內部類），因此隱滾它只在本作用域中有效，屬於一個類，即內部類

想查看結果，在編譯後的指旅目錄下，可以看到一個 主類名$匿名類名.class的文件
匿名類名 由編譯器給出。

親，如果回答滿意，請及時採納。謝謝！！

⑶ java 匿名內部類有沒有構造函數

因為匿名內部類沒有類名(至輪弊少是李判明面上沒有)，不然為何叫匿名？ 構造器是要有類名哪桐改的。 不過有種方式可以起到構造器的作用，但有局限性，那就是「構造代碼塊」

⑷ 一個關於C#3.5新特性中的匿名類型的問題，各位大神幫幫忙！

1. 不用匿名類型. 如果只用一次而且你真的不想單獨為這個創建一個class, 用list = new List<Tuple<string, string>>(); 強類型的話後面就可以讀出來了.
2. 如果一定要用匿名類型:
.NET 3.5 裡面沒有逗敬鋒dynamic, 編譯器不支持auto type inferring. 所以必須用reflection.
3. Jon Skeet提出過一個解決方山晌案, 在: http://msmvps.com/blogs/jon_skeet/archive/2009/01/09/horrible-grotty-hack-returning-an-anonymous-type-instance.aspx. 這個方案利用了編譯器把所有簽名相同的匿名類型看作同一類型的功能. 雖然丑稿碼了點, 但是能用.

⑸ 了解C#特性匿名類型與隱式類型局部變數

C# 里我們已經匿名方法了 現在類型也玩起匿名來了 怪不得大家 舉報 的時候都喜歡匿名 為啥？因為匿名被舉報人就找不著報復對象了唄 是的 匿名就是把名字隱藏起來 沒有名字誰還能找得到你啊

匿名類型

在C#里有這樣一些類型 它是作為臨時儲存數據的 生命周期只在這個方法內 方法結束了 這個類型的生命周期也沒有了 那麼這里我們就可以使用一個匿名類型

varKeyPair=new{Key= yuyi Value= };

這個KeyPair就是一個匿名類型 注意KeyPair這里是一個變數名 並不是類的名字 嗯 前面還有一個var 這又是什麼呢？這是C# 裡面的隱式局部變數

隱式類型局部變數

還是先介紹一下隱式類型局部變數吧

在C# 里多了一個關鍵字var 他表示這樣的一種類型 C#編譯器可以根據上下文推斷的出來比如var I = ;編譯器可以根據後面的賦值推斷的出來i應該是個整型 既然是局部變數 那麼它就只能用在方法內部了 注意C#是強類型的 引入了一個var並不是像javascript那樣 變成了一個弱類型的語言 在編譯器第一次編譯後var就會被確定的類型所替代蠢哪的 所以對於隱式類型局部變數要注意以下幾點

它只能存在於方法內部

它不是一個新的帶升碼類型 只是一個關鍵字 或者叫做一個佔位符 在C#編譯器編譯後它就會被確定的類型所替代

它是編譯器根據上下文推斷出來的 所以所有一切不能被編譯器推斷出來的用法都是錯誤的 比如不能這樣使用 var nullValue = null;因為null啥也不是 他是一個空指針 是一個不確定的東西 也不能這樣使用 var I = ;I = abc ;編譯器根據第一個賦值會推斷出它是一個整型 但是隨後又將一個字元串賦值給它 這是怎麼回事呢？

對於var我的建議是不到逼不得已的時候不用 那什麼是逼不得已呢？來看我們的匿名類型吧

回到匿名類型

剛才說了 匿名類型是沒有名字的類型 沒有名字你怎麼來稱呼它 怎麼來聲明它？但是匿名類型真的是沒有名字的么？

看看C#編譯笑蠢器又在我們背後幹了些什麼

使用ILDASM打開編譯過的程序集 發現多了一個類型

<>f__AnonymousType <<Key>j__TPar <Value>j__TPar>

這個類型是直接繼承自System Object的 並且是internal seald(只在程序集內可見 並且不能被繼承) 有心的你也許會發現 這個類型還是一個泛型類型 那麼只要我們在使用一個匿名類型的時候參數個數 參數名稱不發生變化 編譯器是不會為我們產生更多的類型的

varKeyPair =new{Key= yuyi Value= Programer };varKeyPair =new{Key= y Value= };varKeyPair =new{Key= Value= abc };

上面三個匿名類型 編譯器只會為我們在背後產生一個新類型 一個泛型的新類型 如果我們將這個匿名類型內的屬性名修改一下 對

varKeyPair =new{Key= yuyi Value= Programer };varKeyPair =new{Key= y Value = };

就會產生兩個新泛型了

<>f__AnonymousType <<Key>j__TPar <Value>j__TPar><>f__AnonymousType <<Key>j__TPar <Value >j__TPar>

看看 這個命名還是有規律可循哦 如果你給這個匿名類型添加一個新屬性呢？這樣又產生了一個新類型了

<>f__AnonymousType <<Key>j__TPar <Value >j__TPar <Test>j__TPar>

嗯 這個問題還是值得關注的 所以我們在使用匿名類型的時候應該盡量保持 一致性

屬性個數一致(這個盡量了)

屬性名稱一致 這個比較好把握

只要保持了這個一致性 編譯器會為一致的產生同一個類型 而不一致的會新產生一個類型 如果不一致的太多我想是不是會產生 代碼爆炸 而致使 WorkSet 過大造成性能的損失？這個只是我個人認為 沒有經過測試

繼續隱式類型局部變數

⑹ C# 裡面沒字元識別問題 高分求解

LINQ語法大全
Select/Distinct操作包括9種形式，分別為簡單用法、匿名類型形式、條件形式、指定類型形式、篩選形念余式、整形類型形式、嵌套槐答類型形式、本地方法調用形式、Distinct形式。
1.簡單用法：
這個示例返回僅含客戶聯系人姓名的序列。
var q =
from c in db.Customers
select c.ContactName;
注意：這個語句只是一個聲明或者一個描述，並沒有真正把數據取出來，只有當你需要該數據的時候，它才會執行這個語句，這就是延遲載入(deferred loading)。如果，在聲明的時候就返回的結果集是對象的集合。你可以使用ToList() 或ToArray()方法把查詢結果先進行保存，然後再對這個集合進行查詢。當然延遲載入(deferred loading)可以像拼接SQL語句那樣拼接查詢語法，再執行它。
2.匿名類型形式：
說明：匿名類型是C#3.0中新特性。其實質是編譯器根據我們自定義自動產生一個匿名的類來幫助我們實現臨時變數的儲存。匿名類型還依賴於另外一個特性：支持根據property來創建對象。比如，var d = new { Name = "s" };編譯器自動產生一個有property叫做Name的匿名類，然後按這個類型分配內存，並初始化對象。但是var d = new {"s"};是編譯不通過的。因為，編譯器不知道匿名類中的property的名字。例如string c = "d";var d = new { c}; 則是可以通過編譯的。編譯器會創建一個叫做匿名類帶有叫c的property。
例如下例：new{c,ContactName,c.Phone};ContactName和Phone都是在映射文件中定義與表中欄位相對應的property。編譯器讀取數據並創建對象時，會創建一個匿名類，這個類有兩個屬性，為ContactName和Phone，然後根據數據初始化對象。另外編譯器還可以重命名property的名字。
var q =
from c in db.Customers
select new {c.ContactName, c.Phone};
上面語句描述：使用 SELECT 和匿名類型返回僅含客戶聯系人姓名和電話號碼的序列
var q =
from e in db.Employees
select new
{
Name = e.FirstName + " " + e.LastName,
Phone = e.HomePhone
};
上面語句描述：使用SELECT和匿名類型返回僅含雇員仔明滾姓名和電話號碼的序列，並將FirstName和LastName欄位合並為一個欄位「Name」，此外在所得的序列中將HomePhone欄位重命名為Phone。
var q =
from p in db.Procts
select new
{
p.ProctID,
HalfPrice = p.UnitPrice / 2
};
上面語句描述：使用SELECT和匿名類型返回所有產品的ID以及HalfPrice(設置為產品單價除以2所得的值)的序列。
3.條件形式：
說明：生成SQL語句為：case when condition then else。
var q =
from p in db.Procts
select new
{
p.ProctName,
Availability =
p.UnitsInStock - p.UnitsOnOrder < 0 ?
"Out Of Stock" : "In Stock"
};
上面語句描述：使用SELECT和條件語句返回產品名稱和產品供貨狀態的序列。
4.指定類型形式：
說明：該形式返回你自定義類型的對象集。
var q =
from e in db.Employees
select new Name
{
FirstName = e.FirstName,
LastName = e.LastName
};
上面語句描述：使用SELECT和已知類型返回雇員姓名的序列。
5.篩選形式：
說明：結合where使用，起到過濾作用。
var q =
from c in db.Customers
where c.City == "London"
select c.ContactName;
上面語句描述：使用SELECT和WHERE返回僅含倫敦客戶聯系人姓名的序列。
6.shaped形式(整形類型)：
說明：其select操作使用了匿名對象，而這個匿名對象中，其屬性也是個匿名對象。
var q =
from c in db.Customers
select new {
c.CustomerID,
CompanyInfo = new {c.CompanyName, c.City, c.Country},
ContactInfo = new {c.ContactName, c.ContactTitle}
};
語句描述：使用SELECT 和匿名類型返回有關客戶的數據的整形子集。查詢顧客的ID和公司信息（公司名稱，城市，國家）以及聯系信息（聯系人和職位）。
7.嵌套類型形式：
說明：返回的對象集中的每個對象DiscountedProcts屬性中，又包含一個集合。也就是每個對象也是一個集合類。
var q =
from o in db.Orders
select new {
o.OrderID,
DiscountedProcts =
from od in o.OrderDetails
where od.Discount > 0.0
select od,
FreeShippingDiscount = o.Freight
};
語句描述：使用嵌套查詢返回所有訂單及其OrderID 的序列、打折訂單中項目的子序列以及免送貨所省下的金額。
8.本地方法調用形式(LocalMethodCall)：
這個例子在查詢中調用本地方法PhoneNumberConverter將電話號碼轉換為國際格式。
var q = from c in db.Customers
where c.Country == "UK" || c.Country == "USA"
select new
{
c.CustomerID,
c.CompanyName,
Phone = c.Phone,
InternationalPhone =
PhoneNumberConverter(c.Country, c.Phone)
};
PhoneNumberConverter方法如下：
public string PhoneNumberConverter(string Country, string Phone)
{
Phone = Phone.Replace(" ", "").Replace(")", ")-");
switch (Country)
{
case "USA":
return "1-" + Phone;
case "UK":
return "44-" + Phone;
default:
return Phone;
}
}
下面也是使用了這個方法將電話號碼轉換為國際格式並創建XDocument
XDocument doc = new XDocument(
new XElement("Customers", from c in db.Customers
where c.Country == "UK" || c.Country == "USA"
select (new XElement("Customer",
new XAttribute("CustomerID", c.CustomerID),
new XAttribute("CompanyName", c.CompanyName),
new XAttribute("InterationalPhone",
PhoneNumberConverter(c.Country, c.Phone))
))));
9.Distinct形式：
說明：篩選欄位中不相同的值。用於查詢不重復的結果集。生成SQL語句為：SELECT DISTINCT [City] FROM [Customers]
var q = (
from c in db.Customers
select c.City )
.Distinct();
語句描述：查詢顧客覆蓋的國家。
Count/Sum/Min/Max/Avg操作符
適用場景：統計數據吧，比如統計一些數據的個數，求和，最小值，最大值，平均數。
Count
說明：返回集合中的元素個數，返回INT類型；不延遲。生成SQL語句為：SELECT COUNT(*) FROM
1.簡單形式：
得到資料庫中客戶的數量：
var q = db.Customers.Count();
2.帶條件形式：
得到資料庫中未斷貨產品的數量：
var q = db.Procts.Count(p => !p.Discontinued);
LongCount
說明：返回集合中的元素個數，返回LONG類型；不延遲。對於元素個數較多的集合可視情況可以選用LongCount來統計元素個數，它返回long類型，比較精確。生成SQL語句為：SELECT COUNT_BIG(*) FROM
var q = db.Customers.LongCount();
Sum
說明：返回集合中數值類型元素之和，集合應為INT類型集合；不延遲。生成SQL語句為：SELECT SUM(…) FROM
1.簡單形式：
得到所有訂單的總運費：
var q = db.Orders.Select(o => o.Freight).Sum();
2.映射形式：
得到所有產品的訂貨總數：
var q = db.Procts.Sum(p => p.UnitsOnOrder);
Min
說明：返回集合中元素的最小值；不延遲。生成SQL語句為：SELECT MIN(…) FROM
1.簡單形式：
查找任意產品的最低單價：
var q = db.Procts.Select(p => p.UnitPrice).Min();
2.映射形式：
查找任意訂單的最低運費：
var q = db.Orders.Min(o => o.Freight);
3.元素：
查找每個類別中單價最低的產品：
var categories =
from p in db.Procts
group p by p.CategoryID into g
select new {
CategoryID = g.Key,
CheapestProcts =
from p2 in g
where p2.UnitPrice == g.Min(p3 => p3.UnitPrice)
select p2
};
Max
說明：返回集合中元素的最大值；不延遲。生成SQL語句為：SELECT MAX(…) FROM
1.簡單形式：
查找任意雇員的最近僱用日期：
var q = db.Employees.Select(e => e.HireDate).Max();
2.映射形式：
查找任意產品的最大庫存量：
var q = db.Procts.Max(p => p.UnitsInStock);
3.元素：
查找每個類別中單價最高的產品：
var categories =
from p in db.Procts
group p by p.CategoryID into g
select new {
g.Key,
MostExpensiveProcts =
from p2 in g
where p2.UnitPrice == g.Max(p3 => p3.UnitPrice)
select p2
};
Average
說明：返回集合中的數值類型元素的平均值。集合應為數字類型集合，其返回值類型為double；不延遲。生成SQL語句為：SELECT AVG(…) FROM
1.簡單形式：
得到所有訂單的平均運費：
var q = db.Orders.Select(o => o.Freight).Average();
2.映射形式：
得到所有產品的平均單價：
var q = db.Procts.Average(p => p.UnitPrice);
3.元素：
查找每個類別中單價高於該類別平均單價的產品：
var categories =
from p in db.Procts
group p by p.CategoryID into g
select new {
g.Key,
ExpensiveProcts =
from p2 in g
where p2.UnitPrice > g.Average(p3 => p3.UnitPrice)
select p2
};
Aggregate
說明：根據輸入的表達式獲取聚合值；不延遲。即是說：用一個種子值與當前元素通過指定的函數來進行對比來遍歷集合中的元素，符合條件的元素保留下來。如果沒有指定種子值的話，種子值默認為集合的第一個元素。
LINQ to SQL語句的關鍵字一覽
Where 過濾；延遲
Select 選擇；延遲
Distinct 查詢不重復的結果集；延遲
Count 返回集合中的元素個數，返回INT類型；不延遲
LongCount 返回集合中的元素個數，返回LONG類型；不延遲
Sum 返回集合中數值類型元素之和，集合應為INT類型集合；不延遲
Min 返回集合中元素的最小值；不延遲
Max 返回集合中元素的最大值；不延遲
Average 返回集合中的數值類型元素的平均值。集合應為數字類型集合，其返回值類型為double；不延遲
Aggregate 根據輸入的表達式獲取聚合值；不延遲

⑺ 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內部類
匿名內部類如果繼承自介面,必須實現指定介面的方法,且無參數
匿名內部類如果繼承自類,參數必須按父類的構造函數的參數傳遞