【翻译】(52)grant-uri-permission元素
see
http://developer.android.com/guide/topics/manifest/grant-uri-permission-element.html
原文见
http://developer.android.com/guide/topics/manifest/grant-uri-permission-element.html
-------------------------------
<grant-uri-permission>
grant-uri-permission元素
-------------------------------
* syntax:
* 语法：
-------------------------------
<grant-uri-permission android:path="string"
android:pathPattern="string"
android:pathPrefix="string" />
-------------------------------
* contained in:
* 被包含在：
<provider>
* description:
* 描述：
Specifies which data subsets of the parent content provider permission can be granted for. Data subsets are indicated by the path part of a content: URI. (The authority part of the URI identifies the content provider.) Granting permission is a way of enabling clients of the provider that don't normally have permission to access its data to overcome that restriction on a one-time basis.
指定父内容提供者权限的哪个数据子集可以被授权。数据子集通过一个content: URI的路径部分来指定。（URI的权力部分标识内容提供者。）授权权限是使正常情况下没有权限访问其数据的提供者客户端能够在单次的基础上跨越那个限制的一种方式。
If a content provider's grantUriPermissions attribute is "true", permission can be granted for any the data under the provider's purview. However, if that attribute is "false", permission can be granted only to data subsets that are specified by this element. A provider can contain any number of <grant-uri-permission> elements. Each one can specify only one path (only one of the three possible attributes).
如果一个内容提供者的grantUriPermissions属性为"true"，那么权限可以对该提供者的范围下的任意数据授权。然而，如果那个属性为"false"，那么权限可以只对这个元素指定的数据子集授权。一个提供者可以包含任意数量的<grant-uri-permission>元素。每个元素只可以指定一个路径（只是三种可能属性中的一种）。
For information on how permission is granted, see the <intent-filter> element's grantUriPermissions attribute.
想获得关于权限如何被授权的信息，请参见<intent-filter>元素的grantUriPermissions属性。
* attributes:
* 属性：
* android:path
* android:pathPrefix
* android:pathPattern
A path identifying the data subset or subsets that permission can be granted for. The path attribute specifies a complete path; permission can be granted only to the particular data subset identified by that path. The pathPrefix attribute specifies the initial part of a path; permission can be granted to all data subsets with paths that share that initial part. The pathPattern attribute specifies a complete path, but one that can contain the following wildcards:
一个标识权限可以授权到的一个或多个数据子集的路径。path属性指定一个完整的路径；权限只可以授权给那个路径标识的特殊数据子集。pathPrefix属性指定路径的开始部分；权限可以授权给所有带有共享那个开始部分的路径的数据子集。pathPattern属性指定一个完整路径，但是它可以包含以下通配符：
* An asterisk ('*') matches a sequence of 0 to many occurrences of the immediately preceding character.
* 一个星号（'*'）匹配一个零到多次出现的即时（注：紧接）前驱字符的序列。
* A period followed by an asterisk (".*") matches any sequence of 0 to many characters.
* 一个点后面跟着一个星号（".*"）匹配0到多个字符的任意序列。
Because '\' is used as an escape character when the string is read from XML (before it is parsed as a pattern), you will need to double-escape: For example, a literal '*' would be written as "\\*" and a literal '\' would be written as "\\\\". This is basically the same as what you would need to write if constructing the string in Java code.
因为'\'被用作一个转义字符当该字符串从XML中被读取（在它被解释为一个模式之前），你将需要双转义：例如，一个字面'*'应该被写成"\\*"而一个字面'\'应该被写成"\\\\"。这基本上和如果在Java代码中构造字符串的话你需要写的东西是相同的。
For more information on these types of patterns, see the descriptions of PATTERN_LITERAL, PATTERN_PREFIX, and PATTERN_SIMPLE_GLOB in the PatternMatcher class.
想获得关于这三种类型模式的更多信息，参见PatternMatcher类中PATTERN_LITERAL，PATTERN_PREFIX，和PATTERN_SIMPLE_GLOB的描述。
* introduced in:
* 引入：
API Level 1
API级别1
* see also:
* 另见：
the grantUriPermissions attribute of the <provider> element
<provider>元素的grantUriPermissions属性
Except as noted, this content is licensed under Apache 2.0. For details and restrictions, see the Content License.
除特别说明外，本文在Apache 2.0下许可。细节和限制请参考内容许可证。
Android 4.0 r1 - 10 Feb 2012 0:44
-------------------------------
Portions of this page are modifications based on work created and shared by the Android Open Source Project and used according to terms described in the Creative Commons 2.5 Attribution License.
（此页部分内容基于Android开源项目，以及使用根据创作公共2.5来源许可证描述的条款进行修改）
（本人翻译质量欠佳，请以官方最新内容为准，或者参考其它翻译版本：
* ソフトウェア技術ドキュメントを勝手に翻訳
http://www.techdoctranslator.com/android
* Ley's Blog
http://leybreeze.com/blog/
* 农民伯伯
http://www.cnblogs.com/over140/
* Android中文翻译组
http://androidbox.sinaapp.com/
）
http://replicant.us/
https://www.codeaurora.org/
http://idroidproject.org/
http://code.google.com/p/android-on-freerunner/
class A {
public A() {
init();
}
public void init() {
}
}
public class B extends A {
int i;
int s = 0;
public void init() {
i = 100;
s = 100;
}
public void println() {
System.out.println(i);
System.out.println(s);
}
public static void main(String[] arg) {
new B().println();
}
}
它的输出是什么呢？为什么不输出 100 100，而输出 100 0呢？
可以用下面的代码来尝试解释：
class A {
public A() {
System.out.println("enter A()");
init();
System.out.println("exit A()");
}
public void init() {
System.out.println("enter A.init");
System.out.println("exit A.init");
}
}
public class B extends A {
public B() {
System.out.println("enter B()");
System.out.println("exit B()");
}
int i;
int s = inits();
public static int inits() {
System.out.println("enter B.inits");
System.out.println("exit B.inits");
return 0;
}
public void init() {
System.out.println("enter B.init");
i = 100;
s = 100;
System.out.println("exit B.init");
}
public void println() {
System.out.println("enter B.println");
System.out.println(i);
System.out.println(s);
System.out.println("exit B.println");
}
public static void main(String[] arg) {
new B().println();
}
}
上面的代码输出如下：
enter A()
enter B.init
exit B.init
exit A()
enter B.inits
exit B.inits
enter B()
exit B()
enter B.println
100
0
exit B.println
由此可以看出大致执行顺序如下：
main的new B()
->class B的public B()的第一行（首先调用基类构造函数，隐含的super()调用），第二行还没执行又
->class A的public A()第一行，第二行init()去调用class B的init()而不是class A的init()所以
这里i=100,s=100（运行时多态性），public A()完了之后
->public B()的第一行，下面先执行实例变量的初始化。（此处在下面继续讨论）
下来是s=inits()结果s=0，i没变还是100，最后才执行public B()的两条输出，到这里new B()才算完，
下面就是B的println()。
关于i和s在类初始化方面的赋值方面的问题，请继续看下面的例子：
class Base {
Base() {
System.out.println("Base() before print()");
print();
System.out.println("Base() after print()");
}
public void print() {
System.out.println("Base.print()");
}
}
class Derived extends Base {
int value = 100;
Derived() {
System.out.println("Derived() With " + value);
}
public void print() {
System.out.println("Derived.print() with " + value);
}
}
public class Main {
public static void main(String[] args) {
new Derived();
}
}
如果变量有定义初始化值，如value=100,则先赋初始值,然后运行构造函数，那么在这个程
序的任何位置value都应该是100，但事实却非如此，输出结果如下：
Base() before print()
Derived.print() with 0 <---------这里是0而不是100
Base() after print()
Derived() With 100
会不会比较容易让人迷惑？
总结一下吧，顺序当然是很容易就推出，没什么好讨论的。
实际上例子只是说明，
int i; != int i = 0;
一般的初学者都会认为两者是相同的。
但是实际上不但是在顺序上不一样，而且javac对两者的编译是完全不一样。
前者只是申明一个变量,在初始化对象变量(这里指int i = 0;)的时候并不会编译成初始化指令。
而这些初始化对象变量的指令，会在本类构造函数里面的第一条指令（注意不是构造函数之前）
之前执行，而在此之前可能已经执行了父类的构造函数。
所以我们不难推出最开始那个例子的结果为什么一个是100,一个是0。
还有要注意的是构造函数实际上并没有分配空间（尽管我们通常都会认为）。
对于一般的对象生成（用new关键字，其他情况要另外分析）。
javac会把它编译成new #number 这个指令,#number指向的是类在常数池的索引。
这个new指令就是分配对象空间，并根据类里面所声明的变量进行空间分配，
并把他们赋值成初始化的值（就是大家都知道的，int(0),objct(null)）。
举个简单的例子。对于一般的语句：比如说new A();
实际上执行顺序如下：
new #A的索引
//然后是下面大括号的指令，它们都是A的构造函数（这里的构造函数并不等同于我们代码
里面的public A() {.. }，实际上是大于,然后
根据里面的代码生成A的构造函数字节代码段。)
{
执行父类构造函数字节代码段
本类对象变量的初始化指令（比如int i = 10；这些指令是在编译时确定的）
然后下面的指令就是public A() {...}里面代码的指令
{
...
...
}
}
实际上，假如你只是在类申明了int i;而在以后的代码都不引用它的话,
javac是不会把它编译到class里面的。这也许是javac的优化结果。