Java基础语法
一、关键字和保留字
1.1关键字
定义:被Java 语言赋予了特殊含义,用做专门用途的字符串
特点: 关键字中所有字母都为小写
用于定义数据类型的关键字 | class、interface、 enum 、byte 、short 、 int 、long、 float、 double、 char 、boolean、 void |
用于定义流程控制的关键字 | if 、else 、switch、 case、 default、 while 、do、 for 、break、 continue 、return |
用于定义访问权限修饰符的关键字 | private、 protected、 public |
用于定义类,函数,变量修饰符的关键字 | abstract 、final 、static 、synchronized |
用于定义类与类之间关系的关键字 | extends、 implements |
用于定义建立实例及引用实例,判断实例的关键字 | new 、this、 super、 instanceof |
用于异常处理的关键字 | try 、catch 、finally、 throw、 throws |
用于包的关键字 | package 、import |
其他修饰符关键字 | native 、strictfp、 transient 、volatile、 asser |
用于定义数据类型值的字面值 | true、 false、 null |
1.2保留字
Java保留字:现有Java版本尚未使用,但以后版本可能会作为关键字使
用。自己命名标识符时要避免使用这些保留字
goto 、const
二、标识符
2.1标识符
是指在程序中,我们自己定义内容。比如类的名字、方法的名字和变量的名字等等,都是标识符。
- 定义合法标识符规则:
1、标识符就是名称的意思,所有的名字都统称为标识符
2、Java 中经常要定义类、方法、变量等,在定义的时候需要给它们取名字,这些名字就是标识符
3、只有字母(区分大小写),下划线 (_),美元符号 ($) 和数字组成,长度不受限制
4、第一个字母不能是数字,不能用数字开头
5、不能是关键字
6、不能是 true、false、null (尽管三个都不是关键字,而是 常量标识)
2.2命令规范:
- Java中的名称命名规范:
1、类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz StudentBoy
2、变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个
单词首字母大写:xxxYyyZzz
注意:见名知意 驼峰命名法 尽量不要用拼音
驼峰命名法:
- 小驼峰 一般用于变量名,方法名 首字母小写,之后的每一个单词首字母大写
比如:bookName
大驼峰 一般用于类名,接口名 所有单词首字母大写
比如:HelloWorld
三、变量
3.1变量概述
变量:在程序中可以变化的量称为变量。
Int clothesPrice ;
clothesPrice = 89;
Java中要求一个变量每次只能保存一个数据,并且要明确变量的数据类型。
Java语言中数据类型:2大类
基本数据类型 (int double....)
引用数据类型(String)
3.2字节
字节是计算机中最小存储单元,计算机存储任何的数据,都是以字节的形式存储。8个bit(二进制位) 0000-0000表示为1个字节,写成1 byte或者1 B。
1 8 bit = 1 B
2 1024 B =1 KB
3 1024 KB =1 MB
4 1024 MB =1 GB
5 1024 GB = 1 TB
3.3 Java基本数据类型
基本数据类型:4类8种
布尔类型:boolean,数值只有2个:true,false
字符类型:char,2个字节(16位)
整数类型:
byte,字节。1字节(8bit),
short,短整型。2字节(16bit),
int,整型。(默认类型)。4字节(32bit)
long,长整型。加L或l。8个字节(64bit)
浮点类型(小数):
float,单精度。加f或F。4个字节(32bit)
double,双精度。(默认类型)。8个字节(64bit)
基本数据类型是 Java 语言中内置的类型。整数类型、小数类型、字符类型、布尔类型 这四类是最基础的类型
char 字符型 ,2 个字节 ,用单引号表示 '' ,刚好容纳一个汉字
注意: char 里面只能放一个
long类型:建议数据后加L表示。
float类型:建议数据后加F表示。
3.4变量定义
变量:计算机内存中的一块存储空间,是存储数据的基本单元。
语法:
变量包括三个要素: 数据类型 、 变量名 、 数据值 。
1 数据类型 变量名 = 数据值;
public class HelloWorld {
public static void main(String[] args) {
/*
变量定义例子
变量包括三个要素: 数据类型 、 变量名 、 数据值 。
*/
boolean isMan = false;
char c = 'a';//存数据
byte b = 1;
short s = 100;
int i = 200;//(默认类型)
long l = 1000L;
float f = 1.2F;
double d = 5.6;//双精度。(默认类型)
System.out.println(isMan);
System.out.println(c);//取数据
System.out.println(b);
System.out.println(s);
System.out.println(i);
System.out.println(l);
System.out.println(f);
System.out.println(d);
System.out.println("-------------------");
int aaa ;
aaa = 1000;
System.out.println(aaa);
//int aaa;
{
int bbb = 200;
}
//System.out.println(bbb);
/*
转义字符例子
*/
System.out.println("\"HelloWorld\"");
System.out.println("\'HelloWorld\'");
//System.out.println("Hello World");
/*
基本数据类型的转换例子
*/
double myDouble = 1000;
long myLong = 100;
int myInt = (int)1.1;
}
}
注意:
- Java中每个变量必须先声明,后使用
- 使用变量名来访问这块区域的数据
- 变量的作用域:在一对{ }内,变量只有在其作用域内才有效
- 同一个作用域内,不能定义重名的变量
转义字符
System.out.println("\"hello,world\"");
输出"hello,world"
System.out.println("\'hello,world\'");
输出'hello,world'
3.5基本数据类型的转换
Java允许程序员在一定程度上进行数据类型的转换。
8种基本数据类型:
7种数值类型可以参加转换:byte,short,char,int,long,float,double(boolean不参加)。
显式转换
显式转换(强制转换):取值范围大的转为取值范围小的。
小范围数据类型 变量 = (小范围数据类型 变量)大范围数据类型;
int n = (int)6.7;
语法结构:(要转换的类型)数值
隐式转换
隐式转换(自动转换):取值范围小的转为取值范围大的。
大范围数据类型 变量 = 小范围的数据类型;
double d = 1;
数据范围从大到小:
double >float>long>int>short>byte
3.6运算符
算术运算符
- +,-,*, / , %,++,--
- +:加
- -:减
- *:乘
- /:取商
- %:取余或者取模
自增自减运算
++:自增1 (i++ // i = i + 1;
--:自减1
i++和++i
i++,给i加1,但是i++的值是i本身。(先计算,后加1)
++i,给i加1,但是++i的值是i+1了。(先加1,后计算)
public class Operator {
public static void main(String[] args) {
int myInt = 10;
int myInt2 = 3;
/*
* java中的加减乘除
* */
int myInt3 = 10 + 1;
int myInt4 = 10 -1;
int myInt5 = 10*2;
int myInt6 = 10/2;
System.out.println(myInt3);
System.out.println(myInt4);
System.out.println(myInt5);
System.out.println(myInt6);
System.out.println("---------------------------");
int myInt7 = 5 % 3;
System.out.println(myInt7);
int myInt8 = 10 %2 ;
System.out.println(myInt8);
//xxx / 9 (0-8);
yyyy / 6 (0- 5);
//ttt / 1024 ( 0 -1023);
System.out.println("---------------------------");
int i = 5;
int myInt10 = i++; //i++,给i加1,但是i++的值是i本身。(先计算,后加1)
System.out.println(myInt10);
System.out.println(i);
System.out.println("---------------------------");
int j = 5;
int myInt11 = ++j;//++i,给i加1,但是++i的值是i+1了。(先加1,后计算)
System.out.println(myInt11);
System.out.println(j);
}
}
3.7赋值运算符
=,赋值:=右侧的数据,赋值给=左边的变量
+=,-=,*=,/=,%=
a += b //a =a + b
public class Demo1 {
public static void main(String[] args) {
/*
* 赋值运算符
*
* =
* +=
* -=
* *=
* /=
* %=
*
* */
int i = 2; // 相当于把右边的值赋值给左边的变量
i += 2;// i = i+2;
System.out.println(i);
i -= 2;//i = i-2;
System.out.println(i);
i *= 2; //i = i*2;
System.out.println(i);
i /=2 ; //i = i/2;
System.out.println(i);
i %=2; //i = i%2;
System.out.println(i);
}
}
3.8关系运算符(比较运算符)
用于比较两个数的关系,结果是boolean类型的
>,<,>=,<=,==,!=
==:判断两个数是否相等==,和=的区别
=:赋值运算符
==:比较数值是否相等
!= :判断两个数是否不相等
public class Demo2 {
public static void main(String[] args) {
/**
*
* 赋值运算符
* =,赋值:=右侧的数据,赋值给=左边的变量
*/
System.out.println( 1 == 1 );
System.out.println( 1 == 2);
System.out.println( 5 > 3);
System.out.println( 6 < 8);
System.out.println( 5 >= 5);
System.out.println( 6 <= 3);
System.out.println( 7 != 8);
}
}
3.9逻辑运算符(重点)
操作数是boolean类型,结果也是boolean类型
&:与操作
规则:操作数都是true,结果才是true,有一个是false就为false。
一假则假,全真才真
|:或操作
规则:操作数都是false,结果才是false,有一个是true,就是true
一真则真,全假才假
&&:短路与
规则:遇到一个false就直接返回结果为false,后面的不再参加计算了。
||:短路或
规则:遇到一个true就直接返回结果为true,后面不再计算了
!:取非,取反
规则:!T-->F, !F-->T
public class Demo3 {
public static void main(String[] args) {
int salary = 800;
int deposit = 4000;
char ascii=98;
/*
*
* 逻辑运算符(重点)
操作数是boolean类型,结果也是boolean类型
&:与操作
规则:操作数都是true,结果才是true,有一个是false就为false。
一假则假,全真才真
|:或操作
规则:操作数都是false,结果才是false,有一个是true,就是true
一真则真,全假才假
* */
System.out.println(ascii);//
System.out.println( salary >1000 & deposit >5000); //&:与操作
System.out.println( salary > 1000 | deposit > 5000);
System.out.println( salary >1000 && deposit >5000); // 短路与
System.out.println( salary > 1000 || deposit > 5000); //短路或
System.out.println( ! (salary >1000)); //取反
}
}
四、程序流程控制
4.1选择结构
程序的流程结构:顺序结构,选择结构,循环结构
选择结构通过分支语句实现:if,switch
4.2if语句
简单if语句语法:
if (条件){
执行语句
}
public class Demo4_If {
public static void main(String[] args) {
/*
if(布尔表达式)
{
// 如果布尔表达式为 true 将执行的语句
}
*/
int source = 20;
if(source >= 60){
System.out.println("小明成绩及格");
}
if(true){
System.out.println("我是布尔运算符");
}
if(false){
System.out.println("这里会不会执行");
}
}
}
4.3if else语句
if (条件){
执行语句1
}else{
执行语句2
}
public class Demo5_If_Else {
public static void main(String[] args) {
int source = 50;
/*
if.....else.....结构
if(布尔表达式){
// 如果布尔表达式为 true 将执行的语句
}else{
// 如果布尔表达式为 false 将执行这里的语句
}
*/
if( source >= 60 ){
System.out.println("考试及格了");
}else {
System.out.println("考试考砸了");
}
}
}
使用逻辑运算符进行判断 ,一般实际工作当中我们使用的是 短路与 && 不会使用 &
public class Demo6_If_Else2 {
public static void main(String[] args) {
int yw_source = 60;
int sx_source = 70;
/*
if.....else.....结构
使用逻辑运算符进行判断
一般实际工作当中我们使用的是 短路与 && 不会使用 &
if(布尔表达式){
// 如果布尔表达式为 true 将执行的语句
}else{
// 如果布尔表达式为 false 将执行这里的语句
}
*/
if(yw_source >=60 && sx_source >= 80){
System.out.println("小明真优秀");
}else{
System.out.println("小明真一般");
}
}
}
4.4if的嵌套
if (条件1){
执行语句1
}else if(条件2){
执行语句2
}else ....
4.5switch语句
可以实现选择结构
switch( 变量 ){
case 常量值1:
分支1;
break;
case 常量值2:
分支2;
break; ...
default:
}
注意事项:
1.作用在int类型,byte,short,int,char,String,枚举
2.case后的数值必须唯一
3.case可以无序
4.break用于防止switch的穿透
5.default是可选的语句。
public class Demo8_Switch {
public static void main(String[] args) {
/*
* switch( 变量 ){
* case 常量值1:
* 分支1;
* break;
* case 常量值2:
* 分支2;
* break; ...
* default:
* }
*
* 注意事项:
1.作用在int类型,byte,short,int,char,String,枚举
2.case后的数值必须唯一
3.case可以无序
4.break用于防止switch的穿透
5.default是可选的语句。
*/
int source = 70;
switch(source){
case 80:
System.out.println("小明真普通");
//break;
case 90:
System.out.println("小明真优秀");
// break;
case 60:
System.out.println("小明考试及格了");
break;
}
// if(source == 90){
// System.out.println("小明真优秀");
// }else if(source == 80){
// System.out.println("小明真普通");
// }else if(source == 60 ){
// System.out.println("小明考试及格了");
// }else {
// System.out.println("小明真差劲");
// }
}
}
4.6循环结构
条件结构:条件满足,某些代码才会被执行。
执行次数:0,1。
循环结构:条件满足,某些会被反复的多次执行,直到条件不满足。
执行次数:0,1,多次
for循环语法结构:
for (初始化表达式; 循环条件; 操作表达式) {
执行语句; 3 ......
}
for
(表达式1; 表达式2; 表达式3) {
执行语句; 8 ......
}
public class Demo_For {
public static void main(String[] args) {
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
// System.out.println("Hello World");
/*
* for循环语法结构:
for (初始化表达式; 循环条件; 操作表达式) {
执行语句; 3 ......
}
*
* 满足循环的条件就反复执行 一旦条件不满足就推出循环
* */
for(int i=0;i<10;i++){
System.out.println("Hello World");
}
}
}
- For循环语句和条件分支语句的结合
public class Demo_For1 {
public static void main(String[] args) {
//打印出1-100之内对偶数
for(int i=0;i<100;i++){
if(i % 2 == 0){
System.out.println(i);
}
}
}
}
- For循环的嵌套(嵌套For循环最多2层)
*
**
***
****
*****
******
*******
********
*********
public class Demo_for2 {
public static void main(String[] args) {
/*
* For循环的嵌套
*
**
***
****
*****
******
*******
********
*********
* */
for(int i=0;i<10;i++){
for(int j=0;j<i;j++){
System.out.print("*");
}
System.out.println();
}
}
}
4.7while循环
语法:
while(循环条件){
循环体;
}
先判断循环条件,如果满足,就执行里面的循环体;然后再来判断条件是否依然成立,如果成立继续执行,否则结束了循环。
public class Demo_While1 {
public static void main(String[] args) {
int i=0;
/*
* 先判断循环条件,如果满足,就执行里面的循环体;然后再来判断条件是否依然成立,如果成立继续执行,否则结束了循环。
* */
while (i<10){
System.out.println("Hello World");
i++; //死循环
}
}
}
While循环和条件判决的结合
public class Demo_While2 {
public static void main(String[] args) {
int i=0;
/*
* 先判断循环条件,如果满足,就执行里面的循环体;然后再来判断条件是否依然成立,如果成立继续执行,否则结束了循环。
* */
while (i<100){
if(i % 2 == 0){
System.out.println(i);
}
i++;
}
}
}
4.8do-while循环
do{
循环体;
}while(条件);
先执行循环体,然后判断条件,如果满足,再执行循环体,再判断条件,如果不满足就结束了循环。
至少执行1次。
while:先判断,再执行
do-while:先执行,再判断
public class Demo_Do_While {
public static void main(String[] args) {
int i = 200;
/*
*do{
循环体;
}while(条件);
先执行循环体,然后判断条件,如果满足,再执行循环体,再判断条件,如果不满足就结束了循环。
至少执行1次。
while:先判断,再执行
do-while:先执行,再判断
* */
do{
System.out.println("Hello World");
i++;
}while (i<10);
}
}
4.9 Break(强制手动退出循环)、continue(继续循环)
用法1:在switch中,用于防止穿透。
用法2:在循环中:for,while,do-while,用于强制结束循环。终止。
continue:词意:继续
只是结束某一次循环,循环下次继续的。中止。
break示例
public class Demo_Break_Cont {
public static void main(String[] args) {
/*
* Break(退出循环)、continue(继续循环)
用法1:在switch中,用于防止穿透。
用法2:在循环中:for,while,do-while,用于强制结束循环。终止。
continue:词意:继续
只是结束某一次循环,循环下次继续的。中止。
break示例
*
for(int i=0;i<5;i++){
System.out.println("Hello World");
if(i == 2){
break;
}
}*/
for(int i=0;i<5;i++){
if(i ==2){
continue;
}
System.out.println("Hello world");
}
}
}