一.变量运算符
今日内容介绍
变量
运算符
第1章 变量
1.1 变量概述
前面我们已经学习了常量,接下来我们要学习变量。在Java中变量的应用比常量的应用要多很多。所以变量也是尤为重要的知识点!
什么是变量?变量是一个内存中的小盒子(小容器),容器是什么?生活中也有很多容器,例如水杯是容器,用来装载水;你家里的大衣柜是容器,用来装载衣裤;饭盒是容器,用来装载饭菜。那么变量是装载什么的呢?答案是数据!结论:变量是内存中装载数据的小盒子,你只能用它来存数据和取数据。
1.2 计算机存储单元
变量是内存中的小容器,用来存储数据。那么计算机内存是怎么存储数据的呢?无论是内存还是硬盘,计算机存储设备的最小信息单元叫“位(bit)”,我们又称之为“比特位”,通常用小写的字母b表示。而计算机最小的存储单元叫“字节(byte)”,通常用大写字母B表示,字节是由连续的8个位组成。
当程序需要使用存储空间时,操作系统最小会分派给程序1个字节,而不是1个位。你可能会说,如果程序只需要1个位的空间,系统分派不能只分派1个位吗?答案是不能!这就像你只需要1支烟,你到商店去买烟,商店分派的最小单元是1盒(20支),他不可能卖给你1支烟。
你可能会想,1个字节(8位)可以存储很大的数值了,1位最大是9那么8位最大值为99999999。你错了,因为计算机是采用二进行存储的,而不是我们生活中常用的十进制。所以1个字节存储的最大数据是11111111的二进制数。
除了字节外还有一些常用的存储单位,大家可能比较熟悉,我们一起来看看:
1B(字节) = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1PB = 1024TB
1.3 基本类型之4类8种
大衣柜不能用来装载水,水杯也不能用来装载衣裤。这说明不同的容器装载不同的物品。变量也是如此,在创建变量时需要指定变量的数据类型,例如整型变量、浮点型变量等等。结论:变量必须要有明确的类型,什么类型的变量装载什么类型的数据。
水杯是用来装水的,那么水杯能装多少水呢?一吨?我们知道水杯在创建时不只确定了要装载的是水(数据类型),而且还确定了能装多少水(数据类型的具体种类)。变量也是如此,需要指定变量能装载什么类型的数据,同时也要指定变量能装载多大的数据。
Java中基本类型一共4类,把这4类展开后共8种基本类型。我们今后编写程序时使用的是这8种基本类型而不是4类,这8种基本类型指定了范围。
四类 | 八种 | 字节数 | 数据表示范围 |
---|---|---|---|
整型 | byte | 1 | -128~127 |
short | 2 | -32768~32767 | |
int | 4 | -2147483648~2147483648 | |
long | 8 | -263~263-1 | |
浮点型 | float | 4 | -3.403E38~3.403E38 |
double | 8 | -1.798E308~1.798E308 | |
字符型 | char | 2 | 表示一个字符,如(‘a’,‘A’,‘0’,‘家’) |
布尔型 | boolean | 1 | 只有两个值true与false |
1.4 常量与类型
前面我们说过100是整数常量,但它是byte、short、int、long中的哪一种呢?下面我们来聊聊这一常量类型的问题。
整数常量可以根据所在范围来确定类型,例如100在-128~~~127之间,所以他是byte类型;500在-32768------32767之间,所以它是short类型;100000在-2147483648~2147483648之间,所以它是int类型。java中默认的整数类型是int类型
你可能会认为12345678901在-263----263-1之间,所以它是long类型。注意了,这是错误的!!!在Java中整数常量如果不在-2147483648-----2147483648之间就必须添加“L”后缀(小写的也可以,但建议使用大写),在-2147483648-----2147483648之间的也可以添加“L”后缀。也就是说12345678901不在-2147483648------2147483648之间,所以它在Java中是错误的常量,你必须这样写:12345678901L,这才是正确的常量。所以添加了“L”后缀的整数常量都是long类型的,例如:100L、12345678901L都是long类型的常量。
浮点类型的常量也可使用后缀,在Java中所有没有后缀以及使用“D”后缀(小写也可以,但建议使用大写)的小数都是double类型;float类型常量必须添加“F”后缀(小写也可以,但建议使用大写)java中默认的浮点类型是double类型
3.14没有后缀,所以它是double类型;
5.28D为double类型;
1.26F为float类型。
1.5 定义变量(创建变量)
定义变量的语法格式:
数据类型 变量名 = 数据值;
int a = 100;
其中int是数据类型,指定了变量只能存储整数,而且指定了存储范围为-2147483648~2147483648。
其中a表示变量名,变量名是标识符,这说明只要是合法的标识符都可以用来做变量名。在程序中可以通过变量名来操作变量(内存中的小盒子)。
其中“=100”是给变量赋值,即向a变量中写入100(变量是个小盒子,现在小盒子中保存的是100)。注意,给变量赋的值一定要与类型符合,也就是说int类型只能存储整数,而且必须是在-2147483648~2147483648范围内的整数。100满足了这两个条件,所以是正确的。
练习:
Variabe.java
/*
变量定义格式:
数据类型 变量名 = 变量值;
*/
public class Variable {
public static void main(String[] args) {
int a = 10;
double b = 3.14;
char c = 'z';
String s = "i love java";
a = 20;
System.out.println(a);
}
}
123456789101112131415
1.6 变量使用的注意事项
我们使用变量的时候需要注意,要满足变量的使用规则才可以使用的,我们来看看都有哪些注意事项。
变量使用的注意事项
变量定义后可以不赋值,使用时再赋值。不赋值不能使用。
public static void main(String[] args) {
int x;
x = 20; //为x赋值20
System.out.println(x);//读取x变量中的值,再打印
}
12345
变量使用时有作用域的限制。
public static void main(String[] args) {
int x = 20;
{
int y = 20;
}
System.out.println(x);//读取x变量中的值,再打印
System.out.println(y);//读取y变量中的值失败,失败原因,找不到y变量,因为超出了y变量作用范围,所以不能使用y变量
}
变量不可以重复定义。
public static void main(String[] args){
int x = 10;
double x = 5.5;//编译失败,变量重复定义
}
1.7 数据类型转换
不同类型的变量是否可以在一起运算呢?答案是可以的,但要先进行类型转换再运算。下面我们来学习一下类型转换。
其实,我们所学习的数据,它的表示方式是可以灵活多变的,比如把小数转换成整数的操作
转换的过程中,数据遵循一个原则:
范围小的数据类型值(如byte),可以直接转换为范围大的数据类型值(如int);
范围大的数据类型值(如int),不可以直接转换为范围小的数据类型值(如byte)
那么,大家还记得每种类型表示数据的范围吗?忘记了不要紧,我来告诉大家,将各种数据类型按照数据范围从小到大依次列出:
byte < short < int < long < float < double
关于数据类型转换有两种方式,我们来学习一下:
自动类型转换
表示范围小的数据类型转换成范围大的数据类型,这种方式称为自动类型转换
自动类型转换格式:
范围大的数据类型 变量 = 范围小的数据类型值;
如:
double d = 1000;
或
int i = 100;
double d2 = i;
强制类型转换
表示范围大的数据类型转换成范围小的数据类型,这种方式称为强制类型转换
强制类型转换格式:
范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型值;
如:
int i = (int)6.718; //i的值为6
或
double d = 3.14;
int i2 = (int)d; //i2的值为3
第2章 运算符
2.1 算术运算符
运算符是用来计算数据的符号。数据可以是常量,也可以是变量。被运算符操作的数我们称为操作数。
算术运算符最常见的操作就是将操作数参与数学计算,具体使用看下图:
运算符 | 运算规则 | 范例 | 结果 |
---|---|---|---|
+ | 正号 | +3 | 3 |
+ | 加 | 2+3 | 5 |
+ | 连接字符串 | “中”+“国” | “中国” |
- | 负号 | int a=3;-a | -3 |
- | 减 | 3-1 | 2 |
* | 乘 | 2*3 | 6 |
/ | 除 | 5/2 | 2 |
% | 取模 | 5/2 | 1 |
++ | 自增 | int a=1;a++/++a | 2 |
– | 自减 | int b=3;a–/–a | 2 |
我们在使用算术运算符时,记得要注意下列事项:
取余(取模)有个规律就是:左边小于右边,结果为左边,左边大于右边,看余数
加法运算符在连接字符串时要注意,只有直接与字符串相加才会转成字符串。
除法“/”当两边为整数时,取整数部分,舍余数。当其中一边为浮点型时,按正常规则相除。
“%”为整除取余符号,小数取余没有意义。结果符号与被取余符号相同。
整数做被除数,0不能做除数,否则报错。
代码演示
/*
* 算术运算符
*/
public class OperatorDemo1 {
public static void main(String[] args) {
/*
* 常量使用算数运算符
*/
System.out.println(10+20);
/*
* 变量使用算数运算符
*/
int x = 10;
int y = 20;
//"+"作为加法运算使用
int z = x + y;
//"+"作为连接字符串使用
System.out.println("x="+x);
System.out.println("y="+y);
System.out.println("z="+z);
}
}
运行结果如下图所示。
图1-1 运行结果
2.2 算数运算符++、–的使用
算数运算符在前面我们已经学习过了,这里进行一些补充。
在一般情况下,算数运算符不会改变参与计算的变量值。而是在原有变量值不变的情况下,计算出新的值。但是有些操作符会改变参与计算的变量的值,比如++,–。
我们来看一段代码:
int a = 3;
int b = 3;
a++;
b--;
System.out.println(a);
System.out.println(b);
上面代码的输出结果a值为4,b值为2;
这说明a的原有值发生了改变,在原有值的基础上自增1;b的原有值也发生了改变,在原有值的基础上自减1;
++运算符,会在原有值的基础上自增1;
--运算符,会在原有值的基础上自减1。
我们再看一段代码:
int a = 3;
int b = 3;
++a;
--b;
System.out.println(a);
System.out.println(b);
上面代码的输出结果a值为4,b值为2;
这说明++,–运算符单独使用,不参与运算操作时,运算符前后位置导致的运算结果是一致的。
接下来,介绍下++,–运算符参与运算操作时,发生了怎样的变化,我们来看一段代码:
int a = 3;
int b;
b = a++ + 10;
System.out.println(a);
System.out.println(b);
上面代码的输出结果a值为4,b值为13;
这里我要强调一下了,当++,–运算符参与运算操作时,后置++,–的作用:
++,- -运算符后置时,先使用变量a原有值参与运算操作,运算操作完成后,变量a的值自增1或者自减1;
再介绍下++,–运算符前置时,参与运算操作的变化,我们来看一段代码:
int a = 3;
int b;
b = ++a + 10;
System.out.println(a);
System.out.println(b);
上面代码的输出结果a值为4,b值为14;
这里我强调一下,当++,–运算符参与运算操作时,前置++,–的作用:
++,- -运算符前置时,先将变量a的值自增1或者自减1,然后使用更新后的新值参与运算操作。
2.3 赋值运算符
我们来学习一下赋值运算符,赋值运算符就是为变量赋值的符号,赋值运算符的使用看下图:
运算符 | 运算规则 | 范例 | 结果 |
---|---|---|---|
= | 赋值 | int a=2 | 2 |
+= | 加后赋值 | int a=2,a+=2 | 4 |
-= | 减后赋值 | int a=2,a-=2 | 0 |
*= | 乘后赋值 | int a=2,a*=2 | 4 |
/= | 整除后赋值 | int a=2,a/=2 | 1 |
%= | 取模后赋值 | int a=2,a%=2 | 0 |
注意:诸如+=这样形式的赋值运算符,会将结果自动强转成等号左边的数据类型。
写一个代码,我们看一下赋值运算符的使用
/*
* 赋值运算符
* +=, -=, *=, /=, %= :
* 上面的运算符作用:将等号左右两边计算,会将结果自动强转成等号左边的数据类型,再赋值给等号左边的
* 注意:赋值运算符左边必须是变量
*/
public class OperatorDemo2 {
public static void main(String[] args) {
byte x = 10;
x += 20;// 相当于 x = (byte)(x+20);
System.out.println(x);
}
}
12345678910111213
运行结果如下图所示。
图1-2 运行结果
2.4 比较运算符
比较运算符,又叫关系运算符,它是用来判断两个操作数的大小关系及是否相等关系的,结果是布尔值true或者false。
运算符 | 运算规则 | 范例 | 结果 |
---|---|---|---|
== | 相等于 | 4==3 | False |
!= | 不等于 | 4!=3 | True |
< | 小于 | 4<3 | False |
> | 大于 | 4>3 | True |
<= | 小于等于 | 4<=3 | False |
>= | 大于等于 | 4>=3 | True |
这里需要注意一下:
赋值运算符的 = 符号与比较运算符的 == 符号是有区别的,如下:
赋值运算符的 = 符号,是用来将 = 符号右边的值,赋值给 = 符号左边的变量;
比较运算符的 == 符号,是用来判断 == 符号 左右变量的值是否相等的。
我们通过下面的一段代码,我们演示一下这个注意事项:
int a = 3;
int b = 4;
System.out.println( a=b );
System.out.println( a==b );
1234
上面代码输出的结果第一个值为4,第二个值为false。
1
2.5 逻辑运算符
逻辑运算符,它是用于布尔值进行运算的,运算的最终结果为布尔值true或false。
运算符 | 运算规则 | 范例 | 结果 |
---|---|---|---|
& | 与 | false&true | False有错就错 |
| | 或 | false/true | True有对就对 |
^ | 异或 | true^flase | True |
! | 非 | !true | Flase |
&& | 短路与 | false&&true | False |
|| | 短路或 | false//true | True |
2.6 三元运算符
接下来我们要学习的三元运算符与之前的运算符不同。之前学习的均为一元或者二元运算符。元即参与运算的数据。
格式:
(条件表达式)?表达式1:表达式2;
表达式:通俗的说,即通过使用运算符将操作数联系起来的式子,例如:
3+2,使用算数运算符将操作数联系起来,这种情况,我们称为算数表达式。
3>2,使用比较运算符(也称为条件运算符)将操作数联系起来,这种情况,我们称为条件表达式。
其他表达式,不再一一举例。
三元运算符运算规则:
先判断条件表达式的值,若为true,运算结果为表达式1;若为false,运算结果为表达式2。
通过代码演示,我们来学习下三元运算符的使用:
1
//方式一:
System.out.println( 3>2 ? “正确” : “错误” );
// 三元运算符运算后的结果为true,运算结果为表达式1的值“正确”,然后将结果“正确”,在控制台输出打印
//方式二:
int a = 3;
int b = 4;
String result = (a==b) ? “相等” : “不相等”;
//三元运算符运算后的结果为false,运算结果为表达式2的值“不相等”,然后将结果赋值给了变量result
//方式三:
int n = (3>2 && 4>6) ? 100 : 200;
//三元运算符运算后的结果为false,运算结果为表达式2的值200,然后将结果200赋值给了变量n
12345678910111213
2.7 运算符优先级
在学习运算符的过程中,我们发现,当多个运算符一起使用的时候,容易出现不清晰先后运算顺序的问题,那么,在这里,我们来学习下,运算符之间的运算优先级。
下图是每种运算符的优先级,按照运算先后顺序排序(优先级相同的情况下,按照从左到右的顺序依次运算)
优先级顺序看完了,我们来通过代码,加强一下:
int n = 3>4 ? 100 : 200;
这行的代码运算执行顺序我们来写一下:
1.执行 3>4操作,得到布尔类型false的结果
2.通过结果false,将对应的表达式2的结果200,作为运算的最终结果
3.把200 赋值给变量n
接下来,我们看一个比较复杂的代码:
int a = 5;
int b = 3;
int c = 1;
int n2 = (a>b && b>c) ? (c++) : (++c);
1234
这段代码运算执行顺序我们也写一下:
1
1.小括号优先级高,我们先运算第一组小括号中的代码
1.1. 比较运算符”>” 优先级大于 逻辑运算符”&&”
先执行 a>b,得到结果true;
再执行 b>c,得到结果true;
最后执行 a>b的结果 && b>c的结果,即 true && true, 结果为true
2.三元运算符中的条件判断结果为true,返回表达式1的结果 c++
先将变量c的原有值赋值给变量n2,即n2值为1;
再将变量c的值自增1,更新为2。
运算符我们学到这里就结束了,稍后在“趣味乐园”中,我们可以运用运算符进行练习。
第3章 商场库存清单案例
3.1 案例介绍
现在我们来做一个复杂点的案例——商场库存清单案例,这个案例最终会在控制台输出如下结果:
3.2 案例需求分析
观察清单后,可将清单分解为三个部分(清单顶部、清单中部、清单底部)
1.清单顶部为固定的数据,直接打印即可
2.清单中部为商品,为变化的数据,需要记录商品信息后,打印
经过观察,我们确定一项商品应该有如下几个属性:
品牌型号: 即商品名称,String型
尺寸:物品大小,double型
价格:物品单价,double型
配置:这一项为每种商品的配置信息,String型
库存数:这一项为每种商品的库存个数,int型
3.清单底部包含了统计操作,需经过计算后,打印
我们发现两个单独的可变化量
总库存数:所有商品总个数,int型
库存商品总金额:所有商品金额,double型
3.3 实现代码步骤
一起分析完毕了,我们开始完成案例代码的编写:
创建Demo01库存清单.java文件,编写main主方法
public class Demo01库存清单 {
public static void main(String[] args) {
}
}
记录每种库存商品信息
//苹果笔记本电脑
String macBrand = "MacBookAir";
double macSize = 13.3;
double macPrice = 6988.88;
int macCount = 5;
//联想Thinkpad笔记本电脑
String thinkpadBrand = "ThinkpadT450";
double thinkpadSize = 14.0;
double thinkpadPrice = 5999.99;
int thinkpadCount = 10;
//华硕ASUS笔记本电脑
String ASUSBrand = "ASUS-FL5800";
double ASUSSize = 15.6;
double ASUSPrice = 4999.50;
int ASUSCount = 18;
```
统计所有库存商品数量与金额
//统计库存总个数、库存总金额
int totalCount = macCount + thinkpadCount + ASUSCount;
double totalMoney = (macCount * macPrice) + (thinkpadCount * thinkpadPrice) + (ASUSCount * ASUSPrice);
// 打印库存清单顶部信息
//列表顶部
System.out.println("------------------------------商城库存清单-----------------------------");
System.out.println("品牌型号 尺寸 价格 库存数");
// 打印库存清单中部信息
//列表中部
System.out.println(macBrand+" "+macSize+" "+macPrice+" "+macCount);
System.out.println(thinkpadBrand+" "+thinkpadSize+" "+thinkpadPrice+" "+thinkpadCount);
System.out.println(ASUSBrand+" "+ASUSSize+" "+ASUSPrice+" "ASUSCount);
// 打印库存清单底部信息
//列表底部
System.out.println("-----------------------------------------------------------------------");
System.out.println("总库存数:"+totalCount);
System.out.println("库存商品总金额:"+totalMoney);
第4章 总结
注释
Java的三种注释写法
// 单行
// 多行
/*/ 文档注释
关键字
定义
被Java定义好的,赋予特殊含义单词
全部采用小写字母
class public static void true false
标识符
自定义的内容,类名,方法名,变量名
包含字母大小写,数字,下划线和美元符,不能数字开头
不允许是关键字
数据类型和常量
基本数据类型
整数 0 1 2
浮点 0.1 1.0 2.2
布尔 true false
字符 ‘a’
字符串常量 “” 任意长度
数据类型转换
数据类型范围从小到大排序(byte < char < short < int < long < float < double),布尔类型Boolean不能参与类型转换;
自动类型转换,范围小的数据类型向范围大的数据类型转换时使用;
强制类型转换,范围大的数据类型向范围小的数据类型转换时使用。
算数运算符
用来完成算数运算(如加减乘除计算等)
++,–运算符的使用
++,–前置(如++a),当参与运算时,变量a的值先自增1,然后用自增后的新值再参与运算;
++,–后置(如a++),当参与运算时,变量a先使用原有值参与运算符,变量a的值再自增1。
赋值运算符
用来完成数据的赋值(如 int a = 100;)
+=,-,*=,/=这样的赋值运算符包含了一个强制转换的操作,会将左右两边运算后的结果,强制类型转换后赋值给左边
int n = 10;
byte by = 20;
by += n; // 运算完毕后,by的值为byte类型30, 相当于代码 by = (byte)(by + n);
比较运算符
用来比较数据的大小(如 3>4),比较运算符也称为条件运算符。
比较后的结果为布尔类型Boolean的值
“==”两个等号代表比较是否相等,“=”一个等号代表赋值。
逻辑运算符
逻辑与& 和逻辑短路与&&:代表着并且的意思,左右两边都要条件成立,结果才为true;
逻辑或| 和逻辑短路或||:代表着或者的意思,左边两边有一个条件成立,结果就为true;
逻辑非!:代表着相反的意思,原先是false,结果就为true;原先是ture,结果就为false;
逻辑异或^: 左右两边条件结果相同,结果就为false,左右两边条件结果不同,结果就为true;
三元运算符
根据判断条件运算结果,执行不同的表达式值;条件为true,执行表达式1,否则,执行表达式2。
二. 分支结构和循环
1.选择结构switch
switch 条件语句也是一种很常用的选择语句,它和if条件语句不同,它只能针对某个表达式的值作出判断,从而决定程序执行哪一段代码。例如,在程序中使用数字1~7来表示星期一到星期天,如果想根据某个输入的数字来输出对应中文格式的星期值,可以通过下面的一段伪代码来描述:
用于表示星期的数字
如果等于1,则输出星期一
如果等于2,则输出星期二
如果等于3,则输出星期三
如果等于4,则输出星期四
如果等于5,则输出星期五
如果等于6,则输出星期六
如果等于7,则输出星期天
对于上面一段伪代码的描述,大家可能会立刻想到用刚学过得if…else if…else语句来实现,但是由于判断条件比较多,实现起来代码过长,不便于阅读。Java中提供了一种switch语句来实现这种需求,在switch语句中使用switch关键字来描述一个表达式,使用case关键字来描述和表达式结果比较的目标值,当表达式的值和某个目标值匹配时,会执行对应case下的语句。具体实现代码如下:
switch(用于表示星期的数字) {
case 1 :
输出星期一;
break;
case 2 :
输出星期二;
break;
case 3 :
输出星期三
break;
case 4 :
输出星期四;
break;
case 5 :
输出星期五;
break;
case 6:
输出星期六;
break;
case 7:
输出星期天;
break;
}
上面改写后的伪代码便描述了switch语句的基本语法格式,具体如下:
switch (表达式){
case 目标值1:
执行语句1
break;
case 目标值2:
执行语句2
break;
......
case 目标值n:
执行语句n
break;
default:
执行语句n+1
break;
}
在上面的格式中,switch语句将表达式的值与每个case中的目标值进行匹配,如果找到了匹配的值,会执行对应case后的语句,如果没找到任何匹配的值,就会执行default后的语句。switch语句中的break关键字将在后面的做具体介绍,此处,我们只需要知道break的作用是跳出switch语句即可。
需要注意的是,在switch语句中的表达式只能是byte、short、char、int类型的值,如果传入其它类型的值,程序会报错。但上述说法并不严谨,实际上在JDK5.0中引入的新特性enum枚举也可以作为switch语句表达式的值,在JDK7.0中也引入了新特性,switch语句可以接收一个String类型的值。
1.1 选择结构switch练习
接下来通过一个案例演示根据数字来输出中文格式的星期,如下所示。SwitchDemo01.java
public class SwitchDemo01 {
public static void main(String[] args) {
int week = 5;
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;
}
}
}
运行结果如图所示。
图1-1 运行结果
上述代码中,由于变量week的值为5,整个switch语句判断的结果满足第17行的条件,因此打印“星期五”,例程中的default语句用于处理和前面的case都不匹配的值,将第3行代码替换为int week = 8,再次运行程序,输出结果如下图所示。
图1-2 运行结果
在使用switch语句的过程中,如果多个case条件后面的执行语句是一样的,则该执行语句只需书写一次即可,这是一种简写的方式。例如,要判断一周中的某一天是否为工作日,同样使用数字1~7来表示星期一到星期天,当输入的数字为1、2、3、4、5时就视为工作日,否则就视为休息日。接下来通过一个案例来实现上面描述的情况,如下所示。SwitchDemo02.java
public class SwitchDemo02 {
public static void main(String[] args) {
int week = 2;
switch (week) {
case 1:
case 2:
case 3:
case 4:
case 5:
// 当 week 满足值 1、2、3、4、5 中任意一个时,处理方式相同
System.out.println("今天是工作日");
break;
case 6:
case 7:
// 当 week 满足值 6、7 中任意一个时,处理方式相同
System.out.println("今天是休息日");
break;
}
}
}
运行结果如下图所示。
图1-3 运行结果
上述代码中,当变量week值为1、2、3、4、5中任意一个值时,处理方式相同,都会打印“今天是工作日”。同理,当变量week值为6、7中任意一个值时,打印“今天是休息日”。
2.for循环语句
循环结构的组成:
**初始化语句:**用于表示循环开启时的起始状态,简单说就是循环开始的时候什么样条件
**条件控制语句:**用于表示循环执行中每次变化的内容,简单说就是控制循环是否能执行下去.
**循环体语句:**用于表示循环反复执行的内容简单说就是循环反复执行的事情.
**条件控制语句:**用于表示循环执行中每次变化的内容,简单说就是控制循环是否能执行下去.
循环结构对应的语法:
**初始化语句:**这里可以是一条或者多条语句,这些语句可以完成一些初始化操作
条件判断语句:这里使用一个结果值为boolean类型的表达式,这个表达式能决定是否执行循环体。例: a<3
**循环体语句:**这里可以是任意语句,这些语句将反复执行
**条件控制语句:**这里通常是使用一条语句来改变变量的值,从而达到控制循环是否继续向下执行的效果。常见i++,i–这样的操作
执行流程:
2.1.for循环语句格式
格式:
for(初始语句;条件判断语句;条件控制语句){
循环体语句;
}
========================================================
public class Demo03 {
public static void main(String[] args) {
for(int i=1;i<=5;i++){
System.out.println("hellowrod");
}
}
}
/*
输出结果
hellowrod
hellowrod
hellowrod
hellowrod
hellowrod
*/
=========================================================
public class Demo03 {
public static void main(String[] args) {
for(int i=5;i>=1;i--){
System.out.println(i);
}
}
}
/*
5
4
3
2
1
*/
求和案例
public class Demo03 {
public static void main(String[] args) {
int sum =0 ;
for(int i=1;i<=5;i++){
sum +=i;
/*
sum+=i; sum=sum+i;
*/
}
System.out.println("1-5之间的数据和是:"+sum);
}
}
/*输出结果:
1-5之间的数据和是:15
*/
案例:求偶数和
public class Demo03 {
public static void main(String[] args) {
int ousum =0 ;
for(int i=1;i<=100;i++){
if (i%2==0){
ousum+=i;
}
}
System.out.println("1-100之间的偶数数据和是:"+ousum);
}
}
/*
输出结果:
1-100之间的偶数数据和是:2550
*/
水仙花案例
public class Demo03 {
public static void main(String[] args) {
for(int i=100;i<=999;i++){
int g = i%10;
int s = i/10%10;
int b= i/10/10%10;
if (g*g*g+s*s*s+b*b*b==i){
System.out.println("水仙花数是:"+i);
}
}
}
}
/*
输出结果
水仙花数是:153
水仙花数是:370
水仙花数是:371
水仙花数是:407
*/
案例:统计水仙花数量
public class Demo03 {
public static void main(String[] args) {
int count=0;
for(int i=100;i<=999;i++){
int g = i%10;
int s = i/10%10;
int b= i/10/10%10;
if (g*g*g+s*s*s+b*b*b==i){
count++;
}
}
System.out.println("水仙花数数量共有:"+count);
}
}
/*
输出结果
水仙花数数量共有:4
*/
3.while循环语句
//基本格式
初始化语句;
while(条件判断语句){
循环体语句;
条件控制语句;
}
=====================================================
public static void main(String[] args) {
int j=1;
while (j<=5){
System.out.println("helloword!");
j++;
}
}
}
public static void main(String[] args) {
int count = 0;
double j=0.1f;
while (j<=8844430){
j = j*2;
count++;
}
System.out.println("纸张要折叠次数:"+count);
}
}
/*
输出结果
纸张要折叠次数:27
*/
执行流程:
4.do…while循环语句
//格式
初始化语句;
do{
循环体语句;
条件控制语句;
}while(条件判断语句);
====================================
public class Demo04 {
public static void main(String[] args) {
int j =1;
do {
System.out.println("hellowrod");
j++;
}while (j<=5);
}
}
/*
输出结果
hellowrod
hellowrod
hellowrod
hellowrod
hellowrod*/
执行流程:
5.三种循环的区别
循环说明 | while | do while | for |
---|---|---|---|
结构 | while(条件【true或false】){ 循环体;} | do{ 循环体;}while(条件【true或false】); | for(循环次数【数组的length或集合的size】){ if(条件【true或false】){ 循环体; }} |
特点 | 先判断后执行 | 先执行后判断,至少会执行一次 | 先判断后执行 |
作用 | 不确定循环次数 | 不确定循环次数 | 循环次数确 |
6.转跳控制语句
- continue 用在循环中,基于条件控制,跳过某次循环体内容的执行,继续下一次的执行.
- break 用在循环中,基于条件控制,终止循环体内容的执行,也就是说结束当前的整个循环.
public class Demo04 {
public static void main(String[] args) {
for (int i =1;i<=5; i++){
if ( i%2==0){
continue;
//break;
}
System.out.println(i);
}
}
}
7.循环嵌套
public class Demo06 {
public static void main(String[] args) {
for (int minute = 0; minute < 4; minute++) {
System.out.println("0时" + minute + "分");
}
System.out.println("=========================");
for (int minute = 0; minute < 4; minute++) {
System.out.println("1时" + minute + "分");
}
System.out.println("=========================");
for (int minute = 0; minute < 4; minute++) {
System.out.println("2时" + minute + "分");
}
}
}
/*
输出结果
0时0分
0时1分
0时2分
0时3分
========
1时0分
1时1分
1时2分
1时3分
========
2时0分
2时1分
2时2分
2时3分
*/
//============改进循环====================================
public class Demo06 {
public static void main(String[] args) {
for (int hour = 0; hour < 3; hour++) {
for (int minute = 0; minute < 4; minute++) {
System.out.println(hour + "时" + minute + "分");
}
System.out.println("=======");
}
}
}
/*
输出结果
0时0分
0时1分
0时2分
0时3分
=======
1时0分
1时1分
1时2分
1时3分
=======
2时0分
2时1分
2时2分
2时3分
=======
*/
8 无限循环
最简单无限循环格式:
while(true){
}
或
for(;;){
}
无限循环存在的原因是并不知道循环多少次,而是根据某些条件,来控制循环。
9 跳转语句(break、continue)
跳转语句用于实现循环执行过程中程序流程的跳转,在Java中的跳转语句有break语句和continue语句。接下来分别进行详细地讲解。
1、 break语句
在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时,作用是终止某个case并跳出switch结构。当它出现在循环语句中,作用是跳出循环语句,执行后面的代码。关于在switch语句中使用break前面的例程已经用过了,接下来通过下面一段代码,实现将当变量x的值为3时,使用break语句跳出循环,代码如下所示。BreakDemo.java
public class BreakDemo {
public static void main(String[] args) {
int x = 1; // 定义变量x,初始值为1
while (x <= 4) {
// 循环条件
System.out.println("x = " + x); // 条件成立,打印x的值
if (x == 3) {
break;
}
x++; // x进行自增
}
}
}
运行结果如下图所示。
图1-15 运行结果
在上述带代码中,通过while循环打印x的值,当x的值为3时使用break语句跳出循环。因此打印结果中并没有出现“x=4”。
3、 continue语句
continue语句用在循环语句中,它的作用是终止本次循环,执行下一次循环。接下来通过一个练习对1~100之内的奇数求和,ContinueDemo.java
public class ContinueDemo {
public static void main(String[] args) {
int sum = 0; // 定义变量sum,用于记住和
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) { // i是一个偶数,不累加
continue; // 结束本次循环
}
sum += i; // 实现sum和i的累加
}
System.out.println("sum = " + sum);
}
}
运行结果如下图所示。
上述代码中,使用for循环让变量i的值在1----100之间循环,在循环过程中,当i的值为偶数时,将执行continue语句结束本次循环,进入下一次循环。当i的值为奇数时,sum和i进行累加,最终得到1------100之间所有奇数的和,打印“sum = 2500”。
在嵌套循环语句中,continue语句后面也可以通过使用标记的方式结束本次外层循环,用法与break语句相似,在此不再举例说明。
10.总结
for循环:
for(初始A;条件判断B;循环后操作C){
//循环体D
}
for循环执行流程:
第一次: A>B(true)>D>C
第二次: B(true)>D>C
第三次: B(true)>D>C
…
第n次: B(false) 结束整个循环
判断的次数永远比执行的次数多一次
举个例子:
for(int i = 0;i<5;i++){
System.out.println("Hello World");
}
这便是一个最基本的for循环语句
while循环:
while(条件(布尔类型的)){
// 循环体à具体做什么事情
}
举个例子:
int i = 0;
while(i < 5){
System.out.println("Hello World");
i++;
}
这便是最基本的while循环例子
注意:while循环一定要给到一个终止循环的条件,如果条件一直为true的话便会一直循环下去变成死循环,适合描述未知循环次数的循环
do while循环:
do{
// 循环体
}while(条件);
举个例子:
inti = 0;
do{
System.out.println("Hello World");
i++;
}while(i < 5)
while循环和do while循环的区别:
while循环需要先判断结果为真再执行
do while是先执行一次以后再去判断 如果结果为真便继续执行
嵌套循环:
概念:循环嵌套 循环里面还有循环,可以嵌套多层,不同的循环结构相互之间也可以嵌套。
for(){
//外层循环
for(){
//内层循环
}
}
注意:在使用嵌套循环时最好不要超过两个,不然会大大降低代码的可读性和程序性能
Random
public class Demo07 {
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);
}
}
/*
number:8
number:6
number:9
number:9
number:6
number:9
number:6
number:9
number:9
number:5
60
*/
9.1案例:猜数字
需求:程序自动生成一个1-100之间的数字,使用程序实现猜出这个数字是多少?
当猜错的时候根据不同情况给出相应的提示
-
如果猜的数字比真实数字大,提示你猜的数据大了
-
如果猜的数字比真实数字小,提示你猜的数据小了
-
如果猜的数字与真实数字相等,提示恭喜你猜中了
public class Demo07 {
public static void main(String[] args) {
//创建对象
Random r = new Random();
int number = r.nextInt(100) + 1;
//无限循环
while (true) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入猜的数字:");
int guessNumber = scanner.nextInt();
if (guessNumber > number) {
System.out.println("你猜的数字" + guessNumber + "大了");
} else if (guessNumber < number) {
System.out.println("你猜的数字" + guessNumber + "小了");
} else {
System.out.println("恭喜你猜中了");
break;
}
}
}
}
三.数组
数组(array)是一种用于储存多个相同类型的数据储存模型
1.数组定义格式
- 格式一 : 数据类型学[] 变量名
- 范例 : int [] arr
- 定义了一个int类型的数组,数组名是arr
- 格式二 : 数据类型 变量名[]
- int arr []
- 定义了一个int类型的变量,变量名是arr数组
2. 数组初始化之动态初始化
Java中的数组必须先初始化,然后才能使用
所谓初始化:就是为数组中的数组元素分配内存空间,并为每个数组元素赋值
-
动态初始化
- 初始化时只指定数组长度,由系统为数组分配初始值
- 格式:数据类型 [] 变量名 = new数据类型[数组长度];
- 范例: int [] arr =new int[3];
public class Demo08 {
public static void main(String[] args) {
int [] arr = new int [3];
/*
* 左边:
* int:说明数组中的元素是int类型
* []:说明这个是一个数组
* arr:是数组的名称
* 右边:
* new:为数组申请内存空间
* int:说明数组中的元素类型是int类型
* []:说明这是一个数组
* 3:数组长度,其实就是数组中的元素个数
* */
}
}
3. 数组元素访问
-
数组变量访问方式
-
格式: 数组名
-
数组内部保存的数据的访问方式
-
格式:数组名[索引]
- 索引是数组中数据的编导方式
- 作用:索引用于访问数组中的数据使用,数组名[索引]等同于变量名,是一种特殊的变量名
- 特征①:索引是从0开始的
- 特征②: 索引是连续的
- 特征③:索引是逐一增加的,每次加1
public class Demo08 {
public static void main(String[] args) {
int [] arr = new int [3];
/*
* 左边:
* int:说明数组中的元素是int类型
* []:说明这个是一个数组
* arr:是数组的名称
* 右边:
* new:为数组申请内存空间
* int:说明数组中的元素类型是int类型
* []:说明这是一个数组
* 3:数组长度,其实就是数组中的元素个数
* */
//输出数组名
System.out.println(arr);//[I@14ae5a5
//输出数组中的元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
/*
输出结果
[I@14ae5a5
0
0
0
*/
4. 内存分配
java中的内存分配
Java程序在运行时,需要在内存中分配空间。为了提高运算效率,就对空间进行了不同区域的划分,因为每一片区域都有特定的处理数据方式和内存管理方式。
单个数组内存图
public class Demo08 {
public static void main(String[] args) {
int [] arr = new int [3];
/*
* 左边:
* int:说明数组中的元素是int类型
* []:说明这个是一个数组
* arr:是数组的名称
* 右边:
* new:为数组申请内存空间
* int:说明数组中的元素类型是int类型
* []:说明这是一个数组
* 3:数组长度,其实就是数组中的元素个数
* */
//输出数组名
System.out.println(arr);//[I@14ae5a5
//输出数组中的元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
arr[0]=100;
arr[2]=200;
System.out.println("=============");
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr[2]);
}
}
/*
[I@14ae5a5
0
0
0
=============
100
0
200
*/
↑↑
![image-20201102132414032](https://i.loli.net/2020/11/13/OklbRNron2wBKHM.png)
多个数组内存图
public class Demo08 {
public static void main(String[] args) {
int [] arr = new int [2];
int [] arr2 = new int [3];
/*
* 左边:
* int:说明数组中的元素是int类型
* []:说明这个是一个数组
* arr:是数组的名称
* 右边:
* new:为数组申请内存空间
* int:说明数组中的元素类型是int类型
* []:说明这是一个数组
* 3:数组长度,其实就是数组中的元素个数
* */
//输出数组名
System.out.println(arr);//[I@14ae5a5
//输出数组中的元素
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[2]);
arr[0]=100;
arr2[0]=200;
arr2[2]=300;
System.out.println("================");
System.out.println(arr);
System.out.println(arr[0]);
System.out.println(arr[1]);
System.out.println(arr2);
System.out.println(arr2[0]);
System.out.println(arr2[2]);
}
}
/*
[I@14ae5a5
0
0
[I@7f31245a
0
0
================
[I@14ae5a5
100
0
[I@7f31245a
200
300
*/
多个数组指向相同
5. 数组初始化之静态初始化
静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度
-
格式: 数据类型 [] 变量名= new数据类型 [] { 数据1,数据2,数据3,……};
-
范例: int [] arr=new int [] {1,2,3};
-
简化格式 数据类型[]变量名 = {数据1,数据2,数据3,…}
-
范例: int [] arr = {1,2,3};
public class Demo09 { public static void main(String[] args) { //定义数组 int [] arr = { 1,2,3}; //输出数组名 System.out.println(arr); //输出数组中的元素 System.out.println(arr[0]); System.out.println(arr[1]); System.out.println(arr[2]); } } /* [I@14ae5a5 1 2 3 */
动态:是自定义元素个数系统加默认值你可对其赋值
静态:是你输入的元素个数并可以开始可以给数组赋值
6. 数组常见问题
数组操作的两个常见小问题
**索引越界:**访问了数组中不存在的索引对应的元素,造成索引越界问题
**空指针异常:**访问的数组已经不再指向堆内存的数据,造成空指针异常
**null:**空值,引用数据类型的默认值,表示不指向任何有效对象
7. 数组常见操作
7.1 遍历
/*获取数组元素数量
范例:数组名.length
范例:arr.length
*/
public class Demo09 {
public static void main(String[] args) {
//定义数组
int[] arr = {
11, 22, 33, 44, 55};
for (int x=0; x< arr.length;x++){
System.out.println(arr[x]);
}
}
}
/*
11
22
33
44
55
*/
7.2 获取最值
public class Demo09 {
public static void main(String[] args) {
//定义数组
int[] arr = {
11, 22, 33, 44, 55};
int max = arr[0];
for (int x=1; x< arr.length;x++){
if (arr[x]>max){
max= arr[x];
}
}
System.out.println(max);
}
}
/*
55
*/
四.方法的定义和调用
public class Demo10 {
public static void main(String[] args) {
//调用方法
isEvenNumber();
}
public static void isEvenNumber(){
//定义变量
int number = 10;
number=9;
//判断该数据是否是偶数
if (number%2==0){
System.out.println(true);
}else {
System.out.println(false);
}
}
}
//==============练习============
public class Demo11 {
public static void main(String[] args) {
//在main()方法中调用定义好的方法
getMax();
}
//定义一个方法,用于打印两个数字中较大的数,例如getMax()
public static void getMax() {
//方法中定义两个变量,用于保存两个数字
int a =10;
int b =20;
//使用分支语句分两种情况对两个数字的大小关系进行处理
if (a>b){
System.out.println(a);
}else
System.out.println(b);
}
}
/*
20
*/
1. 带参数方法的定义和调用
带参数方法定义
-
格式 : public static void 方法名() {…}
-
格式(单个参数):
public static void 方法名 (数据类型 变量名 ){ .........}
-
范例(单个参数):
public static void isEvenNumber (int number){ ........}
-
格式(多个参数):
public static void 方法名 (数据类型 变量名1,数据类型 变量名2,......... ){ ..... ....}
-
范例(多个参数):
public static void getMax(int number1,int number2) { ... ...}
注意
- 方法定义时,参数中的数据类型与变量名都不能缺少,缺少任意一个程序将报错
- 方法定义时,多个参数之间使用逗号(,)分隔
带参数方法调用
-
格式 方法名(参数);
-
格式(单个参数): 方法名(变量名/常量值);
-
范例(单个参数):isEvennumber(5);
-
格式(多个参数): 方法名(变量名1/常量值1,变量名2/常量值2);
-
范例(多个参数):getMAx(5,6);
注意
方法调用时,参数的数量与类型必须与方法定义中的设置相匹配,否则程序将报错
public class Demo12 {
public static void main(String[] args) {
//常量值的调用
isEvenNumber(10);
//变量的调用
int number =10;
isEvenNumber(number);
}
//需求:定义一个方法,该方法接受一个参数,判断该数据是否是偶数
public static void isEvenNumber(int number){
if (number%2==0){
System.out.println(true);
}else{
System.out.println(false);
}
}
}
/*
true
true
*/
2. 形参和实参
形参:方法定义中的参数
等同于变量定义格式,例如: int number
实参:方法调用中的参数
等同于使用变量或常量,例如: 10 number
3. 带参数的方法练习
需求:设计一个方法用于打印两个数中的较大数,数据来自于方法参数
public class Demo12 {
public static void main(String[] args) {
//常量值的调用
getMAx(10,20);
//要几个给几个,要什么类型的就放什么类型的
}
//需求:设计一个方法用于打印两个数中的较大数,数据来自于方法参数
public static void getMAx(int a ,int b){
if (a > b){
System.out.println(a);
}else{
System.out.println(b);
}
}
}
//20
4. 带返回值定义和调用
带返回值方法定义
格式:
public static 数据类型 方法名 (参数){
return 数据;
}
//范例1:
public static boolean getMax (参数){
return true;
}
//范例2:
public static int getMAx (inta, intb){
return 100;
}
方法定义时return后面的返回值与方法定义上的数据类型要匹配,否则程序将报错
带返回值方法调用
格式1:
方法名(参数);
范例:
getMax (5)
这种方法可能没有意义
格式2:
数据类型 变量名 = 方法名(参数);
范例:
boolean flag = isEvenNumber
注意:
方法的返回值通常会使用变量接收,否则该返回值将无意义
public class Demo12 {
public static void main(String[] args) {
//常量值的调用
// isEvenNumber(10); 可能没有意义
boolean flag = isEvenNumber(10);
System.out.println(flag);
}
//
public static boolean isEvenNumber(int number){
if (number%2==0){
return true;
}else{
return false;
}
}
}
https://ngabbs.com/read.php?tid=23881293
//================== 练习 =======================
public class Demo13 {
public static void main(String[] args) {
//方法1:在main()方法中调用定义好的方法并使用变量保存
int result = getMax(10,20);
System.out.println(result);
//方法2在main()方法中调用定义好的方法并直接打印结果
System.out.println(getMax(10,20));
}
public static int getMax(int a, int b){
if (a>b){
return a;
}else{
return b;
}
}
}
5. 方法的注意事项
- 方法不能嵌套定义
- void表示无返回值,可以省略return,也可以单独的书写return,后面不加数据
6. 方法的通用格式
7. 方法重载
概述
- 方法重载指同一个类中定义的多个方法之间的关系,满足下列条件的多个方法相互构成重载
- 多个方法在同一个类中
- 多个方法真有相同的方法名
- 多个方法的参数不相同,类型不同或者数量不同
特点
-
重载仅对应方法的定义,与方法的调用无关,调用方式参照标准格式
-
重载仅针对同一个类中方法的名称与参数进行识别,与返回值无关,换句话说不能通过返回值来判定两个方法是否相互构成重载
//与返回值无关
//在调用的时候,Java虚拟机会通过参数的不同来区分同名的方法
public class Demo15 {
public static void main(String[] args) {
//调用方法
int result = sum(10,20);
System.out.println(result);
double result2 = sum(10.0,20.0);
System.out.println(result2);
int result3 = sum (10,20,30);
System.out.println(result3);
}
//需求1:求两个int类型的数据和方法
public static int sum (int a , int b){
return a+b;
}
//需求2:求两个double类型的数据和方法
public static double sum(double a,double b){
return a+b;
}
//需求3:求三个int类型的数据的方法
public static int sum (int a, int b,int c){
return a+b+c;
}
}
/*
输出结果
30
30.0
60
*/
方法重载练习
需求:
使用方法重载的思想,设计比较两个整数是否相同的方法,兼容全整数类型(byte,short,int,long)
public class Demo16 {
public static void main(String[] args) {
//调用方法
boolean x= compare((byte) 10,(byte) 20);//想要哪一个输出就强转
boolean x2= compare((short) 10,(short) 20);//想要哪一个输出就强转
boolean x3= compare( 10l,20l);//想要哪一个输出就强转
System.out.println(x);
System.out.println(x2);
System.out.println(x3);
}
public static boolean compare (int a,int b){
System.out.println("int");
return a==b;
}
public static boolean compare (byte a,byte b){
System.out.println("byte");
return a==b;
}
public static boolean compare (short a,short b){
System.out.println("short");
return a==b;
}
public static boolean compare (long a,long b){
System.out.println("long");
return a==b;
}
}
/*
byte
short
long
false
false
false
*/
8. 方法的参数传递
基本类型
对于基本数据类型的参数,形式参数的改变,不影响实际参数的值
形参的改变不影响实参的值
方法参数的传递(引用类型)
对于引用类型的参数,形式参数的改变,影响实际参数的值
案例:数组的遍历
System.out.printIn(“内容”);输出内容并换行
System.out.print(“内容”);输出内容不换行
System.out.printIn();起到换行的作用
public class Demo17 {
public static void main(String[] args) {
System.out.println("hello");
System.out.println("world");
System.out.print("hello");
System.out.print("world");
System.out.println();
}
}
/*
hello
world
helloworld
*/
//==============================================
public class Demo17 {
public static void main(String[] args) {
int[] arr = {
11,22,33,55};
//调用方法
printArray(arr);
}
//定义一个方法,用数组遍历通用格式对数组进行遍历
/*
两个明确
返回值:void
参数:int[]arr
*/
public static void printArray(int[]arr){
System.out.print("[");
for (int x=0;x<arr.length;x++){
if (x== arr.length-1){
System.out.print(arr[x]);
}else{
System.out.print(arr[x]+",");
}
}
System.out.println("]");
}
}
/*
[11,22,33,55]
*/
案例:数组的最大值
public class Demo17 {
public static void main(String[] args) {
int[] arr = {
12,45,98,73,60};
//调用方法
int number= max(arr);
System.out.println(number);
}
public static int max(int[]arr){
int max = arr[0];
for (int x=1;x<arr.length;x++){
if (arr[x]>max){
max=arr[x];
}
}
return max;
}
}
//98
9. 基础知识运用(案例1-8)
案例一: 减肥计划
//================= switch版本 ====================
import java.util.Scanner;
public class Demo18 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("用中文输入星期数,显示今天的减肥活动:");
String week = scanner.nextLine();
switch (week) {
case "周一":
System.out.println("跑步");
break;
case "周二":
System.out.println("游泳");
break;
case "周三":
System.out.println("慢走");
break;
case "周四":
System.out.println("动感单车");
break;
case "周五":
System.out.println("拳击");
break;
case "周六":
System.out.println("爬山");
break;
case "周日":
System.out.println("好好吃一顿");
break;
default:
System.out.println("输入错误");
break;
}
}
}
//==================== if版本 ===========================
import java.util.Scanner;
public class Demo19 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("输入星期,显示今天的减肥活动:");
int week = scanner.nextInt();
if (week < 1 || week > 7) {
System.out.println("错误");
} else if (week == 1) {
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 {
System.out.println("好好吃一顿");
}
}
}
案例二: 逢七过
import java.util.Scanner;
public class Demo20 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("包含7或者7的倍数的数据");
int seven = 0;
for (int x = 1; x <= 100; x++) {
if (x % 7 == 0 || x / 10 % 10 == 7 || x % 10 == 7) {
System.out.println(x);
}
}
}
}
案例三: 兔子繁殖
public class Demo21 {
public static void main(String[] args) {
int[] arr = new int[20];
arr[0] = 1;
arr[1] = 1;
for (int x = 2; x < arr.length; x++) {
arr[x] = arr[x - 2] + arr[x - 1];
}
System.out.println("第二十个月兔子的对数是:"+arr[19]);
}
}
案例三: 百钱白鸡
public class Demo22 {
public static void main(String[] args) {
//1:第1层循环,用于表示鸡翁的范围,初始化表达式的变量定义为 x=0,判断条件是x<=20
for (int x = 0; x <= 20; x++) {
//第2层循环,用于表示鸡母的范围,初始化表达式的变量定义为 y=0,判断条件是y<=33
for (int y = 0; y <= 33; y++) {
//这个时候,用于表示鸡雏的变量z=100-x-y
int z = 100 - x - y;
//判断表达式 z%3==0和表达式5*x+3*y + z/3 = 100 是否同时成立
if (z % 3 == 0 && 5 * x + 3 * y + z / 3 == 100) {
System.out.println(x + "," + y + "," + z);
}
}
}
}
}
/*
0,25,75
4,18,78
8,11,81
12,4,84
*/
案例四: 数组元素求和
public class Demo23 {
public static void main(String[] args) {
int[] arr = {
68, 27, 95, 88, 171, 996, 51, 210};
int sum = 0;
for (int x = 0; x < arr.length; x++) {
if (arr[x] % 10 != 7 && arr[x] / 10 % 10 != 7 && arr[x] % 2 == 0) {
sum += arr[x];
}
}
System.out.println("和:" + sum);
}
}
/*
和:1362
*/
案例五: 数组内容相同
public class Demo24 {
public static void main(String[] args) {
int[] arr = {
11, 22, 33, 44, 55};
int[] arr2 = {
11, 29, 33, 44, 55};
boolean flag = compare(arr, arr2);
System.out.println(flag);
}
public static boolean compare(int[] arr, int[] arr2) {
if (arr.length != arr2.length) {
return false;
}
for (int x = 0; x < arr.length; x++) {
if (arr[x] != arr2[x]) {
return false;
}
}
return true;
}
}
//true
案例六: 查找
import java.util.Scanner;
public class Demo25 {
public static void main(String[] args) {
int[] arr = {
19, 28, 37, 46, 50};
// 键盘录入要查找的数据,用一个变量接收
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要查找到数据:");
int number = scanner.nextInt();
//定义一个索引变量,初始值为-1
int index = -1;
//遍历数组,获取到数组中的每一个元素
for (int x = 0; x < arr.length; x++) {
//拿键盘录入的数据和数组中的每个元素进行比较,如果值相同,就把该值对应的索引赋值给索引变量,并结束循环
if (arr[x] == number) {
index = x;
break;
}
}
System.out.println("index:" + index);
}
}
//====================== 方 法 二 =========================
import java.util.Scanner;
public class Demo25 {
public static void main(String[] args) {
int[] arr = {
19, 28, 37, 46, 50};
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要查找到数据:");
int number = scanner.nextInt();
int index = getIndex(arr,number);
System.out.println("index:" + index);
}
public static int getIndex(int[] arr, int number) {
//定义一个索引变量,初始值为-1
int index = -1;
//遍历数组,获取到数组中的每一个元素
for (int x = 0; x < arr.length; x++) {
//拿键盘录入的数据和数组中的每个元素进行比较,如果值相同,就把该值对应的索引赋值给索引变量,并结束循环
if (arr[x] == number) {
index = x;
break;
}
}
return index;
}
}