Java学习笔记Day02 Java语言基础

最新推荐文章于 2024-07-23 22:57:12 发布
最新推荐文章于 2024-07-23 22:57:12 发布
阅读量275 收藏 1
点赞数 1
分类专栏： java 文章标签： java 编程语言 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43832328/article/details/104606026
版权

第二章 Java语言基础

文章目录

2.1.1 字符集

  • 字符是各种文字和符号的总称，包括个国家文字、标点符号、图形符号、数字等。字符集是多个字符的集合，不同的字符集所包含的字符个数也不同
  • 常见字符集：
    • ASCII字符集
    • GB2312字符集
    • Unicode字符集
类型长度说明
UTF-8长度可变UTF-8使用可变长度字节来存储Unicode字符，例如ASCII字母继续使用1字节储存；重音文字、希腊字母或西里尔字母等使用2字节来储存；而常用的汉字就要使用3字节；辅助平面字符则使用4字节
UTF-1616位UTF-16大部分字符都以固定长度的2个字节（16位）储存，但UTF-16无法ASCII编码
UTF-3232位UTF-32将每一个Unicode代码点表示为相同值的32位整数

Java语言中基本所有输入元素都是采用ASCII，而标识符、字符、字符串和注解则采用Unicode。

2.1.2 分隔符

  • Java中使用多种字符作为分隔符，用于辅助程序编写、阅读和理解。这些分隔符可以分为两类：
    • 空白符：没有确定意义，但帮助编译其正确理解源程序，包括空格、回车、换行和制表符（Tab）
    • 普通分隔符：拥有确定含义，常用的普通分隔符如下表所示

任意两个相邻的标识符之间至少有一个分隔符，便于编译程序理解；空白符的数量多少没有区别，使用一个和多个空白符实现相同的分隔作用；分隔符不能相互替换，比如该用逗号的地方不能使用空白符。

类型长度说明
()小括号1.方法签名
2.表达式，以提升操作符的优先级
3.类型转换
4.循环，已包含要运算的表达式
{}大括号1.类型声明
2.语句块
3.数组初始化
[]中括号1.数组声明
2.数组值的引用
<>尖括号1.泛型
2.将参数传递给参数化类型
.句号1.隔开域或者方法与引用变量
2.隔开包、子包及类型名称
;分号1.结束一条语句
2.for语句
,逗号1.声明变量时，分隔各个变量
2.分隔方法中的参数
:冒号1.for语句中，用于迭代数组或集合
2.三元运算符

2.1.3 标识符

  • 在各种编程语言中，通常要为程序中处理的各种变量、常量、方法、对象和类等起个名字作为标记，以便通过名字进行访问，这些名字统称标识符。

  • Java中的标识符由字母、数字、下划线或美元符组成，且必须以字母、下划线（_）或美元符（$）开头。

  • Java中标识符的命名规则如下：

    • 可以包含数字，但不能以数字开头；
    • 除下划线“_”和“$”符以外，不包含任何其他特殊字符，如空格；
    • 区分大小写，例如“abc”和“ABC”是两个不同的标识符；
    • 不能使用Java关键字。

2.1.4 关键字

abstractassertbooleanbreakbyte
casecatchcharclassconst
continuedefaultdodoubleelse
enumextendsfinalfinallyfloat
forgotoifimplememtsimport
instanceofintinterfacelongnative
newpackageprivateprotectpublic
returnstrictfpshortstaticsuper
switchsynchronizedthisthrowthrows
transienttryvoidvolatilewhile

2.2.1 变量

  • 变量是数据的基本存储形式，因Java是一种强类型的语言，所以每个变量都必须先声明后再使用。变量的定义包括变量类型和变量名，其定义的基本格式如下：

  • 语法

    数据类型 变量名 = 初始值;

2.2.2 常量

  • 常量是指一旦赋值之后其值不能再改变的变量。在Java语言中，使用final关键字来定义常量，其语法格式如下：

    final 数据类型 变量名 = 初始值;

在开发过程中常量名习惯采用全部大写字母，如果名称中含有多个单词，则单词之间以“_”分隔。此外常量在定义时，需要对常量进行初始化，初始化后，在应用程序中就无法再对该常量赋值。

2.2.3 变量作用域

  • 在变量的使用过程中会涉及到变量的作用域和初始化，根据作用域范围可以将变量分为两种：
    • 局部变量
    • 成员变量
  • 局部变量被定义在某个程序块内或方法体内，局部变量的作用范围有限，只在相应的程序块内或方法体内有效，超出程序块或方法体则这些变量将无效

程序块就是使用“{”和“}”包含起来的代码块，它是一个单独的模块。

示例代码VarScope.java

public static void main(String[] args) {
		// 变量a的作用域是main()方法体内
		int a = 10;
		{
            // 变量b的作用域是当前程序块的两个大括号中｛｝
			int b = a * a;
			// 此处变量a和变量b都在作用域范围内，都可以访问
			System.out.println("a=" + a + ",b=" + b);
		}
		// 此处变量a在作用域范围内，可以访问
		System.out.println("a=" + a);
		// 错误，此处变量b已经不在作用域范围内，不可以访问
		// System.out.println("b=" + b);
	}

2.2.4 变量初始化

  • 局部变量在使用之前必须进行初始化，即变量必须有值后才能被使用（先写后读）。
  • 变量的初始化有两种方式：
    • 在声明变量的同时赋初值；
    • 先声明变量，在使用变量前再赋值。

示例代码VarValue.java

public static void main(String[] args) {
    //声明变量a并赋初值	
    int a=10;
    //声明变量b
    int b;
    //a已经有值，可以使用
    System.out.println("a="+a);
    //错误，b还没有值，不能使用
    // System.out.println("b="+b);
    //在使用之前先给b赋值
    b=20;
    //正确，b有值后可以使用
    System.out.println("b="+b);
	}

