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/5e1049723.html,pareTo(nm); 复制代码 这段程序使用一个string类型对象作为实参传给things的CompareTo函数。这个函数本来是需要一个tings对象作为实参。现在编译器使用string nm来构造并初始化一个things对象，新生成的临时的things对象被传递给CompareTo函数，并在离开这段函数后被析构。 这种行为的正确与否取决于业务需要。假如你只是想测试一下a的重量与10的大小之比，这么做也许是方便的。但是假如在CompareTo函数中还涉及到了要除以初始化为0的height 属性，那么这么做可能就是错误的。需要在构造tings之后更改height属性不为0。所以要限制这种隐式类型转换。 那么这时候就可以通过将构造函数声明为explicit，来防止隐式类型转换。
Java 关键字速查表 访问控制: private 私有的 protected 受保护的 public 公共的 类、方法和变量修饰符abstract 声明抽象 class 类 extends 扩允,继承 final 终极,不可改变的implements实现 interface 接口 native 本地 new 新,创建 static 静态 strictfp 严格,精准synchronized 线程,同步transient 短暂 volatile 易失 程序控制语句 break 跳出循环 continue 继续 return 返回 do 运行 while 循环 if 如果 else 反之 for 循环 instanceof 实例 switch 开关 case 返回开关里的结果 default 默认 错误处理 catch 处理异常 finally 有没有异常都执行 throw 抛出一个异常对象throws 声明一个异常可能被抛出try 捕获异常 包相关 import 引入 package 包
基本类型 boolean 布尔型 byte 字节型 char 字符型 double 双精度, float 浮点 int 整型 long 长整型 short 短整型 null 空 true 真 false 假 变量引用 super 父类,超类 this 本类 void 无返回值 java关键字 关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字。Java的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名。一个Java语言中的关键字，用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现break 一个Java的关键字，用来改变程序执行流程，立刻从当前语句的下一句开始执行从。如果后面跟有一个标签，则从标签对应的地方开始执行case Java语言的关键字，用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。catch ：Java的一个关键字，用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。char ：Java语言的一个关键字，用来定义一个字符类型 abstract boolean break byte case catch char class continue default do double else extends final finally float for if implements import instanceof int interface long native new package private protected public return short static super switch synchronized this throw throws transient try void volatile while 详细介绍
认识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); // 下面是一个程序员的编码；发生一个意想不到的转换：
阅读教学中“关键词”的作用 【摘要】阅读教学在语文教学中占有较大比重，然而，如何有效地指导学生阅读却是我们每个语文老师都迫切需要解决却又无法彻底解决的一个问题。面对这一矛盾，笔者主张抓住一篇文章中的关键词，如题目、文眼、过渡段、小序等“点”，运用“抓关键词”法来指导学生实现轻松、高效地阅读目标。 【关键词】关键词教学；阅读教学；选取；实效 阅读教学向来是语文教师最为重视却又最不易取得实效的板块，我们往往通过五花八门的技巧来提高学生的阅读能力，殊不知，看似热闹的训练中，学生真正吸收的东西少之又少，如何在语文阅读教学中找到有力的“抓手”，让我们的阅读教学真正切实有效，笔者在教学实践中经过不断地摸索、尝试，认为可以使用“关键词教学”这“一发”来拎起解读文本的“全身”。 1 关键词教学大义 教育部2011年最新颁布的《初中语文新课程标准》提出：欣赏文学作品，能有自己的情感体验，初步领悟作品的内涵，从中获得对自然、社会、人生的有益启示。对作品的思想感情倾向，能联系文化背景作出自己的评价；对作品中感人的情境和形象，能说出自己的体验；品味作品中富于表现力的语言。而在我们的语文课堂上，往往有的只是分段落、理大意、记主旨等传统的步骤。学生的阅读兴趣越来越小，阅读效率越来越低，他们对于文本的了解也只是限于教师传授的“死水”而已，很难在文章中得到有益的启示，形成自己的独特体验。于是，语文教学中就形成了学生怕阅读、不阅读的局面。如何在枯燥机械地阅读模式中另辟一条蹊径，无论是对于学生还是教师而言，都显得尤为重要。那么，何谓关键词教学呢？在这里，笔者先简单列举执教的几篇课例供大家参考。在人教版九年级上册的《孤独之旅》中，抓住“孤独”一词，就可以准确地把握全文的脉络，这时候，整个教学就可以划分成清晰的三大步：感受杜小康的孤独——理解孤独的真正含义——学会战胜孤独，当然，看似简单的三个步骤下其实还需要教师精心地备课。然而这样的关键词一旦找出，在课堂上，学生便不再像无头的苍蝇，乱撞、乱飞。例如人教版八年级上册的《湖心亭看雪》，属于文言文。拿到这样的文章，学生有时候连读的兴趣都没有，更不要说读懂、读透了。其实，只要我们换一种教法，引导学生抓住文中的关键字“痴”，就不难体会作者的写作意图了。此外，在古典文学名著《智取生辰纲》一文中，我带领学生着重去品味一个“智”字，将吴用的“智”和杨志的“智”作一个比较，不仅让学生在轻松的氛围中解读了文本，更培养了他们客观评价历史人物的意识。纵观以上几个课例，我们不难发现，无论是所谓的长文短教，还是短文长教，都绕不开文章中的一些“文眼”，准确地找到这个文眼，并利用现有的知识去挖掘它，拓展它，就成了我们语文教师需要去做的功课。那么，如何有效地选取这个阅读教学的关键词，就成了我们语文教师要去思考和斟酌的内容。 2 语文关键词的选取
使用super来引用父类的成分，用this来引用当前对象一、super关键字 在JAVA类中使用super来引用父类的成分，用this来引用当前对象，如果一个类从另 外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用。 1.1.super关键字测试 1package cn.galc.test; 2 3/** 4 * 父类 5 * @author gacl 6 * 7*/ 8class FatherClass { 9public int value; 10public void f() { 11 value=100; 12 System.out.println("父类的value属性值="+value); 13 } 14 } 15 16/** 17 * 子类ChildClass从父类FatherClass继承 18 * @author gacl 19 * 20*/ 21class ChildClass extends FatherClass { 22/**
23 * 子类除了继承父类所具有的valu属性外，自己又另外声明了一个value属性， 24 * 也就是说，此时的子类拥有两个value属性。 25*/ 26public int value; 27/** 28 * 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现，即重写了f()方法的方法体。 29*/ 30public void f() { 31super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法 32 value=200;//这个value是子类自己定义的那个valu，不是从父类继承下来的那个value 33 System.out.println("子类的value属性值="+value); 34 System.out.println(value);//打印出来的是子类自定义的那个value的值，这个值是200 35/** 36 * 打印出来的是父类里面的value值，由于子类在重写从父类继承下来的f()方法时， 37 * 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法， 38 * 即相当于是这个父类对象自己调用f()方法去改变自己的value 属性的值，由0变了100。 39 * 所以这里打印出来的value值是100。 40*/ 41 System.out.println(super.value); 42 } 43 } 44 45/** 46 * 测试类 47 * @author gacl 48 * 49*/ 50public class TestInherit { 51public static void main(String[] args) { 52 ChildClass cc = new ChildClass();
public class HelloWorld { public static void main(String[] args) { Dog d=new Dog(); d.shout(); d.printName(); } } class Animal{ String name="动物"; void shout() { System.out.println("动物发出叫声"); } } class Dog extends Animal{ String name="犬类"; void shout() { super.shout();//使用super关键字访问父类的成员方法} public void printName() { System.out.println("它的名字是name="+https://www.doczj.com/doc/5e1049723.html,); //使用super关键字访问父类的成员变量
} public class HelloWorld { public static void main(String[] args) { Dog d=new Dog(); } } class Animal{ String name="动物"; public Animal(String name){ System.out.println("它是一只"+name); } void shout() { System.out.println("动物发出叫声"); } } class Dog extends Animal{ String name="犬类"; public Dog() { super("二哈");
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;}
如果子类中定义的成员变量和父类中成员变量同名时，子类就隐藏了从父类继承的成员变量。当子类中定义了一个方法，并且这个方法的名字、返回类型、参数个数和类型和父类的某个方法完全相同盟时，子类从父类继承的这个方法将被隐藏。如果在子类中想使用被隐藏的成员变量或方法就可以使用关键字 super。 1 使用关键字super调用父类的构造方法 子类不继承父类的构造方法，因此，子类如果想使用父类的构造方法，必须在子类的构造方法中使用，并且必须使用关键字super来表示，而且super必须是子类构造方法中的关一条语句,如例子4.23所示. 例子4.23 class Student { int number; String name; public Student() { } public Student(int number,String name) { this.number=number; https://www.doczj.com/doc/5e1049723.html,=name; System.out.println(" I am "+name+" my number is "+ number); } } class Univer_Student extends Student { boolean marry; public Univer_Student(int number,String name,boolean b) { super(number,name); marry=b; System.out.println("婚否=" + marry); }
} public static void Example4_23 { public static void main(String args[]) { Univer_Student zhang=new Univer_Student(9901,"和晓林",false); } } 运行结果： I am 和晓林my number is 9901 婚否=false; 需要注意的是：如果在子类的构造方法中，没有使用关键字super调用父类的某个构造方法，那么默认有 super(); 语句，即调用父类的不带参数的构造方法。 如果类时定义了一个或多个构造方法，那么Java不提供默认的构造方法（不带参数的构造方法），因此，当在父类中定义多个构造方法时，应当包括一个不带参数的构造方法，以防子类省略super时出现错 误。
super 关键字的使用 super 关键字出现在子类中，主要功能就是完成子类调用父类中的内容，也就是调用父类中的属性或方法。 super 调用父类中的构造方法： class Person { String name; int age; public Person(String name,int age) { https://www.doczj.com/doc/5e1049723.html,=name; this.age=age; } } class Student extends Person { String school; public Student() { super("张三",27); } } public class TestPersonStudentDemo { public static void main(String args[]) { Student s=new Student(); S.shchool=”北京”; System.out.println("我是:"+https://www.doczj.com/doc/5e1049723.html,+",今年:"+s.age+"岁,学校:"+s.school) ; } } 输出结果为：我是张三，今年27岁，学校：北京 本程序在子类的构造方法中明确地指明了调用的是父类中有两个参数的构造方法，所以程序在编译时不再去找父类中无参的构造方法。 用super 调用父类中的构造方法，只能放在子类的第一行。 通过super 调用父类的属性和方法： class Person 父类构造方法 子类构造方法 调用父类构造方法
{ String name; int age; public Person() { } public String talk() { return "我是："+https://www.doczj.com/doc/5e1049723.html,+",今年："+this.age+"岁"; } } class Student extends Person { String school; public Student(String name,int age,String school) { //在这里用super 调用父类中的属性 https://www.doczj.com/doc/5e1049723.html,=name; super.age=age; //调用父类中的talk()方法 System.out.print(super.talk()); //调用本类中属性 this.school=school; } } public class TestPersonStudentDemo3 { public static void main(String args[]) { Student s=new Student("张三",27,"北京"); System.out.println(",学校："+s.school); } } 输出结果为： 我是：张三,今年：27岁,学校：北京 限制子类的访问 有些时候，父类并不希望子类可以访问自己的类中全部的属性或方法，所以需要将一些属性父类构造方法 子类构造方法 父类一般方法
谈谈explicit关键字 2004-08-19 20:35 16677人阅读评论(7) 收藏举报 今天看到公司的代码内有大量的explicit关键字,但是老版的MSDN内例子并不完善,实在是不明白,最终从网上一篇文章内找到了答案:原来explicit是为了防止隐式使用拷贝构造函数的.以下附上从新版MSDN中找到的例子和网上那篇文章: // Copy From MSDN This keyword is a declaration specifier that can only be applied to in-class constructor declarations. An explicit constructor cannot take part in implicit conversions. It can only be used to explicitly construct an object. The following program will fail to compile because of the explicit keyword. To resolve the error, remove the explicit keywords and adjust the code in g. // spec1_explicit.cpp // compile with: /EHsc #include class C { public: int i; explicit C(const C&) // an explicit copy constructor { printf("/nin the copy constructor"); } explicit C(int i ) // an explicit constructor { printf("/nin the constructor"); } C() { i = 0; } }; class C2 { public: int i;
1、下列选项中关于Java中封装的说法错误的是（）。 A、封装就是将属性私有化，提供共有的方法访问私有属性 B、属性的访问方法包括setter方法和getter方法 C、setter方法用于赋值，getter方法用于取值 D、包含属性的类都必须封装属性，否则无法通过编译 2、Java中，如果类C是类B的子类，类B是类A的子类，那么下面描述正确的是（） A、C不仅继承了B中的成员，同样也继承了A中的成员 B、C只继承了B中的成员 C、C只继承了A中的成员 D、C不能继承A或B中的成员 3、分析选项中关于Java中this关键字的说法正确的是（） A、this关键字是在对象内部指代自身的引用 B、this关键字可以在类中的任何位置使用 C、this关键字和类关联，而不是和特定的对象关联 D、同一个类的不同对象共用一个this 4、以下关于布局的说法，错误的是（） A、BorderLayout是边框布局，它是窗体的默认布局 B、null是空布局，它是面板的默认布局 C、FlowLayout是流布局，这种布局将其中的组件按照加入的先后顺序从左向
右排列，一行排满之后就转到下一行继续从左至右排列 D、GridLayout是网格布局，它以矩形网格形式对容器的组件进行布置。容器被分成大小相等的矩形，一个矩形中放置一个组件 5、以下用于创建容器对象的类是（）（多选） A、Frame B、Checkbox C、Panel D、TextField 6、以下关于抽象类和接口的说法错误的是（） A、抽象类在Java语言中表示的是一种继承关系，一个类只能使用一次继承。但是一个类却可以实现多个接口。 B、在抽象类中可以没有抽象方法 C、实现抽象类和接口的类必须实现其中的所有方法，除非它也是抽象类。接口中的方法都不能被实现 D、接口中的方法都必须加上public关键字。 7、关于面向对象的说法正确的是（） A、类可以让我们用程序模拟现实世界中的实体 B、有多少个实体就要创建多少个类 C、对象的行为和属性被封装在类中，外界通过调用类的方法来获得，但是要知道类的内部是如何实现
VB关键字大总结 1.编译命令关键字总结 作用关键字 定义编译常数。 #Const 编译程序码中的选择区块。 #If...Then...#Else 2.变量与常数关键字总结 作用关键字 指定值。 Let 声明变量或常数。 Const, Dim, Private, Public, New, Static 声明模块为私有。 Option Private Module 判断 Variant。 IsArray, IsDate, IsEmpty, IsError, IsMissing, IsNull, IsNumeric, IsObje TypeName, VarType 引用当前对象。 Me 变量须明确声明。 Option Explicit 设置缺省数据类型。 Deftype 3.运算符关键字总结 作用关键字 算术。 ^, -, *, /, \, Mod, +, & 比较。 =, <>, <, >, <=, >=, Like, Is 逻辑运算。 Not, And, Or, Xor, Eqv, Imp 4.错误关键字总结 作用关键字 产生运行时错误。 Clear, Error, Raise 取得错误信息。 Error 提供错误信息。 Err 返回 Error 变体。 CVErr 运行时的错误处理。 On Error, Resume １
型确认。 IsError Collection 对象关键字总结 用关键字 立一个 Collection 对象。 Collection 加对象到集合对象中。 Add 集合对象中删除对象。 Remove 用集合对象中的项。 Item 金融关键字总结 用关键字 算折旧率。 DDB, SLN, SYD 算未来值。 FV 算利率。 Rate 算本质利率。 IRR, MIRR 算期数。 NPer 算支付。 IPmt, Pmt, PPmt 算当前净值。 NPV, PV 控制流关键字总结 用关键字 支。 GoSub...Return, GoTo, On Error, On...GoSub, On...GoTo 出或暂停程序。 DoEvents, End, Exit, Stop 环。 Do...Loop For...Next, For Each...Next, While...Wend, With 断。 Choose, If...Then...Else, Select Case, Switch 用过程。 Call, Function, Property Get, Property Let, Property Set, Sub 目录和文件关键字总结 用关键字 变目录或文件夹。 ChDir 变磁盘。 ChDrive 制文件。 FileCopy 建目录或文件夹。 MkDir 除目录或文件夹。 RmDir 新命名文件、目录或文件夹。 Name ２
JA V A的保留关键字 在java中保留关键字是被java本身定义使用的字母组合，具有特殊意义，所以不能用作变量名、方法名以及包名。Java共有51个关键字，中const和goto虽然被保留但未被使用。保留关键字分为8大类： 一、访问控制： 序号保留关键字定义或作用 1 private 私有的 2 protected 受保护的 3 public 公共的 二、类、方法、变量的修饰符： 序号保留关键字定义或作用 4 abstract 声明为抽象 5 class 类 6 extends 扩展、继承 7 final 终极、不可变 8 implements 实现 9 interface 接口 10 native 本地 11 new 新建、创建 12 static 静态 13 strictfp 严格精准 14 synchronized 同步 15 transient 短暂 16 volatile 易失 三、程序控制语句： 序号保留关键字定义或作用 17 break 中断、跳出循环 18 continue 继续 19 return 返回 20 do 运行 21 while 循环 22 if 如果 23 else 那么、反之 24 for 循环 25 instanceof 是否实例 26 switch 开关 27 case 返回开关的结果 28 deault 默认
四、异常处理 序号保留关键字定义或作用 29 catch 处理异常 30 finally 最终都执行 31 throw 抛出一个异常对象 32 throws 声明一个异常可能被抛出 33 try 捕获异常 五、包相关： 序号保留关键字定义或作用 34 import 引入 35 package 包 六、基本类型： 序号保留关键字定义或作用 36 boolean 布尔 37 byte 字节 38 char 字符 39 double 双精度 40 float 单精度 41 int 整型 42 long 长整型 43 short 短整型 44 null 对象的空 45 true 真 46 false 假 null “” 七、变量引用： 序号保留关键字定义或作用 47 super 父类、超类 48 this 本类 49 void 无返回值 八、访问控制保留字（未使用） 序号保留关键字定义或作用 50 const 常量 51 goto 跳转
1.子类的构造函数如果要引用super的话，必须把super放在函数的首位. class Base { Base() { System.out.println("Base"); } } public class Checket extends Base { Checket() { super();//调用父类的构造方法，一定要放在方法的首个语句 System.out.println("Checket"); } public static void main(String argv[]) { Checket c = new Checket(); } } 如果想用super继承父类构造的方法，但是没有放在第一行的话，那么在super 之前的语句，肯定是为了满足自己想要完成某些行为的语句，但是又用了super继承父类的构造方法。那么以前所做的修改就都回到以前了，就是说又成了父类的构造方法了。 2．在Java中，有时还会遇到子类中的成员变量或方法与父类（有时也称父类）中的成员变量或方法同名。因为子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或方法就隐藏了父类的成员变量或方法，但是我们如果想要使用父类中的这个成员变量或方法，就需要用到super. class Country { String name; void value() { name = "China"; } } class City extends Country { String name; void value() { name = "Hefei"; super.value();//不调用此方法时，https://www.doczj.com/doc/5e1049723.html,返回的是父类的成员变量的值null System.out.println(name);
abstract do implement private this boolean double import protected throw break else instanceof public throws byte extend int return transient case false interface short true catch final long static try char fianlly native strictfp void class float new super volatile continue for null switch while default if package synchronized abstract: 含义：抽象的 作用：用来修饰类和方法 用来修饰类时表示这个类为抽象类、用来修饰方法的时候表示这个方法为抽象方法。boolean： 含义：布尔型数据定义，这种数据类型只有两种值：true(真) 和false(假) 作用：用来修饰变量，把这个变量定义成为布尔型的变量。 break: 含义：跳出 作用：用于在某个循环中，或者在某个swicth语句中跳出某个循环或者跳出某个选择。byte： 含义：字节 作用：用来修饰变量，把这个变量定义成为字节型的变量。 case： 含义：英文原义是--案例、实例，但在Java中表示符合某个值。 作用：用于在switch语句中对条件进行选择。 catch： 含义：捕获、得到 作用：用于在异常处理中捕获某种异常。 char：
含义：字符 作用：用来修饰变量，把这个变量定义成为字符型的变量。 class： 含义：类 作用：用来修饰变量，把这个变量定义成为类。 continue： 含义：英文原义是继续，但在Java中表示进入下一个循环的意思。 作用：在循环中，跳过continue下面的语句，进入下一个循环。 default: 含义：缺省的、默认的 作用：用于在switch语句中表示如果以上的值都不满足的情况下，选择default表示的内容执行。 do 含义：执行 作用：用于do…..while语句中，在里面表示循环体。 double 含义：英文原义是双，一对的意思，但在Java中表示双精度型 作用：用来修饰变量，把这个变量定义成为双精度型的变量。 else： 含义：否则 作用：用于在if…..else语句中表示如果不满足if所包含的条件，那么就执行else所包含的内容。 extend： 含义：英文的原意是扩展的意思，但在Java中表示继承 作用：用于子类继承父类的时候，子类的定义语法中。 false： 含义：假 作用：用于表示一个布尔类型变量的值-----------假 final 含义：最终的 作用：用于修饰类、方法、变量 用于修饰类时表示这个类为最终类，也就是意味着这个类不能被继承。 用于修饰方法时表示这个方法为最终方法，也就是意味着这个方法不能被重载。 用于修饰变量的时候，表示这个变量为常量----不能改变值。 finally： 含义：最终的 作用：用于在try…..catch….finally语法中。表示不管程序运行时能否捕获到异常，都必须执行finally里的语句。一般用于释放内存资源，如Connection,DataReader的对象等。float： 含义：浮点型 作用：用来修饰变量，把这个变量定义成为浮点型的变量。 for： 含义：在Java中表示for循环 作用：用于for循环的语法中，表示循环语句的开始。
C++ 中explicit 关键字的作用 在C++中，explicit关键字用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换，只能以显示的方式进行类型转换。 explicit使用注意事项:explicit 关键字只能用于类内部的构造函数声明上，explicit 关键字作用于单个参数的构造函数。 在C++中，explicit关键字用来修饰类的构造函数，被修饰的构造函数的类，不能发生相应的隐式类型转换。 在C++中，如果一个类有只有一个参数的构造函数，C++允许一种特殊的声明类变量的方式。在这种情况下，可以直接将一个对应于构造函数参数类型的数据直接赋值给类变量，编译器在编译时会自动进行类型转换，将对应于构造函数参数类型的数据转换为类的对象。如果在构造函数前加上explicit修饰词，则会禁止这种自动转换，在这种情况下，即使将对应于构造函数参数类型的数据直接赋值给类变量，编译器也会报错。 下面以具体实例来说明。 建立people.cpp 文件，然后输入下列内容： class People { public: int age; People (int a) { age=a; } }; void foo ( void ) { People p1(10);//方式一 People* p_p2=new People(10); //方式二 People p3=10; //方式三 } 这段C++程序定义了一个类people，包含一个构造函数，这个构造函数只包含一个整形参数a，可用于在构造类时初始化age变量。 然后定义了一个函数foo，在这个函数中我们用三种方式分别创建了三个10岁的“人”。第一种是最一般的类变量声明方式。第二种方式其实是声明了一个people类的指针变量，然后在堆中动态创建了一个people实例，并把这个实例的地址赋值给了p_p2.第三种方式就是我们所说的特殊方式，为什么说特殊呢？我们都知道，C/C++是一种强类型语言，不同的数据类型是不能随意转换的，如果要进行类型转换，必须进行显式强制类型转换，而这里，没有进行任何显式的转换，直接将一个整型数据赋值给了类变量p3.
Java常见关键字及用法总结 关键字目录 abstract - 1 - boolean - 2 - break - 2 - byte - 2 - case - 3 - catch - 3 - char - 4 - class - 4 - continue - 5 - default - 5 - do - 6 - double - 6 - else - 6 - extends - 6 - false - 7 - final - 7 - finally - 7 - float - 8 - for - 8 - if - 8 - implements - 9 - import - 9 - instanceof - 9 - int - 9 - interface - 10 - long - 10 - native - 10 -
new - 11 - null - 11 - package - 11 - private - 11 - protected - 12 - public - 12 - return - 13 - short - 13 - static - 13 - super - 14 - switch - 14 - synchronized - 15 - this - 16 - throw - 16 - throws - 16 - transient - 17 - try - 17 - true - 18 - void - 18 - volatile - 18 - while - 18 - 1.abstract abstract 关键字可以修改类或方法。 abstract 类可以扩展（增加子类），但不能直接实例化。 abstract 方法不在声明它的类中实现，但必须在某个子类中重写。-示例- public abstract class MyClass{ } public abstract String myMethod();