01_Java语言基础组成

来源：互联网发布：免费dede织梦cms模板编辑：程序博客网时间：2024/04/28 23:37

一、关键字

a、定义：在Java语言中被赋予了特殊含义的单词。
b、特点：关键字中所有的字母都小写。
c、如：class、public、static、void、if、try、true、int、this。。。。

二、标识符

a、定义：在程序中自定义的一些名称。
b、特点：数字不可以开头，不可以使用关键字，严重区分大小写，起名字要有意义，以提高阅读性
c、书写规范：

包名：多单词组合时，所有字母小写，如xxxyyyzzz
类名接口：多单词组合时，所有单词首字母大写，如XxxYyyZzz
变量名和函数名：多单词组合时，第一个单词首字母小写，其余首字母大写，如：xxxYyyZzz
常量名：所有字母都大写，多单词组合时每个单词用下划线连接，如：XXX_YYY_ZZZ

三、注释

a、“//”单行注释
b、“/*..........*/”多行注释
c、“/**..........*/”文本注释

四、常量和变量

a、常量：表示不能改变的数值，包括整数常量、小数常量、布尔型常量、字符常量、字符串常量和null常量。
b、变量：内存中的一个存储区域，该区域有自己的名称和类型，该区域内的数据可以在同一类型范围内不断变化。

格式：数据类型变量名=初始化值；
基本数据类型：byte、short、int、long、float、double、char、boolean。
引用数据类型：class、interface、[ ]
类型初始化值：
boolean false
byte、short、int、long、char 0
float、double 0.0
一般情况下，整数默认int，小数默认double。