2.3 数据类型

Java的数据类型分为两大类：基本类型和引用类型。

  • 基本类型是一个单纯的数据类型，表示一个具体的数字、字符或布尔值。基本类型存放在内存的“栈”中，可以快速从栈中访问这些数据。
  • 引用类型是一个复杂的数据结构，是指向存储在内存的“堆”中数据的指针或引用（地址）。引用类型包括类、接口、数组和字符串等，由于要在运行时动态分配内存，其存取速度较慢。
  • Java的基本数据类型主要包括如下四类：
    • 整数类型：byte、short、int、long
    • 浮点类型：float、double
    • 字符类型：char
    • 布尔类型：boolean

2.3.1 基本类型

  • Java各种基本类型的大小和取值范围

    类型名称关键字大小取值范围
    字节型byte8-27~27-1
    短整型short16-215~215-1
    整型int32-231~231-1
    长整型long64-263~263-1
    浮点型float323.4e-38~3.4e+38
    双精度double641.7e-38~1.7e+38
    布尔型boolean1true/false
    字符型char16“\u0000”~”\uFFFF”
整数类型

  • byte

  • short

  • int

  • long

  • Java中整数值表示方法

    • 二进制
    • 八进制
    • 十进制
    • 十六进制

示例代码IntValueDemo.java:

// 二进制数
int a = 0b1001; 
System.out.println("二进制数0b1001的值是：" + a);	
// 八进制数
int b = 071; 
System.out.println("八进制数071的值是：" + b);	
// 十进制数
int c = 19; 
System.out.println("十进制数19的值是：" + c);
// Integer.toBinaryString()方法将一个整数以二进制形式输出
System.out.println("19的二进制表示是：" +Integer.toBinaryString(c));	
// 十六进制数
int d = 0xFE; 
System.out.println("十六进制数0xFE的值是：" + d);
System.out.println("十六进制数0xFE的二进制表示是" + Integer.toBinaryString(d));	
// 负数以补码形式存储
int e = -19;           
System.out.println("-19的二进制表示是：" + Integer.toBinaryString(e));
字符型

  • 字符型char是采用16位的Unicode字符集作为编码方式,每个字符占两个字节

  • 表示形式

    • 通过单个字符来指定字符型值，例如：‘A’、‘8’、'Z’等；
    • 通过转义字符来表示特殊字符型值，例如：’\n’、’\t’等；
    • 直接使用Unicode值来表示字符型值，格式是‘\uXXXX’

  • 转义字符表

    转义字符说明Unicode编码
    \b退格符\u0008
    \t制表符\u0009
    \n换行符\u000a
    \r回车符\u000d
    \"双引号\u0022
    \’单引号\u0027
    \\反斜杠\u005c

2.3.2 引用类型

  • 引用类型变量中的值是指向内存“堆”中的指针，即该变量所表示数据的地址。
  • 引用类型与基本类型在内存中存储的区别：

引用类型与基本类型在内存中存储的区别

  • 常用引用类型：
    • 数组：具有相同数据类型的变量的集合；
    • 类（class）：变量和方法的集合；
    • 接口（interface）：一系列方法的声明，方法特征的集合；
    • 枚举（enum）：一种独特的值类型，用于声明一组命名的常数。

2.3.3 类型转换

  • 类型转换的方式：
    • 自动类型转换
    • 强制类型转换
自动类型转换

  • 自动类型转换是将某种基本类型变量的值直接赋值给另一种基本类型变量

    自动类型转换

强制类型转换

  • 当把一个数值范围大的变量赋值给一个数值范围小的变量时，必须强制类型转换

  • 语法：

    数据类型 变量1 = (数据类型) 变量2;

强制类型转换示例代码AutoChange.java

byte b = 7;
char c = 'A';
int a = 10;
long l = 789L;
float f = 3.14f;
double d = 5.3d; 

// 字符型变量c自动转换为整型，参加加法运算
int i1 = a + c; 
System.out.println("i1=" + i1);

// 整型变量i1自动转换为长整型，参加减法运算
long l1 = l - i1; 
System.out.println("l1=" + l1);

// 字节型变量b自动转换为浮点型，参加乘法运算
float f1 = b * f; 
System.out.println("f1=" + f1);	

// 整型变量a自动转换为双精度，参加除法运算
double d1 = d / a; 
System.out.println("d1=" + d1); 

// 将浮点型变量f1强制类型转换为整数
int i2 = (int) f1;
System.out.println("i2=" + i2);

// 整型变量a自动类型转换为长整型后参加除法运算，算出的长整型结果再强制类型转换为字符型
char c2 = (char) (l / a); 
System.out.println("c2=" + c2);

2.4 操作符

  • 操作符也称为运算符，是一种特殊的符号，用来将一个或多个操作数连接成执行性语句，以实现特定功能。
  • 操作符类型：
    • 一元操作符：只操作一个操作数；
    • 二元操作符：操作两个操作数；
    • 三元操作符：操作三个操作数。
分类说明符号
一元操作符自增、自减++、–
逻辑非!
按位非~
强制类型转换(type)
二元操作符算数运算+、-、*、/、%
位运算&、|、^、<<、>>、>>>
关系运算>、>=、<、<=、==、!=
逻辑运算&&、||
赋值=、+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=、>>>=
三元操作符三元判断? :
2.4.1 一元操作符
  • 一元操作符之操作一个操作数
  • 在运算符的两边只有一个操作数

1.自增运算只能操作单个数值型的变量（整型、浮点型都行），不能操作常量或表达式；

