2. Java基本语法

一、变量与运算符

关键字：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字 goto 、const

通常标识符的使用

1.标识符： Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符(凡是自己可以起名字的地方都叫标识符)

比如：类名、变量名、方法名、接口名、包名...

2.标识符的命名规则：严格遵守

由26个英文字母大小写，0-9，_或 $ 组成

数字不可以开头：

不可以使用关键字和保留字，但能包含关键字和保留字。

Java中严格区分大小写，长度无限制。

标识符不能包含空格。

3.Java中的名称命名规范：建议遵守

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

注意1：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。

注意2：java采用unicode字符集，因此标识符也可以使用汉字声明，但是不建议使用。

变量

变量的使用

Java定义变量的格式：数据类型变量名 = 变量值；
说明：

①Java中每个变量必须先声明，后使用

②使用变量名来访问区域的数据

③变量的作用域在其定义所在的一对{}内

④同一个作用域内，不能定义重名的变量

变量分类

各数据类型所占字节大小

基本数据类型：

byte：1byte = 8bit，1个字节是8个bit
short：2byte
int：4byte
long：8byte
float：4byte
double：8byte
boolean：1byte
char：2byte

一个bit代表一个0或1

整数类型

①byte范围：-128~127

②声明long型变量，必须以"l"或"L"结尾

③通常定义整型变量时，使用int型

浮点类型（表示带小数点的数值）：

① float表示数值的范围比long还大

②定义float类型变量时，变量要以"f"或"F"结尾（ float:单精度，尾数可以精确到7位有效数字； double:双精度，精度是float的两倍）

③通常定义浮点型变量时，使用double型

字符型（1字符=2字节）：

①定义char型变量，通常使用一对''，内部只能写一个字符

②表示方式：1.声明一个字符 2.转义字符 3.直接使用Unicode值来表示字符型常量

布尔型：

①只能取true或false

②常常在条件判断、循环结构中使用

注意：整数常量默认类型为int型，浮点型常量默认为double型

二、基本数据类型之间的运算规则：

前提：不包含boolean类型

1. 自动类型转换

当容量小的数据类型变量与容量大的数据类型变量做运算时，结果自动提升为容量大的数据类型。

byte 、char 、short --> int --> long --> float --> double

特别地：当char、byte、short三种类型的变量做运算时，结果为int型

2. 强制类型转换

①需要使用强转符：()
②强制类型转换，可能导致精度损失

三、String类型变量的使用

String属于引用数据类型（字符串）
声明String类型变量时，使用一对""
String可以和8种基本数据类型做运算，且运算只能是连接运算：+
运算的结果仍然是String类型

示例：

注意：
①当char类型和常量做“+”运算时，会将字符转换为ASCII码，如'a'+1=98
②数值型变量可以轻松转化为String，但String转回数值型条件苛刻

//String str1 = 123;编译不通过
String str1 = 123 + "";
system.out.println(str1);//"123"

//int num1 = str1;编译不通过
//int num1 = (int)str1;编译不通过

int num1 = Integer.parseInt(str1);
System.out.println(num1);//123

③String初始化时String a=new String("")和String a=""的区别

String a = “a”;
String b = “a”;
String c = “c”;

区别：
1、直接定义的String "a" "c"是储存在常量存储区中的字符串常量池中;new String(“a”)是存储在堆中；
2、常量池中相同的字符串只会有一个，但是new String()，每new一个对象就会在堆中新建一个对象，不管这个值是否相同；
String a = “a”;String b = “a”;a和b都指向字符串常量池中的“a”,所以a==b为true;
String a = new String(“a”);String b = new String(“a”);
是会在堆中创建两个对象new String(),“a”是不同对象中的,所以a==b返回false；
a.equals(b)返回true;==比较的是引用，equals比较的是内容值
3、String a = “a”在编译阶段就会在内存中创建；
String a = new String(“a”);是在运行时才会在堆中创建对象

四、运算符

是一种特殊的符号，用以表示数据的运算、赋值和比较等。
分类：算术运算符、赋值运算符、比较运算符（关系运算符）、逻辑运算符、位运算符、三元运算符

算数运算符

注意：
①取余运算的结果符号和被模数的符号相同
②自增自减不会改变变量的数据类型(short s=1;s=(short)(s+1)才等于s++)

赋值运算符

对于扩展赋值运算符：
num += 2相当于num = num + 2;其它同理
区别：扩展赋值运算符不会改变变量的数据类型

比较运算符

