java第二章基础语法笔记_java中j % 2000 == 0-优快云博客

本文详细介绍了Java的基础概念，包括关键字与保留字、标识符的定义及命名规范、变量的分类与使用注意事项、基本数据类型及其转换规则等内容。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

2.1关键字与保留字

关键字(keyword)的定义和特点

1.定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）。
2.特点：关键字中所有字母都为小写。
官方地址：https:/docs.oracle.com/javase/tutorial/java/nutsandboits/_keywords.html
用于定义数据类型的关键字

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
assert

用于定义数据类型值的字面值

true
false
null

保留字(reserved word)

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

2.2标识符(Identifier)

标识符：

Java对各种变量、方法和类等要素命名时便用的字符序列称为标识符（如：变量名，类名，包名，方法名，接口名）
技巧：凡是自己可以起名字的地方都叫标识符>
定义合法标识符规则：
1.由26个英文字母大小写，0-9，_或$组成
2.数字不可以开头。
3.不可以使用关键字和保留字，但能包含关键字和保留字。
4.Java中严格区分大小写，长度无限制。
5.标识符不能包含空格。

Java中的名称命名规范：

1.包名：多单词组成时所有字母都小写：xxxyyyzzz
2.类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
3.变量名、方法名：多单词组成时，第一个单词首子母小写，第二个单词开始每个单词首字母大写：xoxYyyZzz
4.常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX YYY ZZZ

2.3变量

●变量的概念：
1.内存中的一个存储区域
2.该区域的数据可以在同一类型范围内不断变化
3.变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值。

变量的作用：用于在内存中保存数据
使用变量注意：
1.Java中每个变量必须先声明，后使用
2.使用变量名来访问这块区域的数据
3.变量的作用域：变量都定义在其作用域内，出了作用域就失效。同一个作用域内，不能定义重名的变量。

变量的分类-按数据类型

一、变量按照数据类型来分：
基本数据类型：

整型：byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean

引用数据类型：

类(class)
接口(interface)

整数类型：byte、short、int、long

Java各整数类型有固定的表数范围和字段长度，不受具体Os的影响，以保证java程序的可移植性。
java的整型常量默认为int型，声明long型常量须后加甲"l’或’L’
java程序中变量通常声明为int型，除非不足以表示较大的数，才使用long。

注：longl类型变量的声明(以‘L’或‘l’结尾），如： long num=123456L;

类型	占用存储空间	表数范围
byte	1字节=8bit位	-128~127
short	2字节	- $2^{15}$ ~ $2^{15}$ -1
int	4字节	$2^{31}$ ~ $2^{13}$ -1
long	8字节	$2^{63}$ ~ $2^{63}$ -1

注：bit计算机中的最小存储单位，byte计算机中基本存储单元

浮点类型：float、double

与整数类型类似，Java浮点类型也有固定的表数范围和字段长度，不受具体
系统的影响。
浮点型常量有两种表示形式：

十进制数形式：如：5.12 512.0f .512(必须有小数点)
料学计数法形式如：5.12e2 512E2 100E-2

float:单精度，尾数可以精确到位有效数字。很多情况下，精度很难满足需求。
double:双精度，精度是float的两倍。通常采用此类型。
注：Java的浮点型常量默认为double型，声明float型常量，须后加f或F。

类型	占用存储空间	表数范围
单精度float	4字节	-3.403E38~3.403E38
双精度double	8字节	-1.798E308~1.798E308

字符类型：char

char型数据用来表示通常意义上“字符”(2字节)。
Java中的所有字符都使用Unicode编码，故一个字符可以存储一个字母，一个汉字，或其他书面语的一个字符。
字符型变量的三种表现形式：

1.字符常量是用单引号‘ ’括起来的单个字符。例如：char c1=‘a’;ch =‘中’；char c3=‘9;
2.Java中还允许使用转义字符来将其后的字符转变为特殊字符型。例如：char c3=’\n’;’\n’表示换行符。直接使用Unicode值来表示字符型常量\uXXXX。其中，XXXX代表一个十六进制整数。如：\u000a表示\n。
3.char类型是可以进行运算的。因为它都对应有Unicode码。

ASClI码

在计算机内部，所有数据都使用二进制表示。每一个二进制位(bit)有0和1两种状态。因此8个二进制位就可以组合出256种状态，这被称为一个字节(byte)。一个字节共可以用来表示256种不同的状态，每一个状态对应一个符号，就是256个符号，0000000到11111111。
ASCII码：上个世纪60年代，美国制定了一套字符编码，对英语字符与二进制位之间的关系，做了统一规定。这被称为ASC1码。ASC1码一共规定了128个字符的编码，比如空格“SPACE”是32（二进制00100000），大写的字母A是65（二进制01000001）128个符号（包括32个不能打印出来的控制符号），只占用了一个字节的后面7位，最前面的1位统一规定为0。
●缺点：
1.不能表示所有字符。

相同的编码表示的字符不一样：比如，130在法语编码中代表了é，在希伯来语编码中却了字母Gimel。
Unicode编码

乱码：世界上存在着多种编码方式，同一个二进制数字可以被解释成不同的符号。因此，要想打开一个文本文件，就必须知道它的编码方式，否则用错误的编码方式解读就会出现乱码。
Unicode:一种编码，将世界上所有的符号都纳入其中。每一个符号都给予一个独一无二的编码，使用Unicode没有乱码的问题。
Unicode的缺点：Unicode只规定了符号的二进制代码，却没有规定这个二进制代码应该如何存储。无法区别Unicode和ASCII:计算机无法区分三个字节表示一个符号还是分别表示三个符号。另外，我们知道，英文字母只用一个字节表示就够了，如果unicode统一规定，每个符号用三个或四个字节表示，那么每个英文字母前都必然有二到三个字节是，这对于存储空间来说是极大的浪费。

UTF-8
1.UTF-8是在互联网上使用最广的一种Unicode的实现方式。
2.UTF-8是一种变长的编码方式。它可以使用1-6个字节表示一个符号，根据不同的符号而变化字节长度。
3.UTF-8的编码规则：
对于单字节的UTF-8编码，该字节的最高位为0，其余7位用来对字符进行编码（等同于ASCII码)。
对于多字节的UTF-8编码，如果编码包含n个字节，那么第一个字节的前n位为1，第一个字节的第n+1位为0，该字节的剩余各位用来对字符进行编码。在第一个字节之后的所有的字节，都是最高两位为”10”，其余6位用来对字符进行编码。