2.自增运算可以放在操作数的前面（前缀自增），也可以放在操作数后面（后缀自增）。

  • ++ 运算，变量自己增长1。反之，-- 运算，变量自己减少1，用法与 ++ 一致。

    • 独立运算：

      • 变量在独立运算时，前++ 和 后++ 没有区别
      • 变量前++ ：例如 ++i 。
      • 变量后++：例如 i++ 。

    • 混合运算

      • 和其他变量放在一起，前++ 和 后++ 就产生了不同。

      • 变量前++ ：变量a自己加1，将加1后的结果赋值给b，也就是说a先计算。a和b的结果都是2。

        public static void main(String[] args){
    int a = 1;                             
    int b = ++a;     
    System.out.println(a);
    System.out.println(b);

    }
    ```

    • 变量 后++ ：变量a先把自己的值1，赋值给变量b，此时变量b的值就是1，变量a自己再加1。a的结果是2，b 的结果是1。

    • public static void main(String[] args){
    int a = 1;     
    int b = a++;     
    System.out.println(a);
    System.out.println(b);
}
非运算
  • ！是逻辑非运算，如果操作数为true，则返回false；如果操作数为false，则返回true。
  • ~是按位非运算，将操作数对应的二进制数的每一位（包括符号位）全部取反，即原来是0，则为1；原来为1，则为0。
int a = 5;
// a先自增变为6，再与8相加，最后b的值是14
int b = ++a + 8;
System.out.println("b的值是：" + b);
int c = a++;
System.out.println("c的值是：" + c);
System.out.println("a的值是：" + a);
int d = 10;
System.out.println("前缀自减--d的值是：" + --d);
System.out.println("当前d的值是：" + d);
System.out.println("后缀自减d--的值是：" + d--);
System.out.println("当前d的值是：" + d);
boolean flag = true;
System.out.println("逻辑非：" + !flag);
int t = 10;
// Integer.toBinaryString()以二进制形式输出一个整数
System.out.println("整数10的二进制表示：" + Integer.toBinaryString(t));
// 按位非后的二进制是11111111111111111111111111110101
System.out.println("按位非的二进制表示：" + Integer.toBinaryString(~t));
// 按位非后的数值是-11,因为11111111111111111111111111110101是-11的补码
System.out.println("按位非的十进制表示：" + ~t);
2.4.2 二元运算符
算术运算
操作符描述示例
+两个数相加，或两个字符串连接int a=5,b=3; //c的值为8 int c=a+b;String s1=“abc”,s2=“efg”; //s3的值为"abcefg" String s3=s1+s2;
-两个数相减int a=5,b=3; //c的值为2 int c=a-b;
*两个数相乘int a=5,b=3; //c的值为15 int c=a*b;
/两个数相除int a=5,b=3; //c的值为1（整数） int c=a/b;double a=5.1,b=3; //c的值为1.7（浮点数） double c=a/b;
%取余：第一个数除以第二个数，整除后剩下的余数int a=5,b=3; //c的值为2 int c=a%b;double a=5.2,b=3.1; //c的值为2.1 double c=a%b;

如果/和%的两个操作数都是整数类型，则除数不能是0，否则引发除以0异常。但如果两个操作数有一个是浮点数，或者两个都是浮点数，此时允许除数是0或0.0，任何数除0得到的结果是正无穷大（Infinity）或负无穷大（-Infinity），任何数对0取余得到的结果是非数：NaN。

int a = 5;
int b = 3;
int c = a + b; 
System.out.println(c);
// 字符串连接
String s1 = "abc";
String s2 = "efg"; 
String s3 = s1 + s2; // s3的值为"abcefg"
System.out.println(s3);
// 两个数相减，结果为2
System.out.println(a - b); 
// 两个数相乘，结果为15
System.out.println(a * b);
// 两个整数相除，结果为1
System.out.println(a / b);
// 两个浮点数相除，结果为1.7
System.out.println(5.1 / 3);
// 两个整数取余，结果为2
System.out.println(a % b);
// 两个浮点数取余，结果为2.1
System.out.println(5.2 % 3.1); 
//正浮点数除以0，结果为Infinity
System.out.println(3.1/0); 
//负浮点数除以0，结果为-Infinity
System.out.println(-8.8/0); 
//正浮点数对0取余，结果为NaN
System.out.println(5.1%0); 
//负浮点数对0取余，结果为NaN
System.out.println(6.6%0); 
//整数除以0,将引发异常
System.out.println(3/0);
位运算符
操作符描述示例
&按位与，当两位同时为1才返回100101010 & 00001111 = 00001010
|按位或，只要有一位为1即可返回100101010 | 00001111 = 00101111
^按位异或，当两位相同时返回0，不同时返回100101010 | 00001111 = 00100101
<<左移，N<<S的值是将N左移S位，右边空出来的位填充0，相当于乘2的S次方11111000<<1 =11110000
>>右移，N>>S的值是将N右移S位，左边空出来的位如果是正数则填充0，负数则填充1，相当于除2的S次方11111000>>1 =1111100
>>>无符号右移，无论正数还是负数，无符号右移后左边空出来的位都填充011111000>>>1 =0111100
int a = 0b00101010;
int b = 0b00001111;
// 按位与
System.out.println(Integer.toBinaryString(a & b)); 
// 按位或
System.out.println(Integer.toBinaryString(a | b)); 
//按位异或
System.out.println(Integer.toBinaryString(a^b )); 
int c=0b11111000000000000000000000000000;
//左移
System.out.println(Integer.toBinaryString(c<<1 )); 
//右移
System.out.println(Integer.toBinaryString(c>>1)); 
//无符号右移
System.out.println(Integer.toBinaryString(c>>>1));
关系运算符
操作符描述示例
>大于，左边操作数大于右边操作数，则返回trueint a=5,b=3; System.out.println(a>b);//true
>=大于等于，左边操作数大于或等于右边操作数，则返回trueint a=5,b=3; System.out.println(a>=b);//true
<小于，左边操作数小于右边操作数，则返回trueint a=5,b=3; System.out.println(a<b);//false
<=小于等于，左边操作数小于或等于右边操作数，则返回trueint a=5,b=3; System.out.println(a<=b);//false
==等于，两个操作数相等，则返回trueint a=5,b=3; System.out.println(a==b);//false
int a = 5;
int b = 3;
System.out.println(a + ">" + b + "结果为" + (a > b));
System.out.println(a + ">=" + b + "结果为" + (a >= b));
System.out.println(a + "<" + b + "结果为" + (a < b));
System.out.println(a + "<=" + b + "结果为" + (a <= b));
System.out.println(a + "==" + b + "结果为" + (a == b));
//'a'的ASCII值为97，因此相等，结果为true
System.out.println("'a'==97结果为"+('a'==97));

关系运算符中==比较特别，如果进行比较的两个操作数都是数值类型，即使它们的数据类型不同，只要它们的值相等，都将返回true。

例如’a’97返回true，55.0也返回true。

如果两个操作数都是引用类型，则只有当两个引用变量的类型具有继承关系时才可以比较，且这两个引用必须指向同一个对象（地址相同）才会返回true。如果两个操作数是布尔类型的值也可以进行比较。

例如true==false返回false。

逻辑运算符
操作符描述示例
&/&&逻辑与，前后两个操作数都为true，则返回trueboolean a=true,b=false; System.out.println(a&&b);//false
|/||逻辑或，前后两个操作数都为false，则返回falseboolean a=true,b=false; System.out.println(a||b);//true
&&短路与，第一个操作数为假则不判断第二个操作数
||短路或，第一个操作数为真则不判断第二个操作数
^逻辑异或
  • 逻辑运算真值表
ABA && BA || B
truetruetruetrue
truefalsefalsetrue
falsetruefalsetrue
falsefalsefalsefalse
// &&
System.out.println("true && true = " + (true && true));
System.out.println("true && false = " + (true && false));
System.out.println("false && true = " + (false && true));
System.out.println("false && false = " + (false && false));
// ||
System.out.println("true || true = " + (true || true));
System.out.println("true || false = " + (true || false));
System.out.println("false || true = " + (false || true));
System.out.println("false || false = " + (false || false));

在逻辑运算时，为了提高运行效率，Java提供了“短路运算”功能。&&运算符检查第一个操作数是否为false，如果是false则结果必为false，无需检查第二个操作数。||运算符检查第一个表达式是否为true，如果是true则结果必为true，无需检查第二个操作数。检查其他内容。因此，对于&&当第一个操作数为fasle时会出现短路；对于||当第一个操作数为true时会出现短路。

赋值运算符

  • 赋值运算符用于为变量指定变量值，Java中使用“=”作为赋值运算符

  • 可以直接将一个值赋给变量

  • 将一个变量值或表达式的值赋给另一个变量

类赋值运算符：

混合赋值运算符示例等价于
+=a +=ba=a+b
-=a-=ba=a-b
*=a*=ba=a*b
/=a/=ba=a/b
%=a%=ba=a%b
&=a&=ba=a&b
|=a|=ba=a|b
^=a^=ba=a^b
<<=a<<=ba=a<<b
>>=a>>=ba=a>>b
>>>=a>>>=ba=a>>>b
int a = 8;
int b = 3;
System.out.println(a += b);
System.out.println(a -= b);
System.out.println(a *= b);
System.out.println(a /= b);
System.out.println(a %= b);
System.out.println(a &= b);
System.out.println(a |= b);
System.out.println(a <<= b);
System.out.println(a >>= b);
System.out.println(a >>>= b);
2.4.3 三元操作符

  • 语法

    表达式 ? value1 : value2

    表达式的值必须为布尔类型，可以是关系表达式或逻辑表达式；

    若表达式的值为true，则返回value1的值；

    表达式的值为false，则返回value2的值。

2.4.4 运算符优先级
优先级（由高到低）运算符
分割符. [] () {} , ;
一元运算++ – ! ~
强制类型转换(type)
乘、除、取余* / %
加、减+ -
移位运算符>> >>> <<
关系大小运算符> < >= <=
等价运算符== !=
按位与&
按位异或^
按位或|
逻辑与&&
逻辑或||
三元运算符?:
赋值运算符= += -= *= /= %= ^= &= |= <<= >>= >>>=

不要把一个表达式写得太复杂，如果一个表达式过于复杂，则把它分成多步来完成；

不要过多依赖运算符的优先级来控制表达式的执行顺序，以免降低可读性，尽量使用()来控制表达式的执行顺序。

2.5 流程控制

  • 分支语句：if和switch语句；
  • 循环语句：while、do-while和for循环语句
  • 转移语句：break、continue和return语句
2.5.1 分支结构

  • 分支结构是根据表达式条件的成立与否，决定执行哪些语句的结构。其作用是让程序根据具体情况有选择性地执行代码。

  • 分支语句有以下两个：

    • if条件语句
    • switch多分支语句
if语句：

  • 语法：

    if(条件表达式1) {语句块1}
[else if(条件表达式2) {语句块2}]
[else if(条件表达式3) {语句块3}]
......
[else {语句块n}]

    1.所有条件表达式的结果为布尔值（true或false）；

    2.当“条件表达式1”为true时执行if语句中的“语句块1”部分；

    3.当“条件表达式1”为false时，执行else if语句，继续向下判断条件表达式，哪个条件表达式成立，执行相应的语句块；

    4.当所有条件表达式为false时执行else语句中的“语句块n”部分。

    5.else if可以有多个；

    6.[]括起来的else if、else可以省略。

    • 语法形式一：

      if语法形式一

if(条件表达式){
语句块
}
```

  • 语法形式二

    if语法形式二