①比较运算符的结果都是boolean型；"=="不能误写成"="

②> < >= <= :只能使用在数值类型的数据之间（Java中不允许 90>n>=70）

③== != :可以使用在其它引用类型变量之间

逻辑运算符

开发中，建议使用"&&"和"||"

位运算符

位运算是直接对整数的二进制进行的运算

运算符	运算	位运算符的细节
<<	左移	空位补0，被移除的高位丢弃，空缺位补0
>>	右移	被移位的二进制最高位是0，右移后，空缺位补0；最高位是1，空缺位补1
>>>	无符号右移	被移位二进制最高位无论是0或者是1，空缺位都用0补
&	与运算	二进制位进行&运算，只有1&1时结果是1，否则是0
\|	或运算	二进制位进行 \| 运算，只有0 \| 0时结果是0，否则是1
^	异或运算	相同二进制位进行 ^ 运算，结果是0； 1^1=0 ; 0^0=0 不相同二进制位 ^ 运算，结果是1； 1^0=1 , 0^1=1
~	取反运算	正数取反，各二进制码按补码各位取反；负数取反，各二进制码按补码各位取反

知识扩充：交换两个变量的值

定义临时变量（推荐方式）

int temp = num1;
num1 = num2;
num2 = temp;

节省内存（弊端：相加操作可能超出存储范围；有局限性，只允许数值交换）

num1 = num1 + num2;
num2 = num1 - num2;
num1 = num1 - num2;