基本数据类型转换

1.自动类型转换：容量小的类型自动转换为容量大的数据类型。

2.有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。
（1）byte,short,char之间不会相互转换，他们三者在计算时首先转换为int类型(byte和byte做运算也要用int接收，short、char同理)。
（2）boolean类型不能与其它数据类型运算。
（3）当把任何基本数据类型的值和字符串(String)进行连接运算时(+)，基本数据类型的值将自动转化为字符串(String)类型。

强制类型转换

1.自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符：()，但可能造成精度降低或溢出，格外要注意。

例：double a=12.9; int b=(int)a;

2.通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型。

如：String a=“43"; int i=Integer.parselnt(a);

3.boolean类型不可以转换为其它的数据类型。<\code>

4.整型常量，默认类型为int型。浮点型常量，默认类型为double型。

字符串类型：String

String不是基本数据类型，属于引用数据类型。
1.使用方式与基本数据类型一致。例如：String str=“abcd";

2.一个字符串可以串接另一个字符串，也可以直接串接其他类型(8种基本数据类型)的数据。即String类型和其他数据类型做运算的结果仍为String类型。例如：

str=str+“xyz";
int n=100;
str=str + n;

关于String的示例：

示例1：
char c=a’; //a为97   A为65
int num 10;
String str “hello”;
System.out.printIn(c+num+str);     //107hello
System.out.printIn(c+str+num);    //ahello10
System.out.println(c +(num+str));    //al0hello
System.out.println((c+num)+str);    //107hello
System.out.println(str+num+c);    //hello10a

关于进制

所有数字在计算机底层都以二进制形式存在。
对于整数，有四种表示方式：

二进制(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

Integer类下的方法：

toBinaryString： public static String toBinaryString(int i)以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
toHexString：public static String toHexString(int i)以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
toOctalString： public static String toOctalString(int i)以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

变量的分类-按声明的位置的不同

在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。
在这里插入图片描述

注意：二者在初始化值方面的异同：

同：都有生命周期。
异：局部变量除形参外，需显式初始化。

在这里插入图片描述

2.4运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

算术运算符

在这里插入图片描述
%取余运算结果的符号与被模数的符号相同。

2.4.2运算符：赋值运算符

符号：=
1.当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理。
2.支持连续赋值。如：int a=1,b=2;
扩展赋值运算符：+=，-=，*=，/=，%=

2.4.3运算符：比较运算符

1.比较运算符的结果都是boolean型，也就是要么是true,要么是false。
2.比较运算符“==”不能误写成“=”，例：

int i=10,j=20;
System.out.printIn(i==j); //输出false
System.out.printIn(i=j); //输出20

2.4.4运算符：逻辑运算符

&（逻辑与）
|（逻辑或）
!（逻辑非）
&&（短路与）
||（短路或）
^(逻辑异或)
1.&&和&区别：都是表示与，&&只要第一个条件不满足，后面条件就不再判断。
2.区分|和||：||只要满足第一个条件，后面的条件就不再判断，而|要对所有的条件进行判断。

2.4.5运算符：位运算符

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

1.位运算是直接对整数的二进制进行的运算。
2.对于&、|、^运算符，若两边为布尔类型则是逻辑运算符，若是整型数字则是位运算符。

用^实现两个变量的交换：
a=a^b; //a==a ^ b
b=a^b; // b=a
a=a^b; // a=(a ^ b) ^ a ==b

2.4.6运算符：三元运算符

格式：

在这里插入图片描述
1.表达式1和表达式2为同种类型
2.三元运算符与if-else的联系与区别：
1)三元运算符可简化if-else语句。
2)三元运算符要求必须返回一个结果。
3)if后的代码块可有多个语句。