if(条件表达式) {
语句块
}else{
语句块
}
```

  • 语法形式三

    if语法形式三

if(条件表达式) {
语句块
}else if(条件表达式){
语句块
} else if(条件表达式){
语句块
}
…//可以有多个else if语句
else{
语句块
}
```

int g = 67;
// 判断g是否是负数
if (g < 0) {
	System.out.println("负数");
}
// 判断g是偶数还是奇数
if (g % 2 == 0) {
	System.out.println("偶数");
} else {
	System.out.println("奇数");
}
// 判断g的等级
if (g >= 90) {
	System.out.println("优秀");
} else if (g >= 80) {
	System.out.println("良好");
} else if (g >= 70) {
	System.out.println("中等");
} else if (g >= 60) {
	System.out.println("及格");
} else {
	System.out.println("不及格");
}
switch语句
  • switch语句是由一个控制表达式和多个case标签组成
  • 与if语句不同的是，switch语句后面的控制表达式的数据类型只能是byte、short、char、int四种类型，boolean类型等其他类型是不被允许的
  • 但从Java 7开始允许枚举类型和String字符串类型

语法：

switch (控制表达式){
case value1 : 
	语句1;
	break;
case value2 : 
	语句2;
	break;
......
case valueN : 
	语句N;
	break;
[default : 默认语句; ]
}