使用位运算符(k=m^n; m=k^n=(mn)^n; //有局限性，只允许数值交换)

num1 = num1 ^ num2;
num2 = num1 ^ num2;
num1 = num1 ^ num2;

三元运算符（都可以转换成if-else,但不一定可以反转换）

三元运算符的嵌套使用：

运算符的优先级（仅了解）

五、进制

计算机中整数的表示：

二进制(binary)：0,1 ，满2进1.以0b或0B开头。
十进制(decimal)：0-9 ，满10进1。
八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。如：0x21AF +1= 0X21B0

示例：

计算机以二进制补码的形式保存所有的整数
正数的原码、反码、补码都相同; 负数的补码是其反码+1
强制转换128为byte型，会使0000 0000 1000 0000中的1充当符号位，从而输出为-128(-127的补码减1)

进制转换

二进制转十进制 --> 2的(n-1)次幂相加(从右往左数)
十进制转二进制 --> 除以2取余数(从下往上排列)
十进制转八进制或十六进制时先转换为二进制再做转换

六、程序流程控制

流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块

三种基本流程结构：

顺序结构：程序从上到下逐行地执行，中间没有任何判断和跳转
分支结构：根据条件，选择性地执行某段代码；有if…else和witch-case两种分支语句
循环结构：根据循环条件，重复性的执行某段代码；有while、do…while、for三种循环语句

分支结构：

1. if...else(条件判断结构)

三种结构：

①
if(条件表达式){
        执行表达式
    }
②
if(条件表达式){
        执行表达式1
    }
else{
        执行表达式2
    }
③
if(条件表达式1){
        执行表达式1
    }
else if(条件表达式2){
        执行表达式2
    }
...
else {
        执行表达式
    }

从键盘获取不同类型的变量

需要使用Scanner类：(具体可以查看API文档，相当使用说明）

/*
1.导包：import java.util.Scanner;
2.Scanner的实例化: Scanner scan = new Scanner(System.in);
3.调用Scanner类的相关方法，来获取指定类型的变量
*/
import java.util.Scanner//导包
class ScannerTest{
    pubulic static void main(String[] args){
        Scanner scan = new Scanner(System.in);//实例化
        int num = scan.nextInt();//调用方法
        System.out.println(num);
    }
}
小知识点：
String gender = scan.next();
char genderChar = gender.charAt(0);//获取string类型数据的第一个字符（索引从0计算） 
gender.equals("男")  常用于判断字符串的内容是否与“”中的内容相等，相等则ture,不相等则false

获取一个随机数

/*有三种方式
1.java.util.Random：Random().nextInt(int bound)会生成一个从 0(包括)到 bound(不包括)的随机整数；
公式(max – min) + 1) + min将生成一个介于 min(含)和 max(含)之间的随机整数。
例：Random r = new Random();
return r.nextInt((max - min) + 1) + min;(子程序)

2.数学.随机：Math.random()给出了一个从 0.0(包括)到 1.0(不包括)的随机双精度值；
公式(int)(Math.random() * ((max - min) + 1)) + min
例：int r = (int)(Math.random() * ((max - min) + 1)+min)

3.Random.ints：Random.ints(int min, int max)生成一个从原点(包括)到绑定(不包括)的随机整数
例：Random r = new Random();
return r.ints(min, (max + 1)).limit(1).findFirst().getAsInt();

2. switch - case

switch(表达式){ 
    case 常量1: 语句1; // break;
    case 常量2: 语句2; // break; 
    … …
    case 常量N: 语句N; // break; 
    default: 语句; // break; }

①调用完执行语句后，仍然继续向下执行其它case中的执行语句，直到遇到break或结构末尾才结束（default可以不用break）
②switch结构中的表达式，只能是以下六种数据类型之一：
byte、short、char、int、枚举类型、String类型
③case之后只能声明常量，不能声明范围。
④default相当于if-else结构中的else；default结构是可选的，而且位置是灵活的。
⑤当switch-case结构中的多个case的执行语句相同，则可以考虑进行合并

⑥因为break关键字是可选的，在有些情况下case语句倒着写会是一个不错的思路
⑦凡是可以使用switch-case的结构，都可以转换为if-else，反之不成立。

循环结构：

在某些条件满足的情况下，反复执行特定代码的功能。

循环语句分类：
for循环和while循环是可以相互转换的

1. for 循环

for(①;②;④)   //①出了for循环就不能调用了(甚至可以在下一个循环里重复定义)
{
    ③；          //执行过程：① -> ② -> ③ ->④ -> ② -> ③ ->④ ...-> ②
}

//例题：遍历100以内的偶数
        for(int i = 1;i <= 100;i++){
            if(i % 2 == 0){
                System.out.println(i);
            }
        }

2. while循环

①
while(②)
{
    ③;
    ④;
}

//遍历100以内的偶数
        int i = 1;
        while(i <= 100){
            if(i % 2 == 0){
                System.out.println(i);
            }
            i++;
        }

3. do-while循环

①
do{
    ③;
    ④;
}while(②);        //执行过程：① - ③ - ④ - ② - ③ - ④ - ... - ②
1.do-while循环至少会执行一次循环体！
2.开发中，使用for和while更多一些。较少使用do-while

//遍历100以内的偶数
        int num = 1;
        do{
            if(num % 2 == 0){
                System.out.println(num);
            }
            num++;
        }while(num <= 100);  //当循环执行多次时和for、while没区别

死循环

for(;😉{}和while(ture){}是一样的效果，用break跳出

break语句对if-else的条件语句不起作用, if else里面的break也是对if外层的循环语句起作用
在多层循环中，一个break语句只向外跳一个

//求100以内的质数
label:for(int i=2;i<=100;i++){
    for(int j=2;j<i/2;j++){
        if(i%j==0)  continue label;
    }
    System.out.print(i+"  ");
}

最基本思路：设置某个变量为1，当i%j==0时该变量赋值为0，最后判断该变量是否还为1
最终优化：break减少非质数的运算并将j<=i改为j<=math.sqrt(i)

补充知识：

程序运行时间

//获取当前时间距离1970-01-01 00:00:00 的毫秒数
long start = System.currentTimeMillis();
long end = System.currentTimeMillis();
System.out.println("程序运行所花费的时间为：" + (end - start));

break和continue关键字的使用

	使用范围	作用	相同点
break	switch - case 循环结构	结束当前循环	关键字后不能声明执行语句
continue	循环结构	结束当次循环	关键字后不能声明执行语句

label:for(int i = 1;i <= 4;i++){
            for(int j = 1;j <= 10;j++){
                if(j % 4 == 0){
                    //break;//默认跳出包裹此关键字最近的一层循环
                    //continue;//默认跳出包裹此关键字最近的一次循环
                    //break label;//结束指定标识的一层循环结构
                    continue label;//结束指定标识的一层循环结构当次循环
                }
                System.out.print(j);
            }
            System.out.println();
        }

关于switch-case

在某些情况中，不同case中需要重复定义同一个变量，例：

case 1:int i=1;
        ......
      break;
case 2:int i=2;
        ......
      break;
编译不通过：在同一个块内重复定义变量

修改方法：
1. 采用不同的变量名
2. 加{}
case 1:{int i=1;
        ......
        break;}
case 2:{int i=2;
        ......
        break;}

posted @ 2023-09-30 16:11 LemonPuer 阅读(21) 评论(0) 收藏举报

刷新页面返回顶部

柠檬普洱