第二天 变量&数据类型&运算符【悟空教程】
第02天 Java基础
第1章 变量
1.1变量
1.1.1变量概念
变量是用来存储数值的内存区域
1.1.2作用
变量用来记录数值。使用变量进行代数计算，则该变量中数值可以随着程序的逻辑计算而改变。当计算全部结束后，再将数值拿出展示给用户。
1.1.3变量的使用格式
日常变量的使用分为四个部分
变量定义格式
数据类型 变量名 = 变量值；
如 int a = 100;
变量类型 每一个变量均必须指定其变量类型。Java是强类型语言，在Java中不同的数据类型在内存中的存储方式是不尽相同的。所以必须在存储内容之前指定数据类型。
变量名 即使用标识符为变量起一个名字，之后在计算时，使用该名字即可参与计算。这个名字就代表了存储数值的空间。
“=”号 这里的“=”号是运算符的一种，即=代表赋值运算，并非数学意义上的相等。
值 即真正变量存储的数值，需要与变量的数据类型一致。
/*
变量:存储数值的一块内存区域
变量的定义格式:
数据类型变量名=数据值;
*/
public class Demo01Variable{
public static void main(String[] args){
//定义一个存储整数的变量
int myVar = 10;
//打印变量的值
System.out.println(myVar);//10
//改变变量的值
myVar = 20;
//打印变量的值
System.out.println(myVar);//20
}
}
1.1.4日常变量使用的注意事项
可以同时定义多个变量
变量定义后可以不赋值，使用时再赋值。不赋值不能使用。
变量使用时有作用域的限制。
/*
变量使用的注意事项:
可以同时定义多个变量
变量定义后可以不赋值，使用时再赋值。不赋值不能使用。
变量使用时有作用域的限制
*/
public class Demo02Variable{
public static void main(String[] args){
//可以同时定义多个变量
int a=5,b=10;
/*
int a = 5;
int b = 10;
*/
System.out.println(a);//5
System.out.println(b);//10
//变量定义后可以不赋值，使用时再赋值。不赋值不能使用。
int c;
//System.out.println(c);//错误: 可能尚未初始化变量c
//System.out.println(c=20);
c = 20;
System.out.println(c);
}
}
1.2数据类型
Java是一种强类型语言，对不同数据结构进行了严格的区分，对每一种数据类型都做了明确定义，也同时规定了每一种数据类型的变量在内存中占用空间的大小。
1.2.1字节
字节是计算机当中存储数据的基本单位，每种数据类型都会占用一定的空间。
比特位
比特位(bit)是计算机当中最小的存储单位，由于机器码只识别1与0，所以每一位的1与0均为一个比特位
字节组成规则
在计算机当中如果使用bit来计算数据过于冗余复杂，所以以8个比特位组成一个新的单位——字节，作为数据存储的基本单位
常见的数据存储单位之间的换算
1B（字节） = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB
1.2.2数据类型分类
数据类型分为基本类型与引用类型，引用类型包括：数组、类、接口，在面向对象后期会全部介绍完毕。这里着重介绍基本数据类型。
整数型(精确)
int 占用4个字节 (整数的默认值)
byte 占用1个字节
short 占用2个字节
long 占用8个字节
long类型在赋值时，需要在值后加入字母l(L)区分其是一个长整型
如 int i = 100; short s = 66; long l = 100L;
浮点型(小数型，非精确，为近似值)
double 占用8个字节 (小数的默认值)
float 占用4个字节
float类型在赋值时，需要在值后加入字母f(F)区分其是一个浮点型
如 double d = 100.0; double d2 = 10.1; float f = 100.0F;
字符型
char 占用2个字节，必须使用’’包裹，且不能为空。
如 char c = ‘a’; char c2 = ‘中’; char c3 = ‘ (空格)’; char c4 = ‘$’
转义字符
有时我们无法直接给出一个字符，需要使用转义字符进行转义动作。转义字符也为一个字符，由转义符号与被转义字符组成
转义符号：\
如:
\t 制表符
\’ 单引号
\” 双引号
\\ 反斜杠
字符存储原理
每一个值在存储时，均存储的为值对应的数字。即字符、声音、图片、文字，使用都以数字1或0的方式存储在计算机中。
每一个英文字符都有其固定的数字对应。英文字符与数字的对应关系组成了一张编码表，该表名称为ASCII表。(内容见资料)
布尔型
布尔值是我们比较陌生的类型，它代表一些条件成立与不成立的判断。只有两个值true与false。
boolean 占用1个字节
如 boolean b = true; boolean b2 = false;
类型数据表示范围
整数类型byte-128～127
整数类型short-32768～32767
整数类型int(整数的默认值)-2147483648～2147483648
整数类型long-263～263-1
小数类型float-3.403E38～3.403E38
小数类型double(小数的默认值)-1.798E308～1.798E308
字符类型char表示一个字符，如('a'，'A'，'0'，'家')
布尔类型boolean只有两个值true与false
/*
数据类型:
整数:(精确)
byte:占用1个字节
short:占用2个字节
int:占用4个字节(默认)
long:占用8个字节,使用时必须在末尾加上一个小写字母l或者大写字母L
小数:(不精确,近似值)
float:占用4个字节,使用时必须在末尾加上一个小写字母f或者大写字母F
double:占用8个字节(默认)
布尔:
boolean:(true,false)占用1个字节
字符:
char:占用2个字节
注意事项:
字符不能为空
字符实际存储的是一个数值
想把具有特殊含义',转换成普通的字符,用转义字符\'
想把普通字符t,变成一个具有特殊含义的字符,用转义字符\t
*/
public class Demo03Variable{
public static void main(String[] args){
//整数
byte b = 100;
System.out.println(b);
short s = 10000;
System.out.println(s);
int i = 1600000000;
System.out.println(i);
long l = 6000000000L;
System.out.println(l);
//小数
double d = 3.14;
System.out.println(d);
float f = 2.6f;
System.out.println(f);
//小数是一个不精确的数
System.out.println(f-2);//0.5999999
//布尔
boolean b1 = true;
System.out.println(b1);
boolean b2 = false;
System.out.println(b2);
//字符
char c = 'a';
System.out.println(c);
//转义字符
char c1 = '\'';
System.out.println(c1);
char c2 = '\t';
System.out.println(c2+"Hello");
System.out.println('\\');
//字符实际存储的是一个数值
System.out.println(c+1);
}
}
1.2.3数字类型转换
数字类型可以有数据类型上的转换，即将一种类型的值赋值给另外一种类型的变量。但要依据数据范围，符合一定规则：
各种数据类型按照数据范围从小到大：
byte -> short -> int -> long -> float -> double
自动类型转换
范围小的数据类型值（如int），可以自动转换为范围大的数据类型值（如double）
范围大的数据类型 变量 = 范围小的数据类型值；
如：
double d = 1000;
或
int i = 100;
double d2 = i;
强制类型转换
范围大的数据类型值（如double），不可以自动转换为范围小的数据类型值（如int），但是可以强制转换
范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型值;
如：
int i = (int)6.718; //i的值为6
或
double d = 3.14;
int i2 = (int)d; //i2的值为3
/*
数字类型转换:就是数值转换,包括整数,小数,字符
自动类型转换:小-->大
byte < short(char)< int < long < float < double
格式:范围大的数据类型 变量名 = 范围小的数据类型的值;
强制类型转换:大-->小
格式:范围小的数据类型 变量名 = (范围小的数据类型)范围大的数据类型的值;
*/
public class Demo04Variable{
public static void main(String[] args){
//自动类型转换 int --> double
int i = 100;
double d = i;
System.out.println(i);
System.out.println(d);
//强制类型转换
double d2 = 3.14;
//int i2 = d2;//错误: 可能损失精度
int i2 = (int)d2;
System.out.println(i2);
System.out.println(d2);
}
}
1.3变量案例---超市水果报价单
1.3.1案例介绍与演示
根据不同的水果种类，使用变量在控制台打印所有水果价格的列表。
1.3.2案例分析
我们通过以下方式定义5个变量，来记录可能改变的数据：
一个记录整数类型的榴莲编号
一个记录小数类型的榴莲价格
两个分别记录字符串类型的水果名称与计价单位
一个记录字符类型的榴莲品质
int liulianId = 1;
String liulianName = “榴莲”;
double liulianPrice = 32.0;
String liulianUnit = “公斤”;
char liulianLevel = ‘A’;
按照同样的方法，我们也可以将苹果的编号与属性用变量表示。(注意命名)
int appleId = 2;
String appleName = “苹果”;
double applePrice = 6.5;
String appleUnit = “公斤”;
char appleLevel = ‘B’;
这时，再打印时，便可以直接使用变量打印
System.out.println("水果编号 水果名称 水果单价 计价单位 品质");
System.out.println(" "+ liulianId +" "+ liulianName +" "+
liulianPrice +" "+ liulianUnit +" "+ liulianLevel);
System.out.println(" "+ appleId +" "+ appleName +" "+
applePrice +" "+ appleUnit +" "+ appleLevel);
很明显，在这种方式打印时价格列表时，可以随意操作价格或者其他属性值而后边打印表单的代码不需要更改。我们用变量来记录各种属性值，将最终的值存储到变量中。
/*
水果超市报价单:变量版本
水果编号水果名称水果单价计价单位品质
1榴莲32.0公斤A
2苹果6.5公斤B
3 猕猴桃6.0公斤A
分析:定义3组15个变量用来记录水果信息
水果编号:采用int类型定义
水果名称:采用String类型定义
水果单价:采用double类型定义
计价单位:采用String类型定义
品质:采用char类型定义
*/
public class List02{
public static void main(String[] args){
//定义榴莲的水果信息
int llId = 1;
String llName = "榴莲";
double llPrice = 32.0;
String llUnit = "公斤";
char llLevel = 'A';
//定义苹果的水果信息
int appleId = 2;
String appleName = "苹果";
double applePrice = 6.5;
String appleUnit = "公斤";
char appleLevel = 'B';
//定义猕猴桃的水果信息
int mhtId = 3;
String mhtName = "猕猴桃";
double mhtPrice = 6.0;
String mhtUnit = "公斤";
char mhtLevel = 'A';
System.out.println("水果编号水果名称水果单价计价单位品质");
System.out.println(llId+""+llName+""+llPrice+""+llUnit+""+llLevel);
System.out.println(appleId+""+appleName+""+applePrice+""+appleUnit+""+appleLevel);
System.out.println(3+" 猕猴桃"+6.0+"公斤"+'A');
}
}
第2章 运算符
2.1运算符概念
运算符是用来计算数据的指令。数据可以是常量，也可以是变量。被运算符操作的数成为操作数。
Int x = 3;
Int y = 4;
Int z = x + y
2.2算数运算符
将操作数参与数学计算(通常为数学计算)
运算符运算规则范例结果
+正号+33
+加2+35
+连接字符串“中”+“国”“中国”
-负号int a=3;-a-3
-减3-12
*乘2*36
/除5/22
%取模(余数)5%21
++自增int a=1;a++/++a2
--自减int b=3;a--/--a2
注意：
加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。
除法“/”当两边为整数时，取整数部分，舍余数。当两边为浮点型时，按正常规则相除。
“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数的符号相同。
得到的是两个相除数据的余数。
用处: 判断两个数据是否整除。
整数做被除数，0不能做除数，否则报错。
小数做被除数，整除0结果为Infinity，对0取模结果为NaN
自增与自减
单独使用：
前置与后置效果相同，均为直接+1或-1
混合使用：
自增（++）：将变量的值加1，分前缀式（如++i）和后缀式（如i++）。前缀式是先加1再使用；后缀式是先使用再加1。
自减（--）：将变量的值减1，分前缀式（如--i）和后缀式（如i--）。前缀式是先减1再使用；后缀式是先使用再减1。
自增与自减运算符还遵循以下规律：
1. 可以用于整数类型byte、short、int、long，浮点类型float、double，以及字符串类型char。
2. 在Java5.0及以上版本中，它们可以用于基本类型对应的包装器类Byte、Short、Integer、Long、Float、Double、Character。
3. 它们的运算结果的类型与被运算的变量的类型相同。
/*
算数运算符:
+,-,*:相当于数学+,-*
+:做为字符串连接符
/:两个整数相除,结果是整数
%:两个整数取模(余数),结果是整数
++:自增(自身加1)
--:自减(自身减1)
注意事项:
1.加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。
2.除法“/”当两边为整数时，取整数部分，舍余数。当两边为浮点型时，按正常规则相除。
3.“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数的符号相同。
4.整数做被除数，0不能做除数，否则报错。
5.小数做被除数，整除0结果为Infinity，对0取模结果为NaN
自增与自减
单独使用：
前置与后置效果相同，均为直接+1或-1
与其他运算符混合使用：
++或- -为前置时，先+1或-1，再使用值。
++或- -为后置时，先使用值再+1或-1。
*/
public class Demo05Operator{
public static void main(String[] args){
//两个常量相加
System.out.println(3 + 5);//8
//变量加减乘除模
int a = 20;
int b = 7;
System.out.println(a + b);//27
System.out.println(a - b);//13
System.out.println(a * b);//140
System.out.println(a / b);//2
System.out.println(a % b);//6
//+:做为字符串连接符
System.out.println("中"+"国");//中国
/*
单独使用：
前置与后置效果相同，均为直接+1或-1
*/
//++:自增(自身加1)
//--:自减(自身减1)
int c = 10;
int d = 20;
//c++;
//d--;
++c;
--d;
System.out.println("c = " + c);//c = 11
System.out.println("d = " + d);//d = 19
System.out.println("===================================");
//1.加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。
int e = 15;
int f = 20;
System.out.println("e + f = " + e + f);//e + f = 1520
System.out.println("e + f = " + (e + f));//e + f = 35
System.out.println(e + f + " = e + f");//35 = e + f
//2.除法“/”当两边为整数时，取整数部分，舍余数。当两边有浮点型时，按正常规则相除。
System.out.println(5.0 / 2);//2.5
//3.“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数(符号左边的数)的符号相同。
System.out.println(5.1 % 2);//1.0999999999999996
System.out.println(5 % 2);//1
System.out.println(-5 % 2);//-1
System.out.println(5 % -2);//1
System.out.println(-5 % -2);//-1
//4.整数做被除数，0不能做除数，否则报错。
//System.out.println(5 / 0);//ArithmeticException: / by zero
//5.小数做被除数，整除0结果为Infinity(无穷)，对0取模结果为NaN(not number 无效数字)
System.out.println(5.0 / 0);//Infinity
System.out.println(5.0 % 0);//NaN
System.out.println("===================================");
/*
与其他运算混合使用：
++或- -为前置时，先+1或-1，再使用值。
++或- -为后置时，先使用值再+1或-1。
*/
System.out.println(e);//15
System.out.println(f);//20
System.out.println(e++);//15
System.out.println(f--);//20
System.out.println(e);//16
System.out.println(f);//19
int i1 = 100;
int i2 = i1++ + 200;
System.out.println(i1);//101
System.out.println(i2);//300
int i3 = 100;
int i4 = ++i3 + 200;
System.out.println(i3);//101
System.out.println(i4);//301
}
}
2.3赋值运算符
为变量赋值的运算符
运算符运算规则范例结果
=赋值int a=22
+=加后赋值int a=2，a+=24
-=减后赋值int a=2，a-=20
*=乘后赋值int a=2，a*=24
/=整除后赋值int a=2，a/=21
%=取模后赋值int a=2，a%=20
注意：
诸如+=这样形式的赋值运算符，会将结果自动强转成等号左边的数据类型。
/*
赋值运算符:
=,+=,-=,*=,/=,%=
+=,-=,*=,/=,%=运算符的运算规则:
先将运算符两边进行+,-,*,/,%运算,在把结果赋值给左边的变量
+=,-=,*=,/=,%=注意事项:运算符左边必须是一个变量
+=,-=,*=,/=,%=特点:隐含一个强制类型转换
*/
public class Demo06Operator{
public static void main(String[] args){
int a = 10;
a += 20;//相当于 a = a + 20;
System.out.println("a = " + a);
//5 += 6;//错误: 意外的类型,这里5的位置需要一个变量
byte b = 10;
//b = b + 100;//错误: 可能损失精度
//b = (byte)(b + 100);
b += 100;//+=隐含了一个强制类型转换 相当于b = (byte)(b + 100);
System.out.println("b = " + b);
}
}
2.4比较运算符
又叫关系运算符，即判断两个操作数的大小关系及是否相等关系，比较运算符的返回一定为布尔值。
运算符运算规则范例结果
==相等于4==3false
!=不等于4!=3true
<小于4<3false
>大于4>3true
<=小于等于4<=3false
>=大于等于4>=3true
==，!=，>，<，>=，<=
关系运算符的结果都是boolean型，也就是要么是true，要么是false。
注意事项
n 关系运算符“==”不能误写成“=” 。
publicclassDemo06Operator {
publicstaticvoidmain(String[] args) {
inta = 10;
intb = 20;
intc = 10;
System.out.println(a == b);
System.out.println(a == c);
System.out.println("-----------------");
System.out.println(a != b);
System.out.println(a != c);
System.out.println("-----------------");
System.out.println(a > b);
System.out.println(a > c);
System.out.println("-----------------");
System.out.println(a >= b);
System.out.println(a >= c);
System.out.println("-----------------");
intx = 3;
inty = 4;
// System.out.println(x == y);
// System.out.println(x = y);//把y赋值给x，把x的值输出
booleanbb = (x == y);
//报错
// boolean cc = (x = y);
intcc = (x = y);
}
}
2.5逻辑运算符
用于计算两个布尔值经过指定逻辑后的运算结果，结果同样是一个布尔值
运算符运算规则范例结果
&与(并且)false&trueFalse
|或false|trueTrue
^异或true^flaseTrue
!非(取反)!trueFlase
&&短路与false&&trueFalse
||短路或true ||trueTrue
作用:逻辑运算符用于连接布尔型表达式，在Java中不可以写成33 && x<6 。
基本使用: &(与),|(或),^(异或),!(非)
与：& 有false则false
或：| 有true则true
异或：^ 相同则false,不同则true
非：! true则false,false则true
publicclassDemo08Operator {
publicstaticvoidmain(String[] args) {
inta = 10;
intb = 20;
intc = 30;
System.out.println((a > b) & (a > c));// false & false
System.out.println((a < b) & (a > c)); // true & false
System.out.println((a > b) & (a < c)); // false & true
System.out.println((a < b) & (a < c)); // true & true
System.out.println("---------------");
System.out.println((a > b) | (a > c));// false | false
System.out.println((a < b) | (a > c)); // true | false
System.out.println((a > b) | (a < c)); // false | true
System.out.println((a < b) | (a < c)); // true | true
System.out.println("---------------");
System.out.println((a > b) ^ (a > c));// false ^ false
System.out.println((a < b) ^ (a > c)); // true ^ false
System.out.println((a > b) ^ (a < c)); // false ^ true
System.out.println((a < b) ^ (a < c)); // true ^ true
System.out.println("---------------");
System.out.println((a > b)); // false
System.out.println(!(a > b)); // !false
System.out.println(!!(a > b)); // !!false
}
}
&&和&的区别
单&时，左边无论真假，右边都进行运算；
双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。
publicclassDemo09Operator {
publicstaticvoidmain(String[] args) {
inta = 10;
intb = 20;
intc = 30;
System.out.println((a > b) && (a > c));// false && false
System.out.println((a < b) && (a > c)); // true && false
System.out.println((a > b) && (a < c)); // false && true
System.out.println((a < b) && (a < c)); // true && true
System.out.println("---------------");
System.out.println((a > b) || (a > c));// false || false
System.out.println((a < b) || (a > c)); // true || false
System.out.println((a > b) || (a < c)); // false || true
System.out.println((a < b) || (a < c)); // true || true
System.out.println("---------------");
intx = 3;
inty = 4;
// System.out.println((x++ > 4) & (y++ > 5)); // false & false
System.out.println((x++ > 4) && (y++ > 5)); // false && false
System.out.println("x:" + x);
System.out.println("y:" + y);
}
}
2.6三元运算符
接下来我们要学习的三元运算符与之前的运算符不同。之前学习的均为一元或者二元运算符。元即参与运算的数据。
格式：
(条件表达式)？表达式1：表达式2；
表达式：通俗的说，即通过使用运算符将操作数联系起来的式子，例如：
3+2，使用算数运算符将操作数联系起来，这种情况，我们称为算数表达式。
3>2，使用比较运算符（也称为条件运算符）将操作数联系起来，这种情况，我们称为条件表达式。
其他表达式，不再一一举例。
三元运算符运算规则：
先判断条件表达式的值，若为true，运算结果为表达式1；若为false，运算结果为表达式2。
注意：
三元运算符，最终一定会产生一个结果值，这个值必须被使用起来。
要么被运算符使用，要么被打印
/*
三元运算符:求两个数的最大值,判断两个数是否相等
格式:
(条件表达式) ? 表达式1 : 表达式2;
执行流程:
首先判断条件表达式是否成立
true:表达式1作为3元运算符的结果
false:表达式2作为3元运算符的结果
注意：
三元运算符，最终一定会产生一个结果值，这个值必须被使用起来。
要么被运算符使用，要么被打印
*/
public class Demo10Operator{
public static void main(String[] args){
int a = 10;
int b = 20;
int max = (a > b) ? 10 : 20;
System.out.println("max = " + max);
int c = 15;
int d = 10;
//System.out.println((c != d) ? "相等" : "不相等");
String s = (c != d) ? "相等" : "不相等";
System.out.println("s = " + s);
//(c != d) ? "相等" : "不相等";//错误: 不是语句
//3;//错误: 不是语句
}
}
2.7运算符优先级
2.7.1优先级概念
运算符运算的先后顺序，优先级越高(数字越小)，计算顺序越靠前。
2.7.2优先级规则
优先级相同的情况下，按照从左到右的顺序依次运算
优先级描述运算符
1括号()、[]
2正负号+、-
3自增自减，非++、--、!
4乘除，取余*、/、%
5加减+、-
6移位运算<<、>>、>>>
7大小关系>、>=、<、<=
8相等关系==、!=
9按位与&
10按位异或^
11按位或|
12逻辑与&&
13逻辑或||
14条件运算?:
15赋值运算=、+=、-=、*=、/=、%=
16位赋值运算&=、|=、<<=、>>=、
>>>=
2.8运算符案例---超市购物小票案例
2.8.1案例介绍与演示
模拟真实购物逻辑，以上述图片为需求原型，根据不同购物物品完成购物小票内容打印到控制台。
2.8.2案例分析
a)总体思路
案例分析可分为三个部分：
小票界面结构分析：通过小票界面分析，可以将复杂的问题简单化，规划出来更为具体的需求。
数据分析：实际开发过程中的数据是复杂的，存在多个维度的信息。需要分析出我具体需要操作的数据有哪些
业务逻辑分析：在接收到最基本的必要数据后，需要加入业务逻辑来完成所有需求。如本例中，求总价的过程。
b)小票界面结构分析
票头: 又分为两部分，即欢迎光临欢迎语与具体的物品属性标题。
票体: 是读取的真实数据内容，即打印对应的变量值即可。
票脚: 也分为两部分，即统计信息与开发票的提醒信息。这里为了简化需求，去掉了时间与付钱找零的统计,只完成商品价钱和数量统计部分。
c)数据分析
经过观察，我们确定一项物品应该有如下几个属性：
品名：物品名称，String型
商品编号：用于区分管理商品的编号，String型
售价：物品单价，double型
数量：购买数量，原型中是小数，我们这里以个为单位，设计成int型
金额：这一项物品的购物总金额，double型
票脚：我们发现三个单独的可变化量
商品项数：共有几项商品，int型
共计：所有项商品一共多少件，int型
总计：所有商品花费，double型
d)逻辑分析
与直接打印数据不同，这个案例的基本需求中存在许多统计信息，显然类似总价这样的值是由其他数据计算得来。
这里就涉及到了常量或变量的运算问题，需要用到运算符来完成这个需求。
普通变量值直接打印
对于普通的商品名称，商品单价等信息，读取用户数据后可以直接打印。这里我们先“帮用户给出数据”。
需要计算的数据的打印
票脚部分的三个统计信息需要经过计算得到并打印：
商品项数：共有几项商品，直接给出，int型
共计：所有商品数量求和，int型
总计：所有商品金额求和，double型
/*
超市购物小票:
分析:
票头:
用字符串方式直接打印
票体:
先定义3组15个变量用来记录商品信息
票脚:
计算:商品种类
计算:商品数量
计算:商品总金额
*/
public class SuperMarketTicket{
public static void main(String[] args){
//先定义3组15个变量用来记录商品信息
//定义少林寺酥饼核桃
String slsName = "少林寺酥饼核桃";
String slsID = "(090115)";
double slsPrice = 15.50;
int slsNumber = 22;
double slsMoney = slsPrice * slsNumber;
String xjName = "新疆美味羊肉串";
String xjID = "(090028)";
double xjPrice = 16.00;
int xjNumber = 55;
double xjMoney = xjPrice * xjNumber;
String skName = "尚康杂粮牡丹饼";
String skID = "(090027)";
double skPrice = 14.50;
int skNumber = 24;
double skMoney = skPrice * skNumber;
//计算:商品种类
int goodsItem = 3;
//计算:商品数量
int goodsNumner = slsNumber + xjNumber + skNumber;
//计算:商品总金额
double goodsMoney = slsMoney + xjMoney + skMoney;
//打印小票
//票头
System.out.println("欢迎光临");
System.out.println("品名售价数量金额");
System.out.println("------------------------------------------------");
//票体
System.out.println(slsName+slsID+""+slsPrice+""+slsNumber+""+slsMoney);
System.out.println(xjName+xjID+""+xjPrice+""+xjNumber+""+xjMoney);
System.out.println(skName+skID+""+skPrice+""+skNumber+""+skMoney);
System.out.println("------------------------------------------------");
//票脚
System.out.println(""+goodsItem+"项商品共计: "+goodsNumner+"件");
System.out.println("总计: " + goodsMoney);
System.out.println("凭此小票换取发票!");
}
}
第3章本日自习作业：
3.1知识点相关题
3.1.1 知识点：变量
要求：
1)熟练掌握各种基本数据类型及其大小；
2)熟练掌握各种基本数据类型变量的定义；
3)熟练掌握数据类型转换
题目：
1)写出8种数据类型的名称及大小（重要）；
Byte -- 一个字节 2的1*8次方
Short -- 两个字节 2的2*8次方
Int -- 四个字节 2的4*8次方
Long -- 八个字节 2的8*8次方
Char -- 两个字节 2的2*8次方
Float -- 四个字节 2的4*8次方
Double -- 八个字节 2的8*8次方
2)定义类：Test1，定义main()方法，分别定义8种数据类型的变量，并赋初始值；然后打印每种类型的变量。
代码实现：
publicclassTest1 {
//定义主方法
publicstaticvoidmain(String[] args) {
//在控制台上打印
bytea = 1;
shortb = 2;
intc = 3;
longd = 4;
chare = '5';
floatf = 4.5f;
doubleg = 5.43423;
booleanh = true;
booleani = false;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
System.out.println(e);
System.out.println(f);
System.out.println(g);
System.out.println(h);
System.out.println(i);
}
}
3)定义类：Test2，定义main()方法，请按如下要求编写代码：
a)定义一个byte类型的变量v1，赋初始值；
将v1赋给一个int类型的变量v2。
将v2赋给一个long类型的变量v3
将v3赋给一个double类型的变量v4
b)打印每个变量的值；
代码实现：
publicclassTest2 {
//定义主方法
publicstaticvoidmain(String[] args) {
//在控制台上打印
bytev1 = 5;
intv2 =v1;
longv3 = v2;
doublev4 = v3;
System.out.println(v1);
System.out.println(v2);
System.out.println(v3);
System.out.println(v4);
}
}
4)定义类：Test3，定义main()方法，请按如下要求编写代码：
a)定义一个double类型的变量v1，赋值为：3.1
定义一个double类型的变量v2，赋值为：88.88
定义一个int类型的变量v3，将v1强转后赋值给v3
定义一个int类型的变量v4，将v2强转后赋值给v4
打印v3和v4的值，请观察一个浮点型被强转为int型后的结果；
代码实现：
publicclassTest3 {
//定义主方法
publicstaticvoidmain(String[] args) {
//在控制台上打印
doublev1 = 3.1;
doublev2 = 88.88;
intv3 =(int)v1;
intv4 = (int)v2;
System.out.println(v3);
System.out.println(v4);
}
}
3.1.2 分析以下需求，并用代码实现
1.键盘录入一个三位整数数，请分别获取该三位数上每一位的数值
2.例如：键盘录入的整数123的个位、十位、百位，分别是3、2、1
3.打印格式:"数字123的个位是 3, 十位是 2, 百位是 1"
代码实现：
publicclassHelloWorld {
//定义主方法
@SuppressWarnings("resource")
publicstaticvoidmain(String[] args) {
//在控制台上打印
Scanner sc = newScanner(System.in);
System.out.println("请输入一个三位数的数值");
inta = sc.nextInt();
intb = a%100%10;
intc = a%100/10;
intd = a/100;
System.out.println("数字a的个位是"+b+", 十位是"+c+", 百位是"+d);
}
}
3.1.3 分析以下需求，并用代码实现
1.键盘录入三个int类型的数字
2.要求：
(1)求出三个数中的最小值并打印
(2)求出三个数的和并打印
代码实现：
publicclassTest {
@SuppressWarnings("resource")
publicstaticvoidmain(String[] args) {
Scanner sc = newScanner(System.in);
System.out.println("请依次输入三个数值");
inta = sc.nextInt();
intb = sc.nextInt();
intc = sc.nextInt();
//求出三个数中的最小值并打印
inttemp = a
intmin = temp
System.out.println(min);
//求出三个数的和并打印
System.out.println(a+b+c);
}
}
3.1.4 知识点：算数运算符
要求：
1)熟练掌握算数运算符的使用；
题目：
1)定义类：Test4，定义main()方法，请按如下要求编写代码：
a)定义一个int类型的变量v1，初始值：10
定义一个int类型的变量v2，初始值：3
b)请分别打印这两个数加，减，乘，除，取模的结果
c)将v1自增1，将v2自减1
d)再次打印这两个数：加，减，乘，除，取模的结果
代码实现：
publicclassTest {
@SuppressWarnings("resource")
publicstaticvoidmain(String[] args) {
intv1 = 10;
intv2 = 3;
//b)打印这两个数加，减，乘，除，取模的结果
System.out.println(v1+v2);
System.out.println(v1-v2);
System.out.println(v1*v2);
System.out.println(v1/v2);
System.out.println(v1%v2);
//将v1自增1，将v2自减1
//System.out.println(v1++);
System.out.println(++v1);
//System.out.println(v2--);
System.out.println(--v2);
//再次打印这两个数：加，减，乘，除，取模的结果
System.out.println(v1+v2);
System.out.println(v1-v2);
System.out.println(v1*v2);
System.out.println(v1/v2);
System.out.println(v1%v2);
}
}
3.1.5 知识点：赋值运算符
要求：
1)熟练掌握赋值运算符的使用；
题目：
1)定义类：Test5，定义main()方法，请使用赋值运算符编写代码：
a)定义一个int类型的变量v1，初始值：10
b)将此变量加10；
c)将此变量减5；
d)将此变量乘3；
e)将此变量除以10；
f)将此变量模2
g)打印v1的值
代码实现：
packageStudyJavaSE;
/**
* 1)请使用赋值运算符编写代码：
* a)定义一个int类型的变量v1，初始值：10
* b)将此变量加10；
* c)将此变量减5；
* d)将此变量乘3；
* e)将此变量除以10；
* f)将此变量模2
* g)打印v1的值
*
* @author奋斗蒙
*
*/
publicclassFuZhiYunsuanfu {
publicstaticvoidmain(String[] args) {
//a)定义一个int类型的变量v1，初始值：10
inta1 = 10;
inta2 = 10;
System.out.println(a1);
System.out.println(a2);
//b)将此变量加10；
a1+=10;
System.out.println(a1);
a2 = a2 + 10;
System.out.println(a2);
//c)将此变量减5；
a1-=5;
System.out.println(a1);
a2 = a2 - 5;
System.out.println(a2);
//d)将此变量乘3；
a1*=3;
System.out.println(a1);
a2 = a2 * 3;
System.out.println(a2);
//e)将此变量除以10；
a1/=10;
System.out.println(a1);
a2 = a2 / 10;
System.out.println(a2);
//f)将此变量模2
a1%=2;
System.out.println(a1);
a2 = a2 % 2;
System.out.println(a2);
}
}
3.1.6 知识点：比较运算符
要求：
1)熟练掌握比较运算符的使用；
题目：
1)定义类：Test6，定义main()方法，请按如下要求编写代码：
a)定义一个int类型的变量v1，初始值：10
定义一个int类型的变量v2，初始值：3
b)请打印v1是否等于v2
c)请打印v1是否大于v2
d)请打印v1是否小于v2
e)请打印v1是否大于等于v2
f)请打印v1是否小于等于v2
g)请打印v1是否不等于v2
代码实现：
publicclassTest {
@SuppressWarnings("resource")
publicstaticvoidmain(String[] args) {
//a)定义一个int类型的变量v1，初始值：10
//定义一个int类型的变量v2，初始值：3
intv1 = 10;
intv2 = 3;
//b)请打印v1是否等于v2
System.out.println(v1==v2);
//c)请打印v1是否大于v2
System.out.println(v1>v2);
//d)请打印v1是否小于v2
System.out.println(v1
//e)请打印v1是否大于等于v2
System.out.println(v1>=v2);
//f)请打印v1是否小于等于v2
System.out.println(v1<=v2);
//g)请打印v1是否不等于v2
System.out.println(v1!=v2);
}
}
3.1.7 知识点：逻辑运算符
要求：
1)熟练掌握逻辑运算符的使用；
题目：
1)定义类：Test7，定义main()方法，请按如下要求编写代码：
a)定义一个int类型的变量v1，初始值：24
定义一个double类型的变量v2，初始值：3.14
b)请打印：v1是否大于20，并且小于50
c)请打印：v1是否小于20，或者大于50
d)请打印：v1是否大于20，并且v2小于3.5
e)请使用“非运算符”判断：v1是否不等于25
packageStudyJavaSE;
/**
*请按如下要求编写代码：
* a)定义一个int类型的变量v1，初始值：24
*定义一个double类型的变量v2，初始值：3.14
* b)请打印：v1 是否大于20，并且小于50
* c)请打印：v1是否小于20，或者大于50
* d)请打印：v1是否大于20，并且v2小于3.5
* e)思考：请使用“非运算符”判断：v1是否不等于25
* @author奋斗蒙
*
*/
publicclassLuoJiYunsuanfu {
publicstaticvoidmain(String[] args) {
//a)定义一个int类型的变量v1，初始值：24
//定义一个double类型的变量v2，初始值：3.14
intv1 = 24;
doublev2 = 3.14;
//b)请打印：v1 是否大于20，并且小于50
System.out.println((v1>10)&(v1<50));
//c)请打印：v1是否小于20，或者大于50
System.out.println((v1<20)|(v1>50));
//d)请打印：v1是否大于20，并且v2小于3.5
System.out.println((v1>20)&(v2<3.15));
}
}
3.1.8 知识点：三元运算符
要求：
1)熟练掌握三元运算符的使用；
题目：
1)定义类：Test8，定义main()方法，请按如下要求编写代码：
a)定义一个int类型的变量v1，初始值：20
定义一个int类型的变量v2，初始值：18
b)请使用三元运算符求两个数的最大值，并打印；
代码实现：
publicclassTest {
@SuppressWarnings("resource")
publicstaticvoidmain(String[] args) {
//a)定义一个int类型的变量v1，初始值：20
//定义一个int类型的变量v2，初始值：18
intv1 = 20;
intv2 = 18;
//b)请使用三元运算符求两个数的最大值，并打印；
System.out.println(v1>v2?v1:v2);
}
}
2)定义类：Test9，定义main()方法，请按如下要求编写代码：
a)定一个int类型的变量v1，初始值20；
定义一个String类型的变量v2，初始值：“”
b)请使用三元运算符判断：如果v1大于20，v2的值为：大于，
否则，将v2的值赋值为：不大于。
c)打印v2的值
代码实现：
publicclassTest {
@SuppressWarnings("resource")
publicstaticvoidmain(String[] args) {
//a)定一个int类型的变量v1，初始值20；
//定义一个String类型的变量v2，初始值：“”
intv1 = 20;
String v2 = "";
//b)请使用三元运算符判断：如果v1大于20，v2的值为：大于，
//否则，将v2的值赋值为：不大于。
//c)打印v2的值
System.out.println(v1>20?(v2="大于"):(v2="不大于"));
}
}
3.2代码题
3.2.1在控制台打印如下的信息
要求:
1.清单顶部为固定的数据，直接打印即可
2.清单中部为商品，为变化的数据，需要记录水果信息后，打印
3.清单底部包含了统计操作，需经过计算后，打印
答案：
/*
在控制台打印如下的信息:
-----------------------购买的水果信息--------------------------
水果编号水果名称水果单价计价单位品质 购买数量
1香蕉8.0公斤A 5
2苹果6.5公斤B 3
3橙子9.0公斤A 4
---------------------------------------------------------------
您购买的水果总金额为: 95.5 元
分析:
1.定义3组18个变量用来记录水果信息
水果编号:使用int类型变量定义
水果名称:使用String类型定义
水果单价:使用double类型变量定义
计价单位:使用String类型定义
品质:使用char类型定义
购买数量:使用int类型变量定义
2.计算购买的水果总金额
每种水果的单价*购买数量之和
*/
public class Demo01{
public static void main(String[] args){
//1.定义3组18个变量用来记录水果信息
//香蕉
int bananaId = 1;
String bananaName = "香蕉";
double bananaPrice = 8.0;
String bananaUnit = "公斤";
char bananaLevel = 'A';
int bananaNumber = 5;
//苹果
int appleId = 2;
String appleName = "苹果";
double applePrice = 6.5;
String appleUnit = "公斤";
char appleLevel = 'B';
int appleNumber = 3;
//橙子
int orangeId = 3;
String orangeName = "橙子";
double orangePrice = 9.0;
String orangeUnit = "公斤";
char orangeLevel = 'A';
int orangeNumber = 4;
//2.计算购买的水果总金额
double totalMoney = bananaPrice* bananaNumber + applePrice * appleNumber + orangePrice * orangeNumber;
System.out.println("--------------------------------购买的水果信息----------------------------------");
System.out.println("水果编号水果名称水果单价计价单位品质购买数量");
System.out.println(bananaId+""+bananaName+""+bananaPrice+""+bananaUnit+""+bananaLevel+""+bananaNumber);
System.out.println(appleId+""+appleName+""+applePrice+""+appleUnit+""+appleLevel+""+appleNumber);
System.out.println(orangeId+""+orangeName+""+orangePrice+""+orangeUnit+""+orangeLevel+""+orangeNumber);
System.out.println("--------------------------------------------------------------------------------");
System.out.println("您购买的水果总金额为: " + totalMoney +" 元");
}
}
第二天 变量&数据类型&运算符【悟空教程】第02天 Java基础第1章 变量1.1 变量1.1.1 变量概念变量是用来存储数值的内存区域1.1.2 作用变量用来记录数值。使用变量进行代数计算，则该变量中数值可以随着程序的逻辑计算而改变。当计算全部结束后，再将数值拿出展示给用户。1.1.3 变量的使用格式日常变量的使用分为四个部分变量定义格式数据类型 变量名 = 变量值；如 int a = 100;变量类型 每一个变量均必须指定其变量类型。Java是强类型语言，在Java中不同的数据类型在内存中的存储方式是不尽相同的。所以必须在存储内容之前指定数据类型。变量名 即使用标识符为变量起一个名字，之后在计算时，使用该名字即可参与计算。这个名字就代表了存储数值的空间。“=”号 这里的“=”号是运算符的一种，即=代表赋值运算，并非数学意义上的相等。值 即真正变量存储的数值，需要与变量的数据类型一致。/*变量:存储数值的一块内存区域变量的定义格式:数据类型变量名=数据值;*/public class Demo01Variable{public static void main(String[] args){//定义一个存储整数的变量int myVar = 10;//打印变量的值System.out.println(myVar);//10//改变变量的值myVar = 20;//打印变量的值System.out.println(myVar);//20}}1.1.4 日常变量使用的注意事项可以同时定义多个变量变量定义后可以不赋值，使用时再赋值。不赋值不能使用。变量使用时有作用域的限制。/*变量使用的注意事项:可以同时定义多个变量变量定义后可以不赋值，使用时再赋值。不赋值不能使用。变量使用时有作用域的限制*/public class Demo02Variable{public static void main(String[] args){//可以同时定义多个变量int a=5,b=10;/*int a = 5;int b = 10;*/System.out.println(a);//5System.out.println(b);//10//变量定义后可以不赋值，使用时再赋值。不赋值不能使用。int c;//System.out.println(c);//错误: 可能尚未初始化变量c//System.out.println(c=20);c = 20;System.out.println(c);}}1.2 数据类型Java是一种强类型语言，对不同数据结构进行了严格的区分，对每一种数据类型都做了明确定义，也同时规定了每一种数据类型的变量在内存中占用空间的大小。1.2.1 字节字节是计算机当中存储数据的基本单位，每种数据类型都会占用一定的空间。比特位比特位(bit)是计算机当中最小的存储单位，由于机器码只识别1与0，所以每一位的1与0均为一个比特位字节组成规则在计算机当中如果使用bit来计算数据过于冗余复杂，所以以8个比特位组成一个新的单位——字节，作为数据存储的基本单位常见的数据存储单位之间的换算1B（字节） = 8bit1KB = 1024B1MB = 1024KB1GB = 1024MB1TB = 1024GB1.2.2 数据类型分类数据类型分为基本类型与引用类型，引用类型包括：数组、类、接口，在面向对象后期会全部介绍完毕。这里着重介绍基本数据类型。整数型(精确)int 占用4个字节 (整数的默认值)byte 占用1个字节short 占用2个字节long 占用8个字节long类型在赋值时，需要在值后加入字母l(L)区分其是一个长整型如 int i = 100; short s = 66; long l = 100L;浮点型(小数型，非精确，为近似值)double 占用8个字节 (小数的默认值)float 占用4个字节float类型在赋值时，需要在值后加入字母f(F)区分其是一个浮点型如 double d = 100.0; double d2 = 10.1; float f = 100.0F;字符型char 占用2个字节，必须使用’’包裹，且不能为空。如 char c = ‘a’; char c2 = ‘中’; char c3 = ‘ (空格)’; char c4 = ‘$’转义字符有时我们无法直接给出一个字符，需要使用转义字符进行转义动作。转义字符也为一个字符，由转义符号与被转义字符组成转义符号：\如:\t 制表符\’ 单引号\” 双引号\\ 反斜杠字符存储原理每一个值在存储时，均存储的为值对应的数字。即字符、声音、图片、文字，使用都以数字1或0的方式存储在计算机中。每一个英文字符都有其固定的数字对应。英文字符与数字的对应关系组成了一张编码表，该表名称为ASCII表。(内容见资料)布尔型布尔值是我们比较陌生的类型，它代表一些条件成立与不成立的判断。只有两个值true与false。boolean 占用1个字节如 boolean b = true; boolean b2 = false;类型数据表示范围整数类型byte-128～127整数类型short-32768～32767整数类型int(整数的默认值)-2147483648～2147483648整数类型long-263～263-1小数类型float-3.403E38～3.403E38小数类型double(小数的默认值)-1.798E308～1.798E308字符类型char表示一个字符，如('a'，'A'，'0'，'家')布尔类型boolean只有两个值true与false/*数据类型:整数:(精确)byte:占用1个字节short:占用2个字节int:占用4个字节(默认)long:占用8个字节,使用时必须在末尾加上一个小写字母l或者大写字母L小数:(不精确,近似值)float:占用4个字节,使用时必须在末尾加上一个小写字母f或者大写字母Fdouble:占用8个字节(默认)布尔:boolean:(true,false)占用1个字节字符:char:占用2个字节注意事项:字符不能为空字符实际存储的是一个数值想把具有特殊含义',转换成普通的字符,用转义字符\'想把普通字符t,变成一个具有特殊含义的字符,用转义字符\t*/public class Demo03Variable{public static void main(String[] args){//整数byte b = 100;System.out.println(b);short s = 10000;System.out.println(s);int i = 1600000000;System.out.println(i);long l = 6000000000L;System.out.println(l);//小数double d = 3.14;System.out.println(d);float f = 2.6f;System.out.println(f);//小数是一个不精确的数System.out.println(f-2);//0.5999999//布尔boolean b1 = true;System.out.println(b1);boolean b2 = false;System.out.println(b2);//字符char c = 'a';System.out.println(c);//转义字符char c1 = '\'';System.out.println(c1);char c2 = '\t';System.out.println(c2+"Hello");System.out.println('\\');//字符实际存储的是一个数值System.out.println(c+1);}}1.2.3 数字类型转换数字类型可以有数据类型上的转换，即将一种类型的值赋值给另外一种类型的变量。但要依据数据范围，符合一定规则：各种数据类型按照数据范围从小到大：byte -> short -> int -> long -> float -> double自动类型转换范围小的数据类型值（如int），可以自动转换为范围大的数据类型值（如double）范围大的数据类型 变量 = 范围小的数据类型值；如： double d = 1000;或 int i = 100; double d2 = i;强制类型转换范围大的数据类型值（如double），不可以自动转换为范围小的数据类型值（如int），但是可以强制转换范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型值;如：int i = (int)6.718; //i的值为6或double d = 3.14;int i2 = (int)d; //i2的值为3/*数字类型转换:就是数值转换,包括整数,小数,字符自动类型转换:小-->大byte < short(char)< int < long < float < double格式:范围大的数据类型 变量名 = 范围小的数据类型的值;强制类型转换:大-->小格式:范围小的数据类型 变量名 = (范围小的数据类型)范围大的数据类型的值;*/public class Demo04Variable{public static void main(String[] args){//自动类型转换 int --> doubleint i = 100;double d = i;System.out.println(i);System.out.println(d);//强制类型转换double d2 = 3.14;//int i2 = d2;//错误: 可能损失精度int i2 = (int)d2;System.out.println(i2);System.out.println(d2);}}1.3 变量案例---超市水果报价单1.3.1 案例介绍与演示根据不同的水果种类，使用变量在控制台打印所有水果价格的列表。1.3.2 案例分析我们通过以下方式定义5个变量，来记录可能改变的数据：一个记录整数类型的榴莲编号一个记录小数类型的榴莲价格两个分别记录字符串类型的水果名称与计价单位一个记录字符类型的榴莲品质int liulianId = 1;String liulianName = “榴莲”;double liulianPrice = 32.0;String liulianUnit = “公斤”;char liulianLevel = ‘A’;按照同样的方法，我们也可以将苹果的编号与属性用变量表示。(注意命名)int appleId = 2;String appleName = “苹果”;double applePrice = 6.5;String appleUnit = “公斤”;char appleLevel = ‘B’;这时，再打印时，便可以直接使用变量打印System.out.println("水果编号 水果名称 水果单价 计价单位 品质");System.out.println(" "+ liulianId +" "+ liulianName +" "+ liulianPrice +" "+ liulianUnit +" "+ liulianLevel);System.out.println(" "+ appleId +" "+ appleName +" "+ applePrice +" "+ appleUnit +" "+ appleLevel);很明显，在这种方式打印时价格列表时，可以随意操作价格或者其他属性值而后边打印表单的代码不需要更改。我们用变量来记录各种属性值，将最终的值存储到变量中。/*水果超市报价单:变量版本水果编号水果名称水果单价计价单位品质1榴莲32.0公斤A2苹果6.5公斤B3 猕猴桃6.0公斤A分析:定义3组15个变量用来记录水果信息水果编号:采用int类型定义水果名称:采用String类型定义水果单价:采用double类型定义计价单位:采用String类型定义品质:采用char类型定义*/public class List02{public static void main(String[] args){//定义榴莲的水果信息int llId = 1;String llName = "榴莲";double llPrice = 32.0;String llUnit = "公斤";char llLevel = 'A';//定义苹果的水果信息int appleId = 2;String appleName = "苹果";double applePrice = 6.5;String appleUnit = "公斤";char appleLevel = 'B';//定义猕猴桃的水果信息int mhtId = 3;String mhtName = "猕猴桃";double mhtPrice = 6.0;String mhtUnit = "公斤";char mhtLevel = 'A';System.out.println("水果编号水果名称水果单价计价单位品质");System.out.println(llId+""+llName+""+llPrice+""+llUnit+""+llLevel);System.out.println(appleId+""+appleName+""+applePrice+""+appleUnit+""+appleLevel);System.out.println(3+" 猕猴桃"+6.0+"公斤"+'A');}}第2章 运算符2.1 运算符概念运算符是用来计算数据的指令。数据可以是常量，也可以是变量。被运算符操作的数成为操作数。Int x = 3;Int y = 4;Int z = x + y2.2 算数运算符将操作数参与数学计算(通常为数学计算)运算符运算规则范例结果+正号+33+加2+35+连接字符串“中”+“国”“中国”-负号int a=3;-a-3-减3-12*乘2*36/除5/22%取模(余数)5%21++自增int a=1;a++/++a2--自减int b=3;a--/--a2注意：加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。除法“/”当两边为整数时，取整数部分，舍余数。当两边为浮点型时，按正常规则相除。“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数的符号相同。得到的是两个相除数据的余数。用处: 判断两个数据是否整除。整数做被除数，0不能做除数，否则报错。小数做被除数，整除0结果为Infinity，对0取模结果为NaN自增与自减单独使用：前置与后置效果相同，均为直接+1或-1混合使用：自增（++）：将变量的值加1，分前缀式（如++i）和后缀式（如i++）。前缀式是先加1再使用；后缀式是先使用再加1。自减（--）：将变量的值减1，分前缀式（如--i）和后缀式（如i--）。前缀式是先减1再使用；后缀式是先使用再减1。自增与自减运算符还遵循以下规律： 1. 可以用于整数类型byte、short、int、long，浮点类型float、double，以及字符串类型char。 2. 在Java5.0及以上版本中，它们可以用于基本类型对应的包装器类Byte、Short、Integer、Long、Float、Double、Character。 3. 它们的运算结果的类型与被运算的变量的类型相同。/*算数运算符:+,-,*:相当于数学+,-*+:做为字符串连接符/:两个整数相除,结果是整数%:两个整数取模(余数),结果是整数++:自增(自身加1)--:自减(自身减1)注意事项:1.加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。2.除法“/”当两边为整数时，取整数部分，舍余数。当两边为浮点型时，按正常规则相除。3.“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数的符号相同。4.整数做被除数，0不能做除数，否则报错。5.小数做被除数，整除0结果为Infinity，对0取模结果为NaN自增与自减单独使用：前置与后置效果相同，均为直接+1或-1与其他运算符混合使用：++或- -为前置时，先+1或-1，再使用值。++或- -为后置时，先使用值再+1或-1。*/public class Demo05Operator{public static void main(String[] args){//两个常量相加System.out.println(3 + 5);//8//变量加减乘除模int a = 20;int b = 7;System.out.println(a + b);//27System.out.println(a - b);//13System.out.println(a * b);//140System.out.println(a / b);//2System.out.println(a % b);//6//+:做为字符串连接符System.out.println("中"+"国");//中国/*单独使用：前置与后置效果相同，均为直接+1或-1*///++:自增(自身加1)//--:自减(自身减1)int c = 10;int d = 20;//c++;//d--;++c;--d;System.out.println("c = " + c);//c = 11System.out.println("d = " + d);//d = 19System.out.println("===================================");//1.加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。int e = 15;int f = 20;System.out.println("e + f = " + e + f);//e + f = 1520System.out.println("e + f = " + (e + f));//e + f = 35System.out.println(e + f + " = e + f");//35 = e + f//2.除法“/”当两边为整数时，取整数部分，舍余数。当两边有浮点型时，按正常规则相除。System.out.println(5.0 / 2);//2.5//3.“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数(符号左边的数)的符号相同。System.out.println(5.1 % 2);//1.0999999999999996System.out.println(5 % 2);//1System.out.println(-5 % 2);//-1System.out.println(5 % -2);//1System.out.println(-5 % -2);//-1//4.整数做被除数，0不能做除数，否则报错。//System.out.println(5 / 0);//ArithmeticException: / by zero//5.小数做被除数，整除0结果为Infinity(无穷)，对0取模结果为NaN(not number 无效数字)System.out.println(5.0 / 0);//InfinitySystem.out.println(5.0 % 0);//NaNSystem.out.println("===================================");/*与其他运算混合使用：++或- -为前置时，先+1或-1，再使用值。++或- -为后置时，先使用值再+1或-1。*/System.out.println(e);//15System.out.println(f);//20System.out.println(e++);//15System.out.println(f--);//20System.out.println(e);//16System.out.println(f);//19int i1 = 100;int i2 = i1++ + 200;System.out.println(i1);//101System.out.println(i2);//300int i3 = 100;int i4 = ++i3 + 200;System.out.println(i3);//101System.out.println(i4);//301}}2.3 赋值运算符为变量赋值的运算符运算符运算规则范例结果=赋值int a=22+=加后赋值int a=2，a+=24-=减后赋值int a=2，a-=20*=乘后赋值int a=2，a*=24/=整除后赋值int a=2，a/=21%=取模后赋值int a=2，a%=20注意：诸如+=这样形式的赋值运算符，会将结果自动强转成等号左边的数据类型。/*赋值运算符:=,+=,-=,*=,/=,%=+=,-=,*=,/=,%=运算符的运算规则:先将运算符两边进行+,-,*,/,%运算,在把结果赋值给左边的变量+=,-=,*=,/=,%=注意事项:运算符左边必须是一个变量+=,-=,*=,/=,%=特点:隐含一个强制类型转换*/public class Demo06Operator{public static void main(String[] args){int a = 10;a += 20;//相当于 a = a + 20;System.out.println("a = " + a);//5 += 6;//错误: 意外的类型,这里5的位置需要一个变量byte b = 10;//b = b + 100;//错误: 可能损失精度//b = (byte)(b + 100);b += 100;//+=隐含了一个强制类型转换 相当于b = (byte)(b + 100);System.out.println("b = " + b);}}2.4 比较运算符又叫关系运算符，即判断两个操作数的大小关系及是否相等关系，比较运算符的返回一定为布尔值。运算符运算规则范例结果==相等于4==3false!=不等于4!=3true<小于4<3false>大于4>3true<=小于等于4<=3false>=大于等于4>=3true==，!=，>，<，>=，<=关系运算符的结果都是boolean型，也就是要么是true，要么是false。注意事项n 关系运算符“==”不能误写成“=” 。public class Demo06Operator {public static void main(String[] args) {int a = 10;int b = 20;int c = 10;System.out.println(a == b);System.out.println(a == c);System.out.println("-----------------");System.out.println(a != b);System.out.println(a != c);System.out.println("-----------------");System.out.println(a > b);System.out.println(a > c);System.out.println("-----------------");System.out.println(a >= b);System.out.println(a >= c);System.out.println("-----------------");int x = 3;int y = 4;// System.out.println(x == y);// System.out.println(x = y);//把y赋值给x，把x的值输出boolean bb = (x == y);//报错// boolean cc = (x = y);int cc = (x = y);}}2.5 逻辑运算符用于计算两个布尔值经过指定逻辑后的运算结果，结果同样是一个布尔值运算符运算规则范例结果&与(并且)false&trueFalse|或false|trueTrue^异或true^flaseTrue!非(取反)!trueFlase&&短路与false&&trueFalse||短路或true ||trueTrue作用:逻辑运算符用于连接布尔型表达式，在Java中不可以写成33 && x<6 。基本使用: &(与),|(或),^(异或),!(非)与：& 有false则false或：| 有true则true异或：^ 相同则false,不同则true非：! true则false,false则truepublic class Demo08Operator {public static void main(String[] args) {int a = 10;int b = 20;int c = 30;System.out.println((a > b) & (a > c));// false & falseSystem.out.println((a < b) & (a > c)); // true & falseSystem.out.println((a > b) & (a < c)); // false & trueSystem.out.println((a < b) & (a < c)); // true & trueSystem.out.println("---------------");System.out.println((a > b) | (a > c));// false | falseSystem.out.println((a < b) | (a > c)); // true | falseSystem.out.println((a > b) | (a < c)); // false | trueSystem.out.println((a < b) | (a < c)); // true | trueSystem.out.println("---------------");System.out.println((a > b) ^ (a > c));// false ^ falseSystem.out.println((a < b) ^ (a > c)); // true ^ falseSystem.out.println((a > b) ^ (a < c)); // false ^ trueSystem.out.println((a < b) ^ (a < c)); // true ^ trueSystem.out.println("---------------");System.out.println((a > b)); // falseSystem.out.println(!(a > b)); // !falseSystem.out.println(!!(a > b)); // !!false}}&&和&的区别单&时，左边无论真假，右边都进行运算；双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。public class Demo09Operator {public static void main(String[] args) {int a = 10;int b = 20;int c = 30;System.out.println((a > b) && (a > c));// false && falseSystem.out.println((a < b) && (a > c)); // true && falseSystem.out.println((a > b) && (a < c)); // false && trueSystem.out.println((a < b) && (a < c)); // true && trueSystem.out.println("---------------");System.out.println((a > b) || (a > c));// false || falseSystem.out.println((a < b) || (a > c)); // true || falseSystem.out.println((a > b) || (a < c)); // false || trueSystem.out.println((a < b) || (a < c)); // true || trueSystem.out.println("---------------");int x = 3;int y = 4;// System.out.println((x++ > 4) & (y++ > 5)); // false & falseSystem.out.println((x++ > 4) && (y++ > 5)); // false && falseSystem.out.println("x:" + x);System.out.println("y:" + y);}}2.6 三元运算符接下来我们要学习的三元运算符与之前的运算符不同。之前学习的均为一元或者二元运算符。元即参与运算的数据。格式：(条件表达式)？表达式1：表达式2；表达式：通俗的说，即通过使用运算符将操作数联系起来的式子，例如：3+2，使用算数运算符将操作数联系起来，这种情况，我们称为算数表达式。3>2，使用比较运算符（也称为条件运算符）将操作数联系起来，这种情况，我们称为条件表达式。其他表达式，不再一一举例。三元运算符运算规则：先判断条件表达式的值，若为true，运算结果为表达式1；若为false，运算结果为表达式2。注意：三元运算符，最终一定会产生一个结果值，这个值必须被使用起来。要么被运算符使用，要么被打印/*三元运算符:求两个数的最大值,判断两个数是否相等格式:(条件表达式) ? 表达式1 : 表达式2;执行流程:首先判断条件表达式是否成立true:表达式1作为3元运算符的结果false:表达式2作为3元运算符的结果注意：三元运算符，最终一定会产生一个结果值，这个值必须被使用起来。要么被运算符使用，要么被打印*/public class Demo10Operator{public static void main(String[] args){int a = 10;int b = 20;int max = (a > b) ? 10 : 20;System.out.println("max = " + max);int c = 15;int d = 10;//System.out.println((c != d) ? "相等" : "不相等");String s = (c != d) ? "相等" : "不相等";System.out.println("s = " + s);//(c != d) ? "相等" : "不相等";//错误: 不是语句//3;//错误: 不是语句}}2.7 运算符优先级2.7.1 优先级概念运算符运算的先后顺序，优先级越高(数字越小)，计算顺序越靠前。2.7.2 优先级规则优先级相同的情况下，按照从左到右的顺序依次运算优先级描述运算符1括号()、[]2正负号+、-3自增自减，非++、--、!4乘除，取余*、/、%5加减+、-6移位运算<<、>>、>>>7大小关系>、>=、<、<=8相等关系==、!=9按位与&10按位异或^11按位或|12逻辑与&&13逻辑或||14条件运算?:15赋值运算=、+=、-=、*=、/=、%=16位赋值运算&=、|=、<<=、>>=、>>>=2.8 运算符案例---超市购物小票案例2.8.1 案例介绍与演示模拟真实购物逻辑，以上述图片为需求原型，根据不同购物物品完成购物小票内容打印到控制台。2.8.2 案例分析a) 总体思路案例分析可分为三个部分：小票界面结构分析：通过小票界面分析，可以将复杂的问题简单化，规划出来更为具体的需求。数据分析：实际开发过程中的数据是复杂的，存在多个维度的信息。需要分析出我具体需要操作的数据有哪些业务逻辑分析：在接收到最基本的必要数据后，需要加入业务逻辑来完成所有需求。如本例中，求总价的过程。b) 小票界面结构分析票头: 又分为两部分，即欢迎光临欢迎语与具体的物品属性标题。票体: 是读取的真实数据内容，即打印对应的变量值即可。票脚: 也分为两部分，即统计信息与开发票的提醒信息。这里为了简化需求，去掉了时间与付钱找零的统计,只完成商品价钱和数量统计部分。c) 数据分析经过观察，我们确定一项物品应该有如下几个属性：品名：物品名称，String型商品编号：用于区分管理商品的编号，String型售价：物品单价，double型数量：购买数量，原型中是小数，我们这里以个为单位，设计成int型金额：这一项物品的购物总金额，double型票脚：我们发现三个单独的可变化量商品项数：共有几项商品，int型共计：所有项商品一共多少件，int型总计：所有商品花费，double型d) 逻辑分析与直接打印数据不同，这个案例的基本需求中存在许多统计信息，显然类似总价这样的值是由其他数据计算得来。这里就涉及到了常量或变量的运算问题，需要用到运算符来完成这个需求。普通变量值直接打印对于普通的商品名称，商品单价等信息，读取用户数据后可以直接打印。这里我们先“帮用户给出数据”。需要计算的数据的打印票脚部分的三个统计信息需要经过计算得到并打印：商品项数：共有几项商品，直接给出，int型共计：所有商品数量求和，int型总计：所有商品金额求和，double型/*超市购物小票:分析:票头:用字符串方式直接打印票体:先定义3组15个变量用来记录商品信息票脚:计算:商品种类计算:商品数量计算:商品总金额*/public class SuperMarketTicket{public static void main(String[] args){//先定义3组15个变量用来记录商品信息//定义少林寺酥饼核桃String slsName = "少林寺酥饼核桃";String slsID = "(090115)";double slsPrice = 15.50;int slsNumber = 22;double slsMoney = slsPrice * slsNumber;String xjName = "新疆美味羊肉串";String xjID = "(090028)";double xjPrice = 16.00;int xjNumber = 55;double xjMoney = xjPrice * xjNumber;String skName = "尚康杂粮牡丹饼";String skID = "(090027)";double skPrice = 14.50;int skNumber = 24;double skMoney = skPrice * skNumber;//计算:商品种类int goodsItem = 3;//计算:商品数量int goodsNumner = slsNumber + xjNumber + skNumber;//计算:商品总金额double goodsMoney = slsMoney + xjMoney + skMoney;//打印小票//票头System.out.println("欢迎光临");System.out.println("品名售价数量金额");System.out.println("------------------------------------------------");//票体System.out.println(slsName+slsID+""+slsPrice+""+slsNumber+""+slsMoney);System.out.println(xjName+xjID+""+xjPrice+""+xjNumber+""+xjMoney);System.out.println(skName+skID+""+skPrice+""+skNumber+""+skMoney);System.out.println("------------------------------------------------");//票脚System.out.println(""+goodsItem+"项商品共计: "+goodsNumner+"件");System.out.println("总计: " + goodsMoney);System.out.println("凭此小票换取发票!");}}第3章本日自习作业：3.1 知识点相关题3.1.1 知识点：变量要求：1) 熟练掌握各种基本数据类型及其大小；2) 熟练掌握各种基本数据类型变量的定义；3) 熟练掌握数据类型转换题目：1)写出8种数据类型的名称及大小（重要）；Byte -- 一个字节 2的1*8次方Short -- 两个字节 2的2*8次方Int -- 四个字节 2的4*8次方Long -- 八个字节 2的8*8次方Char -- 两个字节 2的2*8次方Float -- 四个字节 2的4*8次方Double -- 八个字节 2的8*8次方2)定义类：Test1，定义main()方法，分别定义8种数据类型的变量，并赋初始值；然后打印每种类型的变量。代码实现：public class Test1 {//定义主方法public static void main(String[] args) {//在控制台上打印byte a = 1;short b = 2;int c = 3;long d = 4;char e = '5';float f = 4.5f;double g = 5.43423;boolean h = true;boolean i = false;System.out.println(a);System.out.println(b);System.out.println(c);System.out.println(d);System.out.println(e);System.out.println(f);System.out.println(g);System.out.println(h);System.out.println(i);}}3)定义类：Test2，定义main()方法，请按如下要求编写代码：a)定义一个byte类型的变量v1，赋初始值；将v1赋给一个int类型的变量v2。将v2赋给一个long类型的变量v3将v3赋给一个double类型的变量v4b)打印每个变量的值；代码实现：public class Test2 {//定义主方法public static void main(String[] args) {//在控制台上打印byte v1 = 5;int v2 =v1;long v3 = v2;double v4 = v3;System.out.println(v1);System.out.println(v2);System.out.println(v3);System.out.println(v4);}}4)定义类：Test3，定义main()方法，请按如下要求编写代码：a)定义一个double类型的变量v1，赋值为：3.1定义一个double类型的变量v2，赋值为：88.88定义一个int类型的变量v3，将v1强转后赋值给v3定义一个int类型的变量v4，将v2强转后赋值给v4打印v3和v4的值，请观察一个浮点型被强转为int型后的结果；代码实现：public class Test3 {//定义主方法public static void main(String[] args) {//在控制台上打印double v1 = 3.1;double v2 = 88.88;int v3 =(int)v1;int v4 = (int)v2;System.out.println(v3);System.out.println(v4);}}3.1.2 分析以下需求，并用代码实现1.键盘录入一个三位整数数，请分别获取该三位数上每一位的数值2.例如：键盘录入的整数123的个位、十位、百位，分别是3、2、13.打印格式:"数字123的个位是 3, 十位是 2, 百位是 1"代码实现：public class HelloWorld {//定义主方法@SuppressWarnings("resource")public static void main(String[] args) {//在控制台上打印Scanner sc = new Scanner(System.in);System.out.println("请输入一个三位数的数值");int a = sc.nextInt();int b = a%100%10;int c = a%100/10;int d = a/100;System.out.println("数字a的个位是"+b+", 十位是"+c+", 百位是"+d);}}3.1.3 分析以下需求，并用代码实现1.键盘录入三个int类型的数字2.要求：(1)求出三个数中的最小值并打印(2)求出三个数的和并打印代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请依次输入三个数值");int a = sc.nextInt();int b = sc.nextInt();int c = sc.nextInt();//求出三个数中的最小值并打印int temp = aint min = tempSystem.out.println(min);//求出三个数的和并打印System.out.println(a+b+c);}}3.1.4 知识点：算数运算符要求：1) 熟练掌握算数运算符的使用；题目：1)定义类：Test4，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：10定义一个int类型的变量v2，初始值：3b)请分别打印这两个数加，减，乘，除，取模的结果c)将v1自增1，将v2自减1d)再次打印这两个数：加，减，乘，除，取模的结果 代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {int v1 = 10;int v2 = 3;//b)打印这两个数加，减，乘，除，取模的结果System.out.println(v1+v2);System.out.println(v1-v2);System.out.println(v1*v2);System.out.println(v1/v2);System.out.println(v1%v2);//将v1自增1，将v2自减1//System.out.println(v1++);System.out.println(++v1);//System.out.println(v2--);System.out.println(--v2);//再次打印这两个数：加，减，乘，除，取模的结果System.out.println(v1+v2);System.out.println(v1-v2);System.out.println(v1*v2);System.out.println(v1/v2);System.out.println(v1%v2);}}3.1.5 知识点：赋值运算符要求：1) 熟练掌握赋值运算符的使用；题目：1)定义类：Test5，定义main()方法，请使用赋值运算符编写代码：a)定义一个int类型的变量v1，初始值：10b)将此变量加10；c)将此变量减5；d)将此变量乘3；e)将此变量除以10；f)将此变量模2g)打印v1的值代码实现：package StudyJavaSE;/*** 1)请使用赋值运算符编写代码：* a)定义一个int类型的变量v1，初始值：10* b)将此变量加10；* c)将此变量减5；* d)将此变量乘3；* e)将此变量除以10；* f)将此变量模2* g)打印v1的值 * * @author奋斗蒙 * */public class FuZhiYunsuanfu {public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：10int a1 = 10;int a2 = 10;System.out.println(a1);System.out.println(a2);//b)将此变量加10；a1+=10;System.out.println(a1);a2 = a2 + 10;System.out.println(a2);//c)将此变量减5；a1-=5;System.out.println(a1);a2 = a2 - 5;System.out.println(a2);//d)将此变量乘3；a1*=3;System.out.println(a1);a2 = a2 * 3;System.out.println(a2);//e)将此变量除以10；a1/=10;System.out.println(a1);a2 = a2 / 10;System.out.println(a2);//f)将此变量模2a1%=2;System.out.println(a1);a2 = a2 % 2;System.out.println(a2);}}3.1.6 知识点：比较运算符要求：1) 熟练掌握比较运算符的使用；题目：1)定义类：Test6，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：10定义一个int类型的变量v2，初始值：3b)请打印v1是否等于v2c)请打印v1是否大于v2d)请打印v1是否小于v2e)请打印v1是否大于等于v2f)请打印v1是否小于等于v2g)请打印v1是否不等于v2 代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：10//定义一个int类型的变量v2，初始值：3int v1 = 10;int v2 = 3;//b)请打印v1是否等于v2System.out.println(v1==v2);//c)请打印v1是否大于v2System.out.println(v1>v2);//d)请打印v1是否小于v2System.out.println(v1//e)请打印v1是否大于等于v2System.out.println(v1>=v2);//f)请打印v1是否小于等于v2System.out.println(v1<=v2);//g)请打印v1是否不等于v2System.out.println(v1!=v2);}}3.1.7 知识点：逻辑运算符要求：1) 熟练掌握逻辑运算符的使用；题目：1)定义类：Test7，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：24定义一个double类型的变量v2，初始值：3.14b)请打印：v1是否大于20，并且小于50c)请打印：v1是否小于20，或者大于50d)请打印：v1是否大于20，并且v2小于3.5e)请使用“非运算符”判断：v1是否不等于25package StudyJavaSE;/***请按如下要求编写代码：* a)定义一个int类型的变量v1，初始值：24*定义一个double类型的变量v2，初始值：3.14* b)请打印：v1 是否大于20，并且小于50* c)请打印：v1是否小于20，或者大于50* d)请打印：v1是否大于20，并且v2小于3.5* e)思考：请使用“非运算符”判断：v1是否不等于25 * @author奋斗蒙 * */public class LuoJiYunsuanfu {public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：24//定义一个double类型的变量v2，初始值：3.14int v1 = 24;double v2 = 3.14;//b)请打印：v1 是否大于20，并且小于50System.out.println((v1>10)&(v1<50));//c)请打印：v1是否小于20，或者大于50System.out.println((v1<20)|(v1>50));//d)请打印：v1是否大于20，并且v2小于3.5System.out.println((v1>20)&(v2<3.15));}} 3.1.8 知识点：三元运算符要求：1) 熟练掌握三元运算符的使用；题目：1)定义类：Test8，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：20定义一个int类型的变量v2，初始值：18b)请使用三元运算符求两个数的最大值，并打印；代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：20//定义一个int类型的变量v2，初始值：18int v1 = 20;int v2 = 18;//b)请使用三元运算符求两个数的最大值，并打印；System.out.println(v1>v2?v1:v2);}}2)定义类：Test9，定义main()方法，请按如下要求编写代码：a)定一个int类型的变量v1，初始值20；定义一个String类型的变量v2，初始值：“”b)请使用三元运算符判断：如果v1大于20，v2的值为：大于，否则，将v2的值赋值为：不大于。c)打印v2的值代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {//a)定一个int类型的变量v1，初始值20；//定义一个String类型的变量v2，初始值：“”int v1 = 20;String v2 = "";//b)请使用三元运算符判断：如果v1大于20，v2的值为：大于，//否则，将v2的值赋值为：不大于。//c)打印v2的值System.out.println(v1>20?(v2="大于"):(v2="不大于"));}}3.2 代码题3.2.1 在控制台打印如下的信息要求:1.清单顶部为固定的数据，直接打印即可2.清单中部为商品，为变化的数据，需要记录水果信息后，打印3.清单底部包含了统计操作，需经过计算后，打印答案：/*在控制台打印如下的信息:-----------------------购买的水果信息--------------------------水果编号水果名称水果单价计价单位品质 购买数量1香蕉8.0公斤A 52苹果6.5公斤B 33橙子9.0公斤A 4---------------------------------------------------------------您购买的水果总金额为: 95.5 元分析:1.定义3组18个变量用来记录水果信息水果编号:使用int类型变量定义水果名称:使用String类型定义水果单价:使用double类型变量定义计价单位:使用String类型定义品质:使用char类型定义购买数量:使用int类型变量定义2.计算购买的水果总金额每种水果的单价*购买数量之和*/public class Demo01{public static void main(String[] args){//1.定义3组18个变量用来记录水果信息//香蕉int bananaId = 1;String bananaName = "香蕉";double bananaPrice = 8.0;String bananaUnit = "公斤";char bananaLevel = 'A';int bananaNumber = 5;//苹果int appleId = 2;String appleName = "苹果";double applePrice = 6.5;String appleUnit = "公斤";char appleLevel = 'B';int appleNumber = 3;//橙子int orangeId = 3;String orangeName = "橙子";double orangePrice = 9.0;String orangeUnit = "公斤";char orangeLevel = 'A';int orangeNumber = 4;//2.计算购买的水果总金额double totalMoney = bananaPrice* bananaNumber + applePrice * appleNumber + orangePrice * orangeNumber;System.out.println("--------------------------------购买的水果信息----------------------------------");System.out.println("水果编号水果名称水果单价计价单位品质购买数量");System.out.println(bananaId+""+bananaName+""+bananaPrice+""+bananaUnit+""+bananaLevel+""+bananaNumber);System.out.println(appleId+""+appleName+""+applePrice+""+appleUnit+""+appleLevel+""+appleNumber);System.out.println(orangeId+""+orangeName+""+orangePrice+""+orangeUnit+""+orangeLevel+""+orangeNumber);System.out.println("--------------------------------------------------------------------------------");System.out.println("您购买的水果总金额为: " + totalMoney +" 元");}}第二天 变量&数据类型&运算符【悟空教程】第02天 Java基础第1章 变量1.1 变量1.1.1 变量概念变量是用来存储数值的内存区域1.1.2 作用变量用来记录数值。使用变量进行代数计算，则该变量中数值可以随着程序的逻辑计算而改变。当计算全部结束后，再将数值拿出展示给用户。1.1.3 变量的使用格式日常变量的使用分为四个部分变量定义格式数据类型 变量名 = 变量值；如 int a = 100;变量类型 每一个变量均必须指定其变量类型。Java是强类型语言，在Java中不同的数据类型在内存中的存储方式是不尽相同的。所以必须在存储内容之前指定数据类型。变量名 即使用标识符为变量起一个名字，之后在计算时，使用该名字即可参与计算。这个名字就代表了存储数值的空间。“=”号 这里的“=”号是运算符的一种，即=代表赋值运算，并非数学意义上的相等。值 即真正变量存储的数值，需要与变量的数据类型一致。/*变量:存储数值的一块内存区域变量的定义格式:数据类型变量名=数据值;*/public class Demo01Variable{public static void main(String[] args){//定义一个存储整数的变量int myVar = 10;//打印变量的值System.out.println(myVar);//10//改变变量的值myVar = 20;//打印变量的值System.out.println(myVar);//20}}1.1.4 日常变量使用的注意事项可以同时定义多个变量变量定义后可以不赋值，使用时再赋值。不赋值不能使用。变量使用时有作用域的限制。/*变量使用的注意事项:可以同时定义多个变量变量定义后可以不赋值，使用时再赋值。不赋值不能使用。变量使用时有作用域的限制*/public class Demo02Variable{public static void main(String[] args){//可以同时定义多个变量int a=5,b=10;/*int a = 5;int b = 10;*/System.out.println(a);//5System.out.println(b);//10//变量定义后可以不赋值，使用时再赋值。不赋值不能使用。int c;//System.out.println(c);//错误: 可能尚未初始化变量c//System.out.println(c=20);c = 20;System.out.println(c);}}1.2 数据类型Java是一种强类型语言，对不同数据结构进行了严格的区分，对每一种数据类型都做了明确定义，也同时规定了每一种数据类型的变量在内存中占用空间的大小。1.2.1 字节字节是计算机当中存储数据的基本单位，每种数据类型都会占用一定的空间。比特位比特位(bit)是计算机当中最小的存储单位，由于机器码只识别1与0，所以每一位的1与0均为一个比特位字节组成规则在计算机当中如果使用bit来计算数据过于冗余复杂，所以以8个比特位组成一个新的单位——字节，作为数据存储的基本单位常见的数据存储单位之间的换算1B（字节） = 8bit1KB = 1024B1MB = 1024KB1GB = 1024MB1TB = 1024GB1.2.2 数据类型分类数据类型分为基本类型与引用类型，引用类型包括：数组、类、接口，在面向对象后期会全部介绍完毕。这里着重介绍基本数据类型。整数型(精确)int 占用4个字节 (整数的默认值)byte 占用1个字节short 占用2个字节long 占用8个字节long类型在赋值时，需要在值后加入字母l(L)区分其是一个长整型如 int i = 100; short s = 66; long l = 100L;浮点型(小数型，非精确，为近似值)double 占用8个字节 (小数的默认值)float 占用4个字节float类型在赋值时，需要在值后加入字母f(F)区分其是一个浮点型如 double d = 100.0; double d2 = 10.1; float f = 100.0F;字符型char 占用2个字节，必须使用’’包裹，且不能为空。如 char c = ‘a’; char c2 = ‘中’; char c3 = ‘ (空格)’; char c4 = ‘$’转义字符有时我们无法直接给出一个字符，需要使用转义字符进行转义动作。转义字符也为一个字符，由转义符号与被转义字符组成转义符号：\如:\t 制表符\’ 单引号\” 双引号\\ 反斜杠字符存储原理每一个值在存储时，均存储的为值对应的数字。即字符、声音、图片、文字，使用都以数字1或0的方式存储在计算机中。每一个英文字符都有其固定的数字对应。英文字符与数字的对应关系组成了一张编码表，该表名称为ASCII表。(内容见资料)布尔型布尔值是我们比较陌生的类型，它代表一些条件成立与不成立的判断。只有两个值true与false。boolean 占用1个字节如 boolean b = true; boolean b2 = false;类型数据表示范围整数类型byte-128～127整数类型short-32768～32767整数类型int(整数的默认值)-2147483648～2147483648整数类型long-263～263-1小数类型float-3.403E38～3.403E38小数类型double(小数的默认值)-1.798E308～1.798E308字符类型char表示一个字符，如('a'，'A'，'0'，'家')布尔类型boolean只有两个值true与false/*数据类型:整数:(精确)byte:占用1个字节short:占用2个字节int:占用4个字节(默认)long:占用8个字节,使用时必须在末尾加上一个小写字母l或者大写字母L小数:(不精确,近似值)float:占用4个字节,使用时必须在末尾加上一个小写字母f或者大写字母Fdouble:占用8个字节(默认)布尔:boolean:(true,false)占用1个字节字符:char:占用2个字节注意事项:字符不能为空字符实际存储的是一个数值想把具有特殊含义',转换成普通的字符,用转义字符\'想把普通字符t,变成一个具有特殊含义的字符,用转义字符\t*/public class Demo03Variable{public static void main(String[] args){//整数byte b = 100;System.out.println(b);short s = 10000;System.out.println(s);int i = 1600000000;System.out.println(i);long l = 6000000000L;System.out.println(l);//小数double d = 3.14;System.out.println(d);float f = 2.6f;System.out.println(f);//小数是一个不精确的数System.out.println(f-2);//0.5999999//布尔boolean b1 = true;System.out.println(b1);boolean b2 = false;System.out.println(b2);//字符char c = 'a';System.out.println(c);//转义字符char c1 = '\'';System.out.println(c1);char c2 = '\t';System.out.println(c2+"Hello");System.out.println('\\');//字符实际存储的是一个数值System.out.println(c+1);}}1.2.3 数字类型转换数字类型可以有数据类型上的转换，即将一种类型的值赋值给另外一种类型的变量。但要依据数据范围，符合一定规则：各种数据类型按照数据范围从小到大：byte -> short -> int -> long -> float -> double自动类型转换范围小的数据类型值（如int），可以自动转换为范围大的数据类型值（如double）范围大的数据类型 变量 = 范围小的数据类型值；如： double d = 1000;或 int i = 100; double d2 = i;强制类型转换范围大的数据类型值（如double），不可以自动转换为范围小的数据类型值（如int），但是可以强制转换范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型值;如：int i = (int)6.718; //i的值为6或double d = 3.14;int i2 = (int)d; //i2的值为3/*数字类型转换:就是数值转换,包括整数,小数,字符自动类型转换:小-->大byte < short(char)< int < long < float < double格式:范围大的数据类型 变量名 = 范围小的数据类型的值;强制类型转换:大-->小格式:范围小的数据类型 变量名 = (范围小的数据类型)范围大的数据类型的值;*/public class Demo04Variable{public static void main(String[] args){//自动类型转换 int --> doubleint i = 100;double d = i;System.out.println(i);System.out.println(d);//强制类型转换double d2 = 3.14;//int i2 = d2;//错误: 可能损失精度int i2 = (int)d2;System.out.println(i2);System.out.println(d2);}}1.3 变量案例---超市水果报价单1.3.1 案例介绍与演示根据不同的水果种类，使用变量在控制台打印所有水果价格的列表。1.3.2 案例分析我们通过以下方式定义5个变量，来记录可能改变的数据：一个记录整数类型的榴莲编号一个记录小数类型的榴莲价格两个分别记录字符串类型的水果名称与计价单位一个记录字符类型的榴莲品质int liulianId = 1;String liulianName = “榴莲”;double liulianPrice = 32.0;String liulianUnit = “公斤”;char liulianLevel = ‘A’;按照同样的方法，我们也可以将苹果的编号与属性用变量表示。(注意命名)int appleId = 2;String appleName = “苹果”;double applePrice = 6.5;String appleUnit = “公斤”;char appleLevel = ‘B’;这时，再打印时，便可以直接使用变量打印System.out.println("水果编号 水果名称 水果单价 计价单位 品质");System.out.println(" "+ liulianId +" "+ liulianName +" "+ liulianPrice +" "+ liulianUnit +" "+ liulianLevel);System.out.println(" "+ appleId +" "+ appleName +" "+ applePrice +" "+ appleUnit +" "+ appleLevel);很明显，在这种方式打印时价格列表时，可以随意操作价格或者其他属性值而后边打印表单的代码不需要更改。我们用变量来记录各种属性值，将最终的值存储到变量中。/*水果超市报价单:变量版本水果编号水果名称水果单价计价单位品质1榴莲32.0公斤A2苹果6.5公斤B3 猕猴桃6.0公斤A分析:定义3组15个变量用来记录水果信息水果编号:采用int类型定义水果名称:采用String类型定义水果单价:采用double类型定义计价单位:采用String类型定义品质:采用char类型定义*/public class List02{public static void main(String[] args){//定义榴莲的水果信息int llId = 1;String llName = "榴莲";double llPrice = 32.0;String llUnit = "公斤";char llLevel = 'A';//定义苹果的水果信息int appleId = 2;String appleName = "苹果";double applePrice = 6.5;String appleUnit = "公斤";char appleLevel = 'B';//定义猕猴桃的水果信息int mhtId = 3;String mhtName = "猕猴桃";double mhtPrice = 6.0;String mhtUnit = "公斤";char mhtLevel = 'A';System.out.println("水果编号水果名称水果单价计价单位品质");System.out.println(llId+""+llName+""+llPrice+""+llUnit+""+llLevel);System.out.println(appleId+""+appleName+""+applePrice+""+appleUnit+""+appleLevel);System.out.println(3+" 猕猴桃"+6.0+"公斤"+'A');}}第2章 运算符2.1 运算符概念运算符是用来计算数据的指令。数据可以是常量，也可以是变量。被运算符操作的数成为操作数。Int x = 3;Int y = 4;Int z = x + y2.2 算数运算符将操作数参与数学计算(通常为数学计算)运算符运算规则范例结果+正号+33+加2+35+连接字符串“中”+“国”“中国”-负号int a=3;-a-3-减3-12*乘2*36/除5/22%取模(余数)5%21++自增int a=1;a++/++a2--自减int b=3;a--/--a2注意：加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。除法“/”当两边为整数时，取整数部分，舍余数。当两边为浮点型时，按正常规则相除。“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数的符号相同。得到的是两个相除数据的余数。用处: 判断两个数据是否整除。整数做被除数，0不能做除数，否则报错。小数做被除数，整除0结果为Infinity，对0取模结果为NaN自增与自减单独使用：前置与后置效果相同，均为直接+1或-1混合使用：自增（++）：将变量的值加1，分前缀式（如++i）和后缀式（如i++）。前缀式是先加1再使用；后缀式是先使用再加1。自减（--）：将变量的值减1，分前缀式（如--i）和后缀式（如i--）。前缀式是先减1再使用；后缀式是先使用再减1。自增与自减运算符还遵循以下规律： 1. 可以用于整数类型byte、short、int、long，浮点类型float、double，以及字符串类型char。 2. 在Java5.0及以上版本中，它们可以用于基本类型对应的包装器类Byte、Short、Integer、Long、Float、Double、Character。 3. 它们的运算结果的类型与被运算的变量的类型相同。/*算数运算符:+,-,*:相当于数学+,-*+:做为字符串连接符/:两个整数相除,结果是整数%:两个整数取模(余数),结果是整数++:自增(自身加1)--:自减(自身减1)注意事项:1.加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。2.除法“/”当两边为整数时，取整数部分，舍余数。当两边为浮点型时，按正常规则相除。3.“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数的符号相同。4.整数做被除数，0不能做除数，否则报错。5.小数做被除数，整除0结果为Infinity，对0取模结果为NaN自增与自减单独使用：前置与后置效果相同，均为直接+1或-1与其他运算符混合使用：++或- -为前置时，先+1或-1，再使用值。++或- -为后置时，先使用值再+1或-1。*/public class Demo05Operator{public static void main(String[] args){//两个常量相加System.out.println(3 + 5);//8//变量加减乘除模int a = 20;int b = 7;System.out.println(a + b);//27System.out.println(a - b);//13System.out.println(a * b);//140System.out.println(a / b);//2System.out.println(a % b);//6//+:做为字符串连接符System.out.println("中"+"国");//中国/*单独使用：前置与后置效果相同，均为直接+1或-1*///++:自增(自身加1)//--:自减(自身减1)int c = 10;int d = 20;//c++;//d--;++c;--d;System.out.println("c = " + c);//c = 11System.out.println("d = " + d);//d = 19System.out.println("===================================");//1.加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。int e = 15;int f = 20;System.out.println("e + f = " + e + f);//e + f = 1520System.out.println("e + f = " + (e + f));//e + f = 35System.out.println(e + f + " = e + f");//35 = e + f//2.除法“/”当两边为整数时，取整数部分，舍余数。当两边有浮点型时，按正常规则相除。System.out.println(5.0 / 2);//2.5//3.“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数(符号左边的数)的符号相同。System.out.println(5.1 % 2);//1.0999999999999996System.out.println(5 % 2);//1System.out.println(-5 % 2);//-1System.out.println(5 % -2);//1System.out.println(-5 % -2);//-1//4.整数做被除数，0不能做除数，否则报错。//System.out.println(5 / 0);//ArithmeticException: / by zero//5.小数做被除数，整除0结果为Infinity(无穷)，对0取模结果为NaN(not number 无效数字)System.out.println(5.0 / 0);//InfinitySystem.out.println(5.0 % 0);//NaNSystem.out.println("===================================");/*与其他运算混合使用：++或- -为前置时，先+1或-1，再使用值。++或- -为后置时，先使用值再+1或-1。*/System.out.println(e);//15System.out.println(f);//20System.out.println(e++);//15System.out.println(f--);//20System.out.println(e);//16System.out.println(f);//19int i1 = 100;int i2 = i1++ + 200;System.out.println(i1);//101System.out.println(i2);//300int i3 = 100;int i4 = ++i3 + 200;System.out.println(i3);//101System.out.println(i4);//301}}2.3 赋值运算符为变量赋值的运算符运算符运算规则范例结果=赋值int a=22+=加后赋值int a=2，a+=24-=减后赋值int a=2，a-=20*=乘后赋值int a=2，a*=24/=整除后赋值int a=2，a/=21%=取模后赋值int a=2，a%=20注意：诸如+=这样形式的赋值运算符，会将结果自动强转成等号左边的数据类型。/*赋值运算符:=,+=,-=,*=,/=,%=+=,-=,*=,/=,%=运算符的运算规则:先将运算符两边进行+,-,*,/,%运算,在把结果赋值给左边的变量+=,-=,*=,/=,%=注意事项:运算符左边必须是一个变量+=,-=,*=,/=,%=特点:隐含一个强制类型转换*/public class Demo06Operator{public static void main(String[] args){int a = 10;a += 20;//相当于 a = a + 20;System.out.println("a = " + a);//5 += 6;//错误: 意外的类型,这里5的位置需要一个变量byte b = 10;//b = b + 100;//错误: 可能损失精度//b = (byte)(b + 100);b += 100;//+=隐含了一个强制类型转换 相当于b = (byte)(b + 100);System.out.println("b = " + b);}}2.4 比较运算符又叫关系运算符，即判断两个操作数的大小关系及是否相等关系，比较运算符的返回一定为布尔值。运算符运算规则范例结果==相等于4==3false!=不等于4!=3true<小于4<3false>大于4>3true<=小于等于4<=3false>=大于等于4>=3true==，!=，>，<，>=，<=关系运算符的结果都是boolean型，也就是要么是true，要么是false。注意事项n 关系运算符“==”不能误写成“=” 。public class Demo06Operator {public static void main(String[] args) {int a = 10;int b = 20;int c = 10;System.out.println(a == b);System.out.println(a == c);System.out.println("-----------------");System.out.println(a != b);System.out.println(a != c);System.out.println("-----------------");System.out.println(a > b);System.out.println(a > c);System.out.println("-----------------");System.out.println(a >= b);System.out.println(a >= c);System.out.println("-----------------");int x = 3;int y = 4;// System.out.println(x == y);// System.out.println(x = y);//把y赋值给x，把x的值输出boolean bb = (x == y);//报错// boolean cc = (x = y);int cc = (x = y);}}2.5 逻辑运算符用于计算两个布尔值经过指定逻辑后的运算结果，结果同样是一个布尔值运算符运算规则范例结果&与(并且)false&trueFalse|或false|trueTrue^异或true^flaseTrue!非(取反)!trueFlase&&短路与false&&trueFalse||短路或true ||trueTrue作用:逻辑运算符用于连接布尔型表达式，在Java中不可以写成33 && x<6 。基本使用: &(与),|(或),^(异或),!(非)与：& 有false则false或：| 有true则true异或：^ 相同则false,不同则true非：! true则false,false则truepublic class Demo08Operator {public static void main(String[] args) {int a = 10;int b = 20;int c = 30;System.out.println((a > b) & (a > c));// false & falseSystem.out.println((a < b) & (a > c)); // true & falseSystem.out.println((a > b) & (a < c)); // false & trueSystem.out.println((a < b) & (a < c)); // true & trueSystem.out.println("---------------");System.out.println((a > b) | (a > c));// false | falseSystem.out.println((a < b) | (a > c)); // true | falseSystem.out.println((a > b) | (a < c)); // false | trueSystem.out.println((a < b) | (a < c)); // true | trueSystem.out.println("---------------");System.out.println((a > b) ^ (a > c));// false ^ falseSystem.out.println((a < b) ^ (a > c)); // true ^ falseSystem.out.println((a > b) ^ (a < c)); // false ^ trueSystem.out.println((a < b) ^ (a < c)); // true ^ trueSystem.out.println("---------------");System.out.println((a > b)); // falseSystem.out.println(!(a > b)); // !falseSystem.out.println(!!(a > b)); // !!false}}&&和&的区别单&时，左边无论真假，右边都进行运算；双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。public class Demo09Operator {public static void main(String[] args) {int a = 10;int b = 20;int c = 30;System.out.println((a > b) && (a > c));// false && falseSystem.out.println((a < b) && (a > c)); // true && falseSystem.out.println((a > b) && (a < c)); // false && trueSystem.out.println((a < b) && (a < c)); // true && trueSystem.out.println("---------------");System.out.println((a > b) || (a > c));// false || falseSystem.out.println((a < b) || (a > c)); // true || falseSystem.out.println((a > b) || (a < c)); // false || trueSystem.out.println((a < b) || (a < c)); // true || trueSystem.out.println("---------------");int x = 3;int y = 4;// System.out.println((x++ > 4) & (y++ > 5)); // false & falseSystem.out.println((x++ > 4) && (y++ > 5)); // false && falseSystem.out.println("x:" + x);System.out.println("y:" + y);}}2.6 三元运算符接下来我们要学习的三元运算符与之前的运算符不同。之前学习的均为一元或者二元运算符。元即参与运算的数据。格式：(条件表达式)？表达式1：表达式2；表达式：通俗的说，即通过使用运算符将操作数联系起来的式子，例如：3+2，使用算数运算符将操作数联系起来，这种情况，我们称为算数表达式。3>2，使用比较运算符（也称为条件运算符）将操作数联系起来，这种情况，我们称为条件表达式。其他表达式，不再一一举例。三元运算符运算规则：先判断条件表达式的值，若为true，运算结果为表达式1；若为false，运算结果为表达式2。注意：三元运算符，最终一定会产生一个结果值，这个值必须被使用起来。要么被运算符使用，要么被打印/*三元运算符:求两个数的最大值,判断两个数是否相等格式:(条件表达式) ? 表达式1 : 表达式2;执行流程:首先判断条件表达式是否成立true:表达式1作为3元运算符的结果false:表达式2作为3元运算符的结果注意：三元运算符，最终一定会产生一个结果值，这个值必须被使用起来。要么被运算符使用，要么被打印*/public class Demo10Operator{public static void main(String[] args){int a = 10;int b = 20;int max = (a > b) ? 10 : 20;System.out.println("max = " + max);int c = 15;int d = 10;//System.out.println((c != d) ? "相等" : "不相等");String s = (c != d) ? "相等" : "不相等";System.out.println("s = " + s);//(c != d) ? "相等" : "不相等";//错误: 不是语句//3;//错误: 不是语句}}2.7 运算符优先级2.7.1 优先级概念运算符运算的先后顺序，优先级越高(数字越小)，计算顺序越靠前。2.7.2 优先级规则优先级相同的情况下，按照从左到右的顺序依次运算优先级描述运算符1括号()、[]2正负号+、-3自增自减，非++、--、!4乘除，取余*、/、%5加减+、-6移位运算<<、>>、>>>7大小关系>、>=、<、<=8相等关系==、!=9按位与&10按位异或^11按位或|12逻辑与&&13逻辑或||14条件运算?:15赋值运算=、+=、-=、*=、/=、%=16位赋值运算&=、|=、<<=、>>=、>>>=2.8 运算符案例---超市购物小票案例2.8.1 案例介绍与演示模拟真实购物逻辑，以上述图片为需求原型，根据不同购物物品完成购物小票内容打印到控制台。2.8.2 案例分析a) 总体思路案例分析可分为三个部分：小票界面结构分析：通过小票界面分析，可以将复杂的问题简单化，规划出来更为具体的需求。数据分析：实际开发过程中的数据是复杂的，存在多个维度的信息。需要分析出我具体需要操作的数据有哪些业务逻辑分析：在接收到最基本的必要数据后，需要加入业务逻辑来完成所有需求。如本例中，求总价的过程。b) 小票界面结构分析票头: 又分为两部分，即欢迎光临欢迎语与具体的物品属性标题。票体: 是读取的真实数据内容，即打印对应的变量值即可。票脚: 也分为两部分，即统计信息与开发票的提醒信息。这里为了简化需求，去掉了时间与付钱找零的统计,只完成商品价钱和数量统计部分。c) 数据分析经过观察，我们确定一项物品应该有如下几个属性：品名：物品名称，String型商品编号：用于区分管理商品的编号，String型售价：物品单价，double型数量：购买数量，原型中是小数，我们这里以个为单位，设计成int型金额：这一项物品的购物总金额，double型票脚：我们发现三个单独的可变化量商品项数：共有几项商品，int型共计：所有项商品一共多少件，int型总计：所有商品花费，double型d) 逻辑分析与直接打印数据不同，这个案例的基本需求中存在许多统计信息，显然类似总价这样的值是由其他数据计算得来。这里就涉及到了常量或变量的运算问题，需要用到运算符来完成这个需求。普通变量值直接打印对于普通的商品名称，商品单价等信息，读取用户数据后可以直接打印。这里我们先“帮用户给出数据”。需要计算的数据的打印票脚部分的三个统计信息需要经过计算得到并打印：商品项数：共有几项商品，直接给出，int型共计：所有商品数量求和，int型总计：所有商品金额求和，double型/*超市购物小票:分析:票头:用字符串方式直接打印票体:先定义3组15个变量用来记录商品信息票脚:计算:商品种类计算:商品数量计算:商品总金额*/public class SuperMarketTicket{public static void main(String[] args){//先定义3组15个变量用来记录商品信息//定义少林寺酥饼核桃String slsName = "少林寺酥饼核桃";String slsID = "(090115)";double slsPrice = 15.50;int slsNumber = 22;double slsMoney = slsPrice * slsNumber;String xjName = "新疆美味羊肉串";String xjID = "(090028)";double xjPrice = 16.00;int xjNumber = 55;double xjMoney = xjPrice * xjNumber;String skName = "尚康杂粮牡丹饼";String skID = "(090027)";double skPrice = 14.50;int skNumber = 24;double skMoney = skPrice * skNumber;//计算:商品种类int goodsItem = 3;//计算:商品数量int goodsNumner = slsNumber + xjNumber + skNumber;//计算:商品总金额double goodsMoney = slsMoney + xjMoney + skMoney;//打印小票//票头System.out.println("欢迎光临");System.out.println("品名售价数量金额");System.out.println("------------------------------------------------");//票体System.out.println(slsName+slsID+""+slsPrice+""+slsNumber+""+slsMoney);System.out.println(xjName+xjID+""+xjPrice+""+xjNumber+""+xjMoney);System.out.println(skName+skID+""+skPrice+""+skNumber+""+skMoney);System.out.println("------------------------------------------------");//票脚System.out.println(""+goodsItem+"项商品共计: "+goodsNumner+"件");System.out.println("总计: " + goodsMoney);System.out.println("凭此小票换取发票!");}}第3章本日自习作业：3.1 知识点相关题3.1.1 知识点：变量要求：1) 熟练掌握各种基本数据类型及其大小；2) 熟练掌握各种基本数据类型变量的定义；3) 熟练掌握数据类型转换题目：1)写出8种数据类型的名称及大小（重要）；Byte -- 一个字节 2的1*8次方Short -- 两个字节 2的2*8次方Int -- 四个字节 2的4*8次方Long -- 八个字节 2的8*8次方Char -- 两个字节 2的2*8次方Float -- 四个字节 2的4*8次方Double -- 八个字节 2的8*8次方2)定义类：Test1，定义main()方法，分别定义8种数据类型的变量，并赋初始值；然后打印每种类型的变量。代码实现：public class Test1 {//定义主方法public static void main(String[] args) {//在控制台上打印byte a = 1;short b = 2;int c = 3;long d = 4;char e = '5';float f = 4.5f;double g = 5.43423;boolean h = true;boolean i = false;System.out.println(a);System.out.println(b);System.out.println(c);System.out.println(d);System.out.println(e);System.out.println(f);System.out.println(g);System.out.println(h);System.out.println(i);}}3)定义类：Test2，定义main()方法，请按如下要求编写代码：a)定义一个byte类型的变量v1，赋初始值；将v1赋给一个int类型的变量v2。将v2赋给一个long类型的变量v3将v3赋给一个double类型的变量v4b)打印每个变量的值；代码实现：public class Test2 {//定义主方法public static void main(String[] args) {//在控制台上打印byte v1 = 5;int v2 =v1;long v3 = v2;double v4 = v3;System.out.println(v1);System.out.println(v2);System.out.println(v3);System.out.println(v4);}}4)定义类：Test3，定义main()方法，请按如下要求编写代码：a)定义一个double类型的变量v1，赋值为：3.1定义一个double类型的变量v2，赋值为：88.88定义一个int类型的变量v3，将v1强转后赋值给v3定义一个int类型的变量v4，将v2强转后赋值给v4打印v3和v4的值，请观察一个浮点型被强转为int型后的结果；代码实现：public class Test3 {//定义主方法public static void main(String[] args) {//在控制台上打印double v1 = 3.1;double v2 = 88.88;int v3 =(int)v1;int v4 = (int)v2;System.out.println(v3);System.out.println(v4);}}3.1.2 分析以下需求，并用代码实现1.键盘录入一个三位整数数，请分别获取该三位数上每一位的数值2.例如：键盘录入的整数123的个位、十位、百位，分别是3、2、13.打印格式:"数字123的个位是 3, 十位是 2, 百位是 1"代码实现：public class HelloWorld {//定义主方法@SuppressWarnings("resource")public static void main(String[] args) {//在控制台上打印Scanner sc = new Scanner(System.in);System.out.println("请输入一个三位数的数值");int a = sc.nextInt();int b = a%100%10;int c = a%100/10;int d = a/100;System.out.println("数字a的个位是"+b+", 十位是"+c+", 百位是"+d);}}3.1.3 分析以下需求，并用代码实现1.键盘录入三个int类型的数字2.要求：(1)求出三个数中的最小值并打印(2)求出三个数的和并打印代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请依次输入三个数值");int a = sc.nextInt();int b = sc.nextInt();int c = sc.nextInt();//求出三个数中的最小值并打印int temp = aint min = tempSystem.out.println(min);//求出三个数的和并打印System.out.println(a+b+c);}}3.1.4 知识点：算数运算符要求：1) 熟练掌握算数运算符的使用；题目：1)定义类：Test4，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：10定义一个int类型的变量v2，初始值：3b)请分别打印这两个数加，减，乘，除，取模的结果c)将v1自增1，将v2自减1d)再次打印这两个数：加，减，乘，除，取模的结果 代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {int v1 = 10;int v2 = 3;//b)打印这两个数加，减，乘，除，取模的结果System.out.println(v1+v2);System.out.println(v1-v2);System.out.println(v1*v2);System.out.println(v1/v2);System.out.println(v1%v2);//将v1自增1，将v2自减1//System.out.println(v1++);System.out.println(++v1);//System.out.println(v2--);System.out.println(--v2);//再次打印这两个数：加，减，乘，除，取模的结果System.out.println(v1+v2);System.out.println(v1-v2);System.out.println(v1*v2);System.out.println(v1/v2);System.out.println(v1%v2);}}3.1.5 知识点：赋值运算符要求：1) 熟练掌握赋值运算符的使用；题目：1)定义类：Test5，定义main()方法，请使用赋值运算符编写代码：a)定义一个int类型的变量v1，初始值：10b)将此变量加10；c)将此变量减5；d)将此变量乘3；e)将此变量除以10；f)将此变量模2g)打印v1的值代码实现：package StudyJavaSE;/*** 1)请使用赋值运算符编写代码：* a)定义一个int类型的变量v1，初始值：10* b)将此变量加10；* c)将此变量减5；* d)将此变量乘3；* e)将此变量除以10；* f)将此变量模2* g)打印v1的值 * * @author奋斗蒙 * */public class FuZhiYunsuanfu {public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：10int a1 = 10;int a2 = 10;System.out.println(a1);System.out.println(a2);//b)将此变量加10；a1+=10;System.out.println(a1);a2 = a2 + 10;System.out.println(a2);//c)将此变量减5；a1-=5;System.out.println(a1);a2 = a2 - 5;System.out.println(a2);//d)将此变量乘3；a1*=3;System.out.println(a1);a2 = a2 * 3;System.out.println(a2);//e)将此变量除以10；a1/=10;System.out.println(a1);a2 = a2 / 10;System.out.println(a2);//f)将此变量模2a1%=2;System.out.println(a1);a2 = a2 % 2;System.out.println(a2);}}3.1.6 知识点：比较运算符要求：1) 熟练掌握比较运算符的使用；题目：1)定义类：Test6，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：10定义一个int类型的变量v2，初始值：3b)请打印v1是否等于v2c)请打印v1是否大于v2d)请打印v1是否小于v2e)请打印v1是否大于等于v2f)请打印v1是否小于等于v2g)请打印v1是否不等于v2 代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：10//定义一个int类型的变量v2，初始值：3int v1 = 10;int v2 = 3;//b)请打印v1是否等于v2System.out.println(v1==v2);//c)请打印v1是否大于v2System.out.println(v1>v2);//d)请打印v1是否小于v2System.out.println(v1//e)请打印v1是否大于等于v2System.out.println(v1>=v2);//f)请打印v1是否小于等于v2System.out.println(v1<=v2);//g)请打印v1是否不等于v2System.out.println(v1!=v2);}}3.1.7 知识点：逻辑运算符要求：1) 熟练掌握逻辑运算符的使用；题目：1)定义类：Test7，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：24定义一个double类型的变量v2，初始值：3.14b)请打印：v1是否大于20，并且小于50c)请打印：v1是否小于20，或者大于50d)请打印：v1是否大于20，并且v2小于3.5e)请使用“非运算符”判断：v1是否不等于25package StudyJavaSE;/***请按如下要求编写代码：* a)定义一个int类型的变量v1，初始值：24*定义一个double类型的变量v2，初始值：3.14* b)请打印：v1 是否大于20，并且小于50* c)请打印：v1是否小于20，或者大于50* d)请打印：v1是否大于20，并且v2小于3.5* e)思考：请使用“非运算符”判断：v1是否不等于25 * @author奋斗蒙 * */public class LuoJiYunsuanfu {public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：24//定义一个double类型的变量v2，初始值：3.14int v1 = 24;double v2 = 3.14;//b)请打印：v1 是否大于20，并且小于50System.out.println((v1>10)&(v1<50));//c)请打印：v1是否小于20，或者大于50System.out.println((v1<20)|(v1>50));//d)请打印：v1是否大于20，并且v2小于3.5System.out.println((v1>20)&(v2<3.15));}} 3.1.8 知识点：三元运算符要求：1) 熟练掌握三元运算符的使用；题目：1)定义类：Test8，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：20定义一个int类型的变量v2，初始值：18b)请使用三元运算符求两个数的最大值，并打印；代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：20//定义一个int类型的变量v2，初始值：18int v1 = 20;int v2 = 18;//b)请使用三元运算符求两个数的最大值，并打印；System.out.println(v1>v2?v1:v2);}}2)定义类：Test9，定义main()方法，请按如下要求编写代码：a)定一个int类型的变量v1，初始值20；定义一个String类型的变量v2，初始值：“”b)请使用三元运算符判断：如果v1大于20，v2的值为：大于，否则，将v2的值赋值为：不大于。c)打印v2的值代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {//a)定一个int类型的变量v1，初始值20；//定义一个String类型的变量v2，初始值：“”int v1 = 20;String v2 = "";//b)请使用三元运算符判断：如果v1大于20，v2的值为：大于，//否则，将v2的值赋值为：不大于。//c)打印v2的值System.out.println(v1>20?(v2="大于"):(v2="不大于"));}}3.2 代码题3.2.1 在控制台打印如下的信息要求:1.清单顶部为固定的数据，直接打印即可2.清单中部为商品，为变化的数据，需要记录水果信息后，打印3.清单底部包含了统计操作，需经过计算后，打印答案：/*在控制台打印如下的信息:-----------------------购买的水果信息--------------------------水果编号水果名称水果单价计价单位品质 购买数量1香蕉8.0公斤A 52苹果6.5公斤B 33橙子9.0公斤A 4---------------------------------------------------------------您购买的水果总金额为: 95.5 元分析:1.定义3组18个变量用来记录水果信息水果编号:使用int类型变量定义水果名称:使用String类型定义水果单价:使用double类型变量定义计价单位:使用String类型定义品质:使用char类型定义购买数量:使用int类型变量定义2.计算购买的水果总金额每种水果的单价*购买数量之和*/public class Demo01{public static void main(String[] args){//1.定义3组18个变量用来记录水果信息//香蕉int bananaId = 1;String bananaName = "香蕉";double bananaPrice = 8.0;String bananaUnit = "公斤";char bananaLevel = 'A';int bananaNumber = 5;//苹果int appleId = 2;String appleName = "苹果";double applePrice = 6.5;String appleUnit = "公斤";char appleLevel = 'B';int appleNumber = 3;//橙子int orangeId = 3;String orangeName = "橙子";double orangePrice = 9.0;String orangeUnit = "公斤";char orangeLevel = 'A';int orangeNumber = 4;//2.计算购买的水果总金额double totalMoney = bananaPrice* bananaNumber + applePrice * appleNumber + orangePrice * orangeNumber;System.out.println("--------------------------------购买的水果信息----------------------------------");System.out.println("水果编号水果名称水果单价计价单位品质购买数量");System.out.println(bananaId+""+bananaName+""+bananaPrice+""+bananaUnit+""+bananaLevel+""+bananaNumber);System.out.println(appleId+""+appleName+""+applePrice+""+appleUnit+""+appleLevel+""+appleNumber);System.out.println(orangeId+""+orangeName+""+orangePrice+""+orangeUnit+""+orangeLevel+""+orangeNumber);System.out.println("--------------------------------------------------------------------------------");System.out.println("您购买的水果总金额为: " + totalMoney +" 元");}}第二天 变量&数据类型&运算符【悟空教程】第02天 Java基础第1章 变量1.1 变量1.1.1 变量概念变量是用来存储数值的内存区域1.1.2 作用变量用来记录数值。使用变量进行代数计算，则该变量中数值可以随着程序的逻辑计算而改变。当计算全部结束后，再将数值拿出展示给用户。1.1.3 变量的使用格式日常变量的使用分为四个部分变量定义格式数据类型 变量名 = 变量值；如 int a = 100;变量类型 每一个变量均必须指定其变量类型。Java是强类型语言，在Java中不同的数据类型在内存中的存储方式是不尽相同的。所以必须在存储内容之前指定数据类型。变量名 即使用标识符为变量起一个名字，之后在计算时，使用该名字即可参与计算。这个名字就代表了存储数值的空间。“=”号 这里的“=”号是运算符的一种，即=代表赋值运算，并非数学意义上的相等。值 即真正变量存储的数值，需要与变量的数据类型一致。/*变量:存储数值的一块内存区域变量的定义格式:数据类型变量名=数据值;*/public class Demo01Variable{public static void main(String[] args){//定义一个存储整数的变量int myVar = 10;//打印变量的值System.out.println(myVar);//10//改变变量的值myVar = 20;//打印变量的值System.out.println(myVar);//20}}1.1.4 日常变量使用的注意事项可以同时定义多个变量变量定义后可以不赋值，使用时再赋值。不赋值不能使用。变量使用时有作用域的限制。/*变量使用的注意事项:可以同时定义多个变量变量定义后可以不赋值，使用时再赋值。不赋值不能使用。变量使用时有作用域的限制*/public class Demo02Variable{public static void main(String[] args){//可以同时定义多个变量int a=5,b=10;/*int a = 5;int b = 10;*/System.out.println(a);//5System.out.println(b);//10//变量定义后可以不赋值，使用时再赋值。不赋值不能使用。int c;//System.out.println(c);//错误: 可能尚未初始化变量c//System.out.println(c=20);c = 20;System.out.println(c);}}1.2 数据类型Java是一种强类型语言，对不同数据结构进行了严格的区分，对每一种数据类型都做了明确定义，也同时规定了每一种数据类型的变量在内存中占用空间的大小。1.2.1 字节字节是计算机当中存储数据的基本单位，每种数据类型都会占用一定的空间。比特位比特位(bit)是计算机当中最小的存储单位，由于机器码只识别1与0，所以每一位的1与0均为一个比特位字节组成规则在计算机当中如果使用bit来计算数据过于冗余复杂，所以以8个比特位组成一个新的单位——字节，作为数据存储的基本单位常见的数据存储单位之间的换算1B（字节） = 8bit1KB = 1024B1MB = 1024KB1GB = 1024MB1TB = 1024GB1.2.2 数据类型分类数据类型分为基本类型与引用类型，引用类型包括：数组、类、接口，在面向对象后期会全部介绍完毕。这里着重介绍基本数据类型。整数型(精确)int 占用4个字节 (整数的默认值)byte 占用1个字节short 占用2个字节long 占用8个字节long类型在赋值时，需要在值后加入字母l(L)区分其是一个长整型如 int i = 100; short s = 66; long l = 100L;浮点型(小数型，非精确，为近似值)double 占用8个字节 (小数的默认值)float 占用4个字节float类型在赋值时，需要在值后加入字母f(F)区分其是一个浮点型如 double d = 100.0; double d2 = 10.1; float f = 100.0F;字符型char 占用2个字节，必须使用’’包裹，且不能为空。如 char c = ‘a’; char c2 = ‘中’; char c3 = ‘ (空格)’; char c4 = ‘$’转义字符有时我们无法直接给出一个字符，需要使用转义字符进行转义动作。转义字符也为一个字符，由转义符号与被转义字符组成转义符号：\如:\t 制表符\’ 单引号\” 双引号\\ 反斜杠字符存储原理每一个值在存储时，均存储的为值对应的数字。即字符、声音、图片、文字，使用都以数字1或0的方式存储在计算机中。每一个英文字符都有其固定的数字对应。英文字符与数字的对应关系组成了一张编码表，该表名称为ASCII表。(内容见资料)布尔型布尔值是我们比较陌生的类型，它代表一些条件成立与不成立的判断。只有两个值true与false。boolean 占用1个字节如 boolean b = true; boolean b2 = false;类型数据表示范围整数类型byte-128～127整数类型short-32768～32767整数类型int(整数的默认值)-2147483648～2147483648整数类型long-263～263-1小数类型float-3.403E38～3.403E38小数类型double(小数的默认值)-1.798E308～1.798E308字符类型char表示一个字符，如('a'，'A'，'0'，'家')布尔类型boolean只有两个值true与false/*数据类型:整数:(精确)byte:占用1个字节short:占用2个字节int:占用4个字节(默认)long:占用8个字节,使用时必须在末尾加上一个小写字母l或者大写字母L小数:(不精确,近似值)float:占用4个字节,使用时必须在末尾加上一个小写字母f或者大写字母Fdouble:占用8个字节(默认)布尔:boolean:(true,false)占用1个字节字符:char:占用2个字节注意事项:字符不能为空字符实际存储的是一个数值想把具有特殊含义',转换成普通的字符,用转义字符\'想把普通字符t,变成一个具有特殊含义的字符,用转义字符\t*/public class Demo03Variable{public static void main(String[] args){//整数byte b = 100;System.out.println(b);short s = 10000;System.out.println(s);int i = 1600000000;System.out.println(i);long l = 6000000000L;System.out.println(l);//小数double d = 3.14;System.out.println(d);float f = 2.6f;System.out.println(f);//小数是一个不精确的数System.out.println(f-2);//0.5999999//布尔boolean b1 = true;System.out.println(b1);boolean b2 = false;System.out.println(b2);//字符char c = 'a';System.out.println(c);//转义字符char c1 = '\'';System.out.println(c1);char c2 = '\t';System.out.println(c2+"Hello");System.out.println('\\');//字符实际存储的是一个数值System.out.println(c+1);}}1.2.3 数字类型转换数字类型可以有数据类型上的转换，即将一种类型的值赋值给另外一种类型的变量。但要依据数据范围，符合一定规则：各种数据类型按照数据范围从小到大：byte -> short -> int -> long -> float -> double自动类型转换范围小的数据类型值（如int），可以自动转换为范围大的数据类型值（如double）范围大的数据类型 变量 = 范围小的数据类型值；如： double d = 1000;或 int i = 100; double d2 = i;强制类型转换范围大的数据类型值（如double），不可以自动转换为范围小的数据类型值（如int），但是可以强制转换范围小的数据类型 变量 = (范围小的数据类型) 范围大的数据类型值;如：int i = (int)6.718; //i的值为6或double d = 3.14;int i2 = (int)d; //i2的值为3/*数字类型转换:就是数值转换,包括整数,小数,字符自动类型转换:小-->大byte < short(char)< int < long < float < double格式:范围大的数据类型 变量名 = 范围小的数据类型的值;强制类型转换:大-->小格式:范围小的数据类型 变量名 = (范围小的数据类型)范围大的数据类型的值;*/public class Demo04Variable{public static void main(String[] args){//自动类型转换 int --> doubleint i = 100;double d = i;System.out.println(i);System.out.println(d);//强制类型转换double d2 = 3.14;//int i2 = d2;//错误: 可能损失精度int i2 = (int)d2;System.out.println(i2);System.out.println(d2);}}1.3 变量案例---超市水果报价单1.3.1 案例介绍与演示根据不同的水果种类，使用变量在控制台打印所有水果价格的列表。1.3.2 案例分析我们通过以下方式定义5个变量，来记录可能改变的数据：一个记录整数类型的榴莲编号一个记录小数类型的榴莲价格两个分别记录字符串类型的水果名称与计价单位一个记录字符类型的榴莲品质int liulianId = 1;String liulianName = “榴莲”;double liulianPrice = 32.0;String liulianUnit = “公斤”;char liulianLevel = ‘A’;按照同样的方法，我们也可以将苹果的编号与属性用变量表示。(注意命名)int appleId = 2;String appleName = “苹果”;double applePrice = 6.5;String appleUnit = “公斤”;char appleLevel = ‘B’;这时，再打印时，便可以直接使用变量打印System.out.println("水果编号 水果名称 水果单价 计价单位 品质");System.out.println(" "+ liulianId +" "+ liulianName +" "+ liulianPrice +" "+ liulianUnit +" "+ liulianLevel);System.out.println(" "+ appleId +" "+ appleName +" "+ applePrice +" "+ appleUnit +" "+ appleLevel);很明显，在这种方式打印时价格列表时，可以随意操作价格或者其他属性值而后边打印表单的代码不需要更改。我们用变量来记录各种属性值，将最终的值存储到变量中。/*水果超市报价单:变量版本水果编号水果名称水果单价计价单位品质1榴莲32.0公斤A2苹果6.5公斤B3 猕猴桃6.0公斤A分析:定义3组15个变量用来记录水果信息水果编号:采用int类型定义水果名称:采用String类型定义水果单价:采用double类型定义计价单位:采用String类型定义品质:采用char类型定义*/public class List02{public static void main(String[] args){//定义榴莲的水果信息int llId = 1;String llName = "榴莲";double llPrice = 32.0;String llUnit = "公斤";char llLevel = 'A';//定义苹果的水果信息int appleId = 2;String appleName = "苹果";double applePrice = 6.5;String appleUnit = "公斤";char appleLevel = 'B';//定义猕猴桃的水果信息int mhtId = 3;String mhtName = "猕猴桃";double mhtPrice = 6.0;String mhtUnit = "公斤";char mhtLevel = 'A';System.out.println("水果编号水果名称水果单价计价单位品质");System.out.println(llId+""+llName+""+llPrice+""+llUnit+""+llLevel);System.out.println(appleId+""+appleName+""+applePrice+""+appleUnit+""+appleLevel);System.out.println(3+" 猕猴桃"+6.0+"公斤"+'A');}}第2章 运算符2.1 运算符概念运算符是用来计算数据的指令。数据可以是常量，也可以是变量。被运算符操作的数成为操作数。Int x = 3;Int y = 4;Int z = x + y2.2 算数运算符将操作数参与数学计算(通常为数学计算)运算符运算规则范例结果+正号+33+加2+35+连接字符串“中”+“国”“中国”-负号int a=3;-a-3-减3-12*乘2*36/除5/22%取模(余数)5%21++自增int a=1;a++/++a2--自减int b=3;a--/--a2注意：加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。除法“/”当两边为整数时，取整数部分，舍余数。当两边为浮点型时，按正常规则相除。“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数的符号相同。得到的是两个相除数据的余数。用处: 判断两个数据是否整除。整数做被除数，0不能做除数，否则报错。小数做被除数，整除0结果为Infinity，对0取模结果为NaN自增与自减单独使用：前置与后置效果相同，均为直接+1或-1混合使用：自增（++）：将变量的值加1，分前缀式（如++i）和后缀式（如i++）。前缀式是先加1再使用；后缀式是先使用再加1。自减（--）：将变量的值减1，分前缀式（如--i）和后缀式（如i--）。前缀式是先减1再使用；后缀式是先使用再减1。自增与自减运算符还遵循以下规律： 1. 可以用于整数类型byte、short、int、long，浮点类型float、double，以及字符串类型char。 2. 在Java5.0及以上版本中，它们可以用于基本类型对应的包装器类Byte、Short、Integer、Long、Float、Double、Character。 3. 它们的运算结果的类型与被运算的变量的类型相同。/*算数运算符:+,-,*:相当于数学+,-*+:做为字符串连接符/:两个整数相除,结果是整数%:两个整数取模(余数),结果是整数++:自增(自身加1)--:自减(自身减1)注意事项:1.加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。2.除法“/”当两边为整数时，取整数部分，舍余数。当两边为浮点型时，按正常规则相除。3.“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数的符号相同。4.整数做被除数，0不能做除数，否则报错。5.小数做被除数，整除0结果为Infinity，对0取模结果为NaN自增与自减单独使用：前置与后置效果相同，均为直接+1或-1与其他运算符混合使用：++或- -为前置时，先+1或-1，再使用值。++或- -为后置时，先使用值再+1或-1。*/public class Demo05Operator{public static void main(String[] args){//两个常量相加System.out.println(3 + 5);//8//变量加减乘除模int a = 20;int b = 7;System.out.println(a + b);//27System.out.println(a - b);//13System.out.println(a * b);//140System.out.println(a / b);//2System.out.println(a % b);//6//+:做为字符串连接符System.out.println("中"+"国");//中国/*单独使用：前置与后置效果相同，均为直接+1或-1*///++:自增(自身加1)//--:自减(自身减1)int c = 10;int d = 20;//c++;//d--;++c;--d;System.out.println("c = " + c);//c = 11System.out.println("d = " + d);//d = 19System.out.println("===================================");//1.加法运算符在连接字符串时要注意，只有直接与字符串相加才会转成字符串。int e = 15;int f = 20;System.out.println("e + f = " + e + f);//e + f = 1520System.out.println("e + f = " + (e + f));//e + f = 35System.out.println(e + f + " = e + f");//35 = e + f//2.除法“/”当两边为整数时，取整数部分，舍余数。当两边有浮点型时，按正常规则相除。System.out.println(5.0 / 2);//2.5//3.“%”为整除取余符号，小数取余没有意义。取余结果的符号与被取余数(符号左边的数)的符号相同。System.out.println(5.1 % 2);//1.0999999999999996System.out.println(5 % 2);//1System.out.println(-5 % 2);//-1System.out.println(5 % -2);//1System.out.println(-5 % -2);//-1//4.整数做被除数，0不能做除数，否则报错。//System.out.println(5 / 0);//ArithmeticException: / by zero//5.小数做被除数，整除0结果为Infinity(无穷)，对0取模结果为NaN(not number 无效数字)System.out.println(5.0 / 0);//InfinitySystem.out.println(5.0 % 0);//NaNSystem.out.println("===================================");/*与其他运算混合使用：++或- -为前置时，先+1或-1，再使用值。++或- -为后置时，先使用值再+1或-1。*/System.out.println(e);//15System.out.println(f);//20System.out.println(e++);//15System.out.println(f--);//20System.out.println(e);//16System.out.println(f);//19int i1 = 100;int i2 = i1++ + 200;System.out.println(i1);//101System.out.println(i2);//300int i3 = 100;int i4 = ++i3 + 200;System.out.println(i3);//101System.out.println(i4);//301}}2.3 赋值运算符为变量赋值的运算符运算符运算规则范例结果=赋值int a=22+=加后赋值int a=2，a+=24-=减后赋值int a=2，a-=20*=乘后赋值int a=2，a*=24/=整除后赋值int a=2，a/=21%=取模后赋值int a=2，a%=20注意：诸如+=这样形式的赋值运算符，会将结果自动强转成等号左边的数据类型。/*赋值运算符:=,+=,-=,*=,/=,%=+=,-=,*=,/=,%=运算符的运算规则:先将运算符两边进行+,-,*,/,%运算,在把结果赋值给左边的变量+=,-=,*=,/=,%=注意事项:运算符左边必须是一个变量+=,-=,*=,/=,%=特点:隐含一个强制类型转换*/public class Demo06Operator{public static void main(String[] args){int a = 10;a += 20;//相当于 a = a + 20;System.out.println("a = " + a);//5 += 6;//错误: 意外的类型,这里5的位置需要一个变量byte b = 10;//b = b + 100;//错误: 可能损失精度//b = (byte)(b + 100);b += 100;//+=隐含了一个强制类型转换 相当于b = (byte)(b + 100);System.out.println("b = " + b);}}2.4 比较运算符又叫关系运算符，即判断两个操作数的大小关系及是否相等关系，比较运算符的返回一定为布尔值。运算符运算规则范例结果==相等于4==3false!=不等于4!=3true<小于4<3false>大于4>3true<=小于等于4<=3false>=大于等于4>=3true==，!=，>，<，>=，<=关系运算符的结果都是boolean型，也就是要么是true，要么是false。注意事项n 关系运算符“==”不能误写成“=” 。public class Demo06Operator {public static void main(String[] args) {int a = 10;int b = 20;int c = 10;System.out.println(a == b);System.out.println(a == c);System.out.println("-----------------");System.out.println(a != b);System.out.println(a != c);System.out.println("-----------------");System.out.println(a > b);System.out.println(a > c);System.out.println("-----------------");System.out.println(a >= b);System.out.println(a >= c);System.out.println("-----------------");int x = 3;int y = 4;// System.out.println(x == y);// System.out.println(x = y);//把y赋值给x，把x的值输出boolean bb = (x == y);//报错// boolean cc = (x = y);int cc = (x = y);}}2.5 逻辑运算符用于计算两个布尔值经过指定逻辑后的运算结果，结果同样是一个布尔值运算符运算规则范例结果&与(并且)false&trueFalse|或false|trueTrue^异或true^flaseTrue!非(取反)!trueFlase&&短路与false&&trueFalse||短路或true ||trueTrue作用:逻辑运算符用于连接布尔型表达式，在Java中不可以写成33 && x<6 。基本使用: &(与),|(或),^(异或),!(非)与：& 有false则false或：| 有true则true异或：^ 相同则false,不同则true非：! true则false,false则truepublic class Demo08Operator {public static void main(String[] args) {int a = 10;int b = 20;int c = 30;System.out.println((a > b) & (a > c));// false & falseSystem.out.println((a < b) & (a > c)); // true & falseSystem.out.println((a > b) & (a < c)); // false & trueSystem.out.println((a < b) & (a < c)); // true & trueSystem.out.println("---------------");System.out.println((a > b) | (a > c));// false | falseSystem.out.println((a < b) | (a > c)); // true | falseSystem.out.println((a > b) | (a < c)); // false | trueSystem.out.println((a < b) | (a < c)); // true | trueSystem.out.println("---------------");System.out.println((a > b) ^ (a > c));// false ^ falseSystem.out.println((a < b) ^ (a > c)); // true ^ falseSystem.out.println((a > b) ^ (a < c)); // false ^ trueSystem.out.println((a < b) ^ (a < c)); // true ^ trueSystem.out.println("---------------");System.out.println((a > b)); // falseSystem.out.println(!(a > b)); // !falseSystem.out.println(!!(a > b)); // !!false}}&&和&的区别单&时，左边无论真假，右边都进行运算；双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。“|”和“||”的区别同理，双或时，左边为真，右边不参与运算。public class Demo09Operator {public static void main(String[] args) {int a = 10;int b = 20;int c = 30;System.out.println((a > b) && (a > c));// false && falseSystem.out.println((a < b) && (a > c)); // true && falseSystem.out.println((a > b) && (a < c)); // false && trueSystem.out.println((a < b) && (a < c)); // true && trueSystem.out.println("---------------");System.out.println((a > b) || (a > c));// false || falseSystem.out.println((a < b) || (a > c)); // true || falseSystem.out.println((a > b) || (a < c)); // false || trueSystem.out.println((a < b) || (a < c)); // true || trueSystem.out.println("---------------");int x = 3;int y = 4;// System.out.println((x++ > 4) & (y++ > 5)); // false & falseSystem.out.println((x++ > 4) && (y++ > 5)); // false && falseSystem.out.println("x:" + x);System.out.println("y:" + y);}}2.6 三元运算符接下来我们要学习的三元运算符与之前的运算符不同。之前学习的均为一元或者二元运算符。元即参与运算的数据。格式：(条件表达式)？表达式1：表达式2；表达式：通俗的说，即通过使用运算符将操作数联系起来的式子，例如：3+2，使用算数运算符将操作数联系起来，这种情况，我们称为算数表达式。3>2，使用比较运算符（也称为条件运算符）将操作数联系起来，这种情况，我们称为条件表达式。其他表达式，不再一一举例。三元运算符运算规则：先判断条件表达式的值，若为true，运算结果为表达式1；若为false，运算结果为表达式2。注意：三元运算符，最终一定会产生一个结果值，这个值必须被使用起来。要么被运算符使用，要么被打印/*三元运算符:求两个数的最大值,判断两个数是否相等格式:(条件表达式) ? 表达式1 : 表达式2;执行流程:首先判断条件表达式是否成立true:表达式1作为3元运算符的结果false:表达式2作为3元运算符的结果注意：三元运算符，最终一定会产生一个结果值，这个值必须被使用起来。要么被运算符使用，要么被打印*/public class Demo10Operator{public static void main(String[] args){int a = 10;int b = 20;int max = (a > b) ? 10 : 20;System.out.println("max = " + max);int c = 15;int d = 10;//System.out.println((c != d) ? "相等" : "不相等");String s = (c != d) ? "相等" : "不相等";System.out.println("s = " + s);//(c != d) ? "相等" : "不相等";//错误: 不是语句//3;//错误: 不是语句}}2.7 运算符优先级2.7.1 优先级概念运算符运算的先后顺序，优先级越高(数字越小)，计算顺序越靠前。2.7.2 优先级规则优先级相同的情况下，按照从左到右的顺序依次运算优先级描述运算符1括号()、[]2正负号+、-3自增自减，非++、--、!4乘除，取余*、/、%5加减+、-6移位运算<<、>>、>>>7大小关系>、>=、<、<=8相等关系==、!=9按位与&10按位异或^11按位或|12逻辑与&&13逻辑或||14条件运算?:15赋值运算=、+=、-=、*=、/=、%=16位赋值运算&=、|=、<<=、>>=、>>>=2.8 运算符案例---超市购物小票案例2.8.1 案例介绍与演示模拟真实购物逻辑，以上述图片为需求原型，根据不同购物物品完成购物小票内容打印到控制台。2.8.2 案例分析a) 总体思路案例分析可分为三个部分：小票界面结构分析：通过小票界面分析，可以将复杂的问题简单化，规划出来更为具体的需求。数据分析：实际开发过程中的数据是复杂的，存在多个维度的信息。需要分析出我具体需要操作的数据有哪些业务逻辑分析：在接收到最基本的必要数据后，需要加入业务逻辑来完成所有需求。如本例中，求总价的过程。b) 小票界面结构分析票头: 又分为两部分，即欢迎光临欢迎语与具体的物品属性标题。票体: 是读取的真实数据内容，即打印对应的变量值即可。票脚: 也分为两部分，即统计信息与开发票的提醒信息。这里为了简化需求，去掉了时间与付钱找零的统计,只完成商品价钱和数量统计部分。c) 数据分析经过观察，我们确定一项物品应该有如下几个属性：品名：物品名称，String型商品编号：用于区分管理商品的编号，String型售价：物品单价，double型数量：购买数量，原型中是小数，我们这里以个为单位，设计成int型金额：这一项物品的购物总金额，double型票脚：我们发现三个单独的可变化量商品项数：共有几项商品，int型共计：所有项商品一共多少件，int型总计：所有商品花费，double型d) 逻辑分析与直接打印数据不同，这个案例的基本需求中存在许多统计信息，显然类似总价这样的值是由其他数据计算得来。这里就涉及到了常量或变量的运算问题，需要用到运算符来完成这个需求。普通变量值直接打印对于普通的商品名称，商品单价等信息，读取用户数据后可以直接打印。这里我们先“帮用户给出数据”。需要计算的数据的打印票脚部分的三个统计信息需要经过计算得到并打印：商品项数：共有几项商品，直接给出，int型共计：所有商品数量求和，int型总计：所有商品金额求和，double型/*超市购物小票:分析:票头:用字符串方式直接打印票体:先定义3组15个变量用来记录商品信息票脚:计算:商品种类计算:商品数量计算:商品总金额*/public class SuperMarketTicket{public static void main(String[] args){//先定义3组15个变量用来记录商品信息//定义少林寺酥饼核桃String slsName = "少林寺酥饼核桃";String slsID = "(090115)";double slsPrice = 15.50;int slsNumber = 22;double slsMoney = slsPrice * slsNumber;String xjName = "新疆美味羊肉串";String xjID = "(090028)";double xjPrice = 16.00;int xjNumber = 55;double xjMoney = xjPrice * xjNumber;String skName = "尚康杂粮牡丹饼";String skID = "(090027)";double skPrice = 14.50;int skNumber = 24;double skMoney = skPrice * skNumber;//计算:商品种类int goodsItem = 3;//计算:商品数量int goodsNumner = slsNumber + xjNumber + skNumber;//计算:商品总金额double goodsMoney = slsMoney + xjMoney + skMoney;//打印小票//票头System.out.println("欢迎光临");System.out.println("品名售价数量金额");System.out.println("------------------------------------------------");//票体System.out.println(slsName+slsID+""+slsPrice+""+slsNumber+""+slsMoney);System.out.println(xjName+xjID+""+xjPrice+""+xjNumber+""+xjMoney);System.out.println(skName+skID+""+skPrice+""+skNumber+""+skMoney);System.out.println("------------------------------------------------");//票脚System.out.println(""+goodsItem+"项商品共计: "+goodsNumner+"件");System.out.println("总计: " + goodsMoney);System.out.println("凭此小票换取发票!");}}第3章本日自习作业：3.1 知识点相关题3.1.1 知识点：变量要求：1) 熟练掌握各种基本数据类型及其大小；2) 熟练掌握各种基本数据类型变量的定义；3) 熟练掌握数据类型转换题目：1)写出8种数据类型的名称及大小（重要）；Byte -- 一个字节 2的1*8次方Short -- 两个字节 2的2*8次方Int -- 四个字节 2的4*8次方Long -- 八个字节 2的8*8次方Char -- 两个字节 2的2*8次方Float -- 四个字节 2的4*8次方Double -- 八个字节 2的8*8次方2)定义类：Test1，定义main()方法，分别定义8种数据类型的变量，并赋初始值；然后打印每种类型的变量。代码实现：public class Test1 {//定义主方法public static void main(String[] args) {//在控制台上打印byte a = 1;short b = 2;int c = 3;long d = 4;char e = '5';float f = 4.5f;double g = 5.43423;boolean h = true;boolean i = false;System.out.println(a);System.out.println(b);System.out.println(c);System.out.println(d);System.out.println(e);System.out.println(f);System.out.println(g);System.out.println(h);System.out.println(i);}}3)定义类：Test2，定义main()方法，请按如下要求编写代码：a)定义一个byte类型的变量v1，赋初始值；将v1赋给一个int类型的变量v2。将v2赋给一个long类型的变量v3将v3赋给一个double类型的变量v4b)打印每个变量的值；代码实现：public class Test2 {//定义主方法public static void main(String[] args) {//在控制台上打印byte v1 = 5;int v2 =v1;long v3 = v2;double v4 = v3;System.out.println(v1);System.out.println(v2);System.out.println(v3);System.out.println(v4);}}4)定义类：Test3，定义main()方法，请按如下要求编写代码：a)定义一个double类型的变量v1，赋值为：3.1定义一个double类型的变量v2，赋值为：88.88定义一个int类型的变量v3，将v1强转后赋值给v3定义一个int类型的变量v4，将v2强转后赋值给v4打印v3和v4的值，请观察一个浮点型被强转为int型后的结果；代码实现：public class Test3 {//定义主方法public static void main(String[] args) {//在控制台上打印double v1 = 3.1;double v2 = 88.88;int v3 =(int)v1;int v4 = (int)v2;System.out.println(v3);System.out.println(v4);}}3.1.2 分析以下需求，并用代码实现1.键盘录入一个三位整数数，请分别获取该三位数上每一位的数值2.例如：键盘录入的整数123的个位、十位、百位，分别是3、2、13.打印格式:"数字123的个位是 3, 十位是 2, 百位是 1"代码实现：public class HelloWorld {//定义主方法@SuppressWarnings("resource")public static void main(String[] args) {//在控制台上打印Scanner sc = new Scanner(System.in);System.out.println("请输入一个三位数的数值");int a = sc.nextInt();int b = a%100%10;int c = a%100/10;int d = a/100;System.out.println("数字a的个位是"+b+", 十位是"+c+", 百位是"+d);}}3.1.3 分析以下需求，并用代码实现1.键盘录入三个int类型的数字2.要求：(1)求出三个数中的最小值并打印(2)求出三个数的和并打印代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {Scanner sc = new Scanner(System.in);System.out.println("请依次输入三个数值");int a = sc.nextInt();int b = sc.nextInt();int c = sc.nextInt();//求出三个数中的最小值并打印int temp = aint min = tempSystem.out.println(min);//求出三个数的和并打印System.out.println(a+b+c);}}3.1.4 知识点：算数运算符要求：1) 熟练掌握算数运算符的使用；题目：1)定义类：Test4，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：10定义一个int类型的变量v2，初始值：3b)请分别打印这两个数加，减，乘，除，取模的结果c)将v1自增1，将v2自减1d)再次打印这两个数：加，减，乘，除，取模的结果 代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {int v1 = 10;int v2 = 3;//b)打印这两个数加，减，乘，除，取模的结果System.out.println(v1+v2);System.out.println(v1-v2);System.out.println(v1*v2);System.out.println(v1/v2);System.out.println(v1%v2);//将v1自增1，将v2自减1//System.out.println(v1++);System.out.println(++v1);//System.out.println(v2--);System.out.println(--v2);//再次打印这两个数：加，减，乘，除，取模的结果System.out.println(v1+v2);System.out.println(v1-v2);System.out.println(v1*v2);System.out.println(v1/v2);System.out.println(v1%v2);}}3.1.5 知识点：赋值运算符要求：1) 熟练掌握赋值运算符的使用；题目：1)定义类：Test5，定义main()方法，请使用赋值运算符编写代码：a)定义一个int类型的变量v1，初始值：10b)将此变量加10；c)将此变量减5；d)将此变量乘3；e)将此变量除以10；f)将此变量模2g)打印v1的值代码实现：package StudyJavaSE;/*** 1)请使用赋值运算符编写代码：* a)定义一个int类型的变量v1，初始值：10* b)将此变量加10；* c)将此变量减5；* d)将此变量乘3；* e)将此变量除以10；* f)将此变量模2* g)打印v1的值 * * @author奋斗蒙 * */public class FuZhiYunsuanfu {public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：10int a1 = 10;int a2 = 10;System.out.println(a1);System.out.println(a2);//b)将此变量加10；a1+=10;System.out.println(a1);a2 = a2 + 10;System.out.println(a2);//c)将此变量减5；a1-=5;System.out.println(a1);a2 = a2 - 5;System.out.println(a2);//d)将此变量乘3；a1*=3;System.out.println(a1);a2 = a2 * 3;System.out.println(a2);//e)将此变量除以10；a1/=10;System.out.println(a1);a2 = a2 / 10;System.out.println(a2);//f)将此变量模2a1%=2;System.out.println(a1);a2 = a2 % 2;System.out.println(a2);}}3.1.6 知识点：比较运算符要求：1) 熟练掌握比较运算符的使用；题目：1)定义类：Test6，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：10定义一个int类型的变量v2，初始值：3b)请打印v1是否等于v2c)请打印v1是否大于v2d)请打印v1是否小于v2e)请打印v1是否大于等于v2f)请打印v1是否小于等于v2g)请打印v1是否不等于v2 代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：10//定义一个int类型的变量v2，初始值：3int v1 = 10;int v2 = 3;//b)请打印v1是否等于v2System.out.println(v1==v2);//c)请打印v1是否大于v2System.out.println(v1>v2);//d)请打印v1是否小于v2System.out.println(v1//e)请打印v1是否大于等于v2System.out.println(v1>=v2);//f)请打印v1是否小于等于v2System.out.println(v1<=v2);//g)请打印v1是否不等于v2System.out.println(v1!=v2);}}3.1.7 知识点：逻辑运算符要求：1) 熟练掌握逻辑运算符的使用；题目：1)定义类：Test7，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：24定义一个double类型的变量v2，初始值：3.14b)请打印：v1是否大于20，并且小于50c)请打印：v1是否小于20，或者大于50d)请打印：v1是否大于20，并且v2小于3.5e)请使用“非运算符”判断：v1是否不等于25package StudyJavaSE;/***请按如下要求编写代码：* a)定义一个int类型的变量v1，初始值：24*定义一个double类型的变量v2，初始值：3.14* b)请打印：v1 是否大于20，并且小于50* c)请打印：v1是否小于20，或者大于50* d)请打印：v1是否大于20，并且v2小于3.5* e)思考：请使用“非运算符”判断：v1是否不等于25 * @author奋斗蒙 * */public class LuoJiYunsuanfu {public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：24//定义一个double类型的变量v2，初始值：3.14int v1 = 24;double v2 = 3.14;//b)请打印：v1 是否大于20，并且小于50System.out.println((v1>10)&(v1<50));//c)请打印：v1是否小于20，或者大于50System.out.println((v1<20)|(v1>50));//d)请打印：v1是否大于20，并且v2小于3.5System.out.println((v1>20)&(v2<3.15));}} 3.1.8 知识点：三元运算符要求：1) 熟练掌握三元运算符的使用；题目：1)定义类：Test8，定义main()方法，请按如下要求编写代码：a)定义一个int类型的变量v1，初始值：20定义一个int类型的变量v2，初始值：18b)请使用三元运算符求两个数的最大值，并打印；代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {//a)定义一个int类型的变量v1，初始值：20//定义一个int类型的变量v2，初始值：18int v1 = 20;int v2 = 18;//b)请使用三元运算符求两个数的最大值，并打印；System.out.println(v1>v2?v1:v2);}}2)定义类：Test9，定义main()方法，请按如下要求编写代码：a)定一个int类型的变量v1，初始值20；定义一个String类型的变量v2，初始值：“”b)请使用三元运算符判断：如果v1大于20，v2的值为：大于，否则，将v2的值赋值为：不大于。c)打印v2的值代码实现：public class Test {@SuppressWarnings("resource")public static void main(String[] args) {//a)定一个int类型的变量v1，初始值20；//定义一个String类型的变量v2，初始值：“”int v1 = 20;String v2 = "";//b)请使用三元运算符判断：如果v1大于20，v2的值为：大于，//否则，将v2的值赋值为：不大于。//c)打印v2的值System.out.println(v1>20?(v2="大于"):(v2="不大于"));}}3.2 代码题3.2.1 在控制台打印如下的信息要求:1.清单顶部为固定的数据，直接打印即可2.清单中部为商品，为变化的数据，需要记录水果信息后，打印3.清单底部包含了统计操作，需经过计算后，打印答案：/*在控制台打印如下的信息:-----------------------购买的水果信息--------------------------水果编号水果名称水果单价计价单位品质 购买数量1香蕉8.0公斤A 52苹果6.5公斤B 33橙子9.0公斤A 4---------------------------------------------------------------您购买的水果总金额为: 95.5 元分析:1.定义3组18个变量用来记录水果信息水果编号:使用int类型变量定义水果名称:使用String类型定义水果单价:使用double类型变量定义计价单位:使用String类型定义品质:使用char类型定义购买数量:使用int类型变量定义2.计算购买的水果总金额每种水果的单价*购买数量之和*/public class Demo01{public static void main(String[] args){//1.定义3组18个变量用来记录水果信息//香蕉int bananaId = 1;String bananaName = "香蕉";double bananaPrice = 8.0;String bananaUnit = "公斤";char bananaLevel = 'A';int bananaNumber = 5;//苹果int appleId = 2;String appleName = "苹果";double applePrice = 6.5;String appleUnit = "公斤";char appleLevel = 'B';int appleNumber = 3;//橙子int orangeId = 3;String orangeName = "橙子";double orangePrice = 9.0;String orangeUnit = "公斤";char orangeLevel = 'A';int orangeNumber = 4;//2.计算购买的水果总金额double totalMoney = bananaPrice* bananaNumber + applePrice * appleNumber + orangePrice * orangeNumber;System.out.println("--------------------------------购买的水果信息----------------------------------");System.out.println("水果编号水果名称水果单价计价单位品质购买数量");System.out.println(bananaId+""+bananaName+""+bananaPrice+""+bananaUnit+""+bananaLevel+""+bananaNumber);System.out.println(appleId+""+appleName+""+applePrice+""+appleUnit+""+appleLevel+""+appleNumber);System.out.println(orangeId+""+orangeName+""+orangePrice+""+orangeUnit+""+orangeLevel+""+orangeNumber);System.out.println("--------------------------------------------------------------------------------");System.out.println("您购买的水果总金额为: " + totalMoney +" 元");}}
网友评论