运算符的优先级

运算符有不同的优先级，所谓优先级就是表达式运算中的运算顺序。如右表，上一行运符总优先于下一行。
只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

2.5程序流程控制

顺序结构： 程序从上到下逐行地执行，中间没有任何判断和跳转。
分支结构： 根据条件，选择性地执行某段代码。有if…else和switch-case两种分支语句。
循环结构： 根据循环条件，重复性的执行某段代码。有while、do.….while、for三种循环语句。
注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

输入输出：

如何从键盘获取不同类型的变量：需要使用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);
String name =scan.next();
int num =scan.nextInt();
System.out.println(name);
System.out.println(num);
}
}

2-5-3分支语句2:switch-case结构

格式：

switch(表达式){
case 常量1：
语句1;
 //break
case 常量2：
语句2;
//break:
case 常量N:
语句N;
//break;
default:    //默认情况
语句;
//break;
}

说明：
1.根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，则进入相应case结构中，调用其执行语句。
2.当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case末尾结束为止。
3.break,可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。
4.switch结构中的表达式，只能是如下的6种数据类型之一：byte、short、char、int、枚举类型(JDK5.0新增)、String（JDK7.0新增）。
5.case之后只能声明常量，不能声明范围。
6.break关键字是可选的（可以不要break）。
7.default也是可选的，且位置是任意的。

例程：

import java.util.Scanner;
class SwitchCaseTest{
public static void main(String[]args){
Scanner scan=new Scanner(System.in);
int num=scan.nextInt();
switch(num){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("other");
             }
        }
 }

2.5.4程序流程控制：循环结构

循环结构：在某些条件满足的情况下，反复执行特定代码。
循环语句分类：

for循环
while循环
do-while循环

●循环语句的四个组成部分

初始化部分（init_statement)
循环条件部分(test_exp)(循环条件一定是布尔类型)
循环体部分(body_statemnet)
选代部分(alter_statement)

for循环：

for循环格式：

for(初始化条件；循环条件；迭代部分）{
循环体
}
执行过程：初始化条件–>循环条件–>循环体–>迭代部分–>循环条件。。。

while循环：

whiile循环格式：

初始化条件
while(循环条件){
循环体和迭代部分（相对位置任意）
}

do-while循环：

do-while格式：

初始化条件;
do{
循环体和迭代部分（相对位置任意）
}while(循环条件);

do-while循环至少会执行一次循环体。

for循环、while循环、do-while循环可以相互转化。

循环语句综合例程：

从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序：
最筒单“无限”循环格式：while(true),for( ; ; ); ，无限循环存在的原因是并不知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。

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;
           }
        */  
         for( ; ;){
              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)
2.结束循环有几种方式？
方式一：循环条件部分返回false
方式二：在循环体中，执行break

2-5-7嵌套循环

1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了联套循环。
2.外层循环：循环结构B 。内层循环：循环结构A
3.说明
内层循环结构遍历一遍，只相当于外层循环循环体执行了一次。假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m*n次。
4.技巧：外层循环控制行数，内层循环控制列数。

例程1：打印九九乘法表

class NineNineTable{
      public static  void main(String str[]){
     for(int i =1;i <=9;i++){
          for(int j=1;j<=i;j++){
               System.out.print(i+"*"+j+"="+(i*j)+" ");
               }
                 System.out.println();
           }
    }
}

/*
打印
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
*/

例程2：打印100以内质数并记录程序运行时间

//打印100以内的质数
class PrimeNumberTest{
     public static void main(String[] args){
                 boolean isFlag=true;
                  //获取当前时间距离1970-01-01  00：00：00的毫秒数
                 long start=System.currentTimeMillis();
                for(int i=2;i<=100;i++){
                             isFlag = true; 
                          for(int j=2;j<i;j++){
                              if(i%j==0){
                                    isFlag = false;
                                     break;
                                    }
                                } 
                                if(isFlag) System.out.println(i);
                      
                   }
                 long end=System.currentTimeMillis();
                 System.out.println("Time cost: "+(end-start));
                 }
         }

注：此代码在cmd命令行下运行时，加了注释就编译不通过。编译时改为javac -encoding UTF-8 PrimeNumberTest.java后编译成功。 解决方案参考>>此博客

break和continue:关键字的使用

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

1.break:默认跳出包裹此关键字最近的一层循环。continue:默认跳过包裹此关键字最近的一层循环的当次循环。

break label;结束指识的一层循环结构。 continue label;结束指定标识的一层循环结构当次循环。

示例1：
label: for(int i=1;i<=4;i++){
for(int j=1;j<=10;j++){
if(j%4==0){break label;}
System.out.print(j);
}
System.out.println();
}
// 输出结果123

示例2：
label: for(int i=1;i<=4;i++){
for(int j=1;j<=10;j++){
if(j%4==0){continue label;}
System.out.print(j);
}
System.out.println();
}
/*输出结果
123123123123