1、控制表达式的数据类型只能是byte、short、char、int、String和枚举类型；

2、case标签后的value值必须是常量，且数据类型必须与控制表达式的值保持一致；

3、break用于跳出switch语句，即当执行完一个case分支后，终止switch语句的执行；只有在一些特殊情况下，当多个连续的case值要执行一组相同的操作时，此时可以不用break。

4、default语句是可选的。用在当所有case语句都不匹配控制表达式值时，默认执行的语句。

switch流程图

int g = 67;
switch (g / 10) {// 使用switch 判断g的等级
	case 10:
	case 9:
		System.out.println("优秀"); break;
	case 8:
		System.out.println("良好"); break;
	case 7:
		System.out.println("中等"); break;
	case 6:
		System.out.println("及格"); break;
	default:
		System.out.println("不及格");
}

// 声明变量season是字符串，注意JDK版本是7以上才能支持
String season = "秋天"; 
// 执行swicth分支语句
switch (season) {
	case "春天":
		System.out.println("春暖花开.");break;
	case "夏天":
		System.out.println("夏日炎炎.");break;
	case "秋天":
		System.out.println("秋高气爽.");break;
	case "冬天":
		System.out.println("冬雪皑皑.");break;
	default:
		System.out.println("季节输入错误");
}
2.5.2 循环结构

  • 循环结构可以在满足循环条件的情况下反复执行某一段代码，这段被重复执行的代码被称为“循环体”。

  • 提供的循环语句有以下三种：

    • for循环
    • while循环
    • do-while循环
for循环

语法：

for ([初始化表达式];[条件表达式];[迭代表达式]){
	循环体
}

初始化表达式只在循环开始之前执行一次；

初始化表达式、条件表达式以及迭代表达式都可以省略，但分号不能省，当三者都省略时将成为一个无限循环（死循环）；

在初始化表达式和迭代表达式中可以使用逗号隔开多个语句。

流程图：

for循环流程图

public class ForDemo1 {
	public static void main(String[] args) {
		// 循环的初始化，循环条件，循环迭代语句都在下面一行
		for (int count = 1; count <= 10; count++) {
			System.out.println(count);
		}
		System.out.println("循环结束!");
	}
}

public class ForDemo2 {
	public static void main(String[] args) {
		// 使用for循环求1~100的和
		int sum = 0;
		for (int i = 1; i <= 100; i++) {
			sum += i;
		}
		System.out.println("1~100的和是：" + sum);
	}
}

// 嵌套的for循环打印九九乘法表
//第一个for控制行
for (int i = 1; i <= 9; i++) {
	//第二个for控制列，即每行中输出的算式
	for (int j = 1; j <= i; j++) {
		// 输出j*i=n格式,例如2*3=6
		System.out.print(j + "*" + i + "=" + i * j + " ");
	}
	// 换行
	System.out.println();
}
while循环

语法

while (条件表达式){
	循环体
}

流程图

while循环流程图

public class WhileDemo {
	public static void main(String[] args) {
		// 使用while循环求1~100的和
		int sum = 0;
		int i = 1;
		while (i <= 100) {
			sum += i;
			i++;
		}
		System.out.println("1~100的和是：" + sum);
	}
}
do-while循环

语法

do {
	循环体
} while (条件表达式);

流程图

do-while循环流程图

public static void main(String[] args) {
	// 使用do-while循环求1~100的和
	int sum = 0;
	int i = 1;
	do {
		sum += i;
		i++;
	} while (i <= 100);
	System.out.println("1~100的和是：" + sum);
}
2.5.3 转移语句

  • Java提供一些转移语句来控制分支和循环结构，使程序员更方便地控制程序执行的方向

  • 提供的转移语句有以下三种：

    • break语句
    • continue语句
    • return语句
break语句
  • break语句用于终止分支结构或循环结构，其主要用在以下3种情况：
    • 在switch语句中，用于终止case语句，跳出switch分支结构；
    • 在循环结构中，用于终止循环语句，跳出循环结构。
    • 与标签语句配合使用从内层循环或内层程序块中退出。
public class BreakDemo1 {
	public static void main(String[] args) {
		for (int i = 1; i <= 10; i++) {
			if (i == 5) {
				System.out.println("找到目标,结束循环！");
				// 终止循环
				break;
			}
			System.out.println(i);// 打印当前的i值
		}
	}
}

