一、关键字定义:一些已经指定了含义的词语,即信息的集中化和概括化,方便用户的使用。
下面我们就列举一些常见的关键字:
(1)根类相关:public private protected class interface implements extends import package
abstract
(2)根方法函数/属性相关:void return static final
(3)八大基本数据类型:int short byte long char boolean double float
(4) 循环判断:for switch do while break continue if case
(5)异常:try catch throw throws finally
(6)其他:this super
(7)goto(保留字)
二、关键字命名
例如: swith(){//int/short/ String(JDK1.7版本以前不能用) 枚举类型
case **:break;
}
(1)在这里顺便说一下标识符的命名规则:
1.首字母只能以字母,下划线,$开头,后面可以跟字母,下划线、美元符$、数字。
2.标识符不能是关键字。
3.标识符区分大小写
4.标识符没有长度限制,但是不宜过长
5.如果标识符有多个单词构成,那么从第二个单词开始,首字母大写
6.标识符尽量命名有意义,让人望文生义
7.尽量少用带$符号的标识符,不太习惯,还有内部类中,$具有特殊含义
8.Java语言使用16-bit双字节字符编码标准(unicode字符集),最多可以识别65535个字符。建议标识符中最好使用ASCII字母,虽然中文标识符也能够正常的编译和执行,却不建议使用。
注意:true、false、null不能作为java标识符,因为编译器会会按照字面意思去解释它。
保留字可以做为标识符,但是最好不要用。
(2)下面通过一个比较抽象的表格来说明访问权限修饰符的作用范围:
当前类 当前包 包外子类 包外类
public 可以 可以 可以 可以
protected 可以 可以 可以
默认 可以 可以
private 可以
(3)下面我们用具体的实例来说明每一个访问权限修饰符的作用:
1、 package 测试;
public class Student{
public String name;
int age;
protected String dress;
private String sex;
}
package 测试;
public class Test {
public static void main(String[] args) {
Student st=new Student();
st.name="张三";
st.age=14;
st.dress="衡阳";
//报错,错误为The field Student.sex is not visible
st.sex="男";
}
}
通过观察这段代码我们发现 st.sex="男"语句会报错,报错的原因是 (The field Student.sex is not visible)即主函数
调用不到sex因为它是Student的私有属性,只能被它的当前类调用,主函数调用不了。
2、package 测试;
public class UnStudent extends Student {
public static void main(String[] args) {
UnStudent un=new UnStudent();
un.age=12;
un.dress="长沙";
un.name="李四";
//报错The field Student.sex is not visible
un.sex="女";
System.out.println(un.age);
System.out.println(un.dress);
System.out.println(un.name);
}
}
上面是我创建的Student的一个子类 UnStudent,正如大家所遇见的sex又报错(The field Student.sex is not visible),而其它三个
属性仍然没有错,并且当把un.sex="女";这条语句删除后程序的运行结果就是12 长沙 李四,这就充分的说明了public、protected、默认
这三个访问符号的访问范围都是作用于当前类和当前包。
3、下面在创建一个新包,进一步判断public、protected、默认的区别
package 测试1;
import 测试.Student;
public class UnStudent extends Student {
public void study(){
this.name="张三";
//报错,错误是The field Student.age is not visible
this.age=16;
this.dress="北京";
//报错,错误是The field Student.sex is not visible
this.sex="男";
}
}
上述代码中sex与age均报错了分别是The field Student.sex is not visible和The field Student.age is not visible,这就表明
默认的访问范围不包括包外子类,而public与protect均可以。
4、从上述几个例子可知public与protect的作用范围大致相同,那么这是不是就意味着他们的作用范围一定是错的呢,答案显然是错的,下面
我们再通过一个例子证明我的推断。
package 测试1;
import 测试.Student;
public class Text {
public static void main(String[] args) {
Student sd=new Student();
sd.name = "张三";
//报错The field Student.age is not visible
sd.age = 20;
//报错The field Student.sex is not visible
sd.sex = "男";
//报错The field Student.dress is not visible
sd.dress = "上海";
}
}
根据上述程序可知age,sex,dress均出现报错,这就证明虽然public与protect的作用范围大致相同,但他们最大的不同就是public
能访问所有的包外类,而protect只能访问包外子类,访问范围相对于public来说更小。
(4)this\super
this:当前类的对象
super:父类的对象
普通方法和属性调用:this.方法名(),this.属性名
this();
super.方法名(),super.属性
super();
1、this
package 测试;
public class Student {
public String name;
int age;
protected String dress;
private String sex;
public Student(){
this("n");
System.out.println("执行了第一个");
}
public Student(String n){
System.out.println("执行了第二个");
}
}
this是指当前对象自己,上述程序中的this就是对Student(String n)方法的调用,故执行的结果就是执行了第二个、
执行了第一个,因为this("n");先调用的Student(String n),故先输出执行了第二个。那么问题来了,如果我们把
this("n");放在Student(String n)构造方法的第一行又会发生什么呢,答案是此程序无法运行故我们要将this("n");
改为this();这时程序运行的结果就是执行了第一个,那这又会有一个问题,为什么执行了第二个没有输出了,因为它压根儿
就没有被this()调用,因为this()没有调用Student(String n)所需的形参。故事发展到这里,我想信大家的心理都有了一个
结论,那就是无论是什么构造函数,this()都要放在该构造函数的第一行。
2、super
package 测试1;
public class Student {
public Student(String n){
//调用Object的构造方法
super();
}
public void study(){
System.out.println("学生学习");
}
}
package 测试1;
public class UnStudent extends Student {
public UnStudent() {
//调用父类的对象
super("");
}
public void study() {
super.study();
System.out.println("大学生学习");
}
}
package 测试;
import 测试1.Student;
public class Test {
public static void main(String[] args) {
Student stu = new Student("");
UnStudent us = new UnStudent("");
us.study();
}
}
super指的是在继承关系中,父类相对于子类就是super。和this()一样super也要放在每一个构造函数
的第一行,下面我们就来具体说一下super()在上述各个代码中所起到的作用。在Student类中,super()
起到的是调用当前类中方法的作用,而在UnStudent中super()起到的是调用分类中的方法的作用,故程序
最后的运行结果就是学生学习 大学生学习。
(5)final(最终的,最后的)
可以用来修饰:类、方法、属性、参数、局部变量
1、修饰类:当前类不能被继承
package 测试2;
public final class Student {
public String name;
protected int age;
String dress;
private String sex;
}
package 测试2;
//报错The type UnStudent cannot subclass the final class Student
public class UnStudent extends Student{
}
在这里我又用了一个新包来诠释final的作用,当上述程序中的Student前加上了final的关键词后,Student
就不能被UnStudent继承了。
2、方法:当前方法不能被重写
package 测试2;
public class Student {
public String name;
protected int age;
String dress;
private String sex;
public final void study(){
}
}
package 测试2;
public class UnStudent extends Student{
//报错Cannot override the final method from Student
public void study(){
}
}
显然UnStudent中的study()方法不能覆盖父类中的study()方法
3、属性:代表当前属性只能被赋值一次(常量)
package 测试2;
public class Student {
//name报错The blank final field name may not have been initialized
public final String name;
protected int age;
String dress;
private String sex;
public final void study(){
}
}
上述程序中name报错,说明name的定义方式又问题,当我们在定义name之前加上final时,我们应该
把name值变成一个常量,故正确的定义方式就是public final String name="";这才是正确的定义方式。
4、参数/局部变量:代表当前参数在生命周期范围内不能重新赋值
package 测试2;
public class Student {
public String name;
protected int age;
String dress;
private String sex;
public Student(final String n){
//调用Object的构造方法
super();
}
public void study(){
System.out.println("");
}
}
package 测试2;
public class UnStudent extends Student{
public UnStudent(String n) {
super("");
// TODO Auto-generated constructor stub
}
public void study(){
System.out.println("小学生学习");
}
}
package 测试2;
public class Tess {
public static void main(String[] args) {
Student st=new Student("");
UnStudent un=new UnStudent("");
un.study();
}
}
如上面的程序 public Student(final String n)构造方法参数前加了final,故当前参数在生命周期范围内不能重新赋值。
三、static(静态的):可以用来修饰:方法、属性、静态块(注意一点:静态方法中一定不能直接使用非静态属性或者方法)
package 测试3;
public class Student {
public String name;
public static String dress;
//加载类的时候自动执行
static{
System.out.println( "执行静态块");
}
//创建类的对象的时候自动执行
{
System.out.println( "执行程序块");
}
// public void study(){
//
// }
// public static void play(){
//
// }
}
package 测试3;
public class Tett {
public static void main(String[] args) {
Student stu1 = new Student();
Student stu2 = new Student();
// stu1.dress= "衡阳";
// stu2.dress = "株洲";
// Student.dress = "广州";
// System.out.println(stu1.dress);
// System.out.println(stu2.dress);
// System.out.println(Student.dress);
上述程序的运行结果是执行静态块 执行程序块 执行程序块,其中System.out.println( "执行静态块");一定会运行。
而System.out.println( "执行程序块");因为是要在创建类对象的时候执行,而主函数中创建了两次对象,故其执行
两次,假如主函数创建了三次或更多的对象,那么System.out.println( "执行程序块")也将执行相应的次数,下满让我们
将注释摘掉看会发生什么样的神奇的效果。
package 测试3;
public class Tett {
public static void main(String[] args) {
Student stu1 = new Student();
Student stu2 = new Student();
stu1.dress= "衡阳";
stu2.dress = "株洲";
Student.dress = "广州";
System.out.println(stu1.dress);
System.out.println(stu2.dress);
System.out.println(Student.dress);
现在大家看到的是摘除注释后的主函数,那么现在执行的话又会发生什么呢,答案就是程序的运行结果是执行静态块
执行程序块 执行程序块 广州 广州 广州,那么问题来了为甚摸会出现三个广州呢,主要是因为主函数的默认对象就是
Student,无论Student.dress = "广州";前面有多少个对象,只要最后一句是Student.dress = "广州";那么就执行
为“广州”,因为它将它前面的所有值都覆盖了。
下面我们就列举一些常见的关键字:
(1)根类相关:public private protected class interface implements extends import package
abstract
(2)根方法函数/属性相关:void return static final
(3)八大基本数据类型:int short byte long char boolean double float
(4) 循环判断:for switch do while break continue if case
(5)异常:try catch throw throws finally
(6)其他:this super
(7)goto(保留字)
二、关键字命名
例如: swith(){//int/short/ String(JDK1.7版本以前不能用) 枚举类型
case **:break;
}
(1)在这里顺便说一下标识符的命名规则:
1.首字母只能以字母,下划线,$开头,后面可以跟字母,下划线、美元符$、数字。
2.标识符不能是关键字。
3.标识符区分大小写
4.标识符没有长度限制,但是不宜过长
5.如果标识符有多个单词构成,那么从第二个单词开始,首字母大写
6.标识符尽量命名有意义,让人望文生义
7.尽量少用带$符号的标识符,不太习惯,还有内部类中,$具有特殊含义
8.Java语言使用16-bit双字节字符编码标准(unicode字符集),最多可以识别65535个字符。建议标识符中最好使用ASCII字母,虽然中文标识符也能够正常的编译和执行,却不建议使用。
注意:true、false、null不能作为java标识符,因为编译器会会按照字面意思去解释它。
保留字可以做为标识符,但是最好不要用。
(2)下面通过一个比较抽象的表格来说明访问权限修饰符的作用范围:
当前类 当前包 包外子类 包外类
public 可以 可以 可以 可以
protected 可以 可以 可以
默认 可以 可以
private 可以
(3)下面我们用具体的实例来说明每一个访问权限修饰符的作用:
1、 package 测试;
public class Student{
public String name;
int age;
protected String dress;
private String sex;
}
package 测试;
public class Test {
public static void main(String[] args) {
Student st=new Student();
st.name="张三";
st.age=14;
st.dress="衡阳";
//报错,错误为The field Student.sex is not visible
st.sex="男";
}
}
通过观察这段代码我们发现 st.sex="男"语句会报错,报错的原因是 (The field Student.sex is not visible)即主函数
调用不到sex因为它是Student的私有属性,只能被它的当前类调用,主函数调用不了。
2、package 测试;
public class UnStudent extends Student {
public static void main(String[] args) {
UnStudent un=new UnStudent();
un.age=12;
un.dress="长沙";
un.name="李四";
//报错The field Student.sex is not visible
un.sex="女";
System.out.println(un.age);
System.out.println(un.dress);
System.out.println(un.name);
}
}
上面是我创建的Student的一个子类 UnStudent,正如大家所遇见的sex又报错(The field Student.sex is not visible),而其它三个
属性仍然没有错,并且当把un.sex="女";这条语句删除后程序的运行结果就是12 长沙 李四,这就充分的说明了public、protected、默认
这三个访问符号的访问范围都是作用于当前类和当前包。
3、下面在创建一个新包,进一步判断public、protected、默认的区别
package 测试1;
import 测试.Student;
public class UnStudent extends Student {
public void study(){
this.name="张三";
//报错,错误是The field Student.age is not visible
this.age=16;
this.dress="北京";
//报错,错误是The field Student.sex is not visible
this.sex="男";
}
}
上述代码中sex与age均报错了分别是The field Student.sex is not visible和The field Student.age is not visible,这就表明
默认的访问范围不包括包外子类,而public与protect均可以。
4、从上述几个例子可知public与protect的作用范围大致相同,那么这是不是就意味着他们的作用范围一定是错的呢,答案显然是错的,下面
我们再通过一个例子证明我的推断。
package 测试1;
import 测试.Student;
public class Text {
public static void main(String[] args) {
Student sd=new Student();
sd.name = "张三";
//报错The field Student.age is not visible
sd.age = 20;
//报错The field Student.sex is not visible
sd.sex = "男";
//报错The field Student.dress is not visible
sd.dress = "上海";
}
}
根据上述程序可知age,sex,dress均出现报错,这就证明虽然public与protect的作用范围大致相同,但他们最大的不同就是public
能访问所有的包外类,而protect只能访问包外子类,访问范围相对于public来说更小。
(4)this\super
this:当前类的对象
super:父类的对象
普通方法和属性调用:this.方法名(),this.属性名
this();
super.方法名(),super.属性
super();
1、this
package 测试;
public class Student {
public String name;
int age;
protected String dress;
private String sex;
public Student(){
this("n");
System.out.println("执行了第一个");
}
public Student(String n){
System.out.println("执行了第二个");
}
}
this是指当前对象自己,上述程序中的this就是对Student(String n)方法的调用,故执行的结果就是执行了第二个、
执行了第一个,因为this("n");先调用的Student(String n),故先输出执行了第二个。那么问题来了,如果我们把
this("n");放在Student(String n)构造方法的第一行又会发生什么呢,答案是此程序无法运行故我们要将this("n");
改为this();这时程序运行的结果就是执行了第一个,那这又会有一个问题,为什么执行了第二个没有输出了,因为它压根儿
就没有被this()调用,因为this()没有调用Student(String n)所需的形参。故事发展到这里,我想信大家的心理都有了一个
结论,那就是无论是什么构造函数,this()都要放在该构造函数的第一行。
2、super
package 测试1;
public class Student {
public Student(String n){
//调用Object的构造方法
super();
}
public void study(){
System.out.println("学生学习");
}
}
package 测试1;
public class UnStudent extends Student {
public UnStudent() {
//调用父类的对象
super("");
}
public void study() {
super.study();
System.out.println("大学生学习");
}
}
package 测试;
import 测试1.Student;
public class Test {
public static void main(String[] args) {
Student stu = new Student("");
UnStudent us = new UnStudent("");
us.study();
}
}
super指的是在继承关系中,父类相对于子类就是super。和this()一样super也要放在每一个构造函数
的第一行,下面我们就来具体说一下super()在上述各个代码中所起到的作用。在Student类中,super()
起到的是调用当前类中方法的作用,而在UnStudent中super()起到的是调用分类中的方法的作用,故程序
最后的运行结果就是学生学习 大学生学习。
(5)final(最终的,最后的)
可以用来修饰:类、方法、属性、参数、局部变量
1、修饰类:当前类不能被继承
package 测试2;
public final class Student {
public String name;
protected int age;
String dress;
private String sex;
}
package 测试2;
//报错The type UnStudent cannot subclass the final class Student
public class UnStudent extends Student{
}
在这里我又用了一个新包来诠释final的作用,当上述程序中的Student前加上了final的关键词后,Student
就不能被UnStudent继承了。
2、方法:当前方法不能被重写
package 测试2;
public class Student {
public String name;
protected int age;
String dress;
private String sex;
public final void study(){
}
}
package 测试2;
public class UnStudent extends Student{
//报错Cannot override the final method from Student
public void study(){
}
}
显然UnStudent中的study()方法不能覆盖父类中的study()方法
3、属性:代表当前属性只能被赋值一次(常量)
package 测试2;
public class Student {
//name报错The blank final field name may not have been initialized
public final String name;
protected int age;
String dress;
private String sex;
public final void study(){
}
}
上述程序中name报错,说明name的定义方式又问题,当我们在定义name之前加上final时,我们应该
把name值变成一个常量,故正确的定义方式就是public final String name="";这才是正确的定义方式。
4、参数/局部变量:代表当前参数在生命周期范围内不能重新赋值
package 测试2;
public class Student {
public String name;
protected int age;
String dress;
private String sex;
public Student(final String n){
//调用Object的构造方法
super();
}
public void study(){
System.out.println("");
}
}
package 测试2;
public class UnStudent extends Student{
public UnStudent(String n) {
super("");
// TODO Auto-generated constructor stub
}
public void study(){
System.out.println("小学生学习");
}
}
package 测试2;
public class Tess {
public static void main(String[] args) {
Student st=new Student("");
UnStudent un=new UnStudent("");
un.study();
}
}
如上面的程序 public Student(final String n)构造方法参数前加了final,故当前参数在生命周期范围内不能重新赋值。
三、static(静态的):可以用来修饰:方法、属性、静态块(注意一点:静态方法中一定不能直接使用非静态属性或者方法)
package 测试3;
public class Student {
public String name;
public static String dress;
//加载类的时候自动执行
static{
System.out.println( "执行静态块");
}
//创建类的对象的时候自动执行
{
System.out.println( "执行程序块");
}
// public void study(){
//
// }
// public static void play(){
//
// }
}
package 测试3;
public class Tett {
public static void main(String[] args) {
Student stu1 = new Student();
Student stu2 = new Student();
// stu1.dress= "衡阳";
// stu2.dress = "株洲";
// Student.dress = "广州";
// System.out.println(stu1.dress);
// System.out.println(stu2.dress);
// System.out.println(Student.dress);
上述程序的运行结果是执行静态块 执行程序块 执行程序块,其中System.out.println( "执行静态块");一定会运行。
而System.out.println( "执行程序块");因为是要在创建类对象的时候执行,而主函数中创建了两次对象,故其执行
两次,假如主函数创建了三次或更多的对象,那么System.out.println( "执行程序块")也将执行相应的次数,下满让我们
将注释摘掉看会发生什么样的神奇的效果。
package 测试3;
public class Tett {
public static void main(String[] args) {
Student stu1 = new Student();
Student stu2 = new Student();
stu1.dress= "衡阳";
stu2.dress = "株洲";
Student.dress = "广州";
System.out.println(stu1.dress);
System.out.println(stu2.dress);
System.out.println(Student.dress);
现在大家看到的是摘除注释后的主函数,那么现在执行的话又会发生什么呢,答案就是程序的运行结果是执行静态块
执行程序块 执行程序块 广州 广州 广州,那么问题来了为甚摸会出现三个广州呢,主要是因为主函数的默认对象就是
Student,无论Student.dress = "广州";前面有多少个对象,只要最后一句是Student.dress = "广州";那么就执行
为“广州”,因为它将它前面的所有值都覆盖了。