proper

上网下个系统修复软件 试试。

刚开始学习这一块的内容。请指教

patents指专利权，其包括对发明创造，工业设计和外观设计的相关权利；intellectual property right是比专利权更广泛的知识产权，除专利权外，还包括著作权和商标权等相关权利在内。

人类的追求是进行正确的学习！

The file should be properly secured文件应妥善保护

boot.properties 中用户名密码不对在domian目录下面建立一个boot.properties文件填入weblogic用户名密码username=用户名password=密码

分析：电脑显示未找到启动磁盘。如果此前未曾修改CMOS启动项，则一般为硬盘出现故障如接触不良或损坏而未能通过开机通电自检，或者是硬盘主引导记录损坏，或者是主机插入非启动光盘或U盘。处理办法：1、关机断电开机箱，重新插拔硬盘电源线和数据线（若为笔记本电脑则只需重新插拔硬盘），再开机，按DEL键（笔记本为F2或其它）进入CMOS中BOOT选项卡，看能否检测到硬盘信息。如能则将硬盘设置为第一启动项。按F10键保存按Y键确定退出重启。2、如果检测到硬盘但仍无法启动，则使用系统U盘或光盘启动电脑后，运行DISKGENIUS对硬盘进行检测，并重建主引导记录MBR。3、如果以上操作无效，则需要重装系统。重装系统方法很多，推荐光盘重装系统。4、如不能检测到硬盘，则更换硬盘电源线和数据线，无效再更换硬盘，并重装系统。5、如果CMOS中将光盘或U盘启动设置在硬盘启动之前，则需要将插入在光驱或主机USB接口上的非启动光盘或U盘取出。

我这么记的 p看成poor poverty 是贫穷 property有两个p 负负得正 反而是财产

可以用“分级”的形式来及，pove rty prop erty

Your letter of July 25,( in ) which you express the hope of entering into business connections with us has been received ( with ) thanks. 可以表达为: - In your letter of July 25,you express the hope of entering into business connections with us... 在你7月25日的信中. - .with thanks,常见well received with many thanks!表示谢谢的意思; thanks置于结尾用with,置于前用for,thanks for sth/doing sth We are indebted ( to ) Messrs Wallace Kimber & Co.,( with ) your name and address and should be pleased to open up business relations with your firm. indebt to *** 欠某人钱,负债于某人 with your name and address 以你的名字和地址.

可以和读文本文件一样读取fso = new ActiveXObject("Scripting.FileSystemObject");f = fso.OpenTextFile("c:fps.properties", ForWriting, true);或者用java代码把xx.properties拼成JSON放到那个页面的js代码块里

不会

thermal properties 热性质 请采纳如果你认可我的回答，敬请及时采纳，~如果你认可我的回答，请及时点击【采纳为满意回答】按钮~~手机提问的朋友在客户端右上角评价点【满意】即可。~你的采纳是我前进的动力~~O(∩_∩)O，记得好评和采纳，互相帮助

improper types不当的类型-----------------------------------如有疑问欢迎追问！满意请点击右上方【选为满意回答】按钮

ECMAScript可以识别两种类型的对象，一种叫做Native Object属于语言范畴;一种叫做Host Object，由运行环境提供例如document对象， Dom Node等 Native objects是一种松散的结构并且可以动态的增加属性(property)，所有的属性都有一个名字和一个值，这个值可以是另一个对象的引用 或者是内建的数据类型(String, Number, Boolean, Null 或者 Undefined) 下面的这个简单的例子描述了一个javascript对象是如何设置一个属性的值和如何读取属性的值的。 赋值操作 一个对象的属性的创建非常简单，直接通过赋值操作就可以完成属性的创建。 代码 1. var objectRef = new Object(); //create a generic javascript object. 一个名为testNumber的属性可以这样创建。 代码 1. objectRef.testNumber = 5; 2. /* - or:- */ 3. objectRef["testNumber"] = 5; 如果复制的属性名称已经存在那么不会再次创建这个属性，赋值操作仅仅是重新设置属性的值 代码 1. objectRef.testNumber = 8; 2. /* - or:- */ 3. objectRef["testNumber"] = 8; js对象的原型(prototype)自己本身也可以是对象，也可以有属性(property),对于js对象的(prototype)的赋值操作跟普通对象属性的创建 没什么不同。 取值操作 在取值操作中property和prototype就不一样了，先看最简单的property取值操作。 代码 1. /*为一个对象的属性赋值，如果这个对象没有这个属性，那么在赋值操作后，这个对象就有这个属性了 */ 2. objectRef.testNumber = 8; 3. /* 读出这个属性的值 */ 4. var val = objectRef.testNumber; 5. 6. /* 现在val 就得到了刚才赋予objectRef的值8了*/ prototype揭密 但是所有的对象都可以有prototypes, prototypes自己也是对象，那么他也可以有prototypes,这样循环下去就形成了一个prototype链， 这个链当他遇到链中队形的prototype是null时中止。(Object的默认的prototype是null) 代码 1. var objectRef = new Object(); //create a generic javascript object. 创建一个新的js对象，这时这个对象的prototype是Null，所以objectRef的prototype链只包含一个对象Object.prototype 我们在看下面的代码 代码 1. /* 构建MyObject1这个类型的构造函数 2. MyObject1 - type. 3. */ 4. function MyObject1(formalParameter){ 5. /* 为者对象创建一个属性名字叫testNumber 6. */ 7. this.testNumber = formalParameter; 8. } 9. 10. /* 构建MyObject2这个类型的构造函数 11. MyObject2 - type:- 12. */ 13. function MyObject2(formalParameter){ 14. /* 为者对象创建一个属性名字叫testString*/ 15. this.testString = formalParameter; 16. } 17. 18. /* 下一步的操作会用MyObject1对象替换掉MyObject2默认的prototype属性*/ 19. MyObject2.prototype = new MyObject1( 8 ); 20. 21. /* 最后我们创建MyObject2类型的一个对象*/ 22. 23. var objectRef = new MyObject2( "String_Value" ); objectRef这个MyObject2类型的对象有一个prototype的链，链中的第一个对象是MyObject1对象，MyObject1对象也有prototype, 这个prototype是Object默认的prototype，Object.prototype的prototype是null,至此这条prototype链结束。 当一个取值操作发生时，objectRef 的整个prototype链就开始工作 代码 1. var val = objectRef.testString; objectRef这个对象的有一个属性叫做testString，那么这句代码会把testString的值赋给val 代码 1. var val = objectRef.testNumber; 在objectRef这个对象里并没有testNumber这个属性，但是val却的到了值8，而不是undefine,这是因为解释器在没有在当前对象找到要找 的属性后，就会去检查这个对象的prototype,objectRef的prototype是MyObject1对象，这个对象有testNumber这个属性，所以val得到8这个值。 代码 1. var val = objectRef.toString; 现在val是个function的引用，这个function是Object.prototype的property,由于MyObject1和MyObject2都没有定义toString这个property 所以Object.prototype返回。 代码 1. var val = objectRef.madeUpProperty; 最后val是undefined,因为MyObject1和MyObject2，还有Object都没有定义madeUpProperty这个property,所以得到的是undefine. 读操作会读取在obj自己和prototype 链上发现的第一个同名属性值 写操作会为obj对象本身创建一个同名属性(如果这个属性名不存在 这就意味着objectRef.testNumber = 3会在objectRef对象上创建一个property，名字是testNumber，当下一次在要读取testNumber时 propertype链就不会工作，仅仅会得到objectRef的property 3,而MyObject1的testNumber属性并不会被修改。下面的代码可以验证 代码 1. /* 构建MyObject1这个类型的构造函数 2. MyObject1 - type. 3. */ 4. function MyObject1(formalParameter){ 5. /* 为者对象创建一个属性名字叫testNumber 6. */ 7. this.testNumber = formalParameter; 8. } 9. 10. /* 构建MyObject2这个类型的构造函数 11. MyObject2 - type:- 12. */ 13. function MyObject2(formalParameter){ 14. /* 为者对象创建一个属性名字叫testString*/ 15. this.testString = formalParameter; 16. } 17. 18. /* 下一步的操作会用MyObject1对象替换掉MyObject2默认的prototype属性*/ 19. var obj1 = new MyObject1( 8 ); 20. MyObject2.prototype = obj1; 21. 22. /* 最后我们创建MyObject2类型的一个对象*/ 23. 24. var objectRef = new MyObject2( "String_Value" ); 25. 26. alert(objectRef.testNumber); 27. objectRef.testNumber = 5; 28. alert(objectRef.testNumber); 29. alert(obj1.testNumber);

belonging是你随身带的东西。property是一些不动产，如建筑物。

通过第一印象判断一个人是合适的吗？

tofoodsaftyproblems在这里相当于做后置定语，修饰前面的answers.Notfartoseek的意思是不难找的，不难理解的，这句话可以这样理解：Sometimesproperanswserstofoodsafetyproblemsarenotfartoseek.(全句是系表结构)

网址：网页链接

to food safty problems在这里相当于做后置定语，修饰前面的answers. Not far to seek的意思是不难找的，不难理解的，这句话可以这样理解：Sometimes proper answsers to food safety problems are not far to seek.(全句是系表结构)