public static void main(String[] args) {
	// 外层循环，outer作为标识符
	outer: for (int i = 0; i < 5; i++) {
		// 内层循环
		for (int j = 0; j < 3; j++) {
			System.out.println("i的值为:" + i + "  j的值为:" + j);
			if (j == 1) {
				// 跳出outer标签所标识的循环。
				break outer;
			}
		}
	}
}
continue语句
  • continue的功能与break有点类似，区别是continue只是忽略本次循环体剩下的语句，接着进入到下一次循环，并不会终止循环；而break则是完全终止循环。
for (int i = 1; i <= 10; i++) {			
	if (i == 5) {
		System.out.println("找到目标,继续循环！");
		// 跳出本次循环，进入下一次循环
		continue;
	}
	// 打印当前的i值
    System.out.println(i);
}
return语句
  • return语句主要有以下两种使用格式：
    • 单独一个return关键字；
    • return关键字后面可以跟变量、常量或表达式，例如：return 0;
// 一个简单的for循环
for (int i = 0; i < 3; i++) {
	System.out.println("i的值是" + i);
	if (i == 5) {
		//返回，结束main方法
		return;
	}
	System.out.println("return后的输出语句");
}

2.6 数组

数组是编程语言中常见的一种数据结构。通常，数组用来存储一组大小固定并且类型相同的数据，这些数据可以通过索引进行访问。根据数组存放元素的组织结构，可将数组分为一维数组、二维数组以及多维数组（三维及以上）。

2.6.1 创建数组

语法：

数据类型[] 数组名;
数据类型 数组名[];

数组被创建后，其大小不能改变，但数组中的各个元素值是可以改变的；且访问数组中的元素时，下标索引不能越界，范围必须在0~length-1，否则容易引发数组越界异常。

// 声明一个整型数组a		
int[] a; 
// 给数组a分配存储空间：10*4个字节
a = new int[10]; 
// 定义一个长度为10的双精度浮点型数组
double[] b = new double[10]; 
// 定义一个长度为100的字符型数组c
char[] c = new char[100]; 
// 定义一个长度为20的布尔型数组
boolean[] d = new boolean[20]; 
//定义一个长度为5的字符串数组
String[] s=new String[5]; 
/* 下面输出各数组的数组名，注意输出的内容 */
// 输出数组地址
System.out.println(a);
System.out.println(b);
//输出字符数组中的内容
System.out.println(c);
//输出数组地址
System.out.println(d);
System.out.println(s);
System.out.println("*****************");

//输出各数组中第一个元素的值，注意输出的内容
System.out.println(a[0]);
System.out.println(b[0]);
System.out.println(c[0]);
System.out.println(d[0]);
System.out.println(s[0]);
System.out.println("*****************");

//输出各数组的长度
System.out.println("a.length=" + a.length);
System.out.println("b.length=" + b.length);
System.out.println("c.length=" + c.length);
System.out.println("d.length=" + d.length);
System.out.println("s.length=" + s.length);
  • 当数组使用new分配存储空间后，数组中的元素会具有默认初始值，其中：
    • 数值类型的数组初始值为0；
    • 布尔类型的为false；
    • 字符型的为‘\0’（字符串结束标识）；
    • 引用类型的则为null（空引用）。例如，字符串String就是引用类型。

数组在内存中的组织结构

数组在内存中的组织结构

2.6.2 初始化数组
  • 程序应用中数组元素的值经常是指定值，而非默认值，此时就需要将数组进行初始化。Java中数组的初始化方式有两种：静态初始化和动态初始化。
// 定义并初始化数组，使用静态初始化
int[] a = { 5, 7, 20 }; 
// 定义并初始化数组，使用动态初始化
int[] b = new int[4]; 
for (int i = 0; i < b.length; i++) {
	b[i] = i + 1;
}

// 循环输出a数组的元素
System.out.println("数组a中的元素是："); 
for (int i = 0, len = a.length; i < len; i++) {
	System.out.print(a[i] + " ");
}
System.out.println();

// 输出b数组的长度
System.out.println("b数组的长度为：" + b.length); 
System.out.println("数组b中的元素是：");
// 循环输出b数组的元素
for (int i = 0, len = b.length; i < len; i++) {
	System.out.print(b[i] + " ");
}
System.out.println();

// 因为a是int[]类型，b也是int[]类型，所以可以将a的值赋给b。
// 也就是让b引用指向a引用指向的数组
b = a;
// 再次输出b数组的长度
System.out.println("b数组的长度为：" + b.length);
2.6.3 for each遍历数组——增强for语句

语法

for(数据类型 变量名 : 数组名)

foreach语句的代码

for (int e : a) {
	System.out.println(e);
}

等价于：

for (int i = 0; i < a.length; i++) {
	System.out.println(a[i]);
}
2.6.4 复制数组

  • System.arraycopy方法提供了数组元素复制功能：

    //原数组
int[] source = {1,2,3,4,5,6};
//目的数组
int[] dest={10,9,8,7,6,5,4,3,2,1};
/*赋值原数组中从下标0开始的source.length个元素
到目的数组，从下标0的位置开始存储*/
System.arraycopy(source,0,dest,0,source.length);

    数组复制的常用方法：

    1. for循环，效率最低
    2. System.arraycopy() 效率最高
    3. Arrays.copyOf() 效率次于第二种方法
    4. Object.clone() 效率次于第二种和第三种
2.6.5 二维数组

语法

数据类型[][] 数组名;

内存中的二维数组

内存中的二维数组