package cn.abc;public class Demo {public static void main(String[] args) {// byte在内存中占8位，取值范围从-128到127byte b = 3;// short类型在内存中占2个字节，取值范围从 -32768到32767short c = 4;// int型在内存中占4个字节。取值范围从 -2147483648 到 2147483647int i = 2;// long型在内存中占8个字节。// 取值范围从 -9223372036854775808 到 9223372036854775807long l = 5;// float型在内存中占4个字节。取值范围从 -3.4E38 到 3.4E38float f = 2.3f;// double 型在内存中占8个字节。取值范围从 -1.7E308 到 1.7E308double d = 23.8908;// char类型在内存中占2个字节。表示一个字符，也可以使用ASCII码范围内的值来给char型的变量赋值。// 由于字符在内存中的取值不存在负数范围，所有取值范围从 0 到 65535// 赋值：char i = ‘a’; 或者 char i = 97;char ch = '5';// boolean类型只有两个值：true和false。boolean boo = false;System.out.println(ch);}}

五、运算符

a、算术运算符

Java的算术运算符分为一元运算符和二元运算符。一元运算符只有一个操作数；二元运算符有两个操作数，运算符位于两个操作数之间。算术运算符的操作数必须是数值类型。

(1)一元运算符：

一元运算符有：正（+）、负（－）、加1（++）和减1（－－）4个。
加1、减1运算符只允许用于数值类型的变量，不允许用于表达式中。加1、减1运算符既可放在变量之前（如＋＋i），也可放在变量之后（如i＋＋），两者的差别是：如果放在
变量之前（如＋＋i），则变量值先加1或减1，然后进行其他相应的操作（主要是赋值操作）；如果放在变量之后（如i＋＋），则先进行其他相应的操作，然后再进行变量值加
1或减1。
例如：

    int i = 6，j，k，m，n;    j = +i; //取原值，即j=6    k = -i; //取负值，即k=-6    m = i++; //先m=i,再i=i+1，即m=6，i=7    m = ++i; //先i=i+1,再m=i，即i=7，m=7    n = j--; //先n=j,再j=j-1，即n=6，j=5    n = --j;    //先j=j-1,再n=j，即j=5，n=5

在书写时还要注意的是：一元运算符与其前后的操作数之间不允许有空格，否则编译时会出错。

(2)二元运算符

二元运算符有：加（+）、减（－）、乘（*）、除（／）、取余（%）。其中+、－、*、／完成加、减、乘、除四则运算，%是求两个操作数相除后的余数。
%求余操作举例：
a % b = a － (a / b) * b
取余运算符既可用于两个操作数都是整数的情况，也可用于两个操作数都是浮点数（或一个操作数是浮点数）的情况。当两个操作数都是浮点数时，例如7.6 % 2.9时，计算结
果为：7.6 － 2 * 2.9 = 1.8。
当两个操作数都是int类型数时，a%b的计算公式为：
a % b = a －（int）(a / b) * b
当两个操作数都是long类型（或其他整数类型）数时，a%b的计算公式可以类推。
当参加二元运算的两个操作数的数据类型不同时，所得结果的数据类型与精度较高（或位数更长）的那种数据类型一致。
例如：
7 / 3 //整除，运算结果为2
7.0 / 3 //除法，运算结果为2.33333,即结果与精度较高的类型一致
7 % 3 //取余，运算结果为1
7.0 % 3 //取余，运算结果为1.0
-7 % 3 //取余，运算结果为-1，即运算结果的符号与左操作数相同
7 % -3 //取余，运算结果为1，即运算结果的符号与左操作数相同

b、关系运算符

关系运算符用于比较两个数值之间的大小，其运算结果为一个逻辑类型的数值。关系运算符有六个：等于（==）、不等于（!=）、大于（>）、大于等于（>=）、小于（<）、
小于等于（<=）。
例如：
9 <= 8 //运算结果为false
9.9 >= 8.8 //运算结果为true
'A' < 'a' //运算结果为true，因字符'A'的Unicode编码值小于字符'a'的
要说明的是，对于大于等于（或小于等于）关系运算符来说，只有大于和等于两种关系运算都不成立时其结果值才为false，只要有一种（大于或等于）关系运算成立其结果值
即为true。例如，对于9 <= 8，9既不小于8也不等于8，所以9 <= 8 的运算结果为false。对于9 >= 9，因9等于9，所以9 >= 9的运算结果为true。

c、逻辑运算符

逻辑运算符要求操作数的数据类型为逻辑型，其运算结果也是逻辑型值。逻辑运算符有：逻辑与（&&）、逻辑或（||）、逻辑非（!）、逻辑异或（^）、逻辑与（&）、逻辑
或（|）。
真值表是表示逻辑运算功能的一种直观方法，其具体方法是把逻辑运算的所有可能值用表格形式全部罗列出来。Java语言逻辑运算符的真值表如下：
逻辑运算符的真值表
A B A&&B A||B !A A^B A&B A|B
false false false false true false false false
true false false true false true false true
false true false true true true false true
true true true true false false true true

d、位运算符

位运算是以二进制位为单位进行的运算，其操作数和运算结果都是整型值。
位运算符共有7个，分别是：位与（&）、位或（|）、位非（~）、位异或（^）、右移（>>）、左移（<<）、0填充的右移（>>>）。
位运算的位与（&）、位或（|）、位非（~）、位异或（^）与逻辑运算的相应操作的真值表完全相同，其差别只是位运算操作的操作数和运算结果都是二进制整数，而
逻辑运算相应操作的操作数和运算结果都是逻辑值。
位运算示例
运算符名称示例说明
& 位与 x&y 把x和y按位求与
| 位或 x|y 把x和y按位求或
~ 位非 ~x 把x按位求非
^ 位异或 x^y 把x和y按位求异或
>> 右移 x>>y 把x的各位右移y位
<< 左移 x<<y 把x的各位左移y位
>>> 右移 x>>>y 把x的各位右移y位，左边填0
举例说明：
（1）有如下程序段
    int x = 64;   //x等于二进制数的01000000    int y = 70;   //y等于二进制数的01000110    int z = x&y   //z等于二进制数的01000000
即运算结果为z等于二进制数01000000。位或、位非、位异或的运算方法类同。
（2）右移是将一个二进制数按指定移动的位数向右移位，移掉的被丢弃，左边移进的部分或者补0（当该数为正时），或者补1（当该数为负时）。这是因为整数在机器
内部采用补码表示法，正数的符号位为0，负数的符号位为1。
例如，对于如下程序段：
    int x = 70;   //x等于二进制数的01000110    int y = 2;    int z = x>>y  //z等于二进制数的00010001
即运算结果为z等于二进制数00010001，即z等于十进制数17。
对于如下程序段：
  int x = -70;  //x等于二进制数的11000110    int y = 2;    int z = x>>y  //z等于二进制数的11101110
即运算结果为z等于二进制数11101110，即z等于十进制数-18。要透彻理解右移和左移操作，读者需要掌握整数机器数的补码表示法。
（3）0填充的右移（>>>）是不论被移动数是正数还是负数，左边移进的部分一律补0。

e、其他运算符

（1）赋值运算符与其他运算符的简捷使用方式

赋值运算符可以与二元算术运算符、逻辑运算符和位运算符组合成简捷运算符，从而可以简化一些常用表达式的书写。
赋值运算符与其他运算符的简捷使用方式：
运算符用法等价于说明
+= s+=i s=s+i s， i是数值型
-= s-=i s=s-i s， i是数值型
*= s*= i s=s*i s， i是数值型
/= s/=i s=s/i s， i是数值型
%= s%=i s=s%i s，i是数值型
&= a&=b a=a&b a，b是逻辑型或整型
|= a|=b a=a|b a， b是逻辑型或整型
^= A^=b a=a^b a， b是逻辑型或整型
<<= s<<=i s=s<<i s， i是整型
>>= s>>=i s=s>>i s， i是整型
>>>= s>>>=i s=s>>>i s，i是整型
（2）方括号[]和圆括号（）运算符
方括号[]是数组运算符，方括号[]中的数值是数组的下标，整个表达式就代表数组中该下标所在位置的元素值。
圆括号（）运算符用于改变表达式中运算符的优先级。
（3）字符串加（+）运算符
当操作数是字符串时，加（+）运算符用来合并两个字符串；当加（+）运算符的一边是字符串，另一边是数值时，机器将自动将数值转换为字符串，这种情况在输出语
句中很常见。如对于如下程序段：
int max = 100;System.out.println（"max = "+max）;
计算机屏幕的输出结果为：max = 100，即此时是把变量max中的整数值100转换成字符串100输出的。
（4）条件运算符（？：）
条件运算符（？：）的语法形式为：
<表达式1> ？<表达式2> : <表达式3>
条件运算符的运算方法是：先计算<表达式1>的值，当<表达式1>的值为true时，则将<表达式2>的值作为整个表达式的值；当<表达式1>的值为false时，则将<表达式3>
的值作为整个表达式的值。
如：
int a=1，b=2，max;
max = a>b？a：b; //max等于2
（5）强制类型转换符
强制类型转换符能将一个表达式的类型强制转换为某一指定数据类型，其语法形式为：
(<类型>)<表达式>
（6）对象运算符instanceof
对象运算符instanceof用来测试一个指定对象是否是指定类（或它的子类）的实例，若是则返回true，否则返回false。
（7）点运算符
点运算符“.”的功能有两个：一是引用类中成员，二是指示包的层次等级。
6.运算符的优先级
以下按优先级从高到低的次序列出Java语言中的所有运算符，表中结合性一列中的“左右”表示其运算次序为从左向右，“右左”表示其运算次序为从右向左。
优先级运算符结合性
1 . [] () ; ,
2 ++ ―― += ! ~ +(一元) -(一元) 右左
3 / % 左右
4 +(二元) -(二元) 左右
5 << >> >>> 左右
6 < > <= >= instanceof 左右
7 = = != 左右
8 & 左右
9 ^ 左右
10 | 左右
11 && 左右
12 || 左右
13 ?：右左
14 = *= /= %= += －= <<= >>= >>>= &= ^= |= 右左

六、程序流程控制

a、判断语句

if语句特点：
（1）每一种格式都是单条语句。
（2）第二种格式与三元运算符的区别：三元运算符运算完要有值出现。好处是可以写在其他表达式中。
（3）条件表达式无论写成什么样子，只看最终的结构是否是true或者false；
if语句格式：
1、if(条件语句){执行语句;}2、if(条件语句){执行语句;}else{执行语句;}3、if(条件语句){执行语句;}else if(条件语句){执行语句;}……else{执行语句;}
例子：

class Demo{public static void main(String[] args){//使用if else语句来实现分段函数//y= 2*x (x>=0)//y= x (x<0)int x=1,y;if(x>=0)y=2*x;elsey=x;System.out.println("y="+y);}}

b、选择语句

switch语句格式：
switch(值){case 取值1:执行语句;break;case 取值2:执行语句;break;……default :执行语句;break;}
例子：
class SwitchDemo{public static void main(String[] args) {//根据变量的值获取是一周的第几天int x = 4;switch(x){case 1:System.out.println("星期一");break;case 2:System.out.println("星期二");break;case 3:System.out.println("星期三");break;case 4:System.out.println("星期四");break;case 5:System.out.println("星期五");break;case 6:System.out.println("星期六");break;case 7:System.out.println("星期日");break;default:System.out.println("错误数据");break;}}}
注：switch结构始终从第一个case语句开始选择，条件满足执行case后面的代码，然后break语句结束switch选择。
当所有的case语句都不满足条件是执行default语句，所以default语句不可省略。当default语句放在最后时，后面可以不用跟break语句。

c、循环语句

代表语句：while ， do while ，for

（1）while语句格式：

while(条件表达式){执行语句；}do while语句格式：do{执行语句；}while(条件表达式);
while：先判断条件，只有条件满足才执行循环体。
do while：先执行循环体，再判断条件，条件满足，再执行循环体。
do while特点是条件无论是否满足，循环体至少被执行一次。

（2）for语句格式

for(初始化表达式；循环条件表达式；循环后的操作表达式){执行语句；}
1、for里面的连个表达式运行的顺序，初始化表达式只读一次。判断循环条件，
为真就执行循环体，然后再执行循环后的操作表达式，接着继续判断循环条件，
重复整个过程，知道条件不满足为止。
2、while与for可以互换，区别在于for为了循环而定义的变量在for循环结束就是在内存中
释放。而while循环使用的变量在循环结束后还可以继续使用。
3、最简单无限循环格式：while(true),for(;;),无限循环存在的原因是并不知道循环多少次，而是根据
某些条件，来控制循环。

（3）for和while的区别：

1、变量有自己的作用域。对于for来讲：如果将用于控制循环的增量定义在for语句中。
那么该变量只在for语句内有效。
2、for和while可以进行互换。如果需要定义循环增量。用for更为合适。
总结：
什么时候使用循环结构？
当要对某些语句执行很多次时，就使用循环结构。
例子：
1~100之间7的倍数的个数，并打印。
步骤：
1，定义循环（遍历）语句，选择for语句。
2，再循环中判断，只要是7的倍数即可，使用if即可，判断用x%7==0;
3，定义一个count计数器，每次符合条件时计数器+1，循环结束打印count即可。
class forforDemo{public static void main(String[] args) {   /*    for(int x=0;x<3;x++){for (int y=0;y<4 ;y++ ){System.out.println("ok");}}*/for(int x=0;x<3;x++){for (int y=0;y<4 ;y++ ){System.out.print("*");}    System.out.println();//只有一个功能就是换行。}System.out.println("--------------------------");int z=5;for (int x=0;x<5 ;x++ ){    for (int y=0;y<z ;y++ )    {System.out.print("*");    }System.out.println();z--;}}}

d、其他流程控制语句

break(跳出)，continue(继续)
break语句：应用范围：选择结构和循环结构。
continue语句：应用于循环结构。
1、这两个语句离开应用范围，存在是没有意义的。
2、这个两个语句单独存在下面都不可以有语句，因为执行不到。
3、continue语句是结束本次循环继续下次循环。
4、标号的出现，可以让这两个语句作用于指定的范围。
class OtherDemo{public static void main(String[] args){//break;w:for(int x=0;x<3;x++){for(int y=0;y<4;y++){System.out.println("x="+x);break w;}}//continue:只能作用于循环结构，继续循环。特点：结束本次循环，继续下一次循环。for(int x=1;x<=10;x++){if(x%2==1)   continue; System.out.println("x="+x);}w:for(int x=0;x<3;x++){for(int y=0;y<4;y++){System.out.println("x="+x);continue w;}}  }}

七、函数

a、函数的定义：在类中的具有特定功能的一段独立程序，也称为方法。

b、函数的格式：

修饰符返回值类型函数名（参数类型形式参数1，参数类型形式参数2， ...）｛
执行语句；
return 返回值；
｝
示例代码：
public static int getSum(int x, int y){return x+y;}
格式说明：
修饰符：对函数的外加修饰，让函数具备更多的含义；
返回值类型：函数运行后的返回的结果的数据类型；
函数名：可自行定义，只要不和系统关键字等冲突。建议取有意义的名称，书写规范为动名词结合，若为多单词组合，则第一个单词首字母小写，后面的单词首字母大
写，如getSum，表示获取求和的值。
参数类型：是指形式参数的数据类型；
形式参数：是一个变量，用于存储调用函数时传递给函数的实际参数；
实际参数：传递给形式参数的具体数值；
return：用于结束函数；
返回值：作为函数的处理结果返回给调用者，其数据类型必须与“返回值类型”一样；

c、函数的特点：

定义函数可以将功能代码进行封装；
便于对功能代码进行复用；
函数只有被调用才会被执行；
函数的出现提高了代码的复用性；
对于函数运算后，没有具体的返回值时，返回值类型用关键字void表示，而且如果函数中的return语句如果在最后一行，则可以省略不写。

注意：
函数中只能调用函数，不可以在函数内部定义函数。也就是说函数之间是平级的，没有包含关系，只有调用动作；
定义函数时，函数的结果应该返回给调用者，交由调用者处理

d、函数的应用

函数体现的是一个独立的功能，所以在定义函数之前要有“两个明确”：
1、明确该功能的运算结果。目的是为了明确参数的返回值类型；
2、明确在定义该功能的过程中是否有未知的内容参与运算。也就是说，函数的具体内容我们是否能完全独立实现，还是要依赖调用者给我们的一些值才能具体实现；
其目的是为了明确函数的参数列表（参数的类型和参数的个数）
原则：
如何定义一个好的函数：尽量让函数只实现一个功能，这样能提高函数的复用。

示例代码：

package cn.abc;public class Demo3 {public static void main(String[] args) {printRectangularLattice(3,6);}/*  需求：输出一个矩形点阵   思路：    1、功能结果是输出一个方形点阵，返回值类型是void；    2、有未知内容参与运算，有两个，分别代表方形的长和宽，这两个未知内容类型都是int型 */  public static void printRectangularLattice(int Length, int Width) {for (int x = 0; x < Length; x++) {for (int y = 0; y < Width; y++) {System.out.print("*");}System.out.println();}return;}}

e、函数的重载

（1）、重载的概念：在同一个类中，允许存在一个以上的同名函数，只要这些同名函数的参数个数或者参数类型不同即可。

（2）、重载的特点：与返回值类型无关，只和参数列表有关。即JVM是通过参数列表来区分函数的。而参数列表相同，但返回值类型不同的同名函数不能同时存在与一
个类中。
（3）、重载的好处：方便于阅读，优化了程序设计；
重载示例：
//返回两个整数的和public static int add(int x, int y){return x+y};//返回三个整数的和public static int add(int x, int y, int z){return x+y+z};//返回两个小数的和public static double add(double x, double y){return x+y};

八、数组

a、概念：同一种类型数据的集合。其实数组就是一个容器。

b、数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。

c、格式1：

元素类型[] 数组名= new 元素类型[元素个数或数组长度];

示例：int[] arr = new int[5];

格式2：

元素类型[] 数组名= new 元素类型[]{元素，元素，……};

int[] arr = new int[]{3,5,1,7};

int[] arr = {3,5,1,7};

程序示例：

class ArrayDemo{        public static void main(String[]args)        {        //元素类型[] 数组名= new 元素类型[元素个数或数组长度];        //需求：想定义一个可以存储3个整数的容器。        int[] x=new int[3]; //new在内存中形成一个容器实体;x是引用数据类型中的数组类型，是一种单独的数据类型。               //打印数组中角标为0的元素的值。        System.out.println(x[1]);//输出结果为0        //实体中的变量都有默认初始化值.根据定义数组的元素类型值不同，int值为0；double值为0.0；float值为0.0f；boolean值为false        }  }

d、常见操作

复制、排序、查找、比较

e、二维数组

格式1：
int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;
格式2：
int[][] arr = new int[3][];
二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];

0 0