代码示例:
public class Hello{
public static void main(String[] args){
System.out.println("hello man!");
}
}
Java源代码中的所有标点符号使用英文输入法状态输入;语法规则:
代码示例:
public static void main(String[] args){
int a;
a = 1;
System.out.println(a/b);
}
声明语法:语法规则:
数据类型 变量名 ;
变量名 = 值;
常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量,声明方式和变量类似:
final double PI = 3.1415927; |
---|
虽然常量名也可以用小写,但为了便于识别,通常使用大写字母表示常量。
字面量可以赋给任何内置类型的变量。例如:
byte a = 68; char a = 'A'; |
---|
byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。
当使用常量的时候,前缀0表示8进制,而前缀0x代表16进制, 例如:
int decimal = 100; int octal = 0144; int hexa = 0x64; |
---|
和其他语言一样,Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子:
"Hello World" "two\nlines" "\"This is in quotes\"" |
---|
字符串常量和字符常量都可以包含任何Unicode字符。例如:
char a = '\u0001'; String a = "\u0001"; |
---|
Java语言支持一些特殊的转义字符序列:
符号 | 字符含义 |
---|---|
\n | 换行 (0x0a) |
\r | 回车 (0x0d) |
\f | 换页符(0x0c) |
\b | 退格 (0x08) |
\0 | 空字符 (0x20) |
\s | 字符串 |
\t | 制表符 |
\" | 双引号 |
\' | 单引号 |
\\ | 反斜杠 |
\ddd | 八进制字符 (ddd) |
\uxxxx | 16进制Unicode字符 (xxxx) |
语法规则:
单行注释:
//这一行是注释 |
---|
多行注释:
/* * 多行注释 * 多行注释 */ |
---|
文档注释:
/** * 这是一个文档注释 */ |
---|
说明:
在开始的 /** 之后,第一行或几行是关于类、变量和方法的主要描述。
之后,你可以包含一个或多个各种各样的 @ 标签。每一个 @ 标签必须在一个新行的开始或者在一行的开始紧跟星号(*).
多个相同类型的标签应该放成一组。例如,如果你有三个 @see 标签,可以将它们一个接一个的放在一起。
下面是一个类的说明注释的实例:
/*** 这个类绘制一个条形图 * @author verycode * @version 1.2 */ |
---|
javadoc 工具软件识别以下标签:
标签 | 描述 | 示例 |
---|---|---|
@author | 标识一个类的作者 | @author description |
@deprecated | 指名一个过期的类或成员 | @deprecated description |
{@docRoot} | 指明当前文档根目录的路径 | Directory Path |
@exception | 标志一个类抛出的异常 | @exception exception-name explanation |
{@inheritDoc} | 从直接父类继承的注释 | Inherits a comment from the immediate surperclass. |
{@link} | 插入一个到另一个主题的链接 | {@link name text} |
{@linkplain} | 插入一个到另一个主题的链接,但是该链接显示纯文本字体 | Inserts an in-line link to another topic. |
@param | 说明一个方法的参数 | @param parameter-name explanation |
@return | 说明返回值类型 | @return explanation |
@see | 指定一个到另一个主题的链接 | @see anchor |
@serial | 说明一个序列化属性 | @serial description |
@serialData | 说明通过writeObject( ) 和 writeExternal( )方法写的数据 | @serialData description |
@serialField | 说明一个ObjectStreamField组件 | @serialField name type description |
@since | 标记当引入一个特定的变化时 | @since release |
@throws | 和 @exception标签一样. | The @throws tag has the same meaning as the @exception tag. |
{@value} | 显示常量的值,该常量必须是static属性。 | Displays the value of a constant, which must be a static field. |
@version | 指定类的版本 | @version info |
计算机的最基本用途之一就是执行数学运算,作为一门计算机语言,Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组:
修饰符用来定义类、方法或者变量,通常放在语句的最前端。
Java语言提供了很多修饰符,主要分为以下两类:
(1)访问修饰符
我们可以通过以下表来说明访问权限:
修饰符 | 当前类 | 同一包内 | 子孙类(同一包) | 子孙类(不同包) | 其他包 |
---|---|---|---|---|---|
public | Y | Y | Y | Y | Y |
protected | Y | Y | Y | Y/N | N |
default | Y | Y | Y | N | N |
private | Y | N | N | N | N |
规则:
(2)非访问修饰符
为了实现一些其他的功能,Java 也提供了许多非访问修饰符:
n 当final修饰类时,当前类不能被继承;
n 当final修饰方法时,该方法不能被重写;
n 当final修饰变量时,变量的值不能被修改,即为常量;
(1)什么是方法
(2)方法的优点
(3)方法的命名规则
(4)方法的定义
语法:
修饰符 返回值类型 方法名(参数类型 参数名){ ... 方法体 ... return 返回值; } |
---|
方法包含一个方法头和一个方法体。下面是一个方法的所有部分:
示例:
public static int age(int birthday){...} |
---|
参数可以有多个:
static float interest(float principal, int year){...} |
---|
注意: 在一些其它语言中方法指过程和函数。一个返回非void类型返回值的方法称为函数;一个返回void类型返回值的方法叫做过程。
代码示例:
下面的方法包含 2 个参数 num1 和 num2,它返回这两个参数的最大值。
/** 返回两个整型变量数据的较大值 */ public static int max(int num1, int num2) { int result; if (num1 > num2) result = num1; else result = num2; return result; } |
---|
(5)方法调用
Java 支持两种调用方法的方式,根据方法是否返回值来选择。
当程序调用一个方法时,程序的控制权交给了被调用的方法。当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。
当方法返回一个值的时候,方法调用通常被当做一个值。例如:
int larger = max(30, 40); |
---|
如果方法返回值是void,方法调用一定是一条语句。例如,方法println返回void。下面的调用是个语句:
System.out.println("Very Code!"); |
---|
代码示例:
public class TestMax { /** 主方法 */ public static void main(String[] args) { int i = 5; int j = 2; int k = max(i, j); System.out.println( i + " 和 " + j + " 比较,最大值是:" + k); } /** 返回两个整数变量较大的值 */ public static int max(int num1, int num2) { int result; if (num1 > num2) result = num1; else result = num2; return result; } } |
---|
编译运行结果如下:
5 和 2 比较,最大值是:5 |
---|
用法:
用法:
语法:
概念:重载(overloading) 是在一个类里面,方法名字相同,而参数不同。与返回值类型、访问修饰符无关。
规则:
规则:
当在一个源文件中定义多个类,并且还有import语句和package语句时,要特别注意以下规则:
为了更好地组织类,Java 提供了包机制,用于区别类名的命名空间。
包的作用:
包语句的语法格式为:
package pkg1[.pkg2[.pkg3…]]; |
---|
例如,一个Something.java 文件它的内容
package net.java.util; public class Something{ ... } |
---|
那么它的路径应该是 net/java/util/Something.java 这样保存的。
Package关键字:
在Java中,如果给出一个完整的限定名,包括包名、类名,那么Java编译器就可以很容易地定位到源代码或者类。Import语句就是用来提供一个合理的路径,使得编译器可以找到某个类。
例如,下面的命令行将会命令编译器载入java_installation/java/io路径下的所有类
import java.io.*; |
---|
Java的基本数据类型有4类8种,
类型分别为:整数型、浮点型、字符型、布尔型;
其中整数型有4种,字节型byte、短整型short、整数型int、长整型long;
浮点型有2种:单精度float、双精度double;
字符型char;
布尔型boolean
整型、实型(常量)、字符型数据可以混合运算。运算中,不同类型的数据先转化为同一类型,然后进行运算。
转换从低级到高级:
低 ------------------------------------> 高 byte,short,char—> int —> long—> float —> double |
---|
数据类型转换必须满足如下规则:
int i =128; byte b = (byte)i; |
---|
因为 byte 类型是 8 位,最大值为127,所以当 int 强制转换为 byte 类型时,值 128 时候就会导致溢出。
(int)23.7 == 23; (int)-45.89f == -45; |
---|
必须满足转换前的数据类型的位数要低于转换后的数据类型,例如: short数据类型的位数为16位,就可以自动转换位数为32的int类型,同样float数据类型的位数为32,可以自动转换为64位的double类型。
public class ZiDongLeiZhuan{ public static void main(String[] args){ char c1='a';//定义一个char类型 int i1 = c1;//char自动类型转换为int System.out.println("char自动类型转换为int后的值等于"+i1); char c2 = 'A';//定义一个char类型 int i2 = c2+1;//char 类型和 int 类型计算 System.out.println("char类型和int计算后的值等于"+i2); } } |
---|
运行结果:
char自动类型转换为int后的值等于97 char类型和int计算后的值等于66 |
---|
解析:c1 的值为字符 a ,查 ASCII 码表可知对应的 int 类型值为 97, A 对应值为 65,所以 i2=65+1=66。
条件是转换的数据类型必须是兼容的。
格式:(type)value type是要强制类型转换后的数据类型
实例:
public class QiangZhiZhuanHuan{ public static void main(String[] args){ int i1 = 123; byte b = (byte)i1;//强制类型转换为byte System.out.println("int强制类型转换为byte后的值等于"+b); } } |
---|
运行结果:
int强制类型转换为byte后的值等于123 |
---|
(1)if-else-if语句
语法:
if(条件){ //当条件为true时,执行大括号内的代码 }else if(条件){ } |
---|
(2)switch-case语句
概念:
switch 语句判断一个变量与一系列值中某个值是否相等,每个值称为一个分支。
语法:
switch( 变量 ){ case 值1: break; case 值2: break; default: } |
---|
当程序执行到break关键字时,跳出当前的switch语句;
语法规则:
(1)while循环
语法:
while(条件){ //当条件为true时,执行循环体内的代码; } |
---|
备注:
满足循环的三个条件:初始化变量、关系运算、迭代
(2)do-while循环
语法:
do{ }while(条件); |
---|
备注:与while循环的区别是,当条件为false时,也会被执行一次。
(3)for循环
语法:
for(int i = 0 ; i < 10 ; i++){ } |
---|
说明:
(4)foreach循环
Java5 引入了一种主要用于数组的增强型 for 循环。
Java 增强 for 循环语法格式如下:
for(声明语句 : 表达式) { //代码句子 } |
---|
声明语句:
声明新的局部变量,该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块,其值与此时数组元素的值相等。
表达式:
表达式是要访问的数组名,或者是返回值为数组的方法。
(1)break关键字
break 主要用在循环语句或者 switch 语句中,用来跳出整个语句块。
break 跳出最里层的循环,并且继续执行该循环下面的语句。
代码示例:
public class Test { public static void main(String args[]) { int [] numbers = {10, 20, 30, 40, 50}; for(int x : numbers ) { // x 等于 30 时跳出循环 if( x == 30 ) { break; } System.out.print( x ); System.out.print("\n"); } } } |
---|
编译运行结果如下:
1020 |
---|
(2)continue关键字
continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中,continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中,程序立即跳转到布尔表达式的判断语句。
示例:
public class Test { public static void main(String args[]) { int [] numbers = {10, 20, 30, 40, 50}; for(int x : numbers ) { if( x == 30 ) { continue; } System.out.print( x ); System.out.print("\n"); } } } |
---|
编译运行结果如下:
10 20 40 50 |
---|
语法:
标签名 :
使用:
break 标签名; 或 continue 标签名;
示例:
a: for (int i = 1; i <= 10; i++) { System.out.println("i="+i); b: for (int j = 1; j <= 10; j++) { if(j==5){ //continue a; break a; } System.out.println("j="+j); } } |
---|
规则:
(1)语法:
类型[] 数组名 = new 类型[长度];
示例:
int[] array = new int[10];
(2)语法:
类型[] 数组名 = {值,值,……};
示例:
int[] array2 = {1,2,3,4,5,6,7,8,9,10};
(3)语法:
类型[] 数组名 = new 类型[]{值,值……};
示例:
int[] array3 = new int[]{1,2,3,4,5,6,7,8};
数组通过下标来赋值和取值,例如:
array[0] = 1;
System.out.println(array[0]);
下标的范围是从0开始,到数组的长度-1;
示例:
int[] array = {10,12,32,45,57,68,79,80,90,100,200,300}; //数组的遍历 for(int i = 0 ; i < array.length ; i++){ System.out.println(array[i]); } |
---|
增强for循环:
语法:
for(数组类型 变量名 : 数组名){
System.out.println(变量名);
}
示例:
int[] a = {1,2,3,4,5,6}; //增强for循环 for(int i : a){ System.out.println(i); } |
---|
(1)冒泡排序
从后往前依次确定元素,相邻的两个元素比较,互换位置;
示例:
int[] a = {3,7,9,1,5}; for(int i = 1 ; i < a.length ; i++){ for(int j = 0 ; j < a.length - i; j++){ if(a[j] < a[j+1]){ int temp = a[j]; a[j] = a[j+1]; a[j+1] = temp; } } } |
---|
(2)选择排序
从前往后确定元素,让未确定的第一个数依次和后面的比较,互换位置;
示例:
int[] a = { 3, 7, 9, 1, 5 }; for (int i = 0; i < a.length - 1; i++) { for (int j = i + 1; j < a.length ; j++) { if (a[i] < a[j]) { int temp = a[i]; a[i] = a[j]; a[j] = temp; } } } |
---|
多维数组可以看成是数组的数组,比如二维数组就是一个特殊的一维数组,其每一个元素都是一个一维数组,例如:
String str[][] = new String[3][4]; |
---|
多维数组的动态初始化(以二维数组为例)
(1)直接为每一维分配空间
格式如下:
type[][] typeName = new type[typeLength1][typeLength2]; |
---|
type 可以为基本数据类型和复合数据类型,arraylenght1 和 arraylenght2 必须为正整数,arraylenght1 为行数,arraylenght2 为列数。
例如:
int a[][] = new int[2][3]; |
---|
解析:
二维数组 a 可以看成一个两行三列的数组。
(2)从最高维开始,分别为每一维分配空间
例如:
String s[][] = new String[2][]; s[0] = new String[2]; s[1] = new String[3]; s[0][0] = new String("Good"); s[0][1] = new String("Luck"); s[1][0] = new String("to"); s[1][1] = new String("you"); s[1][2] = new String("!"); |
---|
解析:
s[0]=new String[2] 和 s[1]=new String[3] 是为最高维分配引用空间,也就是为最高维限制其能保存数据的最长的长度,然后再为其每个数组元素单独分配空间 s0=new String("Good") 等操作。
对二维数组中的每个元素,引用方式为 arrayName[index1][index2],例如:
num[1][0]; |
---|
二维数组完整示例:
int[] a = {1,2,3,4,5,20}; int[] b = {6,7,8,9,10}; int[] c = {11,12,13,14,15,16,17,18}; //二维数组 int[][] array = {a,b,c}; //遍历array for(int i = 0 ; i < array.length ; i++){ for(int j = 0 ; j < array[i].length; j++){ System.out.print(array[i][j]+" "); } System.out.println(); } |
---|