// 二维数组静态初始化
int[][] a = { { 1, 2, 3 }, { 4, 5, 6 } };
System.out.println("数组a一维长度：" + a.length);
System.out.println("数组a二维长度：" + a[0].length);
System.out.println("数组a中的元素：");
for (int i = 0; i < a.length; i++) {// 使用嵌套的for循环输出
	for (int j = 0; j < a[i].length; j++) {
		System.out.print(a[i][j] + " ");
	}
	System.out.println();
}
System.out.println("-------------------------");

// 二维数组动态初始化，一维和二维都指定长度
int[][] c = new int[3][4]; 
// 使用嵌套的for循环初始化二维数组
for (int i = 0; i < c.length; i++) {
	for (int j = 0; j < c[i].length; j++) {
		c[i][j] = i + j;
	}
}
System.out.println("数组c中的元素：");
// 使用嵌套的for循环输出
for (int i = 0; i < c.length; i++) {
	for (int j = 0; j < c[i].length; j++) {
		System.out.print(c[i][j] + " ");
	}
	System.out.println();
}
System.out.println("-------------------------");
// 声明二维数组时，只给出一维长度
int[][] d = new int[2][]; 
// 二维长度不等
d[0] = new int[3];
d[1] = new int[4];
// 初始化
for (int i = 0; i < d.length; i++) {
	for (int j = 0; j < d[i].length; j++) {
		d[i][j] = i + j;
	}
}
}
System.out.println("数组d中的元素：");
// 使用嵌套的for循环输出
for (int i = 0; i < d.length; i++) {
	for (int j = 0; j < d[i].length; j++) {
		System.out.print(d[i][j] + " ");
	}
	System.out.println();
}

2.7 练习

案例分析

  • 用“埃氏筛法”求2～100以内的素数。2～100以内的数，先去掉2的倍数，再去掉3的倍数，再去掉5的倍数，……依此类推，最后剩下的就是素数。（要求使用数组及增强的for语句。）

  • 小分析：题目所要求的即是将不大于根号n(题目：100)的所有素数的倍数剔除，剩下的就是素数。

    • 定义一个数组a[99],放置2,3,4,5,…,100.

    • 数组中每个数都除2，能整除的除2之外的数组元素都赋0剩余的便是：

      2,3,5,7,…

    • 同样除3,5,7,…,11（11大于题目所给的n的根号）

    • 将数组中不为0的数输出

案例实现

public class Eratosthenes {
    public static void main(String[] args) {
        int[] list = new int[99];
        for (int i = 0; i < list.length; i++) {
            list[i] = i + 2;
        }
        for (int m = 1; check(list, m) * check(list, m) < list.length; m++) {
            for (int n = 0; n < list.length; n++) {
                if (check(list, m) != 0) {
                    if (list[n] % (check(list, m)) == 0 && list[n] != (check(list, m))) {
                        list[n] = 0;
                    }
                } else {
                    break;
                }
            }
        }
        show(list);
    }

    public static int check(int[] list, int m) {
        int n = 0;
        int c = 0;
        for (int i = 0; n < m; i++) {
            c++;/
            if ((list[i]) != 0) {
                n++;
            }
        }
        return list[c - 1];
    }

    public static void show(int[] list) {
        for (int value : list) {
            if (value != 0) {
                System.out.println(value);
            }
        }
    }
}

总结

  • Java中数据类型分为两类：基本数据类型和引用类型

  • 局部变量在使用之前必须进行初始化

  • 一元运算符有：++、–、~、！

  • 算术运算符有：+、-、*、/、%

  • 位运算符有：~、&、|、^、>>、>>>、<<

  • 关系运算符有：>、>=、<、<=、==、!=

  • 逻辑运算符有：!、&&、||

  • 三元运算符是“ ? : ”

  • Java中通常使用()来改变运算符的优先级

  • Java的分支语句有if-else，switch-case

  • Java的循环语句有for，while，do-while，foreach

  • Java的转移语句有break，continue，return

  • 数组用来存储一组相同数据类型的数据结构

  • 数组的下标索引是从0开始，其取值范围必须在0~数组的长度-1

  • Java中数组是静态结构，其大小不能改变

