编译器会给匿名类一个名字吗

⑴ 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内部类
匿名内部类如果继承自接口,必须实现指定接口的方法,且无参数
匿名内部类如果继承自类,参数必须按父类的构造函数的参数传递