|
Java基础语法
注释
? ? ? 注释是在程序指定位置添加的说明性信息，注释不参与程序运行，仅起到说明作用。
1.单行注释 格式：//注释信息
2.多行注释 格式：/*注释信息*/
3.文档注释 格式：/**注释信息*/
关键字
? ? ? ?关键字就是被Java语言赋予了特定含义的单词。关键字的字母全部小写，我们常用的代码编辑器对关键字会有特殊的颜色标记，可以很直观的看到。
? ? ? ?例如我们刚开始学习代码的时候写的public,class,static,void…这些都是关键字。
常量
? ? ? 常量是在程序运行过程中，其值不可以发生改变的量。
1.字符串常量
用双引号括起来的内容，如：“HelloWorld”,“中国”
2.整数常量
不带小数的数字，如：666，-88
3.小数常量
带小数的数字，如：13.14，-5.21
4.字符常量
用单引号括起来的内容，如：‘A’,‘0’,‘我’
5.布尔常量
布尔值，表示真假。只有两个值：true,false
6.空常量
一个特殊的值，空值。只有一个：null（注意：空常量是不能直接输出的）
数据类型
基本数据类型
数值型: 整数：byte,short,int,long(默认为int类型)
? ? ? ? ? ? ?浮点数：float,double(默认为double类型)
? ? ? ? ? ? ?字符：char
非数值型:布尔：boolean。
引用数据类型
类（class），接口（interface），数组（[]）
变量
? ? ? ?变量就是在程序运行过程中，其值可以发生改变的量。本质上来讲给，变量是内存中的一小块区域。
格式：数据类型 变量名 = 变量值；例如：int a = 10;
变量使用注意事项
1.名字不能重复
2.变量未赋值，不能使用
3.long类型的变量定义的时候，为了防止整数过大，后面要加L（在值后面加）
4.float类型的变量定义的时候，为了防止类型不兼容，后面要加F（在值后面加）
标识符
定义规则
1.由数字、字母、下划线（_）和美元符（$）组成
2.不能以数字开头
3.不能是关键字
4.区分大小写
常见命名约定
小驼峰命名法：（针对方法、变量命名）
约定1：标识符是一个单词的时候，首字母小写
范例1：name
约定2：标识符有多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写
范例2：firstName
大驼峰命名法：（针对类命名）
约定1：标识符是一个单词的时候，首字母大写
范例1：Student
约定2：标识符由多个单词组成的时候，每个单词的首字母大写
范例2：GoodStudent
类型转换
自动类型转换
? ? ? 把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量
范例：double d = 10;
强制类型转换
? ? ? ?把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量
格式：目标数据类型 变量名 = （目标数据类型）值或者变量；
范例： int k = (int)88.88;
一般不建议使用，因为有可能造成数据流失。
Java运算符
算术运算符
加“+” ? ? ? ? ? ? ? ? ? ? ? ? ?如：b+c;
减“-” ? ? ? ? ? ? ? ? ? ? ? ? ? 如：b-c;
乘“*” ? ? ? ? ? ? ? ? ? ? ? ? ? 如：b*c;
除“/” ? ? ? ? ? ? ? ? ? ? ? ? ? 如：b/c;
取余“%” ? ? ? ? ? ? ? ? ? ? ?如：b%c;
字符“+”操作 ? ? ? ? ? ? ? ?如：int i = 10;char a = ‘A’ i+a
字符串的“+”操作 ? ? ? ? 如：“it”+“heima”
赋值运算符
=（赋值号） ? ? a=b :将b的值赋值给a
+= ? ? ? ? ? ? ? ? ? ?a += b：将a+b的值赋值给a
-= ? ? ? ? ? ? ? ? ? ? a -= b：将a-b的值赋值给a
*= ? ? ? ? ? ? ? ? ? ? a ﹡=b：将a*b的值赋值给a
/= ? ? ? ? ? ? ? ? ? ? a /= b：将a/b的值赋值给a
%= ? ? ? ? ? ? ? ? ? a %=b：将a%b的值赋值给a
自增自减运算符
++和- -
1.++和-- 既可以放在变量的后边，也可以放在变量的前边。
2.单独使用的时候， ++和-- 无论是放在变量的前边还是后边，结果是一样的。
3.参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或者–。
4.参与操作的时候，如果放在变量的前边，先拿变量做++或者–，后拿变量参与操作。
（放在变量前边运算出来会加1或减1）
关系运算符
相等 == ? ? ? ? ? ? 如：a == b；a等于b
不相等 != ? ? ? ? ?如：a != b；a不等于b
大于> ? ? ? ? ? ? ? ?如：a > b；a大于b
大于等于>= ? ? ? 如：a >= b；a大于等于b
小于< ? ? ? ? ? ? ? ?如：a < b；a小于b
小于等于<= ? ? ? 如：a <= b；a小于等于b
逻辑运算符
逻辑与& ? ? ? ? ? a&b，a和b都是true，结果为true，否则为false
逻辑或| ? ? ? ? ? ? a|b，a和b都是false，结果为false，否则为true
逻辑异或^ ? ? ? ? a^b，a和b结果不同为true，相同为false
逻辑非！ ? ? ? ? ? !a，结果和a的结果正好相反
短路逻辑运算符：短路与&& ? ? ? ?短路或||
逻辑与&和短路与&&的区别
逻辑与&，无论左边真假，右边都要执行。
短路与&&，如果左边为真，右边执行；如果左边为假，右边不执行。
逻辑或|和短路或||的区别
逻辑或|，无论左边真假，右边都要执行。
短路或||，如果左边为假，右边执行；如果左边为真，右边不执行。
三元运算符
格式： 关系表达式？表达式1：表达式2；
范例：a > b ? a : b;
计算规则：
首先计算关系表达式的值
如果值为true，表达式1的值就是运算结果
如果值为false，表达式2的值就是运算结果
Java数据输入
操作：
1.导包
import java.util.Scanner;
导包的动作必须出现在类定义的上边
2.创建对象
Scanner sc = new Scanner(System.in);
上面这个格式里面，只有sc是变量名，可以变，其他的都不允许变。
3.接收数据
int i = sc.nextInt();
上面这个格式里面，只有i是变量名，可以变，其他的都不允许变。
import java.util.Scanner;
public class ScannerTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.println();
}
}
Java流程控制
顺序结构
? ? ? ?循序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。
执行流程： 开始–语句A–语句B–语句C–结束
分支结构
if语句
格式1：
if（关系表达式） {
语句体；
}
计算关系表达式的值，如果正确则输出语句体，如果不正确则结束程序，执行后面的程序
举例：判断a是否等于b
?
public class IfDemo{
public static void main(String[] args) {
System.out.println("开始");
//定义两个变量
int a = 10;
int b = 20;
//判断a是否等于b，如果等于，输出“a等于b”，如果不等于结束程序
if(a == b) {
System.out.println("a等于b");
}
System.out.println("结束");
}
}
格式2：
if(关系表达式) {
语句体1;
} else {
语句体2;
}
判断关系表达式是否正确，如果正确则输出语句体1，如果不正确则输出语句体2
举例：判断a是否大于b，如果是，就输出：a的值大于b；如果不是。就输出：a的值不大于b
public class IfDemo {
public static void main(String[] args) {
System.out.println("开始");
//定义两个变量
int a = 10;
int b = 20;
//判断a是否大于b，如果是，输出“a的值大于b”，如果不是，输出“a的值不大于b”
if(a>b) {
System.out.println("a的值大于b");
}else {
System.out.println("a的值不大于b");
}
System.out.println("结束");
}
}
格式3：
if(关系表达式) {
语句体1；
}else if(关系表达式2) {
语句体2；
}
…
else{
语句体n+1
}
? ? ? ?按顺序计算关系表达式的值，如果值为true则顺利输出本关系表达式后的语句体；如果值为false，则按顺序继续计算下面的关系表达式，直到计算出值为true的或者直到最后一句语句体n+1
举例：键盘录入1-7的数值，输出对应的星期数（Java基础练习题）
此处用到数据输入的知识
?
//导包
import java.util.Scanner;
public class IfDemo03 {
public static void main(String[] args) {
System.out.println("开始");
//创建对象
//需求：键盘录入一个星期数(1,2,...7),输出对应的星期一，星期二，...星期日
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数(1-7):");
//接收数据
int week = sc.nextInt();
if(week == 1) {
System.out.println("星期一");
} else if (week == 2) {
System.out.println("星期二");
} else if (week == 3) {
System.out.println("星期三");
} else if (week == 4) {
System.out.println("星期四");
} else if (week == 5) {
System.out.println("星期五");
} else if (week == 6) {
System.out.println("星期六");
} else if (week == 7) {
System.out.println("星期日");
} else{
System.out.pritnln("你输入的数字有误");
}
System.out.println("结束");
}
}
switch语句
switch语句
格式：
switch(表达式) {
case 值1;
语句体1;
break;
case值2;
语句体2;
break;
…
default:
语句体n+1;
[break;]
}
case：后面跟的是要和表达式进行比较的值。
break：表示中断，结束的意思，用来结束switch语句。
default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。
举例：我们这里依旧用上一个练习题举例，键盘录入1-7的数字，输出对应的星期数
?
//导包
import java.util.Scanner;
public class SwitchDemo {
public static void main(String[] args) {
System.out.println("开始");
//创建对象
//需求：键盘录入一个星期数(1,2,...7),输出对应的星期一，星期二，...星期日
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个星期数(1-7):");
//接收数据
int week = sc.nextInt();
switch(week) {
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;
}
System.out.println("结束");
}
}
case穿透
???????case穿透相当于更简便一点的switch语句，假如我们要输入月份，对应它们的季节，一个一个的去输入很浪费时间，无法提高效率，那么这个时候我们就可以使用我们的case穿透
举例：输入1-12个月份，然后对应它们的季节
//导包
import java.util.Scanner;
public class SwitchTest {
public static void main(String[] args) {
//创建对象
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个月份:");
//接收数据
int month = sc.nextInt();
//输入月份对应的季节，三个月份为一季，1、2、12为冬季；3、4、5为春季；6、7、8为夏季；9、10、11为秋季
switch(month) {
case 1:
case 2:
case 12:
System.out.println("冬季");
break ;
case 3:
case 4:
case 5:
System.out.println("春季");
break ;
case 6:
case 7:
case 8:
System.out.println("夏季");
break ;
case 9:
case 10:
case 11:
System.out.println("秋季");
break ;
default:
System.out.println("你输入的月份有误：");
break;
}
}
}
循环结构
循环结构主要就是这三个，而这三个也是我们后面要应用到的循环语句
for
while
do…while
循环语句
for循环语句、 while循环语句、 do…while循环语句
for语句格式：
for(初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}
举例：在控制台输出五遍“HelloWorld”
?
public class ForDemo {
public static void main(String[] args) {
for(int i = 1; i<=5; i++) {
System.out.println("HelloWorld");
}
}
}
while语句格式：
初始化语句;
while(条件判断语句) {
循环体语句;
条件控制语句;
}
? ? ? ?while循环语句也是先判断后执行，看条件判断语句结果是否正确，如果正确就输出循环体语句，并且执行条件控制语句后继续返回条件判断语句循环执行循环判断，直到不符合条件。
举例：用while循环语句实现控制台输出五遍“HelloWorld”。
?
public class WhileDemo {
public static void main(String[] args) {
//定义变量，初始化语句
int j = 1;
//输入条件判断语句
while(j<=5) {
//输出循环体语句“HelloWorld”
System.out.println("HelloWorld");
//条件控制语句，变量每循环完一次加一继续返回判断条件，查看是否符合条件
j++;
}
}
}
do…while格式：
初始化语句;
do {
循环体语句;
条件控制语句;
}while(条件判断语句);
??????do…while语句，和其他两个语句不太一样，它先执行循环体语句再进行条件判断，然后循环
举例：还是输出五遍“HelloWorld”
public class DoWhileDemo {
public static void main(String[] args) {
//定义变量，初始化语句
int j = 1;
//执行初始化语句，执行循环体语句，执行条件控制语句
do {
System.out.println("HelloWorld");
j ++;
//执行条件判断语句
}while(j<=5);
}
}
三种循环的区别上面也大致提到了一下
1.do…while和for、while循环不一样，先执行循环语句再进行判断，for和while是先进行条件判断再执行循环语句
2.for循环和while循环的区别就是在条件控制语句那个地方，for的条件控制语句包含在其结构内部，所以循环结束后，无法单独访问到；而while循环的条件控制语句则独立在其结构外，在其循环结束后，变量还可以继续使用
跳转控制语句
continue：跳过某次循环体内容的执行
注意：使用是基于条件控制的
break：终止循环体内容的执行
注意：使用是基于条件控制的
操作：
continue用在循环中，基于条件控制，跳过某次循环体内容的执行，继续下一次的执行。
举例：依次输入1-5，使用continue看最后输出的值都有哪些
?
public class ContinueDemo {
public static void main(String[] args) {
for(int i = 1; i<=5; i++) {
if(i%2 ==0) {
continue;
}
System.out.println(i);
}
}
最后输出的i值都有：1，3，5
break 用在循环中，基于条件控制，终止循环体内容的执行，也就是说结束当前的整个循环
举例：还是上一个例子，依次输出1-5，使用break，看最后输出的数字有哪些
public class BreakDemo {
public static void main(String[] args) {
for(int i = 1; i<=5; i++) {
if(i%2 ==0) {
break;
}
System.out.println(i);
}
}
最后输出的i的值只有1
循环嵌套
? ? ? 循环嵌套就是一个循环套着一个循环
? ? ? 因为有时为了得到结果，需要的限制条件很多，可能就会使用不止一个循环语句，循环嵌套得到最终的输出结果。
用if来展示一下就是：
if (条件) {
if(条件) {
语句体；
}else {
}
}
这就是一个if语句里面嵌套了一个if…else语句
Random
? ? ? ?Random的作用就是产生一个随机数，使用Random时也需要进行导包操作
使用步骤：
1.导包：
import java.util.Random;
导包的动作必须出现在类定义的上面
2.创建对象：
Random r = new Random();
上面这个格式里面，r 是变量名，可以变，其他的都不允许变
3.获取随机数
int number = r.nextInt(10);//获取数据的范围：[0,10) 包括0,不包括10
上面这个格式里面，number是变量名，可以变，数字10可以变。其他的都不允许变
举例：使用Random循环获取1-100以内的10个随机数
?
import java.util.Random;
public class RandomDemo {
public static void main(String[] args) {
//创建对象
Random r = new Random();
//用循环获取10个随机数
for(int i =0; i < 10 ; i++) {
//获取随机数
int number =r.nextInt(10);
System.out.println("number:" + number);
}
//需求：获取一个1-100之间的随机数
int x = r.nextInt(100) + 1;
System.out.println(x);
}
}
|