文章目录
- abstract:
- boolean:
- break:
- byte:
- case:
- catch:
- char:
- class:
- continue:
- default:
- do:
- double:
- else:
- enum:
- extends:
- final:
- finally:
- float:
- for:
- if:
- implements:
- import:
- instanceof:
- int:
- interface:
- long:
- native:
- new:
- null:
- package:
- private:
- protected:
- public:
- return:
- short:
- static:
- strictfp:
- super:
- switch:
- synchronized:
- this:
- throw:
- throws:
- transient:
- try:
- void:
- volatile:
- while:
关键字属于保留字,在 Java 中具有特殊的含义,比如说 public、final、static、new 等等,它们不能用来作为变量名。为了便于你作为参照,我列举了 48 个常用的关键字,你可以瞅一瞅。
abstract:
abstract 关键字用于声明抽象类——可以有抽象和非抽象方法。
abstract修饰符用来修饰类和成员方法
1:用abstract修饰的类表示抽象类,抽象类位于继承树的抽象层,抽象类不能被实例化。
2:用abstract修饰的方法表示抽象方法,抽象方法没有方法体。抽象方法用来描述系统具有什么功能,但不提供具体的实现。
abstract 规则:
1:抽象类可以没有抽象方法,但是有抽象方法的类必须定义为抽象类,如果一个子类继承一个抽象类,子类没有实现父类的所有抽象方法,那么子类也要定义为抽象类,否则的话编译会出错的。
2:抽象类没有构造方法,也没有抽象静态方法。但是可以有非抽象的构造方法
3:抽象类不能被实例化,但是可以创建一个引用变量,类型是一个抽象类,并让它引用非抽象类的子类的一个实例
public class TestAbstract{
public static void main(String[] args){
MyClass mc ; mc = new Sub(); // 强制使用多态
mc.m1(); mc.m2(); mc.m3();
}
}
//抽象类
abstract class MyClass{
int a; // 属性
public void m1(){
System.out.println("m1()...");
}
public abstract void m2();
abstract public void m3();
}
// 子类
class Sub extends MyClass{
public void m2(){ System.out.println("m2()实现内容...");
}
public void m3(){
System.out.println("m3()...实现内 容.../");
}
}
1.如果一个类继承抽象类,此类为抽象类的子类
2. 如果子类不想定义为抽象类,必须覆盖父类中所有的抽象方法,否则子类必须定义为抽象类。
3. 抽象类类名 引用名 = new 子类类名(形参);
boolean:
boolean 关键字用于将变量声明为布尔值类型,它只有 true 和 false 两个值。
Boolean和boolean的区别
boolean是基本数据类型
Boolean是它的封装类,和其他类一样,有属性有方法,可以new,例如:
Boolean flag = new Boolean("true"); // boolean 则不可以!
Boolean 是boolean 的实例化对象类,和Integer对应int一样
自jdk1.5.0以上版本后,Boolean在"赋值"和判断上和boolean一样,
即是你: boolean b1 = true ; 或者 Boolean b2 = true ; 都可以。
唯一只能使用Boolean上的就是从列表或者哈希表获取值时。
比如 :
boolean t = false;
Map map = new HashMap();
map.put("t", t);
那么获取值时只能用
Boolean t1 = (Boolean) map.get(t); //前面只能用Boolean强制转换,不能使用boolean.
break:
break 关键字用于中断循环或 switch 语句。
①只能在循环体内和switch语句体内使用break;
②当break出现在循环体中的switch语句体内时,起作用只是跳出该switch语句体,并不能终止循环体的执行。若想强行终止循环体的执行,可以在循环体中,但并不在switch语句中设置break语句,满足某种条件则跳出本层循环体。
for(int i=0;i<month;i++)
{
switch(i)
{
case 1:
sumday+=31;
break;
case 2:
sumday+=29;
break;
case 3:
sumday+=31;
break;
case 4:
sumday+=30;
break;
case 5:
sumday+=31;
break;
case 6:
sumday+=30;
break;
case 7:
sumday+=31;
break;
case 8:
sumday+=31;
break;
case 9:
sumday+=30;
break;
case 10:
sumday+=31;
break;
case 11:
sumday+=30;
break;
case 12:
sumday+=31;
break;
}
}
break后跳出switch 但是还在for里
byte:
byte 关键字用于声明一个可以容纳 8 个比特的变量。
-
byte是java的基本数据类型,存储整型数据,占据1个字节(8 bits),能够存储的数据范围是-128~+127。
-
Byte是java.lang中的一个类,目的是为基本数据类型byte进行封装
Byte可以将对象的引用传递,使得多个function共同操作一个byte类型的数据,而byte基本数据类型是赋值之后要在stack(栈区域)进行存储的;
在java中包装类,比较多的用途是用在于各种数据类型的转化中。
比如,现在byte要转为String
byte a=0;
String result=Integer.toString(a);
使用泛型时
List<Integer> nums;
这里<>需要类。如果你用int。它会报错的
case:
case 关键字用于在 switch 语句中标记条件的值。
JDK1.7版本之前,case语句只支持可转换为int型的类型(byte ,short,char,int(其他的都不可以))和枚举类型的数据变量;(char可以转换成int)
String input = "Monday";
String output = null;
switch(input){
case "Monday":
output = "星期一";
break;
case "Tuesday":
output = "星期二";
break;
case "Wednesday":
output = "星期三";
break;
case "Thursday":
output = "星期四";
break;
case "Friday":
output = "星期五";
break;
case "Saturday":
output = "星期六";
break;
case "Sunday":
output = "星期日";
break;
default:
throw new IllegalArgumentException("无效的输入参数:" + input);
}
System.out.println(output); //输出:星期一
catch:
catch 关键字用于捕获 try 语句中的异常。
char:
char 关键字用于声明一个可以容纳无符号 16 位比特的 Unicode 字符的变量。
class:
class 关键字用于声明一个类。
continue:
continue 关键字用于继续下一个循环。它可以在指定条件下跳过其余代码。
default:
default 关键字用于指定 switch 语句中除去 case 条件之外的默认代码块。
do:
do 关键字通常和 while 关键字配合使用,do 后紧跟循环体。
double:
double 关键字用于声明一个可以容纳 64 位浮点数的变量。
else:
else 关键字用于指示 if 语句中的备用分支。
enum:
enum(枚举)关键字用于定义一组固定的常量。
extends:
extends 关键字用于指示一个类是从另一个类或接口继承的。
final:
final 关键字用于指示该变量是不可更改的。
finally:
finally 关键字和 try-catch 配合使用,表示无论是否处理异常,总是执行 finally 块中的代码。
float:
float 关键字用于声明一个可以容纳 32 位浮点数的变量。
for:
for 关键字用于启动一个 for 循环,如果循环次数是固定的,建议使用 for 循环。
if:
if 关键字用于指定条件,如果条件为真,则执行对应代码。
implements:
implements 关键字用于实现接口。
import:
import 关键字用于导入对应的类或者接口。
instanceof:
instanceof 关键字用于判断对象是否属于某个类型(class)。
int:
int 关键字用于声明一个可以容纳 32 位带符号的整数变量。
interface:
interface 关键字用于声明接口——只能具有抽象方法。
long:
long 关键字用于声明一个可以容纳 64 位整数的变量。
native:
native 关键字用于指定一个方法是通过调用本机接口(非 Java)实现的。
可以将native方法比作Java程序同C程序的接口,其实现步骤:
1、在Java中声明native()方法,然后编译;
2、用javah产生一个.h文件;
3、写一个.cpp文件实现native导出方法,其中需要包含第二步产生的.h文件(注意其中又包含了JDK带的jni.h文件);
4、将第三步的.cpp文件编译成动态链接库文件;
5、在Java中用System.loadLibrary()方法加载第四步产生的动态链接库文件,这个native()方法就可以在Java中被访问了。
new:
new 关键字用于创建一个新的对象。
null:
如果一个变量是空的(什么引用也没有指向),就可以将它赋值为 null。
package:
package 关键字用于声明类所在的包。
private:
private 关键字是一个访问修饰符,表示方法或变量只对当前类可见。
protected:
protected 关键字也是一个访问修饰符,表示方法或变量对同一包内的类和所有子类可见。
public:
public 关键字是另外一个访问修饰符,除了可以声明方法和变量(所有类可见),还可以声明类。main() 方法必须声明为 public。
return:
return 关键字用于在代码执行完成后返回(一个值)。
short:
short 关键字用于声明一个可以容纳 16 位整数的变量。
static:
static 关键字表示该变量或方法是静态变量或静态方法。
/**
* 说明:静态变量内存分析举例
*
* @author huayu
* @date 2018/8/3
*/
public class Cat {
//静态成员变量,就算不new对象它也会在data seg里面保存一份,它属于整个类
//不属于某个对象。int静态变量可以用来计数。
//对静态值访问:1.任何一个对象通过对象的引用都可以访问这个静态对象,访问的时候都是同一块内存
//2.即便是没有对象,也可以通过 类名. 来访问 如:System.out out是个静态变量
1. private static int sid=0;
//非静态成员变量 new对象的时候在堆内存对象中保存,每new一个对象产生一块
2. private String name;
//非静态成员变量 new对象的时候在堆内存对象中保存,每new一个对象产生一块
3. private int id;
public Cat(String name) {
4. this.name = name;
5. id=sid++;
}
public void info(){
6. System.out.println("My name is "+name+" No."+id);
}
public static void main(String[] args) {
//静态变量sid属于整个Cat类,不属于某个对象,可以用类名.来访问,所以这儿没有new任何对
//象,直接用类名.(Cat.sid)来访问的。
7. Cat.sid=100;
//字符串常量分配在data seg
8. Cat mimi=new Cat("mimi");
9. Cat pipi=new Cat("pipi");
10. mimi.info();
11. pipi.info();
}
}
打印结果:
My name is mimi No.id=100 sid= 102
My name is pipi No.id=101 sid= 102
strictfp:
strictfp 关键字并不常见,通常用于修饰一个方法,确保方法体内的浮点数运算在每个平台上执行的结果相同。
super:
super 关键字可用于调用父类的方法或者变量。
switch:
switch 关键字通常用于三个(以上)的条件判断。
synchronized:
synchronized 关键字用于指定多线程代码中的同步方法、变量或者代码块。
this:
this 关键字可用于在方法或构造函数中引用当前对象。
throw:
throw 关键字主动抛出异常。
throws:
throws 关键字用于声明异常。
transient:
transient 关键字在序列化的使用用到,它修饰的字段不会被序列化。
try:
try 关键字用于包裹要捕获异常的代码块。
void:
void 关键字用于指定方法没有返回值。
volatile:
volatile 关键字保证了不同线程对它修饰的变量进行操作时的可见性,
即一个线程修改了某个变量的值,这新值对其他线程来说是立即可见的。
while:
如果循环次数不固定,建议使用 while 循环。