this关键字
this可以强调用的是本类中的方法，还可以表示类中的属性、可以使用this调用本类中的方法、this表示当前的对象。
一．使用this调用本类中的属性
在程序中可以使用this调用本类属性
classPreason
{
private String name;
privateint age;
public void Preason(String n,int a){
name=n;
age=a;
}
public String getInfo(){
return "姓名："+name+"，年龄："+age;
}
}
在此构造方法中目的很明确，就是为类中的属性赋值，但是从构造方法的传递参数很难看出参数n和a的意义，所以为了可以清楚的表示参数的意义，可以进行如下修改：classPreason
{
private String name;
privateint age;
public void Preason(String name,int age){
name=name;
age=age;
}
public String getInfo(){
return "姓名："+name+"，年龄："+age;
}
}
此时可以从参数的名称中看出其真实意义，要传递的第一个参数是姓名，第二个参数是年龄，但是构造方法内部会出现错误，运行结果为：
姓名：null，年龄：0
从程序运行结果中可以发现，姓名为null，年龄为0，并没有把构造方法传递进去的参数值赋给属性，那么就证明现在的构造方法并不能成功的把传递进去的值赋值给类中的属性。由于在赋值时属性并不是明确地被指出，所以造成此错误，而之中错误就可以用this关键字来解决。代码修改如下：
class Person
{
private String name;
privateint age;
public Person(){
}
public Person(String name,int age){
https://www.doczj.com/doc/ea14459858.html,=name;
this.age=age;
}
public String getInfo(){
return "姓名："+https://www.doczj.com/doc/ea14459858.html,+"，年龄："+this.age;
}
}
public class ThisDemo01
{
public static void main(String[] args)
{
Person per1=new Person("张三",30);
System.out.println(per1.getInfo());
}
}
运行结果：
姓名：张三，年龄：30
从结果来看，程序的目的达到了。在构造方法中明确的标识了类中的两个属性“https://www.doczj.com/doc/ea14459858.html,”
和“this.age”，所以在进行赋值时也不会产生歧义。为了避免类似歧义的发生，建议以后在类中访问属性时都加上this关键字。
二．使用this调用构造方法
如果一个类中有多个构造方法，也可以利用this关键字互相调用。
【使用this调用本类的构造方法】
class Person
{
private String name;
privateint age;
public Person(){
System.out.println("一个新的Person对象被实例化");
}
public Person(String name,int age){
this();
https://www.doczj.com/doc/ea14459858.html,=name;
this.age=age;
}
public String getInfo(){
return "姓名："+name+"，年龄："+age;
}
}
public class ThisDemo03
{
public static void main(String[] args){
Person per1=new Person("张三",33);
System.out.println(per1.getInfo());
}
}
运行结果为：
一个新的Person对象被实例化
姓名：张三，年龄：33
本程序中提供了两个构造方法，其中有两个参数的构造方法中使用this()的形式调用本类中的无参构造方法，所以即使是通过有两个参数的构造方法实例化，最终结果还是会把对象实例化的信息打印出来。
在使用this()调用构造方法的时候，要注意的是：由于构造方法是在实例化对象时自动调用的，也就是说在类中的所有方法中，只有构造方法是被优先调用的，所以使用this()调用构造方法必须也只能在构造方法的首行；在构造方法间相互调用时一定要留一个出口，一般会将无参数的构造方法作为出口，即在无参构造方法中最好不要再去调用其他构造方法。
三．this表示当前的对象
前面已经讲解了如何使用this调用属性和何时使用this调用方法，实际上在这些特性外，this最重要的特点即使表示当前对象，在Java中当前对象就是指当前正在调用类中方法的对象。
【this表示当前对象】
class Person{ // 定义Person类
public String getInfo(){ // 取得信息的方法
System.out.println("Person类--> " + this) ; // 直接打印this
return null ; // 为了保证语法正确，返回null
}
};
public class ThisDemo06{
public static void main(String args[]){
Person per1 = new Person() ; // 调用构造实例化对象
Person per2 = new Person() ; // 调用构造实例化对象
System.out.println("MAIN方法--> " + per1) ; // 直接打印对象
per1.getInfo() ; // 当前调用getInfo()方法的对象是per1
System.out.println("MAIN方法--> " + per2) ; // 直接打印对象
per2.getInfo() ; // 当前调用getInfo()方法的对象是per2
}
};
运行结果：
MAIN方法--> Person@15db9742
Person类--> Person@15db9742
MAIN方法--> Person@6d06d69c
Person类--> Person@6d06d69c
从程序的运行结果来看，直接打印对象和调用getInfo()方法打印的结果是一样的，而且在getInfo()方法中打印的永远是一个this关键字，也就是说哪个对象调用了类中的方法，则this就表示哪个对象，这一个特性的用途如下例：
class Person{ // 定义Person类
private String name ; // 姓名
private int age ; // 年龄
public Person(String name,int age){
this.setName(name) ;
this.setAge(age) ;
}
publicboolean compare(Person per){
// 调用此方法时里面存在两个对象：当前对象、传入的对象
Person p1 = this ; // 当前的对象，就表示per1
Person p2 = per ; // 传递进来的对象，就表示per2
if(p1==p2){ // 判断是不是同一个对象，用地址比较
return true ;
}
// 之后分别判断每一个属性是否相等
if(https://www.doczj.com/doc/ea14459858.html,.equals(https://www.doczj.com/doc/ea14459858.html,)&&p1.age==p2.age){
return true ; // 两个对象相等
}else{
return false ; // 两个对象不相等
}
}
public void setName(String name){ // 设置姓名
https://www.doczj.com/doc/ea14459858.html, = name ;
}
public void setAge(int age){ // 设置年龄
this.age = age ;
}
public String getName(){
return https://www.doczj.com/doc/ea14459858.html, ;
}
publicintgetAge(){
returnthis.age ;
}
};
public class ThisDemo08{
public static void main(String args[]){
Person per1 = new Person("张三",30) ; // 声明两个对象，内容完全相等
Person per2 = new Person("张三",30) ; // 声明两个对象，内容完全相等
// 直接在主方法中依次取得各个属性进行比较
if(https://www.doczj.com/doc/ea14459858.html,pare(per2)){
System.out.println("两个对象相等！") ;
}else{
System.out.println("两个对象不相等！") ;
}
}
};
运行结果为：
两个对象相等！
以上程序Person类中定义了一个compare方法，此方法的主要功能就是专门完成两个对象的比较操作，在比较时，首先进行地址的比较，如果两个对象的地址一样，，则肯定是同一个对象，如果不相等，则将一个个属性进行依次的比较。
搜索引擎使用技巧 1、简单查询 在搜索引擎中输入关键词，然后点击“搜索”就行了，系统很快会返回查询结果，这是最简单的查询方法，使用方便，但是查询的结果却不准确，可能包含着许多无用的信息。 2、使用双引号""、书名号《》 给要查询的关键词加上双引号、书名号（半角，以下要加的其它符号同此），可以实现精确的查询，这种方法要求查询结果要精确匹配，不包括演变形式。例如在搜索引擎的文字框中输入“电传”，它就会返回网页中有“电传”这个关键字的网址，而不会返回诸如“电话传真”之类网页。 3、使用加号（+） 在关键词的前面使用加号，也就等于告诉搜索引擎该单词必须出现在搜索结果中的网页上，例如，在搜索引擎中输入“+电脑+电话+传真”就表示要查找的内容必须要同时包含“电脑、电话、传真”这三个关键词。 4、使用减号（-） 在关键词的前面使用减号，也就意味着在查询结果中不能出现该关键词，例如，在搜索引擎中输入“电视台-中央电视台”，它就表示最后的查询结果中一定不包含“中央电视台”。 5、使用布尔检索 and，称为逻辑“与”，用and进行连接，表示它所连接的两个词必须同时出现在查询结果中，例如，输入“computer and book”，它要求查询结果中必须同时包含computer和book。or，称为逻辑“或”，它表示所连接的两个关键词中任意一个出现在查询结果中就可以，例如，输入“computer or book”，就要求查询结果中可以只有computer，或只有book，或同时包含computer和book。not，称为逻辑“非”，它表示所连接的两个关键词中应从第一个关键
词概念中排除第二个关键词，例如输入“automobile not car”，就要求查询的结果中包含automobile（汽车），但同时不能包含car（小汽车）。 6、使用搜索语法:filetype,site filetype就是按照文件类型搜索，比如搜毕业论文，可以用: 毕业论文filetype:doc site是只搜索某一个站点的，比如只想看百度上的小说，可以用： 玄幻小说site:baidu 关键词后必须带空格 7、使用通配符（*和?） 通配符包括星号（*）和问号（?），前者表示匹配的数量不受限制，后者匹配的字符数要受到限制，主要用在英文搜索引擎中。例如输入“computer*”，就可以找到“computer、computers、computerised、com puterized”等单词，而输入“comp?ter”，则只能找到“computer、compater、competer”等单词。 8、区分大小写 这是检索英文信息时要注意的一个问题，许多英文搜索引擎可以让用户选择是否要求区分关键词的大小写，这一功能对查询专有名词有很大的帮助，例如：Web专指万维网或环球网，而web则表示蜘蛛网。
this的用法总结大全 this的用法你知道吗?今天给大家带来this的用法，希望能够帮助到大家，下面就和大家分享，来欣赏一下吧。 this的用法总结大全 this的意思 pron. 这，这个,这事，这人,这时,下面所说的事 adj. 这，这个,刚过去的，即将到来的,今…，本… adv. 这样地,就是这样,这么地 this用法 this可以用作形容词 this用作形容词作“这”解时,用于修饰表示在时间、地点、想法上更接近讲话者的事物或人,也可与包括现在的日子或一段时间的词语连用。 “this+ones+ n. ”是一种简洁的文体,有强调意味; “this+基数词+时间名词”表示一段时间。this可与of短语连用,后接名词性物主代词或名词所有格。
this用作代词可用以指叙述中的人或事物,即指前面提到过的人或事物或下文提及的事物; this一般作主语时才指人; 在电话用语中, this用来指代自己。 this可以用作代词 this用作代词可用以指叙述中的人或事物,即指前面提到过的人或事物或下文提及的事物; this一般作主语时才指人; 在电话用语中, this用来指代自己。 当陈述部分的主语是this时,附加疑问部分的主语须用it。 this用作代词的用法例句 This is, in part, my own mistake.在某种程度上来说,这是我自己的错。 Now dont laugh when you hear this.听了这个你不要笑。 Its about this high.大约有这样高。 this用法例句 1、He was hand-picked for this job by the Admiral. 他是由海军上将精心挑选出来担任这项工作的。 2、This brings us to the second question I asked. 这就将我们带到了我所提的第二个问题。
C++中explicit关键字的作用 explicit用来防止由构造函数定义的隐式转换。 要明白它的作用，首先要了解隐式转换：可以用单个实参来调用的构造函数定义了从形参类型到该类类型的一个隐式转换。 例如: class things { public: things(const std::string&name = ""): m_name(name),height(0),weight(10){} int CompareTo(const things & other); std::string m_name; int height; int weight; }; 复制代码 这里things的构造函数可以只用一个实参完成初始化。所以可以进行一个隐式转换，像下面这样： things a; ................//在这里被初始化并使用。 std::string nm = "book_1"; //由于可以隐式转换，所以可以下面这样使用 int result = https://www.doczj.com/doc/ea14459858.html,pareTo(nm); 复制代码 这段程序使用一个string类型对象作为实参传给things的CompareTo函数。这个函数本来是需要一个tings对象作为实参。现在编译器使用string nm来构造并初始化一个things对象，新生成的临时的things对象被传递给CompareTo函数，并在离开这段函数后被析构。 这种行为的正确与否取决于业务需要。假如你只是想测试一下a的重量与10的大小之比，这么做也许是方便的。但是假如在CompareTo函数中还涉及到了要除以初始化为0的height 属性，那么这么做可能就是错误的。需要在构造tings之后更改height属性不为0。所以要限制这种隐式类型转换。 那么这时候就可以通过将构造函数声明为explicit，来防止隐式类型转换。
this关键字的作用 this关键字的用法 1. this是指当前对象自己。 当在一个类中要明确指出使用对象自己的的变量或函数时就应该加上this引用。如下面这个例子中: public class Hello { String s = "Hello"; public Hello(String s) { System.out.println("s = " + s); System.out.println("1 -> this.s = " + this.s); this.s = s; System.out.println("2 -> this.s = " + this.s); } public static void main(String[] args) { Hello x="new" Hello("HelloWorld!"); } } 运行结果： s = HelloWorld! 1 -> this.s = Hello 2 -> this.s = HelloWorld! 在这个例子中，构造函数Hello中，参数s与类Hello的变量s同名，这时如果直接对s进行操作则是对参数s进行操作。若要对类Hello的成员变量s进行操作就应该用this进行引用。运行结果的第一行就是直接对构造函数中传递过来的参数s进行打印结果；第二行是对成员变量s的打印；第三行是先对成员变量s赋传过来的参数s值后再打印，所以结果是HelloWorld! 2. 把this作为参数传递 当你要把自己作为参数传递给别的对象时，也可以用this。如： public class A { public A() {
用好关键字，让简历搜索更随心 搜索简历之前，你得先要在搜索框输入一个或多个词语，才可以进行简历搜索。这一个或多个词语就是我们所说的关键字。 关键字是能够最大程度概括你所要查找的简历信息的字或词语，往往描述了简历的主要特征或核心内容，很多时候需要多个关键字才能准确完整地描述一个对象。 关键字搜索是通过字符的匹配原则来对简历进行筛选，只要简历中任何一部分文字描述包含了所搜索的关键字或关键词组，简历便会被搜索引擎检索出来，最终就会显示在搜索结果页面啦。 例如：公司招聘财务人员，可以输入关键字“财务”或“会计”等相关词汇，只要简历中任一模块内容包含“财务”或“会计”词汇都可以被搜索出来。 所以要想搜索到合适的简历，你可要好好选择关键字哦。 为什么搜索到的简历总是不合心意？为什么搜到的简历好像与关键字没什么关系？出现这种问题都是关键字没选好的缘故，下面我们就来说说如何选择关键字吧。 1、从工作内容、任职要求、岗位名称中提炼关键字 关键字要用得准确，需要对招聘岗位有非常透彻的理解，同时还要了解一个有相关资质或有相关工作经验的求职者会如何撰写他的简历，在简历中可能会出现的关键字，这些关键字就可以作为我们用于搜索的关键字。对招聘岗位而言，招聘人员可以从所招聘岗位的名称、工作内容、能力要求着手，去对简历进行检索。 （1）从工作内容中提炼关键字，进行相关搜索。 例如：我们要招聘一个HR专员，主要负责HR的薪酬福利部分工作，如果我们仅用“HR”或“人力资源”去搜索时，会有很多HR相关的简历，但是在薪酬福利方面有丰富经验的简历的比例就很低。而有薪酬福利方面工作经验的求职者，一般都会在其简历中，提到自己熟悉或精通“薪酬福利”模块。这时我们就可以使用“人力资源,薪酬福利”来搜索即包含“人力资源”又包含“薪酬福利”的简历，这样结果虽然减少一些，却准确很多。但如果单用“薪酬福利专员”去搜索符合条件可能就会比较有限了，因为不是每一个公司都会设定这个职位，即使有设定职位名称也不一定完全一样，如果单用职位名称搜索就会比较受限，我们便可以根据相关的工作内容“薪酬福利”来进行搜索，扩展候选人范围。 （2）从岗位名称、任职要求中找寻合适的关键字，进行相关搜索。 例如：我们想要招一个高级JAVA软件工程师，具体要求如下所示 职位名称：高级JAVA软件工程师 职位描述： - 浏览器/服务器前后台程序开发； - 基础框架开发； - 技术文档编写；
复习题2 如有雷同，纯属巧合！ 1.下列哪一种叙述是正确的(D) A. abstract修饰符可修饰字段、方法和类 B.抽象方法的body部分必须用一对大括号{ }包住 C.声明抽象方法，大括号可有可无 D.声明抽象方法不可写出大括号 2.下列说法正确的有(C) A. class中的constructor不可省略 B. constructor必须与class同名，但方法不能与class同名 C. constructor在一个对象被new时执行 D.一个class只能定义一个constructor 3.以下哪个表达式是不合法的（ A ） A、String x=”Hello”; int y=9; x+=y; B、String x=”Hello”; int y=9; if(x= =y) { } C、String x=”Hello”; int y=9; x=x+y; D、String x=null; int y=(x!=null)&&(x.length()>0) ? x.length() : 0 4.下列关于修饰符混用的说法，错误的是（C ） A．abstract不能与final并列修饰同一个类 B．abstract类中不可以有private的成员 C．abstract方法必须在abstract类中 D．static方法中能处理非static的属性 5.（B）修饰符允许对类成员的访问不依赖于该类的任何对象 A、abstract B、static C、return D、public 6.关于被私有访问控制符private修饰的成员变量，以下说法正确的是（ C ） A．可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类 B．可以被两种类访问和引用：该类本身、该类的所有子类 C．只能被该类自身所访问和修改 D．只能被同一个包中的类访问
认识C++ 中的explicit 关键字 (Danny Kalev发表于2004-12-28 11:01:04) 带单一参数的构造函数在缺省情况下隐含一个转换操作符，请看下面的代码： class C { int i; //... public: C(int i);//constructor and implicit conversion operator //as well }; void f() { C c(0); c = 5; //将5 隐式转换为C 对象，然后赋值 } 编译器重新编辑上述例子代码，如下： ////////////////////////////////////////////////////////////////////////////////////////// //"c=5;" 被编译器转换成下面这个样子： ///////////////////////////////////////////////////////////////////////////////////////// C temp(5);// 实例化一个临时对象, c = temp; // 用= 赋值 temp.C::~C(); // temp 的析构函数被激活 在很多情况下，这个转换是有意的，并且是正当的。但有时我们不希望进行这种自动的转换，例如： class String { int size; char *p; //.. public: String (int sz); //这里不希望进行隐式转换操作 }; void f () { String s(10); // 下面是一个程序员的编码；发生一个意想不到的转换：
在向大家详细介绍C# this关键字之前，首先让大家了解下类与对象的区分，然后全面介绍C# this 关键字。 类与对象的区分对我们把握OO编程至关重要。我们说类是对其成员的一种封装，但类的封装设计仅仅是我们编程的第一步，对类进行对象实例化，并在其数据成员上实施操作才是我们完成现实任务的根本。实例化对象采用MyClass myObject=new MyClass()语法，这里的new语义将调用相应的构建器。C#所有的对象都将创建在托管堆上。实例化后的类型我们称之为对象，其核心特征便是拥有了一份自己特有的数据成员拷贝。这些为特有的对象所持有的数据成员我们称之为实例成员。相反那些不为特有的对象所持有的数据成员我们称之为静态成员，在类中用static修饰符声明。仅对静态数据成员实施操作的称为静态函数成员。C#中静态数据成员和函数成员只能通过类名引用获取，看下面的代码： https://www.doczj.com/doc/ea14459858.html,ing System; 2.class A 3.{ 4.public int count; 5.public void F() 6.{ 7.Console.WriteLine(this.count); 8.} 9. 10.public static string name; 11.public static void G() 12.{ 13.Console.WriteLine(name); 14.} 15.} 16.class Test 17.{ 18.public static void Main() 19.{ 20.A a1=new A(); 21.A a2=new A(); 22.a1.F(); 23.a1.count=1; 24.a2.F(); 25.a2.count=2; 26. https://www.doczj.com/doc/ea14459858.html,="CCW"; 28.A.G(); 29.} 30.}
对于搜索中文内容，百度，腾讯等中国人创造的搜索引擎搜索出来的内容比较准确，而google，雅虎等则搜索英文内容比较准确，现在比较有名的还有360，新浪，网易等搜索引擎。 搜索引擎特殊符号 不同的搜索引擎提供的查询方法不完全相同，你要想具体了解，可以到各个网站中去查询，但有一些通用的查询方法，各个搜索引擎基本上都具有。由于使用目录查询比较简单，你只需确定要查找目标所在的目录，然后一层层打开，逐步细化就可以找到。 1、简单查询 在搜索引擎中输入关键词，然后点击“搜索”就行了，系统很快会返回查询结果，这是最简单的查询方法，使用方便，但是查询的结果却不准确，可能包含着许多无用的信息。｝ 2、使用双引号用（" "） 给要查询的关键词加上双引号（半角，以下要加的其它符号同此），可以实现精确的查询，这种方法要求查询结果要精确匹配，不包括演变形式。例如在搜索引擎的文字框中输入“电传”，它就会返回网页中有“电传”这个关键字的网址，而不会返回诸如“电话传真”之类网页。 3、使用加号（+） 在关键词的前面使用加号，也就等于告诉搜索引擎该单词必须出现在搜索结果中的网页上，例如，在搜索引擎中输入“+电脑+电话+传真”就表示要查找的内容必须要同时包含“电脑、电话、传真”这三个关键词。 4、使用减号（-） 在关键词的前面使用减号，也就意味着在查询结果中不能出现该关键词，例如，在搜索引擎中输入“电视台-中央电视台”，它就表示最后的查询结果中一定不包含“中央电视台”。 5、使用通配符（*和?） 通配符包括星号（*）和问号（?），前者表示匹配的数量不受限制，后者匹配的字符数要受到限制，主要用在英文搜索引擎中。例如输入“computer*”，就可以找到“computer、computers、computerised、computerized”等单词，而输入“comp?ter”，则只能找到“computer、compater、competer”等单词。 6、使用布尔检索 所谓布尔检索，是指通过标准的布尔逻辑关系来表达关键词与关键词之间逻辑关系的一种查询方法，这种查询方法允许我们输入多个关键词，各个关键词之间的关系可以用逻辑关系词来表示。
通过用static来定义方法或成员，为我们编程提供了某种便利，从某种程度上可以说它类似于C语言中的全局函数和全局变量。但是，并不是说有了这种便利，你便可以随处使用，如果那样的话，你便需要认真考虑一下自己是否在用面向对象的思想编程，自己的程序是否是面向对象的。 好了，现在开始讨论this&super这两个关键字的意义和用法。 在Java中，this通常指当前对象，super则指父类的。当你想要引用当前对象的某种东西，比如当前对象的某个方法，或当前对象的某个成员，你便可以利用this来实现这个目的，当然，this的另一个用途是调用当前对象的另一个构造函数，这些马上就要讨论。如果你想引用父类的某种东西，则非super莫属。由于this与super有如此相似的一些特性和与生俱来的某种关系，所以我们在这一块儿来讨论，希望能帮助你区分和掌握它们两个。 在一般方法中 最普遍的情况就是，在你的方法中的某个形参名与当前对象的某个成员有相同的名字，这时为了不至于混淆，你便需要明确使用this关键字来指明你要使用某个成员，使用方法是“this.成员名”，而不带this的那个便是形参。另外，还可以用“this.方法名”来引用当前对象的某个方法，但这时this就不是必须的了，你可以直接用方法名来访问那个方法，编译器会知道你要调用的是那一个。下面的代码演示了上面的用法： public class DemoThis{ private String name; private int age; DemoThis(String name,int age){ setName(name); //你可以加上this来调用方法，像这样：this.setName(name);但这并不是必须的 setAge(age); this.print(); br> } public void setName(String name){ https://www.doczj.com/doc/ea14459858.html,=name;//此处必须指明你要引用成员变量 } public void etAge(int age){ this.age=age; } public void print(){ System.out.println("Name="+name+" ge="+age); //在此行中并不需要用this，因为没有会导致混淆的东西 } public static void main(String[] args){ DemoThis dt=new DemoThis("Kevin","22"); 这段代码很简单，不用解释你也应该能看明白。在构造函数中你看到用this.print(), 你完全可以用print()来代替它，两者效果一样。下面我们修改这个程序，来演示super 的用法。 class Person{ public int c; private String name; private int age;
搜索技巧，最基本同时也是最有效的，就是选择合适的查询词。选择查询词是一种经验积累，在一定程度上也有章可循： 一、.表述准确百度会严格按照您提交的查询词去搜索，因此，查询词表述准确是获得良好搜索结果的必要前提。 一类常见的表述不准确情况是，脑袋里想着一回事，搜索框里输入的是另一回事。 例如，要查找2008年国内十大新闻，查询词可以是“2008年国内十大新闻”；但如果把查询词换成“2008年国内十大事件”，搜索结果就没有能满足需求的了。 另一类典型的表述不准确，是查询词中包含错别字。 例如，要查找林心如的写真图片，用“林心如写真”，当然是没什么问题；但如果写错了字，变成“林心茹写真”，搜索结果质量就差得远了。 不过好在，百度对于用户常见的错别字输入，有纠错提示。您若输入“林心茹写真”，在搜索结果上方，会提示“您要找的是不是: 林心如写真”。 二、查询词的主题关联与简练目前的搜索引擎并不能很好的处理自然语言。因此，在提交搜索请求时，您最好把自己的想法，提炼成简单的，而且与希望找到的信息内容主题关联的查询词。 还是用实际例子说明。某三年级小学生，想查一些关于时间的名人名言，他的查询词是“小学三年级关于时间的名人名言”。 这个查询词很完整的体现了搜索者的搜索意图，但效果并不好。 绝大多数名人名言，并不规定是针对几年级的，因此，“小学三年级”事实上和主题无关，会使得搜索引擎丢掉大量不含“小学三年级”，但非常有价值的信息；“关于”也是一个与名人名言本身没有关系的词，多一个这样的词，又会减少很多有价值信息；“时间的名人名言”，其中的“的”也不是一个必要的词，会对搜索结果产生干扰；“名人名言”，名言通常就是名人留下来的，在名言前加上名人，是一种不必要的重复。 因此，最好的查询词，应该是“时间名言”。 试着找出下述查询词的问题，并想出更好的能满足搜索需求的查询词： 所得税会计处理问题探讨 周星驰个人档案和所拍的电影 三、根据网页特征选择查询词很多类型的网页都有某种相似的特征。例如，小说网页，通常都有一个目录页，小说名称一般出现在网页标题中，而页面上通常有“目录”两个字，
this关键字的含义 问题：this关键字的含义回答： this是一个保留字，仅限于构造函数和方法成员中使用 在类的构造函数中出现表示对正在构造的对象本身的引用，在类的方法中出现表示对调用该方法的对象的引用，在结构的构造上函数中出现表示对正在构造的结构的引用，在结构的方法中出现表示对调用该方法的结果的引用 this保留字不能用于静态成员的实现里，因为这时对象或结构并未实例化 在C# 系统中，this 实际上是一个常量，所以不能使用this++ 这样的运算 this保留字一般用于限定同名的隐藏成员、将对象本身做为参数、声明索引访问器、判断传入参数的对象是否为本身 示例： using System; using System.Collections.Generic; using System.Text; namespace Example10 { class Class1
private double c; private string value; public double C { get { return c; } } public Class1(double c) { //限定同名的隐藏成员 this.c = c; } public Class1(Class1 value) { //用对象本身实例化自己没有意义if (this != value) { c = value.C; }
public override string ToString() { //将对象本身做为参数 return string.Format(“{0} Celsius = {1} Fahrenheit”, c, UnitTransClass.C2F(this)); } //由于好奇，在这做了一个效率测试，想看看到底哪种方式访问成员变量更快，结论：区别不大。。。 public string Test1() { long vTickCount = Environment.TickCount; for (int i = 0; i this.value = i.ToString(); return string.Format(“Have this.: {0} MSEL”, Environment.TickCount –vTickCount); } public string Test2() { long vTickCount = Environment.TickCount; for (int i = 0; i value = i.ToString();
搜索引擎中运算符的使用技巧 、简单查询 折叠1 在搜索引擎中输入关键词，然后点击“搜索”就行了，系统很快会返回查询结果，这是最简单的查询方法，使用方便，但是查询的结果却不准确，可能包含着许多无用的信息。 、使用双引号用（""） 折叠2 给要查询的关键词加上双引号（半角，以下要加的其它符号同此），可以实现精确的查询，这种方法要求查询结果要精确匹配，不包括演变形式。例如在搜索引擎的文字框中输入“电传”，它就会返回网页中有“电传”这个关键字的网址，而不会返回诸如“电话传真”之类网页。 、使用加号（+） 折叠3 在关键词的前面使用加号，也就等于告诉搜索引擎该单词必须出现在搜索结果中的网页上，例如，在搜索引擎中输入“+电脑+电话+传真”就表示要查找的内容必须要同时包含“电脑、电话、传真”这三个关键词。 、使用减号（-） 折叠4 在关键词的前面使用减号，也就意味着在查询结果中不能出现该关键词，例如，在搜索引擎中输入“电视台-中央电视台”，它就表示最后的查询结果中一定不包含“中央电视台”。 、使用通配符（*和?） 折叠5 通配符包括星号（*）和问号（?），前者表示匹配的数量不受限制，后者匹配的字符数要受到限制，主要用在英文搜索引擎中。例如输入“computer*”，就可以找到“computer、computers、computerised、computerized”等单词，而输入“comp?ter”，则只能找到“computer、compater、competer”等单词。 、使用布尔检索 折叠6 所谓布尔检索，是指通过标准的布尔逻辑关系来表达关键词与关键词之间逻辑关系的一种查询方法，这种查询方法允许我们输入多个关键词，各个关键词之间的关系可以用逻辑关系词来表示。and，称为逻辑“与”，用and进行连接，表示它所连接的两个词必须同时出现在查询结果中，例如，输入“computer and book”，它要求查询结果中必须同时包含computer 和book。or，称为逻辑“或”，它表示所连接的两个关键词中任意一个出现在查询结果中就可以，例如，输入“computer or book”，就要求查询结果中可以只有computer，或只有book，或同时包含computer和book。not，称为逻辑“非”，它表示所连接的两个关键词中应从第一个关键词概念中排除第二个关键词，例如输入“automobile not car”，就要求查询的结果中包含automobile（汽车），但同时不能包含car（小汽车）。near，它表示两个关键词之间的词距不能超过n个单词。在实际的使用过程中，你可以将各种逻辑关系综合运用，灵活搭配，以便进行更加复杂的查询。 、使用括号 折叠7 当两个关键词用另外一种操作符连在一起，而你又想把它们列为一组时，就可以对这两个词加上圆括号。 、使用元词检索 折叠8 大多数搜索引擎都支持“元词”（metawords）功能，依据这类功能用户把元词放在关键词的前面，这样就可以告诉搜索引擎你想要检索的内容具有哪些明确的特征。例如，你在搜索引擎中输入“ti tle:清华大学”，就可以查到网页标题中带有清华大学的网页。在键入的关键词后加上“domainrg”，就可以查到所有以org为后缀的网站。其他元词还包括：image:用于检索图片，link:用于检索链接到某个选定网站的页面，URL:用于检索地址中带有某个关键词的网页。 、区分大小写 折叠9 这是检索英文信息时要注意的一个问题，许多英文搜索引擎可以让用户选择是否要求区分关键词的大小写，这一功能对查询专有名词有很大的帮助，例如：Web专指万维网或环球网，而web则表示蜘蛛网。
static和this的理解和用法小结 关键字static和this是初学者比较头疼的知识点，自己也一直比较模糊．现在整理一下，既可以加深自己的印象也可以便于以后查询． 其实在think in java里关于为什么要使用static写的比较详细，不明白的多读几遍会有很大的收获．一般在两钟情形下需要使用static关键字：一种情形是只想用一个存储区域来保存一个特定的数据——无论要创建多少个对象，甚至根本不创建对象。另一种情形是我们需要一个特殊的方法，它没有与这个类的任何对象关联。也就是说，即使没有创建对象，也需要一个能调用的方法。一旦将什么东西设为static，数据或方法就不会同那个类的任何对象实例联系到一起.所以尽管从未创建那个类的一个对象，仍能调用一个static方法，或访问一些static数据。而在这之前，对于非static数据和方法，我们必须创建一个对象，并用那个对象访问数据或方法。这是由于非static数据和方法必须知道它们操作的具体对象.有这样的一个类，其中定义一个静态数据： class Test { Static int i = 47; } Test st1 = new StaticTest();Test st2 = new StaticTest();即使们new了两个Test对象,但它们仍然只占据Test.i的一个存储空间。这两个对象都共享同样的i。对方法来说，static一项重要的用途就是帮助我们在不必创建对象的前提下调用那个方法. 静态变量）一个静态对象属于一个类，但它不属于实例对象，也不是实例对象状态的一部分．每一个静态变量只存在一份．静态变量通常称为类变量（class variable)．在实际中，经常需要这样的一个变量，它被一个类的所有实例对象所共享，如果它同时又是公有的，那么它就可以被这个类的任意访问者所使用．静态变量存在于类的作用域之内．通常声明为private.java中许多时候会用到public static final 这样的变量。静态变量可以被位于同一个作用域内的任意方或静态方法访问，访问时使用变量名称即可。如果在类作用域以外访问类，则要使用一个含有类名的表达式访问静态变量，例如： Integer.MAX_VALUE, 其中MAX_VALUE是在类库中声明过的。 静态方法）静态方法或类方法属于一个而不是属于某个实例对象实现的一部分。可以直接通过类来调用这种方法，而并不是只能由某个特定的实例对象调用。静态的方法不能用abstract声明，而且无论是否明确地指定实际上都是final型的。静态方法的声明格式： modifiers static typeName methodName (parameterList){ statementSequence } modifiers(可以从public,protect,private中选择一个），后面可以加上 final,nativc,synchronized中的一个或几个的组合。 static main是静态方法的一个特殊用法，用static main 方法来建立程序的初始状态，创建一组初始对象，并进行合理的方法调用，使得程序能够继续执行下去，static main方法使用String数组型参数包含了用户在运行时给出的任意命令行参数。
用好关键字，让简历搜索更随心 一、关键字是什么 搜索简历之前，你得先要在搜索框输入一个或多个词语，才可以进行简历搜索。这一个或多个词语就是我们所说的关键字。 关键字是能够最大程度概括你所要查找的简历信息的字或词语，往往描述了简历的主要特征或核心内容，很多时候需要多个关键字才能准确完整地描述一个对象。 二、关键字搜索是如何搜索的 关键字搜索是通过字符的匹配原则来对简历进行筛选，只要简历中任何一部分文字描述包含了所搜索的关键字或关键词组，简历便会被搜索引擎检索出来，最终就会显示在搜索结果页面啦。 例如：公司招聘财务人员，可以输入关键字“财务”或“会计”等相关词汇，只要简历中任一模块内容包含“财务”或“会计”词汇都可以被搜索出来。 所以要想搜索到合适的简历，你可要好好选择关键字哦。 三、应该如何选择关键字呢 为什么搜索到的简历总是不合心意？为什么搜到的简历好像与关键字没什么关系？出现这种问题都是关键字没选好的缘故，下面我们就来说说如何选择关键字吧。 1、从工作内容、任职要求、岗位名称中提炼关键字 关键字要用得准确，需要对招聘岗位有非常透彻的理解，同时还要了解一个有相关资质或有相关工作经验的求职者会如何撰写他的简历，在简历中可能会出现的关键字，这些关键字就可以作为我们用于搜索的关键字。对招聘岗位而言，招聘人员可以从所招聘岗位的名称、工作内容、能力要求着手，去对简历进行检索。 （1）从工作内容中提炼关键字，进行相关搜索。 例如：我们要招聘一个HR专员，主要负责HR的薪酬福利部分工作，如果我们仅用“HR”或“人力资源”去搜索时，会有很多HR相关的简历，但是在薪酬福利方面有丰富经验的简历的比例就很低。而有薪酬福利方面工作经验的求职者，一般都会在其简历中，提到自己熟悉或精通“薪酬福利”模块。这时我们就可以使用“人力资源,薪酬福利”来搜索即包含“人力资源”又包含“薪酬福利”的简历，这样结果虽然减少一些，却准确很多。但如果单用“薪酬福利专员”去搜索符合条件可能就会比较有限了，因为不是每一个公司都会设定这个职位，即使有设定职位名称也不一定完全一样，如果单用职位名称搜索就会比较受限，我们便可以根据相关的工作内容“薪酬福利”来进行搜索，扩展候选人范围。 （2）从岗位名称、任职要求中找寻合适的关键字，进行相关搜索。 例如：我们想要招一个高级JAVA软件工程师，具体要求如下所示 职位名称：高级JAVA软件工程师 职位描述： - 浏览器/服务器前后台程序开发； - 基础框架开发； - 技术文档编写；
this, these, that, those 的用法 我们把this, these, that, those 这四个词称为“指示代词”，用来指示或标识人或事物。其中，this 和that 为单数指示代词，these 和those 为复数指示代词。例如： ?This is my mother. 这是我的妈妈。 ?That's my dad. 那是我的爸爸。 ?These are my parents. 这是我的父母。 ?Those are Paul's son and daughter. 那是保罗的儿子和女儿。 通常，我们谈论离自己近的人或物时用 this / these，离自己远的人或物时用that / those 。例如： ?I like these books, but I don't like those books. 我喜欢这些书，但是我不喜欢那些书。 ?This girl is Mary. 这个女孩是玛丽。 ?That boy is in Class 5. 那个男孩在五班。 下面我们来看一下这些指示代词作主语构成一般疑问句时，答句所使用的主语会有什么变化。 ?Is this your bike? ?Yes, it is ?. 这是你的自行车吗？ ?是的，是我的自行车。 ?Are these your grandparents? ?Yes, they are.
?这是你的祖父母吗？ ?是的，他们是。 由此可以看出，当指示代词所指的事物已确定时，后面的指示代词指人时用he、she 和they 来代替，指物时用it 和they 来代替。再如： ?Is that a bird or a plane? ?It's a plane. ?那是鸟还是飞机？ ?是飞机。 ?Is this your friend Tony ?Yes, he is. ?这是你的朋友托尼吗？ ?是的，他是。 上一个：Module1 动词be 说明身份、年龄、状态等 下一个：Module 3 there be 句型的用法
c++中的explicit关键字用来修饰类的构造函数，表明该构造函数是显式的，既然有"显式"那么必然就有"隐式"，那么什么是显示而什么又是隐式的呢？ 如果c++类的构造函数有一个参数，那么在编译的时候就会有一个缺省的转换操作：将该构造函数对应数据类型的数据转换为该类对象，如下面所示： class MyClass { public: MyClass(int num); } .... MyClass obj=10;//ok，convert int to MyClass 在上面的代码中编译器自动将整型转换为MyClass类对象，实际上等同于下面的操作： MyClass temp（10）； MyClass obj=temp； 上面的所有的操作即是所谓的"隐式转换". 如果要避免这种自动转换的功能，我们该怎么做呢？嘿嘿这就是关键字explicit的作用了，将类的构造函数声明为"显示"，也就是在声明构造函数的时候前面添加上explicit即可，这样就可以防止这种自动的转换操作，如果我们修改上面的MyClass类的构造函数为显示的，那么下面的代码就不能够编译通过了，如下所示： class MyClass { public: explicit MyClass(int num);
} .... MyClass obj=10;//err，can‘t non-explict convert class isbn_mismatch:public std::logic_error{public:explicit isbn_missmatch(const std::string &s):std:logic_error(s){}isbn_mismatch(const std::string&s，const std::string&lhs，const std::string &rhs):std::logic_error(s)，left(lhs)，right(rhs){}const std::string left，right;virtual~isbn_mismatch() throw(){}}; Sales_item&operator+(const Sales_item&lhs，const Sales_item rhs){if(!lhs.same_isbn(rhs)) throw isbn_mismatch("isbn missmatch"，lhs.book()，rhs.book());Sales_item ret(lhs);ret+rhs;return ret;} Sales_item item1，item2，sum;while(cinitem1item2){try{sun=item1+item2;}catch(const isbn_mismatch&e){cerre.what()"left isbn is:"e.left"right isbn is:"e.rightendl;}} 用于用户自定义类型的构造函数，指定它是默认的构造函数，不可用于转换构造函数。因为构造函数有三种：1拷贝构造函数2转换构造函数3一般的构造函数（我自己的术语^_^） 另：如果一个类或结构存在多个构造函数时，explicit修饰的那个构造函数就是默认的 class isbn_mismatch:public std::logic_error{public:explicit isbn_missmatch(const std::string &s):std:logic_error(s){}isbn_mismatch(const std::string&s，const std::string&lhs，const std::string &rhs):std::logic_error(s)，left(lhs)，right(rhs){}const std::string left，right;virtual~isbn_mismatch() throw(){}}; Sales_item&operator+(const Sales_item&lhs，const Sales_item rhs){if(!lhs.same_isbn(rhs)) throw isbn_mismatch("isbn missmatch"，lhs.book()，rhs.book());Sales_item ret(lhs);ret+rhs;return ret;}
本文将介绍以下内容： ?面向对象基本概念 ?base关键字深入浅出 ?this关键字深入浅出 1. 引言 new关键字引起了大家的不少关注，尤其感谢Anders Liu的补充，让我感觉博客园赋予的交流平台真的无所不在。所以，我们就有必要继续这个话题，把我认为最值得关注的关键字开展下去，本文的重点是访问关键字（Access Keywords）：base和this。虽然访问关键字不是很难理解的话题，我们还是有可以深入讨论的地方来理清思路。还是老办法，我的问题先列出来，您是否做好了准备。 1.是否可以在静态方法中使用base和this，为什么？ 2.base常用于哪些方面？this常用于哪些方面？ 3.可以base访问基类的一切成员吗？ 4.如果有三层或者更多继承，那么最下级派生类的base指向那一层呢？例 如.NET体系中，如果以base访问，则应该是直接父类实例呢，还是最高 层类实例呢？ 5.以base和this应用于构造函数时，继承类对象实例化的执行顺序如何？ 2. 基本概念 base和this在C#中被归于访问关键字，顾名思义，就是用于实现继承机制的访问操作，来满足对对象成员的访问，从而为多态机制提供更加灵活的处理方式。 2.1 base关键字 其用于在派生类中实现对基类公有或者受保护成员的访问，但是只局限在构造函数、实例方法和实例属性访问器中，MSDN中小结的具体功能包括：?调用基类上已被其他方法重写的方法。 ?指定创建派生类实例时应调用的基类构造函数。 2.2 this关键字 其用于引用类的当前实例，也包括继承而来的方法，通常可以隐藏this，MSDN 中的小结功能主要包括： ?限定被相似的名称隐藏的成员 ?将对象作为参数传递到其他方法 ?声明索引器