1.关键字与标识符
1.关键字:被java语言赋予特殊含义的字符串(或单词)
比如:puclic static void class int float ....
注意:关键字都是小写的!
保留字:被java语言占用,但是还没有具体含义。
2.标识符:凡是可以自己命名的地方,都是标识符。
比如:类名、变量名、方法名、包名、接口名、。。。。
3.定义合法标识符规则:(必须遵守,如果不遵守,编译不通过)
>由26个英文字母大小写,0-9 ,_或 $ 组成
>数字不可以开头。
>不可以使用关键字和保留字,但能包含关键字和保留字。
>Java中严格区分大小写,长度无限制。
>标识符不能包含空格。
4.Java中的名称命名规范:(如果不遵守,编译也可以通过)
包名:多单词组成时所有字母都小写:xxxyyyzzz
类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz
变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz
常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ
5.在起名字时,为了提高阅读性,要尽量有意义,“见名知意”。
2.变量
1.变量的声明格式:数据类型 变量名 = 初始化值;
2.变量类型的分类:按照数据类型分:
1)基本数据类型(8种): 整型:byte short int long
浮点型:float double
布尔型:boolean
字符型:char
2)引用数据类型:类(比如:String)、接口、数组
3.变量要求:先声明,后使用
4.每一个变量,都有其作用域。即声明这个变量时所在的一对{}内。
5.每种数据类型的使用
//1.整型 : byte(1字节) short(2字节) int(4字节) long(8字节)
byte b1 = 127;
//b1 = 128;//编译不通过,超出了byte的取值范围
//定义一个long型的变量,以"l"或者"L"结尾
long l = 1243124L;
//通常定义个整型变量,一般使用int型
//2.浮点型:float(4字节) double(8字节),表示带小数的数值
//比较常用的是double
double d1 = 123.3;
//定义float型变量时,需要末尾添加"f"或者"F"
float f1 = 123.2f;
//3.boolean型:取值只有两个:true 或 false。不能取值为null
boolean isMale = true;
//通过boolean型变量使用在条件判断和循环结构中
if(isMale){
System.out.println("真男人");
}else{
System.out.println("真女人");
}
//4.字符型:char(2字节)
//一个char型变量,表示一个字符
char c1 = 'a';
//char c2 = 'ab';//编译不通过
char c3 = '1';
char c4 = '中';
char c5 = '\n';//转义字符
c5 = '\t';
System.out.println("abcd" + c5 + "def");
//很少用
char c6 = '\u1234';
System.out.println("c6:" + c6);
6.变量间的运算:(除了boolean类型以外的基本数据类型)
①自动类型提升:
//1.自动类型提升:容量小(表数范围)的变量与容量大的变量间做运算,结果的数据类型与容量大的变量的类型一致。
//byte、short、char ---> int --->long---->float----> double
//当byte\short\char三者之间的变量做运算的话,结果都为int型。
long l = 123L;
float f = 12.3F;
②强制类型转换:是自动类型提升的逆过程:将容量大的数据类型的变量转换为容量小的数据类型的变量
使用强制类型转换符:()
double d1 = 123.3;
int i = (int)d1;//123
byte b = (byte)i;
注意:强转时,可能会导致精度损失。
7.关于字符串:String类
>String类的变量可以与基本数据类型的变量做运算:连接运算:+
>运算的结果是字符串类型
>String str1 = "Beijing";
int i = 10;
System.out.println(str1 + 10);
System.out.pritln(10);
int num1 = 10;
int num2 = 20;
System.out.pritln(num1 + num2);//30
System.out.pritln("num1 + num2 = " + (num1 + num2));//num1 + num2 = 30
//System.out.pritln(num1,num2);//错误的!
进制间的转换:
(了解)
1.计算机底层的所有数据都是使用二进制进行存储的。
2.二进制、十进制、八进制、十六进制间的转换
1)十进制---->二进制:除2取余数的逆。
2)二进制---->十进制:
正数:相应的位 * 2的相应次幂的和
负数:原码、反码、补码的概念。
计算机底层都以补码的形式存储数据。
对于正数来说,三码合一。 对于负数来说:负数的原码 除符号位以外,各个位取反,得到反码。反码+1,得到补码。
3)如何实现二进制 与 八进制、十六进制间的转换
二进制:计算机底层都以二进制的方式保存数据,以及进行数据的运算。表示:0b101010101011
十进制:表示:54234850246139
八进制:表示:04235465732542
十六进制:表示:0x375458ABEDF
二进制:在底层都是以补码的形式存储的。
二进制和十进制间的运算:
------------------------------------------------------
十进制转换为二进制:
//问题:
//60 手动的方式,从控制台输出60的十六进制。
int i = 61;
//自动调用Integer类现成的方法
String binary = Integer.toBinaryString(i);//二进制
System.out.println(binary);
String hex = Integer.toHexString(i);//十六进制
System.out.println(hex);
与其他进制间转换的思路:
3.运算符
1.算术运算符:+ - + - * / % (前)++ (后)++ (前)-- (后)-- +(字符串连接运算)
1) int i = 12;
int j = i / 5;
System.out.println(j);//2
2)取模运算与被模数符号一样。
int i = 12;
int j = 3;
if(i % j == 0){....}
3)(前)++ :先+1,后运算
(后)++:先运算,后+1
简单的来说,++i 和 i++,在单独使用时,就是 i=i+1。
而 a = ++i,相当于 i=i+1; a = i;
而 a = i++,相当于 a = i; i=i+1;
++i是先加再使用,而i++是先使用再加
4)// %:取模、取余.
//结果的符号取决于被模数
int num1 = 12;
int num2 = 5;
System.out.println(num1 % num2);//2
num1 = -12;
num2 = 5;
System.out.println(num1 % num2);//-2
num1 = 12;
num2 = -5;
System.out.println(num1 % num2);//2
num1 = -12;
num2 = -5;
System.out.println(num1 % num2);//-2
底层应该是以二进制运算的
2.赋值运算符: = += -= *= /= %=
运算结果不改变原有变量的数据类型:
int i = 12;
i += 10;//i = i + 10;
short s = 10;
//不建议使用,相当于与int类型做运算得到一个int值,再把前面多出的部分砍掉,再赋值给short
s = (short)(s + 2);//这个相当于是加法运算和赋值运算,两个运算
//既可以实现运算,又不会改变原有的数据类型,只会和赋值运算符所要返回的数据类型的二进制数进行运算
s += 2;//这个只是将要加的值赋值给声明的变量,相当于只做了赋值运算
int m = 12;
m *= 0.1;//编译能通过。
m = m * 0.1;//编译不通过
3.比较运算符(关系运算符): == > < >= <= != intanceof
>比较运算符的结果都为boolean类型!
>通常使用在条件判断和循环语句中
int age= 23;
if(20 < age < 30){}//编译不通过
应该写为:
if(age > 20 && age < 30){}
4.逻辑运算符: 且: & && 或: | || ! ^
符号左右两边操作的是boolean类型的变量
//& 与 && 的区别:当符号左端为true时。二者没有区别。
//当符号左端是false时,& : 照样执行符号右边的操作。 && :不再执行符号右边的操作。
//开发中建议:&&
// | 与|| 区别:当符号左端为false时。二者没有区别。
//当符号左端是true时,| : 照样执行符号右边的操作。 || :不再执行符号右边的操作。
//开发中,建议使用:||
5.位运算符: << >> >>> & | ^ ~
>>:在二进制的情况下,整体向右移相应的位数。
<< : 在二进制的情况下,整体向左移相应的位数。
>处理的是数值型的变量
>在一定范围内,左移一位,相当于这个数值 * 2。右移一位,相当于除以2.
int i = 6;
int j = ~i; //-7
<< : 空位补0,被移除的高位丢弃,空缺位补0。
>> : 被移位的二进制最高位是0,右移后,空缺位补0;最高位是1,空缺位补1。
>>>: 被移位二进制最高位无论是0或者是1,空缺位都用0补。
& : 二进制位进行&运算,只有1&1时结果是1,否则是0; 可以看成1是true,0是false
| : 二进制位进行 | 运算,只有0 | 0时结果是0,否则是1;
^ : 相同二进制位进行 ^ 运算,结果是0;1^1=0 , 0^0=0,不相同二进制位 ^ 运算结果是1。1^0=1 , 0^1=1
~ : 正数取反,各二进制码按补码各位取反,负数取反,各二进制码按补码各位取反。十进制(先加1,再取反)
6.三元运算符:(条件表达式)? 表达式1 : 表达式2
例如:int m=10;
int n=5;
int max=(m>n)? 10:5;
当条件表达式为true时,返回表达式1,否则返回表达式2.
注:1.既然是运算符,一定会返回一个结果,表达式1和表达式2的类型要一致
2.表达式1和表达式2的类型,决定了运算符的类型。运算符的结果的数据类型由表达式1 和 表达式2决定。
3.凡是使用三元运算符的操作都可以转换为if-else结构。反之不成立.
如果二者都可以使用的情况下,建议使用三元运算符,效率高。
例子:求两个数的较大值;求三个数的最大值
4.流程控制
System.currentTimeMillis(); //记录当前时间为多少,用来计算出所用时间
4.1 分支结构
1.条件判断:
1. if(true){
执行代码块;
}
2. if(条件表达式){
执行代码块;
}
else{
执行代码块;
}
3. if(条件表达式){
执行代码块;
}
else if (条件表达式){
执行代码块;
}
……
else{
执行代码块;
}
注意1.当程序从上到下执行过程中,若某个条件表达式满足(意味着返回true),就进入其执行语句执行。执行结束,跳出当前结构
2.如果多个条件表达式是"互斥"关系,那么执行结构谁上谁下都可以。
如果多个条件表达式是"包含"关系,要求将范围小的写在范围大的上面
3.条件判断语句可以嵌套
4.如果条件判断的执行语句只有一行的话,可以省略一对{}.
建议:不要省略
2.选择结构:
switch(变量){
case 值1:
语句1;
break;
case 值2:
语句2;
break;
...
default:
语句;
}
1.当变量值的值满足某个case中的值时,就进入相应的case语句中执行,执行完以后,会继续向下执行相应的
case语句,直到遇到break关键字,或者运行到程序末尾
2.default:可选的,同时位置是灵活的。如果不满足任何case,执行当前条件。这条语句可有可无。
3.switch中的变量只能是如下的类型之一:byte short int char 枚举类 String(JDK1.7新加入的)
4.使用switch-case的结构都能转换为if-else结构。反之,不成立。
5.如果switch-case和if-else结构都可以使用,建议使用switch-case,因为效率高
6.case中只能写取值(常量),不能表示范围!
4.2循环结构
1.循环结构的4个要素:
①初始化条件
②循环条件(是boolean类型的结果)
③循环体
④迭代条件
2.三种循环结构:
for(①;②;④){ 1-2-3-4-2-3-4.。。3-4-2
③
}
①
while(②){
③;
④;
}
①
do{
③;
④;
}while(②);
注:三种循环间都可以相互转换
区别:①for循环的初始化条件执行完循环以后就不可再在循环外调用。而while循环的初始化条件在循环结束以后,初始化变量声明所在的{}内还可以被调用
②do-while至少会被执行一次。
3.嵌套循环:在一个循环结构A中,还可以定义另外的一个循环结构B,那么就构成了嵌套循环
A:外层循环 B:内层循环
注:1.内层循环充当了外层循环的循环体。
2.若外层循环执行m次,内层循环执行n次,那么一共执行了m * n 次
3.技巧:对于两层嵌套循环来说:外层控制行数,内层控制列数
/*
*****
*****
*****
*****
*/
for(int j = 0;j < 4;j++){
for(int i = 0;i < 5;i++){
System.out.print("*");
}
System.out.println();
}
【典型例题】①九九乘法表 ②100以内的所有的素数(两种方法)
4.
两个特殊的循环结构:
while(true) 或者 for(;;)
第一种情况:当某次执行时,②循环条件返回false,进而结束当前循环
第二种情况:在循环结构内,执行到break语句,调出当前循环。
无限循环结构:while(true) / for(;;)
明确:若循环结构没有出现上述两种情况之一,那这个循环就是死循环!
死循环是我们写程序要避免的!
break和continue关键字的使用
break:①可以使用在switch-case或者循环结构中
②:如果在循环结构中使用:结束当前循环结构(默认结束的是离break最近的循环结构)
continue:①只能使用在循环结构中
②:如果在循环结构中使用:结束当次循环(默认结束的是离break最近的循环结构)
说明:在break和continue关键字后面不能有任何的操作语句。否则编译不通过。
*/
class BreakContinueTest
{
public static void main(String[] args) {
//对于单层循环来说:
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
//break;//123
continue;//123567910
}
System.out.print(i);
}
//***********************************************
System.out.println();
//在嵌套for循环中
l:for(int i = 1;i <= 5;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break;
//continue;
//break l;
continue l;//123123123123123
}
System.out.print(j);
}
System.out.println();
}
//***********************************************
//说明的知识:
System.out.println();
for(int i = 1;i <= 10;i++){
if(i % 4 == 0){
//break;//123
continue;//123567910
//System.out.println("今晚林志玲要约我!");//编译不通过
}
System.out.print(i);
}
}
}