如果是一个类里的,类名为 Userprivate vName as string "这里真实的存东西的"写一个属性public property let Name(value as string )"这里的name就是别人传过来的值 vname=value"这里是直接等了,你可以在这里入一些代码 又如有性别问题.如果name值变了,你可以清除为空,如果你的类有事件,可以触发你的事件end properptypublic property get Name as string "别人取值时返回的值,你也可以加入一些自己的处理代码 Name=vNameend property"""""也可以有参数的属性"egproperty let Tels(value as string,index as integer ) "如果上面有一个数组类的,你就可以这样用 "如果上面的数组名为 vTels() as string " vtels(index)=value"就可以这样用end proerptyproperty get Tels(index as integer) as string Tels=vtels(index)end property"类的使用 dim t as new usert.name="名称1""这时就会发生你类的let 过程 msgbox t.name "这里就会发生 name 的get 过程t.tels(1)="110""就会发生 tel 的 let 过程 msgbox t.tels(1)" 就是 get 了

我是英语专业的，虽然不是很详尽，但希望我总结出来的可以帮到你。equal:强调两者能力、地位等方面平等或者可以相匹敌。常用搭配：be equal tosame:表示相同。固定搭配：be the same as...和...相同的identical强调的是两者的完全一致。be identical with/to...proper是“正当的，适合的”意思，不会和前3者混淆啊

property的主要意思是财产, 所有物, 所有权, 性质, 特性, (小)道具而estate是房产，房地产所有权

eval:按照名称访问变量、属性、对象或影片剪辑。如果表达式是变量或属性，则返回该变量或属性的值。如果表达式是对象或影片剪辑，则返回对该对象或影片剪辑的引用。如果无法找到表达式中列举的元素，则返回undefined。在Flash4中，eval()用于模拟数组；在Flash5或更高版本中，您应该使用Array类来模拟数组。在Flash4中，您还可以使用eval()动态地设置和检索变量值或实例名称。然而，也可以使用数组访问运算符([])来实现这一点。在Flash5或更高版本中，不能使用eval()动态设置和检索变量值或实例名称，因为不能在等式的左侧使用eval()。例如，将代码eval("var"+i)="first";替换为：this["var"+i]="first"或者替换为：set("var"+i,"first");getProperty:返回影片剪辑my_mc的指定属性的值。比如：this.createEmptyMovieClip("someClip_mc",999);trace("Thealphaof"+getProperty(someClip_mc,_name)+"is:"+getProperty(someClip_mc,_alpha));将会返回someClip_mc的alpha值。

properties一般定义在着色器的起始部分，我们可以在Shader书写的时候定义多种多样的属性，而使用Shader的时候可以直接在材质检视面板(Material Inspector)里编辑这些属性，取不同的值或者纹理。这可以说是Unity贴心&可见即所得的又一体现吧。以Unity自带的BasicVertex Lighting 基本顶点光照为例，一张很直观的图就是这样:需要注意，Properties块内的语法都是单行的。每个属性都是由内部名称开始，后面括号中是显示在检视面板(Inspector)中的名字和该属性的类型。等号后边跟的是默认值。在Properties{}中定义着色器属性，在这里定义的属性将被作为输入提供给所有的子着色器。每一条属性的定义的语法是这样的：_Name("Display Name", type) = defaultValue[{options}]11_Name - 属性的名字，简单说就是变量名，在之后整个Shader代码中将使用这个名字来获取该属性的内容Display Name - 这个字符串将显示在Unity的材质编辑器中作为Shader的使用者可读的内容type - 这个属性的类型，可能的type所表示的内容有以下几种：Color - 一种颜色，由RGBA（红绿蓝和透明度）四个量来定义；2D - 一张2的阶数大小（256，512之类）的贴图。这张贴图将在采样后被转为对应基于模型UV的每个像素的颜色，最终被显示出来；Rect - 一个非2阶数大小的贴图；Cube - 即Cube map texture（立方体纹理），简单说就是6张有联系的2D贴图的组合，主要用来做反射效果（比如天空盒和动态反射），也会被转换为对应点的采样；Range(min, max) - 一个介于最小值和最大值之间的浮点数，一般用来当作调整Shader某些特性的参数（比如透明度渲染的截止值可以是从0至1的值等）；Float - 任意一个浮点数；Vector - 一个四维数；defaultValue 定义了这个属性的默认值，通过输入一个符合格式的默认值来指定对应属性的初始值（某些效果可能需要某些特定的参数值来达到需要的效果，虽然这些值可以在之后在进行调整，但是如果默认就指定为想要的值的话就省去了一个个调整的时间，方便很多）。Color - 以0～1定义的rgba颜色，比如(1,1,1,1)；2D/Rect/Cube - 对于贴图来说，默认值可以为一个代表默认tint颜色的字符串，可以是空字符串或者"white",“black”,“gray”,"bump"中的一个Float，Range - 某个指定的浮点数Vector - 一个4维数，写为 (x,y,z,w)另外还有一个{option}，它只对2D，Rect或者Cube贴图有关，在写输入时我们最少要在贴图之后写一对什么都不含的空白的{}，当我们需要打开特定选项时可以把其写在这对花括号内。如果需要同时打开多个选项，可以使用空白分隔。可能的选择有ObjectLinear, EyeLinear, SphereMap, CubeReflect, CubeNormal中的一个，这些都是OpenGL中TexGen的模式，具体的留到后面有机会再说。所以，一组属性的申明看起来也许会是这个样子的：//Define a color with a default value of semi-transparent blue_MainColor ("Main Color", Color) = (0,0,1,0.5) //Define a texture with a default of white_Texture ("Texture", 2D) = "white" {} 12341234属性案例代码：Properties { Property [Property …] }定义属性块，其中可包含多个属性，其定义如下：name (“display name”, Range (min, max)) =number定义浮点数属性，在检视器中可通过一个标注最大最小值的滑条来修改。name (“display name”, Color) =(number,number,number,number)定义颜色属性name (“display name”, 2D) = “name” {options }定义2D纹理属性name (“display name”, Rect) = “name”{ options }定义长方形（非2次方）纹理属性name (“display name”, Cube) = “name”{ options }定义立方贴图纹理属性name (“display name”, Float) = number定义浮点数属性name (“display name”, Vector) =(number,number,number,number)定义一个四元素的容器(相当于Vector4)属性一些细节说明包含在着色器中的每一个属性通过name索引（在Unity中, 通常使用下划线来开始一个着色器属性的名字）。属性会将display name显示在材质检视器中，还可以通过在等符号后为每个属性提供缺省值。对于Range和Float类型的属性只能是单精度值。对于Color和Vector类型的属性将包含4个由括号围住的数描述。对于纹理(2D, Rect, Cube) 缺省值既可以是一个空字符串也可以是某个内置的缺省纹理：“white”, “black”, “gray” or"bump"。

太简单了。。。。重装系统！

范例人是人类。这里的人类就是一个 Attribute（特性）。人有翅膀。这里的翅膀就是 Properties（属性）。那么 Field（字段） 和 Property（属性）呢？多数时候我们都会听说：Fields（字段）和 Properties（属性）在有时候听起来是相似的，而在有时候它们听起来又是不同的。而实际上，Fields（字段）定义了在存储值或者主题的状态时所必需的区域，而 Properties（属性）则除了对状态或值的呈现之外，其他的什么也没有。

1、写代码时用Alt-Insert（Code|Generate…）可以创建类里面任何字段的getter与setter方法。2、CodeCompletion（代码完成）属性里的一个特殊的变量是，激活Ctrl-Alt-Space可以完成在或不在当前文件里的类名。如果类没有引入则import标志会自动创建。3、使用Ctrl-Shift-V快捷键可以将最近使用的剪贴板内容选择插入到文本。使用时系统会弹出一个含有剪贴内容的对话框，从中你可以选择你要粘贴的部分。4、利用CodeCompletion（代码完成）属性可以快速地在代码中完成各种不同地语句，方法是先键入一个类名地前几个字母然后再用Ctrl-Space完成全称。如果有多个选项，它们会列在速查列表里。5、用Ctrl-/与Ctrl-Shift-/来注释/反注释代码行与代码块。6 、-/用单行注释标记（“//…”）来注释/反注释当前行或者选择地代码块。而Ctrl-Shift-/则可以用块注释标记（“/*…*/”）把所选块包围起来。要反注释一个代码块就在块中任何一个地方按Ctrl-Shift-/即可。7、按Alt-Q（View|Context Info）可以不需要移动代码就能查看当前方法地声明。连续按两次会显示当前所编辑的类名。8、在编辑器里Ctrl-D可以复制选择的块或者没有所选块是的当前行，Ctrl-Y与之相反。

property就不说了。Attribute是对元数据的(metadata)抽象，一般会结合反射使用（方便反射）。 Attribute可以将元数据与程序元素绑定，说起很空洞。你看了Attribute的用法，就知道了。给我的感觉就是简洁

题主应该问的是这两个词的名词在表示“属性”或类似含义时的区别吧。答案是没有区别。在表示“属性”或类似含义时，这两个词是通用的，不会因为这个属性是不是重要、是不是可改变、是不是主要次要等等而有区别。两个简单的例句：An important attribute (of sth.) is the ability to work for long periods almost independently.An important property of a square matrix is its trace.但是，还是要注意：property 在日常使用中多数情况下是“财产”及类似含义，这也是我看到这个词之后的默认第一反应。用这个词表示“属性”的时候稍微留意一点，不要让读者误会成别的意思就好。

DOM元素含有的这两个东西，虽然完全不是一回事，但却又紧密联系在一体，不细细体会，还真不好分清。Property-属性，就像C#等高级语言可以.(dot)获取或者设置其值；Attribute-特性，每一个dom元素都有一个attributes属性来存放所有的attribute节点，通过getAttribute()和setAttribute()方法来进行获取和操作。1 <div id="test" name="div1" class="center" customtag="divTest"/>上例中div里面的id、name、class还有自定义的customtag都放到了attributes里面，attributes类似数组的容器，名字索引存放的是name=value的attribute的节点，上面的就是[class="center",name="div1",id="test",customtag="divTest"]需要获取和设置这些attribute，很简单document.getElemmentById("test").getAttribute("customtag") //divTestdocument.getElemmentById("test").setAttribute("data","11")document.getElemmentById("test").removeAttribute("data")Property就是一个属性，如果把DOM元素看成是一个普通的object对象，那么property就是以name=value形式存放在Object中的属性（C#中的类似），操作很简单elem.gameid = 880; // 添加 console.log( elem.gameid ) // 获取这两个东西有什么联系和区别呢？首先，很多attribute节点有一个相应的property属性，如例子中的div元素的id和class既是attribute也有property，不管哪种方式都可以访问和修改,但是对于自定义的attribute节点，或者自定义property，两者就没有关系了,对于IE6-7来说，没有区分attribute和property。具体的讲解可以考attribute和property的区别，很详细。虽然getAttribute和点号方法都能获取标准属性，但是他们对于某些属性，获取到的值存在差异性，比如href,src,value等<a href="#" id="link">Test Link</a><img src="img.png" id="image" /><input type="text" value="enter text" id="ipt" /><script>var $ = function(id){return document.getElementById(id);};alert($("link").getAttribute("href"));//#alert($("link").href);//fullpath/file.html#alert($("image").getAttribute("src"))//img.pngalert($("image").src)//fullpath/img.pngalert($("ipt").getAttribute("value"))//enter textalert($("ipt").value)//enter text$("ipt").value = 5;alert($("ipt").getAttribute("value"))//enter textalert($("ipt").value)//5</script>

这三个词做名词时都有特征，特点属性的意思。attribute和characteristic即可形容人又可形容物，而property则只能用于形容物体且多用复数形式。characteristic相比于attribute更强调一个人或事物的典型特征。

在C#中有两个属性，分别为Property和Attribute，两个的中文意思都有特性、属性之间，但是用法上却不一样，为了区别，本文暂把Property称为特性，把Attribute称为属性。Attribute才是本文的主角，把它称为属性我觉得很恰当。属性的意思就是附属于某种事物上的，用来说明这个事物的各种特征的一种描述。而Attribute就是干这事的。它允许你将信息与你定义的C#类型相关联，作为类型的标注。这些信息是任意的，就是说，它不是由语言本身决定的，你可以随意建立和关联任何类型的任何信息。你可以作用属性定义设计时信息和运行时信息，甚至是运行时的行为特征。关键在于这些信息不仅可以被用户取出来作为一种类型的标注，它更可以被编译器所识别，作为编译时的一种附属条件参加程序的编译。以下部分内容及代码来源于《C#技术揭秘》(Inside C# Sencond Edition)定义属性：属性实际上是一个派生自System.Attribute基类的类。System.Attribute类含有几个用于访问和检查自定义属性的方法。尽管你有权将任何类定义为属性，但是按照惯例来说，从System.Attribute派生类是有意义的。示例如下：public enum RegHives{HKEY_CLASSES_ROOT,HKEY_CURRENT_USER,HKEY_LOCAL_MACHINE,HKEY_USERS,HKEY_CURRENT_CONFIG}public class RegKeyAttribute : Attribute{public RegKeyAttribute(RegHives Hive, String ValueName){this.Hive = Hive;this.ValueName = ValueName;}protected RegHives hive;public RegHives Hive{get { return hive; }set { hive = value; }}protected String valueName;public String ValueName{get { return valueName; }set { valueName = value; }}}我们在这里添加了不同注册表的枚举、属性类的构造器以及两个特性(Property)。在定义属性时你可以做许许多多的事情，下面我们看看如何在运行时查询属性。要想在运行时查询类型或成员所附着的属性，必须使用反射查询类属性：假设你希望定义一个属性，这个属性定义了将在其上创建对象的远程服务器。如果没有这个属性，就要把此信息保存在一个常量中或是一个应用程序的资源文件中。通过使用属性，只需用以下方法标注出类的远程服务器名即可：using System;namespace QueryAttribs{public enum RemoteServers{JEANVALJEAN,JAVERT,COSETTE}public class RemoteObjectAttribute : Attribute{public RemoteObjectAttribute(RemoteServers Server){this.server = Server;}protected RemoteServers server;public string Server{get{return RemoteServers.GetName(typeof(RemoteServers), this.server);}}}[RemoteObject(RemoteServers.COSETTE)]class MyRemotableClass{}class Test{[STAThread]static void Main(string[] args){Type type = typeof(MyRemotableClass);foreach (Attribute attr intype.GetCustomAttributes(true)){RemoteObjectAttribute remoteAttr =attr as RemoteObjectAttribute;if (null != remoteAttr){Console.WriteLine("Create this object on {0}.",remoteAttr.Server);}}Console.ReadLine();}}}运行结果为:Creat this object on COSETTE。注意：在这个例子中的属性类名具有Attribute后缀。但是，当我们将此属性附着给类型或成员时却不包括Attribute后缀。这是C#语言的设计者提供的简单方式。当编译器看到一个属性被附着给一个类型或成员时，它会搜索具有指定属性名的System.Attribute派生类。如果编译器没有找到匹配的类，它就在指定的属性名后面加上Attribute，然后再进行搜索。因此，常见的使用做法是将属性类名定义为以Attribute结尾，在使用时忽略名称的这一部分。以下的代码都采用这种命名方式。查询方法属性：在下面这个例子中，我们使用属性将方法定义为可事务化的方法，只要存在TransactionableAttribute属性，代码就知道具有这个属性的方法可以属于一个事务。using System;using System.Reflection;namespace MethodAttribs{public class TransactionableAttribute : Attribute{public TransactionableAttribute(){}}class SomeClass{[Transactionable]public void Foo(){}public void Bar(){}[Transactionable]public void Goo(){}}class Test{[STAThread]static void Main(string[] args){Type type = Type.GetType("MethodAttribs.SomeClass");foreach (MethodInfo method in type.GetMethods()){foreach (Attribute attr inmethod.GetCustomAttributes(true)){if (attr is TransactionableAttribute){Console.WriteLine("{0} is transactionable.",method.Name);}}}Console.ReadLine();}}}运行结果如下：Foo is transactionable.Goo is transactionable.

attribute是属性特征的意思 property是财产和性质的意思Property在英语里有财产的含义，一般指对象的组成部分，可以是简单数据也可以是对象或对象集合. Attribute多指一个对象的特征，绝大的数情况下是一个描述性的数据。打个比方，可能不是很恰当：张三是中国人，身上有一百块钱。中国人就是张三的attribute, 100块钱就是张三的property.

在JAVA WEB开发中经常遇到获取请求参数的值和在request对象中set或者get属性，初学者往往容易混淆，那么二者之间关系到底如何呢？下面是个人的总结：区别：来源不同： 参数（parameter）是从客户端（浏览器）中由用户提供的，若是GET方法是从URL中提供的，若是POST方法是从请求体（request body）中提供的； 属性（attribute）是服务器端的组件（JSP或者Servlet）利用requst.setAttribute（）设置的操作不同： 参数（parameter）的值只能读取不能修改，读取可以使用request.getParameter()读取； 属性（attribute）的值既可以读取亦可以修改，读取可以使用request.setAttribute(),设置可使用request.getAttribute()数据类型不同： 参数（parameter）不管前台传来的值语义是什么，在服务器获取时都以String类型看待，并且客户端的参数值只能是简单类型的值，不能是复杂类型，比如一个对象。 属性（attribute）的值可以是任意一个Object类型。共同点二者的值都被封装在request对象中。

两者都是属性，property是指类向外提供的数据区域而attribute则是，描述对象在编译时或运行时的属性。 a总体上来说，Attribute是Property的子集，Property会在适当的时机表现为Attribute； bProperty出现在类图的元模型中，代表了Class的所有结构化特征；Attribute没有出现在元模型中，它仅仅在Class的概念中存在，没有相应的语法了； cProperty有详细的定义和约束，而Attribute没有详细的定义，因此也不能用OCL写出其约束。 dProperty和Attribute都是M2层的概念。在M1层，它们的实例是具体类的属性；在M0层，它们的实例的实例是具体对象的槽中存储的值。

property是指类向外提供的数据区域。而attribute则是描述对象在编译时或运行时属性的，分为固有型和用户自定义型，其中用户自定义型可以利用Reflection在运行期获取。这两者是有本质区别的。资料上说二者一个是service的属性，而另一个是interface的。第一种好象更准确,摘要如下：在很多人的脑海中，Attribute就是类的属性，Property呢？好像也是类的属性？因此有很多人不加区别的统一称为类的属性，尤其是在写中文文章的时候。这种心理是典型的鸵鸟心态，眼不见为净。其实稍微用脚想一下就知道，事实肯定不是这样的，UML中既然发明了这两个术语，显然不是用来冗余的。它们之间肯定有着千丝万缕的联系与区别。各种各样的面向对象语言、各种组件技术、模板技术、Web Service技术，其中大部分涉及到了“属性”这个概念，而其英文术语则常常是Attribute、Property或者Field。很多人一概称之为“属性”，有的地方确实可以不加区分，但有的地方却是差之毫厘、谬以千里。我对于这些纷纷扰扰的技术和术语也很苦恼，但是我们至少可以通过UML中的这两个术语的解释找到一个可以参考的标准。无论如何，UML是面向对象技术的集大成者和事实上的标准。很客观的说，UML1.4中对于这两个术语并没有很清晰的定义，但是其区别还是显而易见的。Attribute应该是UML1.4中的宠儿，而Property连一个单独的术语都没有捞到。谁也没想到在UML2.0中风云突变，Attribute从类图中消失了，而Property堂而皇之入主中原。1。4中 Attribute是与Classifier相关联的术语，它比Property的影响范围要小。Class是Classifier的子类，因此Attribute也可以表示Class的属性。从上面的定义还可以看出，Attribute可以是Classifier的实例的命名的槽。对于Class来说，其实例就是Object，Object的槽就是对象的属性值槽。因此，Attribute是可以作为对象的属性的。而Property似乎没有这一层的含义。按MOF（元对象设施，OMG的另一个规范，后面会有详细解释）的模型层次划分，Attribute涉及的模型层从M2到M0，而Property似乎只是M2层的概念。2。0中 Attribute这里仅仅指一个类元的结构特征，可以将类元的实例联系到一个或者一组具体值。而没有提到实例的槽（slot）等等。我猜想，这是因为UML2.0中已经把Attribute作为Property的一个子集了，所以关于实例的槽（slot）等等的具体赋值方法，都归结到Property的定义中解释了。另外一点值得注意的是，Attribute的定义来自于术语表，而没有在元模型图中出现。而Property出现在元模型图中，并且都做了详细而具体的解释。这一点可以看出，UML强化Property，弱化Attribute的决心。Attribute和Property的总结这一节对Attribute和Property作一个小结，基于目前最新的UML2.0规范：l 总体上来说，Attribute是Property的子集，Property会在适当的时机表现为Attribute；l Property出现在类图的元模型中，代表了Class的所有结构化特征；Attribute没有出现在元模型中，它仅仅在Class的概念中存在，没有相应的语法了；l Property有详细的定义和约束，而Attribute没有详细的定义，因此也不能用OCL写出其约束。l Property和Attribute都是M2层的概念。在M1层，它们的实例是具体类的属性；在M0层，它们的实例的实例是具体对象的槽中存储的值。对于property和attribute这两个名词都叫“属性”的问题，来源于国内it书籍翻译界的疏忽。其实它们来源于两个不同的领域，attribute属于OOA/OOD的概念，而property属于编程语言中的概念。下面我们来说明它们的异同。AttributeAttributes是Microsoft .NET Framework文件的元数据，可以用来向运行时描述你的代码，或者在程序运行的时候影响应用程序的行为。Property属性是面向对象编程的基本概念，提供了对私有字段的访问封装，在C#中以get和set访问器方法实现对可读可写属性的操作，提供了安全和灵活的数据访问封装。关于属性的概念，不是本文的重点，而且相信大部分的技术人员应该对属性有清晰的概念。以下是简单的属性区别可以说两者没有可比性，只不过我们国家的语言特点才引起的歧异，其实只要记住Attribute是派生于System,Attribute类之下，它的主要作用是描述，比如某为了描述某个方法是来自与外部的dll，可以写如下代码，这就是一个Attribute，他是一个描述（或者说声明）[DllImport("User32.dll")]Attribute也有很多系统的“默认”属性，见下表预定义的属性有效目标说明AttributeUsageClass指定另一个属性类的有效使用方式CLSCompliant全部指出程序元素是否与CLS兼容ConditionalMethod指出如果没有定义相关联的字符串，编译器就可以忽略对这个方法的任何调用DllImportMethod指定包含外部方法的实现的DLL位置STAThreadMethod(Main)指出程序的默认线程模型为STAMTAThreadMethod(Main)指出程序的默认模型为多线程(MTA)Obsolete除了Assembly、Module、Parameter和Return将一个元素标示为不可用，通知用户此元素将被从未来的产品ParamArrayParameter允许单个参数被隐式地当作params(数组)参数对待SerializableClass、Struct、enum、delegate指定这种类型的所有公共和私有字段可以被串行化NonSerializedField应用于被标示为可串行化的类的字段，指出这些字段将不可被串行化StructLayoutClass、struct指定类或结构的数据布局的性质，比如Auto、Explicit或sequentialThreadStaticField(静态)实现线程局部存储(TLS)。不能跨多个线程共享给定的静态字段，每个线程拥有这个静态字段的副本而Property是指编程过程中的字段，也即类的成员。如：private int hour; //定义私有变量表示"小时",外部是访问不到的.} public int Hour// 定义Hour程序接口{ set { hour=value; } get { return hour;}

对象取属性值有两种方法： 使用 for...in 遍历对象： 每次循环，会把对象中的一个字符串类型的属性名保存到变量key中。 (可以使用 console.log(typeof key); 验证) 为什么obj.key会输出undefined呢？是因为它被转换为obj["key"]后去obj中去找属性名为“key”的值，而不是把key识别为一个变量，在obj中并没有定义属性“key”，所以是undefined。 那现在给obj添加属性“key”： 会发现每次循环输出属性名为“key”的属性值。 使用 for...in 变量对象时若其 原型 上有 自定义属性 也会拿到。 那如果不想要输出原型上的属性，只要自身属性怎么做呢？ hasOwnProperty(“属性名”)可以验证属性是否为对象本身所具有，返回布尔值。 上面循环改为 “属性名” in 对象 判断对象是否有这个属性（包括原型上的属性），即对象是否能访问到这个属性，返回布尔值。 A instanceof B 判断A对象的原型链上是否有B的原型对象。

配置文件，配置log4j输出的类型，记录的位置，日志的编码格式等等。主要作用就是记录项目运行时产生的动作。比如异常信息，或者关键动作的记录。都可以配置记录到一个文件当中方便查看。

引用这个包下的 import java.util.Properties;Properties prop = new Properties();不会报错的！

general growth properties一般生长特性properties 英[p"ru0252pu0259tu026az] 美[p"ru0252pu0259tu026az] n. 特性; 财产; 房地产(property的名词复数); 所有权; [例句]We can distinguish one kind of substance from another by its properties.我们可以根据物质的特性把一种物质与另一种物质辨别开来。[其他] 形近词： propertied

最常用读取properties文件的方法InputStream in = getClass().getResourceAsStream("资源Name");这种方式要求properties文件和当前类在同一文件夹下面。如果在不同的包中，必须使用：InputStream ins = this.getClass().getResourceAsStream("/cn/zhao/properties/testPropertiesPath2.properties");Java中获取路径方法获取路径的一个简单实现反射方式获取properties文件的三种方式1 反射方式获取properties文件最常用方法以及思考：Java读取properties文件的方法比较多，网上最多的文章是"Java读取properties文件的六种方法"，但在Java应用中，最常用还是通过java.lang.Class类的getResourceAsStream(String name) 方法来实现，但我见到众多读取properties文件的代码中，都会这么干：InputStream in = getClass().getResourceAsStream("资源Name");这里面有个问题，就是getClass()调用的时候默认省略了this！我们都知道，this是不能在static（静态）方法或者static块中使用的，原因是static类型的方法或者代码块是属于类本身的，不属于某个对象，而this本身就代表当前对象，而静态方法或者块调用的时候是不用初始化对象的。问题是：假如我不想让某个类有对象，那么我会将此类的默认构造方法设为私有，当然也不会写别的共有的构造方法。并且我这个类是工具类，都是静态的方法和变量，我要在静态块或者静态方法中获取properties文件，这个方法就行不通了。那怎么办呢？其实这个类就不是这么用的，他仅仅是需要获取一个Class对象就可以了，那还不容易啊－－ 取所有类的父类Object，用Object.class难道不比你的用你正在写类自身方便安全吗 ？呵呵，下面给出一个例子，以方便交流。 import java.util.Properties; import java.io.InputStream; import java.io.IOException; /** * 读取Properties文件的例子 * File: TestProperties.java * User: leizhimin * Date: 2008-2-15 18:38:40 */ public final class TestProperties { private static String param1; private static String param2; static { Properties prop = new Properties(); InputStream in = Object. class .getResourceAsStream( "/test.properties" ); try { prop.load(in); param1 = prop.getProperty( "initYears1" ).trim(); param2 = prop.getProperty( "initYears2" ).trim(); } catch (IOException e) { e.printStackTrace(); } } /** * 私有构造方法，不需要创建对象 */ private TestProperties() { } public static String getParam1() { return param1; } public static String getParam2() { return param2; } public static void main(String args[]){ System.out.println(getParam1()); System.out.println(getParam2()); } } 运行结果： 151 152 当然，把Object.class换成int.class照样行，呵呵，大家可以试试。另外，如果是static方法或块中读取Properties文件，还有一种最保险的方法，就是这个类的本身名字来直接获取Class对象，比如本例中可写成TestProperties.class，这样做是最保险的方法2 获取路径的方式:File fileB = new File( this .getClass().getResource( "" ).getPath()); System. out .println( "fileB path: " + fileB); 2.2获取当前类所在的工程名：System. out .println("user.dir path: " + System. getProperty ("user.dir"))<span style="background-color: white;">3 获取路径的一个简单的Java实现</span> /** *获取项目的相对路径下文件的绝对路径 * * @param parentDir *目标文件的父目录,例如说,工程的目录下,有lib与bin和conf目录,那么程序运行于lib or * bin,那么需要的配置文件却是conf里面,则需要找到该配置文件的绝对路径 * @param fileName *文件名 * @return一个绝对路径 */ public static String getPath(String parentDir, String fileName) { String path = null; String userdir = System.getProperty("user.dir"); String userdirName = new File(userdir).getName(); if (userdirName.equalsIgnoreCase("lib") || userdirName.equalsIgnoreCase("bin")) { File newf = new File(userdir); File newp = new File(newf.getParent()); if (fileName.trim().equals("")) { path = newp.getPath() + File.separator + parentDir; } else { path = newp.getPath() + File.separator + parentDir + File.separator + fileName; } } else { if (fileName.trim().equals("")) { path = userdir + File.separator + parentDir; } else { path = userdir + File.separator + parentDir + File.separator + fileName; } } return path; } 4 利用反射的方式获取路径：InputStream ips1 = Enumeration . class .getClassLoader() .getResourceAsStream( "cn/zhao/enumStudy/testPropertiesPath1.properties" ); InputStream ips2 = Enumeration . class .getResourceAsStream( "testPropertiesPath1.properties" ); InputStream ips3 = Enumeration . class .getResourceAsStream( "properties/testPropertiesPath2.properties" );

CAD 未知命令“PROPERTIES”。按 F1 查看帮助 简介 CAD 有时输入命令，会提示未知命令“XXX”。按 F1 查看帮助，希望对你有帮助。

public class Config { //Properties继承于HashMap key:value都是String类型 private Properties table=new Properties(); public Config(String file){ try{ table.load(new FileInputStream(file)); }catch (IOException e){ e.printStackTrace(); throw new RuntimeException(e); } } public int getInt(String key){ return Integer.parseInt(table.getProperty(key)); } public String getString(String key){ return table.getProperty(key); } public double getDouble(String key){ return Double.parseDouble(table.getProperty(key)); }}

public class SafeProperties extends Properties {private static final long serialVersionUID = 5011694856722313621L;private static final String keyValueSeparators = "=: f";private static final String strictKeyValueSeparators = "=:";private static final String specialSaveChars = "=: f#!";private static final String whiteSpaceChars = " f";private PropertiesContext context = new PropertiesContext();public PropertiesContext getContext() {return context;}public synchronized void load(InputStream inStream) throws IOException {BufferedReader in;in = new BufferedReader(new InputStreamReader(inStream, "8859_1"));while (true) {// Get next lineString line = in.readLine();// intract property/comment stringString intactLine = line;if (line == null)return;if (line.length() > 0) {// Find start of keyint len = line.length();int keyStart;for (keyStart = 0; keyStart < len; keyStart++)if (whiteSpaceChars.indexOf(line.charAt(keyStart)) == -1)break;// Blank lines are ignoredif (keyStart == len)continue;// Continue lines that end in slashes if they are not commentschar firstChar = line.charAt(keyStart);if ((firstChar != "#") && (firstChar != "!")) {while (continueLine(line)) {String nextLine = in.readLine();intactLine = intactLine + " " + nextLine;if (nextLine == null)nextLine = "";String loppedLine = line.substring(0, len - 1);// Advance beyond whitespace on new lineint startIndex;for (startIndex = 0; startIndex < nextLine.length(); startIndex++)if (whiteSpaceChars.indexOf(nextLine.charAt(startIndex)) == -1)break;nextLine = nextLine.substring(startIndex, nextLine.length());line = new String(loppedLine + nextLine);len = line.length();}// Find separation between key and valueint separatorIndex;for (separatorIndex = keyStart; separatorIndex < len; separatorIndex++) {char currentChar = line.charAt(separatorIndex);if (currentChar == "\")separatorIndex++;else if (keyValueSeparators.indexOf(currentChar) != -1)break;}// Skip over whitespace after key if anyint valueIndex;for (valueIndex = separatorIndex; valueIndex < len; valueIndex++)if (whiteSpaceChars.indexOf(line.charAt(valueIndex)) == -1)break;// Skip over one non whitespace key value separators if anyif (valueIndex < len)if (strictKeyValueSeparators.indexOf(line.charAt(valueIndex)) != -1)valueIndex++;// Skip over white space after other separators if anywhile (valueIndex < len) {if (whiteSpaceChars.indexOf(line.charAt(valueIndex)) == -1)break;valueIndex++;}String key = line.substring(keyStart, separatorIndex);String value = (separatorIndex < len) ? line.substring(valueIndex, len) : "";// Convert then store key and valuekey = loadConvert(key);value = loadConvert(value);//memorize the property also with the whold stringput(key, value, intactLine);} else {//memorize the comment stringcontext.addCommentLine(intactLine);}} else {//memorize the string even the string is emptycontext.addCommentLine(intactLine);}}}/** Converts encoded uxxxx to unicode chars and changes special saved* chars to their original forms*/private String loadConvert(String theString) {char aChar;int len = theString.length();StringBuffer outBuffer = new StringBuffer(len);for (int x = 0; x < len;) {aChar = theString.charAt(x++);if (aChar == "\") {aChar = theString.charAt(x++);if (aChar == "u") {// Read the xxxxint value = 0;for (int i = 0; i < 4; i++) {aChar = theString.charAt(x++);switch (aChar) {case "0":case "1":case "2":case "3":case "4":case "5":case "6":case "7":case "8":case "9":value = (value << 4) + aChar - "0";break;case "a":case "b":case "c":case "d":case "e":case "f":value = (value << 4) + 10 + aChar - "a";break;case "A":case "B":case "C":case "D":case "E":case "F":value = (value << 4) + 10 + aChar - "A";break;default:throw new IllegalArgumentException("Malformed \uxxxx encoding.");}}outBuffer.append((char) value);} else {if (aChar == "t")outBuffer.append(" "); /* ibm@7211 */else if (aChar == "r")outBuffer.append(" "); /* ibm@7211 */else if (aChar == "n") {/** ibm@8897 do not convert a to a line.separator* because on some platforms line.separator is a String* of " ". When a Properties class is saved as a file* (store()) and then restored (load()) the restored* input MUST be the same as the output (so that* Properties.equals() works).* */outBuffer.append(" "); /* ibm@8897 ibm@7211 */} else if (aChar == "f")outBuffer.append("f"); /* ibm@7211 */else/* ibm@7211 */outBuffer.append(aChar); /* ibm@7211 */}} elseoutBuffer.append(aChar);}return outBuffer.toString();}public synchronized void store(OutputStream out, String header) throws IOException {BufferedWriter awriter;awriter = new BufferedWriter(new OutputStreamWriter(out, "8859_1"));if (header != null)writeln(awriter, "#" + header);List entrys = context.getCommentOrEntrys();for (Iterator iter = entrys.iterator(); iter.hasNext();) {Object obj = iter.next();if (obj.toString() != null) {writeln(awriter, obj.toString());}}awriter.flush();}private static void writeln(BufferedWriter bw, String s) throws IOException {bw.write(s);bw.newLine();}private boolean continueLine(String line) {int slashCount = 0;int index = line.length() - 1;while ((index >= 0) && (line.charAt(index--) == "\"))slashCount++;return (slashCount % 2 == 1);}

建个.txt文件后，缀改成.properties 粘贴进去就可以了。具体操作方法如下：1.点击new-file，弹出如下图所示对话框，选择好文件存放路径和文件名即可。2..properties .xml文件都是用来存储信息用的 ，区别只是读取的方式不同而已；就比方说你写了段文件可以存为文本， 也可以存为word 看的时候用不同的程序读取而已。

就是配置文件，用来配置一些经常修改的配置项的。

首先我使用的是注解的方式。创建properties配置文件Key=value的形式在spring的配置文件中进行导入代码如下：<util:properties id="test" location="classpath:test.properties"/>提示：路径问题自己把握3.在你需要使用的类中这样：private @Value("#{test["isOpen"]}") String isOpen;记得写getset方法isOpen这个在test.properties中是这样的：isOpen=true如果有任何问题，可追加。望采纳

　　1.[读取配置文件]： 比如你的properties文件叫做mysql.properties，并且放在com.test包下: java.net.URL url = Thread.currentThread().getContextClassLoader().getResource("com/test/mysql.properties"); 注意路径和包名一致,在你的提问中，我们知道是放在classes目录下，则直接 ...getResource("mysql.properties"); 即可 Properties p = new Properties(); p.load(url.openStream()); //由URL载入配置文件 这样你就得到一个Properties的实例　　2. [读取配置文件信息]： 比如你要读取drivers的值，只需： String theDriver = p.get("drivers"); 根据配置文件，这样你就得到了"org.gjt.mm.mysql.Driver"　　3.[利用JDBC连接数据库] 首先你要保证你有MySQL的Jdbc驱动程序，即包含org.gjt.mm.mysql.Driver的jar包，并放在应用的classpath里。你可以搜索一下，很多地方有下的： mysql-connector-java-3.0.15-ga-bin.jar 然后用同样的方法得到url, mysql.user, mysql.password的值，比如分别为 url, user, pass 然后建立连接： Class.forName("com.mysql.jdbc.Driver"); java.sql.Connection conn

properties 如上面所说，一般和文件相关 这个文件比较特殊，必须是键值对的形式 就像windows 里的 .ini文件一样 如: window=800*600 screen=1 左边键名，右边值，用等号连接 properties 读取文件后，会存为一个个键值对的形式， key=window valu

properties文件不可以传递参数,但是可以借鉴模板技术.addUser.errors.ipArrayStr.invalid=IP [{0}] is invalid!然后程序中根据{}做正则来替换掉{0}.

如果是properties文件的话，那么你应该知道key值。如果你不确定那个key值，那么应该知道这个指定的字符串。只能遍历文件内容了。

*.properties文件中输入属性中文读取出来的方法：因为字节流是无法读取中文的，所以采取reader把inputStream转换成reader用字符流来读取中文。代码如下： Properties properties = new Properties(); InputStream inputStream = this.getClass().getResourceAsStream("/menu.properties"); BufferedReader bf = new BufferedReader(new InputStreamReader(inputStream)); properties.load(bf); System.out.println(properties.getProperty("a"));

静态代码块中不行，之前我也遇到过类似的问题，后来我把static代码块去掉直接写到方法体里面了，就解决了

您好，很高兴为您解答。Properties的store/storeToXML 只能在properties文件开头生成一段注释（单行或多行）。除非只是手工编辑生成，程序只读取。如若满意，请点击右侧【采纳答案】，如若还有问题，请点击【追问】希望我的回答对您有所帮助，望采纳！ ~ O(∩_∩)O~

今天做项目过程中,遇到了个 Properties 转换成Map 的地方第一时间想到的肯定有以下:1. 迭代出来 再 put 到 map 中去2. commons 是否有工具类可是 由于 Properties 实现了Map 接口, 所以有最最简单的 ,强制转换package com.feilong.example.util; import java.util.Properties;import java.util.Map;import java.util.HashMap;import java.util.Set; public class PropertiesToMap { public static void main(String[] args) { Properties properties = new Properties(); properties.setProperty("StrictHostKeyChecking", "no"); properties.setProperty("app.version", "1.0"); // Create a new HashMap and pass an instance of Properties. Properties // is an implementation of a Map which keys and values stored as in a string. Map<String, String> map = new HashMap<String, String>((Map) properties); // Get the entry set of the Map and print it out. Set propertySet = map.entrySet(); for (Object o : propertySet) { Map.Entry entry = (Map.Entry) o; System.out.printf("%s = %s%n", entry.getKey(), entry.getValue()); } }}

EXEC sys.sp_addextendedproperty @name=N"MS_Description", @value=N"字段注释" , @level0type=N"SCHEMA",@level0name=N"dbo", @level1type=N"TABLE",@level1name=N"表名", @level2type=N"COLUMN",@level2name=N"字段名"GOEXEC sys.sp_addextendedproperty @name=N"MS_Description", @value=N"表名注释" , @level0type=N"SCHEMA",@level0name=N"dbo", @level1type=N"TABLE",@level1name=N"表名"GOproperties对于管理人员和开发人员都很重要，如果数据库里面有很详细的注释很方便

本人菜鸟,说说个人想法!Properties的 load方法参数是一个 输入流.你要加载的这些文件 一定在一个目录(文件夹)下吧.如果想要加载多个配置文件的话,可以用 File类的 list()方法 遍历改文件夹中的所有文件.当然也就能 获取这些文件的 输入流了.

一般用classloader吧

在进行一些Java APP开发时，在一个配置文件中定义了许多环境特定的变量。 常见的定义文件有xml、properties甚至txt等格式。 Java具有标准配置格式的文件：properties类型的文件。 主要用于保存以propertyname=propertyvalue等样式保存的命名值对的内容。 读取properties文件的方法各种各样，网上也有很多说明。 这里主要对两种典型的方法进行比较。问题场景现在，假设您有一个config.properties文件，其中包含以下信息：dbpassword=passworddatabase=localhostdbuser=user我们想通过程序读取那个内容。粗略地看，这个问题很简单。 然后，看看我们的第一个方法。File IO直接用File Stream的经典方法读取文件，进行分析不就可以了吗？ 这个实现代码是以下：import java.io.FileInputStream；import java.io.IOException；import java.util.Properties；公共类app {publicstaticvoidmain (string [ ] args ) {Properties prop=new Properties (；try {prop.load (new文件输入(config/config.properties ) )；system.out.println (prop.getproperty ) (database )；system.out.println (prop.getproperty ) (dbuser )；system.out.println (prop.getproperty (" db password " ) )；}catch(ioexceptione ) {e .打印任务跟踪(；}}}此代码创建一个java.util.Properties对象，指定properties文件，然后用FileInputStream读取该InputStream作为参数properties对象的load方法分析了结果。 执行此操作将产生以下结果：localhost用户密码另一个需要注意的是，文件输入流的路径是当前相对路径。 这意味着config.properties文件必须位于class文件所在目录的config字目录下。现在，在考虑其他方式之前，我们先来看看FileInputStream这种方式的特征。 在导入属性文件时，必须知道其路径。 如果采用文件输入流，则必须将文件的路径传递给程序。 如果找不到文件，程序将发生异常。 考虑到我们的程序在编译后往往部署在不同的生产环境中，如果每个环境都不一样，我们每次都会修改这个程序吗？ 还是将配置文件所在的路径作为参数传递给程序？ 这两种方式显然不太合适。 那么，有什么方法可以不用我修改程序或者故意把参数传递给程序吗？ 另一种方法可以达到这个理想的结果。类加载器使用classloader的方法主要是使用getResourceAsStream方法加载属性文件。 有关具体细节，请查看以下示例：import java.io.FileInputStream；import java.io.IOException；import java.util.Properties；公共类新应用程序{publicstaticvoidmain (string [ ] args ) {Properties prop=new Properties (；try {prop.load (new app.class.getclass loader ).getresourceasstream (" config.properties " ) )；system.out.println (prop.getproperty ) (database )；system.out.println (prop.getproperty (" dbuser " ) )；system.out.println (prop.getproperty (" db password " ) )；>} catch(IOException e) {e.printStackTrace();}}}这里我们并没有指定一个特定的路径给classloader，我们只是将文件名直接传给了它。如果我们将config.properties文件和class文件放在同一个目录下，结果运行正常。如果我们将properties放到其他地方则会碰到如下的错误：Exception in thread "main" java.lang.NullPointerExceptionat java.util.Properties$LineReader.readLine(Properties.java:434)at java.util.Properties.load0(Properties.java:353)at java.util.Properties.load(Properties.java:341)at NewApp.main(NewApp.java:10)这是怎么回事呢？这是因为classloader每次会去classpath这些路径搜索需要装载的文件。如果不在这些路径下，则会报找不到文件的错误信息。所以说，只要我们将配置文件放在classpath的路径下，我们就可以保证它会被装载进来，而且程序就不会被改动了。这样就带来了一定的灵活性。比如说前面这个示例，如果我们将properties放到当前目录的config子目录下，该怎么装载它呢？我们需要指定这个路径为classpath就可以了，所以我们运行如下的命令：java -cp c:samplecodeconfig; NewApp我们将看到正常运行的结果。这里我们是将代码放在c:samplecode这个路径下。仔细看看这种classloader装载的方法，其实它只是在一个指定的范围内来查找目标文件。我们在不同的环境下部署安装的时候则不需要去修改程序或给特定程序部分传参数来。我们只需要将需要加载的配置项文件配置到classpath中就可以。当然，除了classloader这种装载properties的方式，还有其他几种具体的方法，比如class.getResourceAsStream(), ResourceBundle.getBundle()等几种方法，他们的本质上和classloader的方式都差不多。classpath的作用前面几个地方也一直提到classpath，那么这个classpath有什么作用呢？在哪些地方我们要用到它？这里也一并讨论一下。我们通常写的一些简单的程序，比如说只是通过console显示结果的，很可能没有留意到classpath的作用。它是指定class所在路径的。在一些需要引用到其他类库的情况下，我们需要这些类库所在的具体位置，比如说我们把一个jar包放在一个lib的文件夹下面了，我们希望程序编译或者执行的时候要能够引用到它。可是java怎么知道引用它呢？这就是classpath的作用了。java虚拟机通过搜索指定的classpath路径变量，它会在这些路径里搜索和尝试装载这些需要的类库。如果能够装载成功则可以保证程序的正常运行，否则会产生错误。所以说，classpath说白了就是一个指定类所在位置的路径以使得jvm可以识别和装载它们。总结操作properties文件的方式有好几种，考虑到properties文件主要是用于针对不同环境进行特定配置的，所以我们必须要保证用一种灵活的方式来加载它。使用classloader等加载的话不需要修改程序，只是需要在部署的时候针对特定环境配置好classpath就可以了。

properties文件是一种常用的配置文件，用于存储键值对的配置信息，通常用于Java项目中的配置。在Maven项目中，我们可以使用pom文件来配置项目的依赖、插件、构建等信息，而在pom文件中，我们可以使用profile来定义不同环境下的配置信息。profile中的配置信息可以覆盖pom文件中的默认配置信息，这样可以方便地切换不同环境下的配置。在Maven项目中，我们通常会使用properties文件来存储一些常量、路径等信息，这些信息可以用于pom文件中的配置。如果我们需要在不同的环境中使用不同的配置信息，我们可以在profile中通过properties文件来覆盖pom文件中的配置信息。这样，在不同的环境中，我们只需要修改properties文件中的配置信息，就可以自动切换相关的配置。在实际应用中，我们经常会使用不同的配置文件来实现不同环境下的配置切换。比如，我们可以使用application.properties文件来存储应用程序的配置信息，然后在不同的环境中使用不同的配置文件来覆盖应用程序的默认配置。这样，我们就可以很方便地切换应用程序的配置，而不需要修改代码。

实现在原来sampler2D _MainTex的地方，添加如下代码：[plain] view plain copy print?在CODE上查看代码片派生到我的代码片float4 _EmissiveColor; float4 _AmbientColor; float _MySliderValue 下面，我们使用_EmissiveColor和_AmbientColor来计算surf函数中新的c的值：[plain] view plain copy print?在CODE上查看代码片派生到我的代码片void surf (Input IN, inout SurfaceOutput o) { float4 c; c = pow((_EmissiveColor + _AmbientColor), _MySliderValue); o.Albedo = c.rgb; o.Alpha = c.a; } 最后，我们的代码应该是这样的：[plain] view plain copy print?在CODE上查看代码片派生到我的代码片Shader "Custom/BasicDiffuse" { Properties { _EmissiveColor ("Emissive Color", Color) = (1,1,1,1) _AmbientColor ("Ambient Color", Color) = (1,1,1,1) _MySliderValue ("This is a Slider", Range(0,10)) = 2.5 } SubShader { Tags { "RenderType"="Opaque" } LOD 200 CGPROGRAM #pragma surface surf Lambert //We need to declare the properties variable type inside of the //CGPROGRAM so we can access its value from the properties block. float4 _EmissiveColor; float4 _AmbientColor; float _MySliderValue; struct Input { float2 uv_MainTex; }; void surf (Input IN, inout SurfaceOutput o) { //We can then use the properties values in our shader float4 c; c = pow((_EmissiveColor + _AmbientColor), _MySliderValue); o.Albedo = c.rgb; o.Alpha = c.a; } ENDCG } FallBack "Diffuse" }

在properties的文件中,在行首加上 # 就是注释这行,或者是用 <!-- --> 包括这行也是注释

使用java.util.Propertiesx0dx0ax0dx0a1、创建一个Properties对象。x0dx0a2、使用对象的load方法加载你的property文件。x0dx0a3、使用getProperty方法取值。x0dx0a例子：x0dx0apackage com.bill.test;x0dx0ax0dx0aimport java.io.FileInputStream;x0dx0aimport java.util.Properties;x0dx0ax0dx0apublic class Test {x0dx0apublic static void main(String[] args) throws Exception{x0dx0aProperties property = new Properties();x0dx0aproperty.load(new FileInputStream("你的文件位置"));x0dx0aString value = property.getProperty("你的属性的key");x0dx0a//TODO 使用value...x0dx0a}x0dx0a}

　　*.properties一般为页面消息的配置文件可以用命令直接将里面的内容变成想要的编码。　　1:先建立一个*.properties文件，用想得到的编码编写文件内容；　　2:在磁盘上运行文件nativezascii-encodinggb2312ApplicationResources_temp.propertiesApplicationResources_zh_CN.properties　　这样就可以将gb2312编码的文字内容转化utf-8编码的内容了，将此文件放入存放配置文件的路径里面，就可以解决网页的多语言显示问题了

properties 如上面所说，一般和文件相关这个文件比较特殊，必须是键值对的形式就像windows 里的 .ini文件一样如:window=800*600screen=1左边键名，右边值，用等号连接properties 读取文件后，会存为一个个键值对的形式，key=window value=800*600等.

Android下用Properties保存程序配置

在安卓编译时修改properties参数，需要在build.gradle文件中添加对应的配置，具体步骤如下：1、打开build.gradle文件，找到android节点下defaultConfig或者flavor节点下的相应配置。2、在配置中添加需要修改的properties参数。3、在命令行中执行编译命令时，添加需要修改的properties参数的值。

Properties properties = new Properties();try {InputStream in = new BufferedInputStream (new FileInputStream(Constants.class.getClassLoader().getResource("").getPath()+"rootPath.properties"));properties.load(in);ROOT_PATH = properties.getProperty("rootPath");} catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}

利用父类Hashtable的put(K key, V value) 添加利用父类Hashtable的remove(Object key) 删除

最常用读取properties文件的方法InputStream in = getClass().getResourceAsStream("资源Name");这种方式要求properties文件和当前类在同一文件夹下面。如果在不同的包中，必须使用：InputStream ins = this.getClass().getResourceAsStream("/cn/zhao/properties/testPropertiesPath2.properties");Java中获取路径方法获取路径的一个简单实现反射方式获取properties文件的三种方式1 反射方式获取properties文件最常用方法以及思考：Java读取properties文件的方法比较多，网上最多的文章是"Java读取properties文件的六种方法"，但在Java应用中，最常用还是通过java.lang.Class类的getResourceAsStream(String name) 方法来实现，但我见到众多读取properties文件的代码中，都会这么干：InputStream in = getClass().getResourceAsStream("资源Name");这里面有个问题，就是getClass()调用的时候默认省略了this！我们都知道，this是不能在static（静态）方法或者static块中使用的，原因是static类型的方法或者代码块是属于类本身的，不属于某个对象，而this本身就代表当前对象，而静态方法或者块调用的时候是不用初始化对象的。问题是：假如我不想让某个类有对象，那么我会将此类的默认构造方法设为私有，当然也不会写别的共有的构造方法。并且我这个类是工具类，都是静态的方法和变量，我要在静态块或者静态方法中获取properties文件，这个方法就行不通了。那怎么办呢？其实这个类就不是这么用的，他仅仅是需要获取一个Class对象就可以了，那还不容易啊－－ 取所有类的父类Object，用Object.class难道不比你的用你正在写类自身方便安全吗 ？呵呵，下面给出一个例子，以方便交流。 import java.util.Properties; import java.io.InputStream; import java.io.IOException; /** * 读取Properties文件的例子 * File: TestProperties.java * User: leizhimin * Date: 2008-2-15 18:38:40 */ public final class TestProperties { private static String param1; private static String param2; static { Properties prop = new Properties(); InputStream in = Object. class .getResourceAsStream( "/test.properties" ); try { prop.load(in); param1 = prop.getProperty( "initYears1" ).trim(); param2 = prop.getProperty( "initYears2" ).trim(); } catch (IOException e) { e.printStackTrace(); } } /** * 私有构造方法，不需要创建对象 */ private TestProperties() { } public static String getParam1() { return param1; } public static String getParam2() { return param2; } public static void main(String args[]){ System.out.println(getParam1()); System.out.println(getParam2()); } } 运行结果： 151 152 当然，把Object.class换成int.class照样行，呵呵，大家可以试试。另外，如果是static方法或块中读取Properties文件，还有一种最保险的方法，就是这个类的本身名字来直接获取Class对象，比如本例中可写成TestProperties.class，这样做是最保险的方法2 获取路径的方式:File fileB = new File( this .getClass().getResource( "" ).getPath()); System. out .println( "fileB path: " + fileB); 2.2获取当前类所在的工程名：System. out .println("user.dir path: " + System. getProperty ("user.dir"))<span style="background-color: white;">3 获取路径的一个简单的Java实现</span> /** *获取项目的相对路径下文件的绝对路径 * * @param parentDir *目标文件的父目录,例如说,工程的目录下,有lib与bin和conf目录,那么程序运行于lib or * bin,那么需要的配置文件却是conf里面,则需要找到该配置文件的绝对路径 * @param fileName *文件名 * @return一个绝对路径 */ public static String getPath(String parentDir, String fileName) { String path = null; String userdir = System.getProperty("user.dir"); String userdirName = new File(userdir).getName(); if (userdirName.equalsIgnoreCase("lib") || userdirName.equalsIgnoreCase("bin")) { File newf = new File(userdir); File newp = new File(newf.getParent()); if (fileName.trim().equals("")) { path = newp.getPath() + File.separator + parentDir; } else { path = newp.getPath() + File.separator + parentDir + File.separator + fileName; } } else { if (fileName.trim().equals("")) { path = userdir + File.separator + parentDir; } else { path = userdir + File.separator + parentDir + File.separator + fileName; } } return path; } 4 利用反射的方式获取路径：InputStream ips1 = Enumeration . class .getClassLoader() .getResourceAsStream( "cn/zhao/enumStudy/testPropertiesPath1.properties" ); InputStream ips2 = Enumeration . class .getResourceAsStream( "testPropertiesPath1.properties" ); InputStream ips3 = Enumeration . class .getResourceAsStream( "properties/testPropertiesPath2.properties" );

myeclipse中prop.load报错是因为没有找到要加载的properties文件。Java可使用Properties类读写properties，具体说明如下：1.Properties类与Properties配置文件　　Properties类继承自Hashtable类并且实现了Map接口，也是使用一种键值对的形式来保存属性集。不过Properties有特殊的地方，就是它的键和值都是字符串类型。2.Properties中的主要方法(1)load(InputStream inStream)　　这个方法可以从.properties属性文件对应的文件输入流中，加载属性列表到Properties类对象。如下面的代码：Properties pro = new Properties();FileInputStream in = new FileInputStream("a.properties");pro.load(in);in.close();(2)store(OutputStream out, String comments)　　这个方法将Properties类对象的属性列表保存到输出流中。如下面的代码：FileOutputStream oFile = new FileOutputStream(file, "a.properties");pro.store(oFile, "Comment");oFile.close();　　如果comments不为空，保存后的属性文件第一行会是#comments,表示注释信息；如果为空则没有注释信息。　　注释信息后面是属性文件的当前保存时间信息。(3)getProperty/setProperty　　这两个方法是分别是获取和设置属性信息。3.代码实例属性文件a.properties如下：name=rootpass=liukey=value读取a.properties属性列表，与生成属性文件b.properties。代码如下：import java.io.BufferedInputStream;import java.io.FileInputStream;import java.io.FileOutputStream;import java.io.InputStream;import java.util.Iterator;import java.util.Properties;public class PropertyTest {public static void main(String[] args) {try {// 读取属性文件a.propertiesInputStream in = new BufferedInputStream(new FileInputStream("a.properties"));// /加载属性列表Properties prop = new Properties();prop.load(in);Iterator<String> it = prop.stringPropertyNames().iterator();while (it.hasNext()) {String key = it.next();System.out.println(key + ":" + prop.getProperty(key));}in.close();// /保存属性到b.properties文件FileOutputStream oFile = new FileOutputStream("b.properties", true);// true表示追加打开prop.setProperty("phone", "10086");prop.store(oFile, "The New properties file");oFile.close();} catch (Exception e) {System.out.println(e);}}}

1、首先按下Windows键+R，调用运行窗口，输入ms-settingsabout。2、其按回车，打开“关于你的电脑”设置页面。3、然后在“设备规格”部分下，找到一个名为“设备详细信息”的链接。4、最后单击链接后就会调出系统的“properties”窗口了。

　　一般来说。我们会将一些配置的信息放在。properties文件中。然后使用${}将配置文件中的信息读取至spring的配置文件。那么我们如何在spring读取properties文件呢。1.首先。我们要先在spring配置文件中。定义一个专门读取properties文件的类.例： <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>classpath*:jdbc.properties</value> <!--要是有多个配置文件，只需在这里继续添加即可 --> </list> </property> </bean>这里为什么用locations（还有一个location)是因为。一般来说。我们的项目里面。配置文件可能存在多个。就算是只有一个。那将来新添加的话。只需在下面再加一个value标签即可。而不必再重新改动太多。（当然。性能上是否有影响，这个以当前这种服务器的配置来说。是基科可以忽略不计的）。然后我们就可以在jdbc.properties文件中填写具体的配置信息了。 <!-- 配置C3P0数据源 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> <property name="driverClass"> <value>${jdbc.driverClassName}</value> </property> <property name="jdbcUrl"> <value>${jdbc.url}</value> </property> <property name="user"> <value>${jdbc.username}</value> </property> <property name="password"> <value>${jdbc.password}</value> </property> </bean>jdbc.properties文件写的信息。jdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/testjdbc.username=rootjdbc.password=root附加一个列子：　　<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>file:/data/pc-config/passport.properties</value> <value>classpath:memcached.properties</value> </list> </property> </bean>　　classpath：是指的当前类文件的目录下。　　file：在window下是指的当前分区（比如你的项目是放在d盘，则是在d：/data/pc-config/passport.properties）　　在linux下，则是当前路径下的文件/data/pc-config/passport.properties转载仅供参考，版权属于原作者。祝你愉快，满意请采纳哦

InputStream in = 类名.class.getClassLoader().getResourceAsStream("propertes名字.properties"); Properties prop = new Properties(); prop.load(in) oracleDb_Driver = prop.getProperty("oracleDb_Driver-properties里面的字段");

方法如下，请先保证oracle可以正常运行。　　2　　打开Eclipse，找到“Window”--“Show View”--“Other...”　　3　　在弹出的新窗口中，打开文件夹“Data Management”找到“Data Source Explorer”，并单击“OK”

最常用读取properties文件的方法InputStream in = getClass().getResourceAsStream("资源Name");这种方式要求properties文件和当前类在同一文件夹下面。如果在不同的包中，必须使用：InputStream ins = this.getClass().getResourceAsStream("/cn/zhao/properties/testPropertiesPath2.properties");Java中获取路径方法获取路径的一个简单实现反射方式获取properties文件的三种方式1 反射方式获取properties文件最常用方法以及思考：Java读取properties文件的方法比较多，网上最多的文章是"Java读取properties文件的六种方法"，但在Java应用中，最常用还是通过java.lang.Class类的getResourceAsStream(String name) 方法来实现，但我见到众多读取properties文件的代码中，都会这么干：InputStream in = getClass().getResourceAsStream("资源Name");这里面有个问题，就是getClass()调用的时候默认省略了this！我们都知道，this是不能在static（静态）方法或者static块中使用的，原因是static类型的方法或者代码块是属于类本身的，不属于某个对象，而this本身就代表当前对象，而静态方法或者块调用的时候是不用初始化对象的。问题是：假如我不想让某个类有对象，那么我会将此类的默认构造方法设为私有，当然也不会写别的共有的构造方法。并且我这个类是工具类，都是静态的方法和变量，我要在静态块或者静态方法中获取properties文件，这个方法就行不通了。

如何在spring中读取properties配置文件里面的信息<!-- 正文开始 -->一般来说。我们会将一些配置的信息放在。properties文件中。然后使用${}将配置文件中的信息读取至spring的配置文件。那么我们如何在spring读取properties文件呢。1.首先。我们要先在spring配置文件中。定义一个专门读取properties文件的类.例： <bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>classpath*:jdbc.properties</value> <!--要是有多个配置文件，只需在这里继续添加即可 --> </list> </property> </bean>这里为什么用locations（还有一个location)是因为。一般来说。我们的项目里面。配置文件可能存在多个。就算是只有一个。那将来新添加的话。只需在下面再加一个value标签即可。而不必再重新改动太多。（当然。性能上是否有影响，这个以当前这种服务器的配置来说。是基科可以忽略不计的）。然后我们就可以在jdbc.properties文件中填写具体的配置信息了。 <!-- 配置C3P0数据源 --> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"> <property name="driverClass"> <value>${jdbc.driverClassName}</value> </property> <property name="jdbcUrl"> <value>${jdbc.url}</value> </property> <property name="user"> <value>${jdbc.username}</value> </property> <property name="password"> <value>${jdbc.password}</value> </property> </bean>jdbc.properties文件写的信息。jdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/testjdbc.username=rootjdbc.password=root附加一个列子： <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"> <property name="locations"> <list> <value>file:/data/pc-config/passport.properties</value> <value>classpath:memcached.properties</value> </list> </property> </bean>classpath：是指的当前类文件的目录下。file：在window下是指的当前分区（比如你的项目是放在d盘，则是在d：/data/pc-config/passport.properties） 在linux下，则是当前路径下的文件/data/pc-config/passport.properties

　　properties是配置文件，主要的作用是通过修改配置文件可以方便的修改代码中的参数，实现不用改class文件即可灵活变更参数。　　解释：java运行中java文件会变成class文件，之后无法通过反编译找到原样的代码，这样的话，如果java类中某个参数变更，就很难灵活的实现参数修改，这个时候properties 文件就能很灵活的实现配置，减少代码的维护成本和提高开发效率。

怎样在.properties文件中注释写回答有奖励 共4个回答百度网友f4b5898 高能答主 2019-06-12 致力于成为全知道最会答题的人关注1、打开IDEA，新建一个Web项目，右键点击新建的项目名，选择创建文件目录(Directory)，一般properties文件夹命名应为resoures。2、右键点击新建的resources文件夹，弹出的窗口里选择Mark Dictory as >>Resources Root将文件夹定义为配置文件。3、也可以通过Ctrl+shift+alt+s组合件打开Project Structure面板将需要的文件夹声明为配置文件类型。4、右键点击声明为resources类型的文件夹选择Resource Bundle，就能创架一个properties文件了。5、mysql 的properties配置文件是以键值对形式存读取的，一个对象占用一行，行末不能添加分号。6、配置文件的使用。就可以注释了。