导语：整理了一下Java基础语法部分的笔记，以及部分案例
2.1关键字，标识符，注释
一.关键字keyword的定义和特点
定义：被Java语言赋予了特殊含义，用作专门用途的字符串
特点：关键字中所有字母都为小写
二.保留字reserved word
goto，const
三.标识符
标识符Identifier
java对各种变量，方法和类等要素命名时使用的字符序列成为标识符
四.标识符的使用
1.凡是可以起名字的地方都叫做标识符
2.标识符的命名规则（必须遵守）
五.命名的规范
六.注释Comment
单行注释：//
多行注释：/* /*/（多行注释不可以嵌套使用）
文档注释：/**
文档注释（是可以被解析的，Java特有的）
@author shkstart
*/
javadot -d mydoc(文档名字) -author -version HelloWorld.java（java文件的名字）
七.分隔符
空白分隔符包括空格，回车，换行，制表符（Tab键）
普通分隔符包括{}用来定义块、类、方法及局部范围
[]对数组进行声明
()定义和调用方法
;语句的结束符号
,分隔变量与变量
:说明语句标号
.用于类、对象和他的属性或方法之间的分隔
2.2变量及变量的数据类型及计算
2.2.1变量及变量的数据类型
一.变量
1.变量的概念：
内存中的一个储存区域
该区域的数据可以在同一类型范围内不断变化
变量是程序中最基本的储存单元，包含变量类型（Java属于强类型语言），变量名和存储的值
2.变量的作用：
用于在内存中保存数据
3.使用变量注意：
Java中每个变量必须先声明，后使用，使用变量名来访问这块区域的数据
变量的作用域：其定义所在的一对{}内，变量只有在其作用域内才有效
同一作用域内，不能定义重名的变量
//案例
class VariableTest{
public static void main(String[] args){
//变量的定义，定义整型
int myAge = 12;
//变量的输出
System.out.println(myAge);
int myNumber;
myNumber = 1001;
System.out.println(myNumber);
}
}
二.变量的分类
按数据类型来分类
引用数据类型还包括：枚举（enum）、注释（Annotation）、null
按变量在中声明的位置来分类
1.整数类型：byte，short，int，long
①byte：1字节 = 8bit， 范围-128 -127
②short：2字节
③int：4字节
④long：8字节，long型常量须后加‘l’或‘L’
⑤通常定义整型变量使用int
2.浮点类型：float，double
①单精度float：4字节，尾数可以精确到7位，float常量须后加‘f’或‘F’
②双精度double：8字节，尾数是float的两倍
③通常定义浮点型变量使用double型
3.字符型char
①char：1字符 = 2字节
②定义char型变量，通常使用一对’’，内部只能写一个字符
③表示方式：1.声明一个字符 2.转义字符 3.直接使用Unicode值来表示字符型常量‘\u+代表字符的值’
④\n换行符 \t制表符
4.布尔型：boolean
①boolean：一字节
②只能去两个值之一：true，false
③常常在条件判断、循环结构中使用
5.String类型变量
①String不是基本数据类型，属于引用数据类型，是一个类，翻译为：字符串
②声明String类型变量时，使用一对“”
③String可以和8中数据类型变量进行运算，且只能做连接运算。
④接收只能用String类型
引用数据类型：类（String），接口，数组
//案例
class StringTest{
public static void main(String[] args){
String s1 = "Hello World!";
String s2 = "a";
String s3 = "";
//char c = "";编译不通过
int number = 1001;
String numberStr = "学号：";
String info = numberStr + number;
boolean b1 = true;
String info1 = number + b1;
//String练习1
char c = 'a';//97
int num = 10;
String str = "hello";
System.out.println(c + num + str);//107hello
System.out.println(c + str + num);//ahello10
System.out.println(c + (num + str));//a10hello
System.out.println((c + num) + str);//107hello
System.out.println(str + num + c);//hello10a
//String练习2
//* *打出来两个乘号
System.out.println("* *");//* *
System.out.println('*' + '\t' + '*');//93
System.out.println('*' + "\t" + '*');//* *
System.out.println('*' + '\t' + "*");//51*
System.out.println('*' + ('\t' + '*'));//* *
//双引号代表String类型+表示连接，单引号+表示运算
}
}
2.2.2运算规则及作用域
前提：这里只讨论七种数据类型变量间的运算。不包含boolean类型。
1.自动类型提升
结论：当容量小的数据类型变量与容量大的数据类型变量做运算时，结果自动提升为容量大的类型
byte 、char、 short --> int --> long --> float --> double
特别的：当byte、char、short三种类型做变量时结果为int型，当运算时只要在int范围里，全都定义为int类型
说明：此时的容量大小指的是，表示数的范围的大小
//案例
class VariableTest2{
public static void main(String[] args){
byte b1 = 2;
int i1 = 129;
//编译不通过，超出byte的范围
//byte b2 = b1 + i1;
int b2 = b1 + i1;
long l1 = b1 + i1;
//单浮点型可以接收，会保留一位小数
float f = b1 + i1;
char c1 = "a";
int x1 = c1 + b1;
}
}
2.强制类型转换：
自动类型提升运算的逆运算
①需要使用强转符：（）
②注意点：强制类型转换，可能导致精度损失
//案例
class VariableTest3{
public static void main(String[] args){
double d1 = 12.9;
int i1 = (int)d1;//截断操作
int i2 = 128;
byte b = (byte)i2;
System.out.print(b);//输出b值为-128
}
}
//案例
class VariableTest4{
public static void main(String[] args){
//情况1.没有加l自动默认为整型
long l = 123111;
//编译失败：过大的整数
//long l1 = 123546846846486;
long l1 = 516151651654646l;
System.out.print(l);
//情况2.整型常量，默认类型为int型
//浮点常量，默认类型为double型
byte b = 12;
//byte b1 = b + 1;编译失败
//float f1 = b + 12.3;编译失败
}
}
3.变量的作用域
变量的作用域分为：类级，对象实例级，方法级，块级
①类级：又称为全局变量，需要用static修饰，类级变量在类定以后就存在，占用内存空间，可以通过类名来访问，不需要实例化
②对象实例级：又称为成员变量，实例化后才会分配内存空间，才能访问
③方法级：又称局部变量，在方法内定义的变量
2.2.3变量的进制及进制转换
1.进制的种类
二进制：0,1，以0b或0B开头
十进制：0-9
八进制：0-8，以0开头
十六进制：0-9及A-F，以0x或0X开头
//案例
class BinaryTest{
public static void main(String[] args){
int num1 = 0b110;
int num2 = 110;
int num3 = 0127;
int num4 = 0x110A;
System.out.println(num1);//6
System.out.println(num2);//110
System.out.println(num3);//87
System.out.println(num4);//4362
}
}
2.二进制转换为十进制
00001110 = 0*2º+2+2²+2³
最高位为符号位0为正，1为负
正数原码，反码，补码都是一样的
-14原码10001110 = 反码11110001 = 补码11110010
计算机底层都以补码的方式来存储数据
3.十进制转换为二进制：除2取余的逆
13/2 = 6…1
6/2 = 3…01
同理得1101
4.进制的转换
八进制和十六进制可以转换为二进制
在进一步转化为十进制
5.Java中的进制转换
toBinaryString(int i);转化为二进制
toHexString(int i);转化为十六进制
toOctalString(int i);转化为八进制
//案例：用Java将一个数转化为十六进制
{
int i1 = 60;
int i2 = i1 & 15;
String j = (i2 > 9) ? (char)(i2 - 10 + 'A' ) : i2 + "";
int temp = i1 >>> 4;
i2 = temp & 15;
String k = (i2 > 9)?(char)(i2-10 + 'A')+"":i2 + "";
System.out.println(k + "" + j);
}
2.3运算符
一.运算符
1.算数运算符：+，-，*，/，%，++（在前先赋值在运算，在后先运算后赋值），–（），+（字符串连接）
//案例
int num1 = 12;
int num2 = 5;
double result1 = num1 / num2;//2.0
double result2 = (double)num1 / num2;//2.4
double result3 = num1 + (num2 + 0.0);//2.4
//案例 %：取余运算
结果的符号与被模数的符号相同
{
int m1 = -12;
int n1 = 5;
System.out.println(m1 % n1);//-2
}
//案例问题
{
byte b1 = 127;
b1++;
System.out.print(b1);//-128
}
//案例：给一个三位数的整数，打印出他的个位数，十位数，百位数。
{
int num = 123;
int bai = num/100;
int shi = num%100/10;
int ge = num%10;
System.out.println("百位为" + bai);
System.out.println("十位为" + shi);
System.out.println("个位为" + ge);
}
2.赋值运算符：=，+=，-=，*=，/=，%=
//案例
{
short s1 = 10;
s1 += 10;//不会改变本身的数据类型
}
//如果要实现+2的操作，推荐：num += 2;
//如果要实现+1的操作，推荐：num++；
//案例
{
int m = 10;
int n = 5;
n *= m++;//m = 100;
n += (n++) + (++n);//n = n + (n++5) + (++n7);
}
3.比较运算符（关系运算符）:==，！=，<，>，<=，>=，instanceof（检查是否是类的对象）
比较结果为boolean型
4.逻辑运算符&，|，！，&&，||，^（运算优先级：非，与，或）
//案例 区分&，&&
{
boolean b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("aaa");
}else{
System.out.println("bbb");
}//bbb
System.out.println(num1);//11
boolean b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("aaa");
}else{
System.out.println("bbb");
}//bbb
System.out.println(num2);//10（短路，不给num2+1）
}
//&和&&的区别
//相同点1：& 和 && 的运算结果相同
//相同点2：当符号左边是true时，二者都会执行符号右边的运算
//不同点：当符号左边是false时，&继续执行符号右边的运算。&&不在执行
//|和||的区别
//相同点1：| 和 || 的运算结果相同
//相同点2：当符号左边是false时，二者都会执行符号右边的运算
//不同点3：当符号左边是true时，|继续执行符号右边的运算。||不再执行
//开发中推荐使用 && 和 ||
5.位运算符<<,>>,>>>,&,|,^,~
//<<左移,在一定范围内，每向左移一位，数值*2
//>>右移,在一定范围内，每向右移一位，数值/2
//>>>无符号右移，无论正负最高位都拿0补
&，都为1时为1，0101 & 0001 得 0001
|，有一个为1时为1，0101 | 0001 得 0101
^，不相同时为1，0101 ^ 0001 得 0100
~，取反1变0,0变1,0101 和 1010 互为取反
//案例 交换两个变量的值
{
int num1 = 10;
int num2 = 20;
//方法一:定义临时变量
int one = num1;
num1 = num2;
num2 = one;
//方法二：弊端①可能超出储存范围②只适合于数值运算
num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;
//方法三：(m^n)n == m
num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;
}
6.三元运算符
结构：(条件表达式)？表达式1：表达式2
说明
①条件表达式的结果为boolean类型
②根据条件表达式的真或假，决定执行表达式的1还是表达式2
如果表达式为true，则执行表达式1，反之执行表达式2
③表达式1和表达式2的类型要求是一致的。
④凡是可以使用三元运算符的地方，都可以改写为if-else
⑤如果程序既可以使用三元运算符又可以使用if-else，那选择使用三元运算符
//案例 获取两个数的较大值
{
int m = 12;
int n = 5;
int max = (m > n) ? m : n;//12
}
2.4流程控制
一.顺序结构
程序从上到下执行
二.分支结构
1.if-else
//案例
{
bolean x = true;
bolean y = false;
short z =40;
if((z++ == 40) && (y = true)){
z++;//42
}
if((x = false) || (++z == 43)){
z++;//44
}
System.out.println(z);
}
//案例
//从键盘获取不同类型的变量，需要使用Scanner类
//实现步骤
//1.导包：import java.util.Scanner;
//2.Scanner的实例化：Scanner scan = new Scanner(System.in);
//3.调用Scanner类的相关方法，来获取指定类型的变量
import java.util.Scanner;//导包
class ScannerTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);//Scanner实例化
System.out.println("请输入你的姓名");
String name = scan.next();
System.out.println(name);
System.out.println("请输入你的年龄");
int age = scan.nextInt();
System.out.println(age);//命令行输出后输入int类型的值
System.out.println("请输入你的性别：（男/女）")；
String gender = scan.next();
char genderChar = gender.charAt(0);//索引位置0上的字符
System.out.println(genderChar);
}
}
//案例
//三个变量进行排序，从小到大输出
import java.util.Scanner;//导包
class IfTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个数");
int num1 = scan.nextInt();
System.out.println("请输入第二个数");
int num2 = scan.nextInt();
System.out.println("请输入第三个数");
int num3 = scan.nextInt();
if(num1 < num2){
if(num1 < num3){
if(num2 < num3){
System.out.println(num1+","+num2+","+num3);
}else{
System.out.println(num1+","+num3+","+num2);
}
}else{
System.out.println(num3+","+num1+","+num2);
}
}else{
if(num2 < num3){
if(num1 < num3){
System.out.println(num2+","+num1+","+num3);
}else{
System.out.println(num2+","+num3+","+num1);
}
}else{
System.out.println(num3+","+num2+","+num1);
}
}
}
}
//案例
{
int x = 4;
int y = 1;
if(x>2)
if(y>2)
System.out.println(x+y);
else//就近原则
System.out.println(x);//输出4
}
2.switch-case
//说明
//1.根据switch表达式中的值，一次匹配各个case中的常量，一旦匹配成功，则进入相应的语句执行。当执行完以后，则继续执行下面的语句，直到break或者末尾结束为止。
//2.switch中的表达式，只能是如下的六种类型：byte，short，char，int，枚举类型，String类型
//3.case后只能声明常量
//4.break关键字是可选的，可以加，可以不加
//5.default也是可选的，位置也是灵活的
//案例 对于成绩大于60分的输出合格，反之不合格
{
int score = 78;
switch(score / 10){
case 0:
System.out.println("不及格");
break;
....
case 10:
System.out.println("及格");
break;
}
}
//案例 输入一个月份和日期，输出他是今年的第几天
{
Scanner scan = new Scanner(System.in);
System.out.println("请输入月份");
int month = scan.nextInt();
System.out.println("请输入日期");
int day = scan.nextInt();
//定义一个变量保存天数
int sumDays = 0;
switch(month){
case 13:
sumDays +=31;
case 12:
sumDays +=30;
case 11:
sumDays +=31;
...
case 2:
sumDays +=31;
case 1:
sumDays +=day;
}
}
三.循环结构
1.for循环
循环结构的四个要素
①初始化条件
②循环条件
③循环体
④迭代条件
for（①；②；④）{
③
}
//案例
{
int num = 1;
for(System.ou.print("a");num<=3;System.ou.print("c"),num++){
System.ou.print("b")
}//abcbcbc
}
//案例
//获取最大公约数
{
int min = (m <= n)?m:n;
for(int i = min;i>= 1;i--){
if(m % i ==0&& n % i == 0){
System.out.println(i);
break;//求最大公约数，最小公倍数同理
}
}
}
2.while循环
循环结构的四个要素
①初始化条件
②循环条件
③循环体
④迭代条件
①
while（②）{
③；
④；
}
//说明：①不能丢失迭代条件，防止死循环②for循环和while循环可以相互转换
//不同点：①定义的变量，for循环定义在循环体里，外部不可用，while定义在循环体外，外部可用。
do…while
①
do{
②；
③；
}while（④）；
① ——> ② ——> ③ ——> ④ ——②③④…
//说明do…while至少会执行一次循环体
//案例 输出数，提取负数和正数的个数，当输入0时停止
import java.util.Scanner;
class ForWhileTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int positiveNumber = 0;//正数的个数
int negativeNumber = 0;//负数的个数
while(true){
int number = scan.nextInt();
if(number > 0){
positiveNumber++;
}else if(number < 0){
negativeNumber++;
}else{
break;
}
}
System.out.println("输入正数的个数" + positiveNumber);
System.out.println("输入负数的个数" + negativeNumber);
}
}
//特别注意：
//1.不在循环体中限制次数的结构：for（；；）和while（true）
//结束循环有几种方式？
//方式一：循环条件部分返回false
//方式二：循环体中，执行break
四.嵌套循环
//案例 输入一个三角形的*
{
for(int i = 1; i <= 5;i++){
for(int j = 1;1 <= i;j++){
System.out.println("*");
}
}
}
//案例 99乘法表
{
for(int i = 1;i <= 9;i++){
for(int j = 1;j <= i;j++){
System.out.print(i + "*" + j + "=" + (i*j));
}
System.out.println();
}
}
//案例 输出100以内的所有质数
①
{
for(var i = 2;i < 100;i++){
for(var j = 2;j < Math.sqrt(i);j++){
//设置计算范围到根号i的范围减少计算量
if(i % j == 0){
break;//优化计算时间
}else if(j == i-1){
System.out.println(i);
}
}
}
}
②
{
for(var i = 2;i < 100;i++){
boolean isFlag = true;
for(var j = 2;j < i;j++){
if(i % j == 0){
isFlag = false;
}
}
if(isFlag == true){
System.out.println(i);
}
}
}
③
{
label:for(var i = 2;i < 100;i++){
for(var j = 2;j < Math.sqrt(i);j++){
if(i % j == 0){
continue label;//直接跳出此次数的循环进行下一次循环
}
}
System.out.println(i);
}
}
五.break，continue和return语句的使用
break：结束当前循环
continue：结束当次循环
return：无需判断条件返回一个值
//案例
{
label：for（）{
for(int i = 1; i < 10 ;i++){
if(i % 4 == 0){
break;//输出123
continue;//输出1235679
break label;//结束对应标签的循环
continue label;//结束对应标签的当次循环
}
System.out.println(i);
}
}
}
结束：希望对你有用！