Tao_tao114
关注
专栏目录
运算符
LinkinPark的博客
05-10 2610
运算符是一种特殊的符号，用以表示数据的运算，赋值和比较等。 Java语言使用运算符将一个或多个操作数连缀成执行性语句，用以实现特定功能。 Java语言中的运算符可分为如下几种： 1），算术运算符 2），赋值运算符 3），比较运算符 4），逻辑运算符 5），位运算符 6），类型相关运算符。 算术运算符 Java支持所有的基本算术运算符，整理一下一共有7种。 1），加法运
尚硅谷java学习笔记Day 02
CongM_JueD的博客
12-17 305
java学习笔记Day 02 学习视频：尚硅谷java基础 看了很多别人做的，终究觉得差点意思，所以自己再记录一下，以便日后回顾，同时也算是监督自己学习的一个方式。 JDK、JRE、JVM三者之间的关系：前者包含后者。 JDK = JRE + Java的开发工具（javac.exe、java.exe 、javadoc.exe） JRE = JVM + Java核心类库 为什么配置Path：希望在任何路径下都能执行java； 如何配置：新建JAVA_HOME变量，存放对应jdk的路径，eg：D:\Progr
第三节
weixin_44223589的博客
06-10 92
引用类型变量中的值是指向内存“堆”中的指针，即该变量所表示数据的地址。 常用引用类型： 数组：具有相同数据类型的变量的集合； 类（class）：变量和方法的集合； 接口（interface）：一系列方法的声明，方法特征的集合； 枚举（enum）：一种独特的值类型，用于声明一组命名的常数。 类型转换：1：自动类型转换、强制类型转换。有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大的那种数据类型，然后再进行计算。 2：byte,short,char之间不会相互转换，他们三者在计算时首先转换为in
疯狂Java笔记:3.7 运算符
梦无涯的博客
03-02 495
算术运算符 赋值运算符 比较运算符 逻辑运算符 位运算符 类型相关运算符
strictfp 精确浮点数的计算
qq_39713775的博客
08-30 164
//在声明的范围内，所有浮点数的计算都是精确的，当类被strictfp修饰是，所有方法默认也被strictfp修饰 strictfp class MyClass { public static void main(String[] args) { float aFloat = 0.6710339f; double aDouble = 0.04150553411984792d; double sum...
Java 运算符
风中的劲草
06-27 414
哎，运算符忘记写了。先做个目录。一、算术运算符1、 加 ： + 2、减 ： - 3、乘 : * 4、取整： / 5、 取余 ： % (涉及到正负号的，以左边操作数为准) 7、递增 : ++ 8、递减 : – public static void main(String[] args) { int a = 5; int b,c,d,f,g,h;
JAVA学习笔记DAY3——菜鸟教程Java基础
weixin_47227105的博客
06-09 1168
菜鸟教程面向对象之前的部分都走马观花看了一遍。用于突击学习和复习。
Java学习笔记day02
最新发布
lovelyOvO的博客
07-23 1668
顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执。条件运算符是唯一的一个三元运算符，它有三个表达式操作数（不是典型的两个操作数），时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。，代码要执行具体的逻辑运算进行判断，逻辑运算的结果有两个，依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程。的情况下，反复执行某一段代码，这段被重复执行的代码被称为。先执行循环操作，再判断条件，至少会执行一次循环操作。的区别同理，双或时，左边为真，右边不参与运算。
java学习笔记（持续更新）
快乐学习，daydayup!
12-24 7740
如果您也在学习java，希望能够和您一起讨论，一起学习。这篇文章是记录笔者0基础学习java的过程，如果您阅读这篇文章时，发现一些错误，也希望您愿意指出。本次java学习流程以黑马程序员的java教学视频为主，其他博主或公开教程为辅。学习过程中遇到的一些个别情况或错误都会记录其中并记载解决方案。本篇学习记录会一直更新，希望能与大家一起学习，共同成长。
day3 java 学习笔记
01-13
day3 java 笔记
黑马程序员java培训就业班笔记：day10总结JAVA语言
03-26
黑马程序员java培训就业班笔记：day10总结
java学习笔记markdown
12-22
Java学习笔记Markdown版包含了多个章节，涵盖了Java编程的多个核心概念。这些笔记是学习Java时进行知识总结的理想资源，尤其适合初学者或正在巩固基础知识的开发者。以下是对这些笔记内容的详细解读： 1. **继承** ...
Java学习笔记Day06 工具类及常用算法
Taotao114的博客
05-29 2138
第六章 工具类及常用算法 文章目录第六章 工具类及常用算法Java语言基础类Java基础类库Object类概述toString方法方法摘要覆盖重写equals方法方法摘要默认地址比较对象内容比较Objects类Math类概述基本运算的方法日期时间类Date类概述常用方法DateFormat类构造方法格式规则常用方法format方法parse方法Calendar类概念获取方式常用方法get/set方法add方法getTime方法新版日期APISystem类currentTimeMillis方法arraycop
Java学习笔记Day03 面向对象基础
Taotao114的博客
03-09 1916
第三章 面向对象基础 文章目录第三章 面向对象基础本章重点学习路线本章目标3.1 面向对象思想3.1.1 面向对象简介对象类类与对象之间的关系类的关系3.1.3 面向对象特征3.2 类与对象3.2.1 类的声明类字段和方法(成员变量和成员方法)3.2.2 对象的创建和使用创建对象使用对象访问类中的成员对象存储图成员变量和局部变量的区别封装（补充）封装概述封装的步骤封装的操作 --private关键...
Java学习笔记Day07 流与正则表达式
Taotao114的博客
05-29 1604
第七章 流与正则表达式 文章目录第七章 流与正则表达式IO概述什么是IOIO的分类IO的流向说明图解顶级父类们字节流一切皆为字节字节输出流OutputStreamFileOutputStream类构造方法写出字节数据数据追加续写写出换行字节输入流【InputStream】FileInputStream类构造方法读取字节数据字符流字符输入流【Reader】FileReader类构造方法读取字符数据字符输出流【Writer】FileWriter类构造方法基本写出数据关闭和刷新写出其他数据IO异常的处理JDK7前
Java学习笔记Day01 Java概述
Taotao114的博客
03-02 794
第一章 Java概述 文章目录第一章 Java概述本章重点学习路线本章目标1.1.1 Java起源以及发展历程1.1.2 Java语言简介1.2.1 Java语言优势1.2.2 Java应用平台1.2.3 专有名词JVM、JRE、JDK关系1.2.4 Java跨平台原理一次编译随处运行流程Java字节码执行方式1.2.5 垃圾回收机制1.3.1 JDK安装配置1.3.2 JDK目录1.3.3 JD...
Java学习笔记Day05 异常处理
Taotao114的博客
05-29 223
第五章 异常处理 5.1 异常 异常概念 异常 ：指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止。 在Java等面向对象的编程语言中，异常本身是一个类，产生异常就是创建异常对象并抛出了一个异常对象。Java处理异常的方式是中断处理。 异常指的并不是语法错误,语法错了,编译不通过,不会产生字节码文件,根本不能运行. 异常体系 异常机制其实是帮助我们找到程序中的问题，异常的根类是java.lang.Throwable，其下有两个子类：java.lang.Error与java.lan
Java日志分析：Javaday02训练重点与下午笔记
资源摘要信息:"Javaday02训练课程是一门针对Java初学者或有一定基础但需要进一步提升的学员的培训课程。该课程的目的是通过一系列系统的训练和实际操作练习，加深学员对Java编程语言的理解，提升编程技能。Javaday02...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值