黑马java代码01-03.docx
Posted 961013-yu
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了黑马java代码01-03.docx相关的知识，希望对你有一定的参考价值。
01_关键字
1 /* 2 关键字：被java语言赋予特定含义的单词。 3 4 特点：组成关键字单词的字母全部小写。 5 6 注意： 7 A:goto和const是保留字 8 B:类似于Notepad++这样的高级记事本，针对关键字都有特殊的颜色标记。 9 */ 10 class KeyWordDemo { 11 public static void main(String[] args) { 12 System.out.println("HelloWorld"); 13 } 14 }
02_标识符
1 /* 2 标识符：就是给类，接口，方法，变量等起名字。 3 4 组成规则： 5 A:英文字母大小写 6 B:数字字符 7 C:$和_ 8 9 注意事项： 10 A:不能以数字开头 11 B:不能是Java中的关键字 12 C:Java语言严格区分大小写 13 14 常见的命名规则：见名知意 15 举例：我要定义一个学生类 16 class Student {} 17 class S{} 18 19 包：其实就是文件夹，用于把相同的类名进行区分 20 全部小写 21 22 单级：liuyi 23 多级：cn.itcast 24 cn 25 itcast 26 27 类或者接口： 28 一个单词：单词的首字母必须大写 29 举例：Student,Dog 30 多个单词：每个单词的首字母必须大写 31 举例：HelloWorld,StudentName 32 33 方法或者变量： 34 一个单词：单词的首字母小写 35 举例：main,age 36 多个单词：从第二个单词开始，每个单词的首字母大写 37 举例：studentAge,showAllNames() 38 39 常量： 40 一个单词：全部大写 41 举例：PI 42 多个单词：每个字母都大写，用_隔开 43 举例：STUDENT_MAX_AGE 44 45 */ 46 class MakeNameDemo { 47 public static void main(String[] args) { 48 //正确做法 49 int x = 100; 50 51 //不能以数字开头 52 //int 1y = 100; 53 int y1 = 100; 54 55 //不能是Java中的关键字 56 //int public = 100; 57 int Public = 100; 58 } 59 }
03_注释
1 /* 2 需求：我准备写一个java程序，把"HelloWorld"这句话输出在控制台 3 4 分析： 5 A:要写一个Java程序，必须定义类 6 B:把数据能够输出，说明我们的程序是可以独立运行的，而程序要独立运行，必须定义main方法 7 C:把数据输出在控制台，必须使用输出语句 8 9 实现： 10 A:java语言提供了一个关键字：class用来定义类，后面跟的是类名 11 B:main方法的格式是固定的： 12 public static void main(String[] args) { 13 14 } 15 C:输出语句的格式是固定的： 16 System.out.println("HelloWorld"); 17 "HelloWorld"这个内容是可以改变的 18 */ 19 20 //这是我的HelloWorld案例 21 class HelloWorld { 22 /* 23 为了程序能够独立运行，定义main方法 24 main方法是程序的入口 25 被jvm自动调用 26 */ 27 public static void main(String[] args) { 28 //为了把数据显示在控制台，我们就使用了输出语句 29 System.out.println("HelloWorld"); 30 } 31 }
1 /* 2 注释：用于解释说明程序的文字 3 4 Java中注释的分类及格式 5 单行注释：// 6 多行注释：/星 星/ 7 注意：多行不可以嵌套使用，而单行是可以的 8 文档注释：被javadoc工具解析生成一个说明书，面向对象部分讲解。 9 */ 10 11 //这是我的注释案例 12 class ZhuShiDemo { 13 //main方法是主方法 14 //是程序的入口 15 //被jvm调用 16 public static void main(String[] args) { 17 System.out.println("好好学习,天天向上"); 18 } 19 } 20 21 22 /* 23 注释的作用： 24 A:解释说明程序，提高程序的阅读性 25 B:可以帮助我们调试程序。 26 后面我们会讲解更高级的调试。 27 */ 28 class ZhuShiDemo2 { 29 public static void main(String[] args) { 30 System.out.println("林青霞"); 31 System.out.println("王祖贤"); 32 System.out.println("刘亦菲"); 33 System.out.println("范冰冰"); 34 } 35 }
04_常量和进制问题
1 /* 2 常量： 3 在程序执行过程中，其值不发生改变的量。 4 5 分类： 6 A:字面值常量 7 B:自定义常量(后面讲) 8 9 字面值常量 10 A:字符串常量 用双引号括起来的内容。 11 举例："hello","world","HelloWorld" 12 B:整数常量 所有的整数 13 举例：100,200 14 C:小数常量 所有的小数 15 举例：10.23,110.11 16 D:字符常量 用单引号括起来的内容 17 举例：‘a‘,‘A‘,‘0‘ 18 错误的：‘ab‘ 19 E:布尔常量 比较特殊 20 举例：true,false 21 F:空常量 后面讲 22 举例：null 23 */ 24 class ConstantDemo { 25 public static void main(String[] args) { 26 //字符串常量的输出 27 System.out.println("hello"); 28 29 //整数常量的输出 30 System.out.println(100); 31 32 //小数常量的输出 33 System.out.println(100.10); 34 35 //字符常量的输出 36 System.out.println(‘a‘); 37 System.out.println(‘A‘); 38 System.out.println(‘0‘); 39 //这个是有问题的 40 //System.out.println(‘ab‘); 41 42 //布尔常量的输出 43 System.out.println(true); 44 System.out.println(false); 45 } 46 } 47 48 /* 49 不同进制的数据表现： 50 二进制：由0，1组成。以0b开头。 51 八进制：由0,1,...7组成。以0开头。 52 十进制：由0,1,...9组成。默认整数是十进制。 53 十六进制：由0,1,...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。 54 */ 55 class JinZhiDemo { 56 public static void main(String[] args) { 57 System.out.println(100); //十进制 58 59 System.out.println(0b100); //二进制 60 System.out.println(0100); //八进制 61 System.out.println(0x100); //十六进制 62 } 63 }
05_变量和数据类型
1 /* 2 数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。 3 4 数据类型分类： 5 A:基本数据类型 6 B:引用数据类型(类,接口,数值) 7 8 基本数据类型:4类8种 9 A:整数 占用字节数 10 byte 1 11 short 2 12 int 4 13 long 8 14 15 B:浮点数 16 float 4 17 double 8 18 19 C:字符 20 char 2 21 D:布尔 22 boolean 1 23 24 注意： 25 整数默认是int类型 26 浮点数默认是double类型。 27 28 长整型后缀用L或者l标记。建议使用L。 29 单精度浮点数用F或者f标记。建议使用F。 30 */ 31 class DataTypeDemo { 32 public static void main(String[] args) { 33 //定义变量的格式： 34 //数据类型 变量名 = 初始化值; 35 36 //定义一个字节变量 37 byte b = 10; 38 System.out.println(10); 39 System.out.println(b); 40 41 //定义一个短整型变量 42 short s = 100; 43 System.out.println(s); 44 45 //定义一个整型变量 46 int i = 1000; 47 System.out.println(i); 48 49 //超过了int的范围 50 //int j = 1000000000000; 51 long j = 1000000000000L; 52 //long j = 100L; 53 System.out.println(j); 54 55 //定义浮点数据变量 56 float f = 12.345F; 57 System.out.println(f); 58 59 double d = 12.345; 60 System.out.println(d); 61 62 //定义字符变量 63 char ch = ‘a‘; 64 System.out.println(ch); 65 66 //定义布尔变量 67 boolean flag = true; 68 System.out.println(flag); 69 } 70 } 71 72 /* 73 使用变量的时候要注意的问题： 74 A:作用域 75 变量定义在哪个大括号内，它就在这个大括号内有效。 76 并且，在同一个大括号内不能同时定义同名的变量。 77 78 B:初始化值 79 没有初始化值的变量不能直接使用。 80 你只要在使用前给值就行，不一定非要在定义的时候立即给值。 81 推荐在定义的时候给值。 82 83 定义变量的格式： 84 a:数据类型 变量名 = 初始化值; 85 b:数据类型 变量名; 86 变量名 = 初始化值; 87 88 C:在一行上建议只定义一个变量 89 可以定义多个，但是不建议 90 */ 91 class DataTypeDemo2 { 92 public static void main(String[] args) { 93 //定义变量 94 int x = 100; 95 96 //错误，不能有同名的 97 //int x = 200; 98 99 //定义变量必须给值 100 //int y; 101 //System.out.println(y); 102 103 int z; 104 z = 100; 105 System.out.println(z); 106 107 //在一行上定义多个变量 108 //int a = 10; int b = 20; int c = 30; 109 //上面的写法可以，但是不建议。 110 int a = 10; 111 int b = 20; 112 int c = 30; 113 114 //int d, e; 115 //d = 40; 116 //e = 50; 117 118 //int f,int g; //错误 119 //int h; int i; //正确 120 } 121 } 122 123 /* 124 +是一个运算符(我们等会讲解)。做加法运算的。 125 126 一般来说，我们在运算的时候，要求参与运算的数据类型必须一致。 127 128 注意： 129 boolean类型不能转换为其他的数据类型 130 131 默认转换(从小到大的转换) 132 A:byte,short,char—int—long—float—double 133 B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型 134 */ 135 class DataTypeDemo3 { 136 public static void main(String[] args) { 137 //直接输出的方式做加法 138 //System.out.println(3 + 4); 139 140 //两个int类型做加法 141 int x = 3; 142 int y = 4; 143 int z = x + y; 144 System.out.println(z); 145 146 //定义一个byte类型，一个int类型，做加法 147 byte a = 3; 148 int b = 4; 149 System.out.println(a + b); 150 151 //可能损失精度 152 //byte c = a + b; 153 int c = a + b; 154 System.out.println(c); 155 } 156 } 157 158 /* 159 强制转换： 160 从大的数据类型到小的数据类型。 161 162 格式： 163 目标数据类型 变量 = (目标数据类型) (被转换的数据); 164 165 注意： 166 不要随意的去使用强制转换，因为它隐含了精度损失问题。 167 */ 168 class DataTypeDemo4 { 169 public static void main(String[] args) { 170 byte a = 3; 171 int b = 4; 172 173 //这个肯定没有问题 174 //int c = a + b; 175 176 //byte c = 7; 177 //这个是有问题的 178 //byte c = a + b; 179 //用强制类型转换改进 180 byte c = (byte) (a + b); 181 System.out.println(c); 182 } 183 } 184 185 /* 186 思考题1：请问下面这个有没有问题 187 double d = 12.345; 188 float f = d; 189 190 思考题2：看看下面两个定义有没有区别呢? 191 float f1 = (float)12.345; 192 float f2 = 12.345f; 193 194 f1其实是通过一个double类型转换过来的。 195 而f2本身就是一个float类型。 196 */ 197 class DataTypeDemo5 { 198 public static void main(String[] args) { 199 //把double赋值给float，加了强制类型转换 200 double d = 12.345; 201 float f = (float)d; 202 203 //看看下面两个定义有没有区别呢? 204 float f1 = (float)12.345; 205 float f2 = 12.345F; 206 } 207 } 208 209 /* 210 面试题： 211 byte b1=3,b2=4,b; 212 b=b1+b2; 213 b=3+4; 214 哪句是编译失败的呢？为什么呢？ 215 b = b1 + b2;是有问题的。 216 因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。 217 常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。 218 */ 219 class DataTypeDemo6 { 220 public static void main(String[] args) { 221 //定义了三个byte类型的变量，b1，b2，b3 222 //b1的值是3，b2的值是4，b没有值 223 byte b1 = 3,b2 = 4,b; 224 225 //b = b1 + b2; //这个是类型提升，所有有问题 226 227 b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。 228 } 229 } 230 231 232 /* 233 byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢? 234 235 练习：byte b = (byte)300; 236 */ 237 class DataTypeDemo7 { 238 public static void main(String[] args) { 239 //因为byte的范围是：-128到127。 240 //而130不在此范围内，所以报错。 241 //byte b = 130; 242 243 //我们可以使用强制类型转换 244 byte b = (byte) 130; 245 246 //结果是多少呢? 247 System.out.println(b); 248 } 249 } 250 /* 251 分析过程： 252 我们要想知道结果是什么，就应该知道是如何进行计算的。 253 而我们又知道计算机中数据的运算都是补码进行的。 254 而要得到补码，首先要计算出数据的二进制。 255 256 A:获取130这个数据的二进制。 257 00000000 00000000 00000000 10000010 258 这是130的原码，也是反码，还是补码。 259 B:做截取操作，截成byte类型的了。 260 10000010 261 这个结果是补码。 262 C:已知补码求原码。 263 符号位 数值位 264 补码： 1 0000010 265 266 反码： 1 0000001 267 268 原码： 1 1111110 269 */ 270 271 /* 272 看程序写结果 273 274 通过字符和一个整数相加，我们给出一张表：ASCII码表。 275 通过看完这张表以后，我们要记住三个值： 276 ‘a‘ 97 277 ‘A‘ 65 278 ‘0‘ 48 279 */ 280 class DataTypeDemo8 { 281 public static void main(String[] args) { 282 //直接输出一个字符 283 System.out.println(‘a‘); //a 284 //输出一个字符和一个整数做加法 285 System.out.println(‘a‘+1); //98 286 } 287 } 288 289 /* 290 看程序写结果 291 字符串数据和其他数据做+，结果是字符串类型。 292 这里的+不是加法运算，而是字符串连接符。 293 */ 294 class DataTypeDemo9 { 295 public static void main(String[] args) { 296 System.out.println("hello"+‘a‘+1); //helloa1 297 System.out.println(‘a‘+1+"hello"); //98hello 298 299 System.out.println("5+5="+5+5); //5+5=55 300 System.out.println(5+5+"=5+5"); //10=5+5 301 } 302 }
小结：
1 1:关键字(掌握) 2 (1)被Java语言赋予特定含义的单词 3 (2)特点： 4 全部小写。 5 (3)注意事项： 6 A:goto和const作为保留字存在。 7 B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记 8 9 2:标识符(掌握) 10 (1)就是给类，接口，方法，变量等起名字的字符序列 11 (2)组成规则： 12 A:英文大小写字母 13 B:数字 14 C:$和_ 15 (3)注意事项： 16 A:不能以数字开头 17 B:不能是java中的关键字 18 C:区分大小写 19 (4)常见的命名规则(见名知意) 20 A:包 全部小写 21 单级包：小写 22 举例：liuyi,com 23 多级包：小写，并用.隔开 24 举例：cn.itcast,com.baidu 25 B:类或者接口 26 一个单词：首字母大写 27 举例：Student,Demo 28 多个单词：每个单词首字母大写 29 举例：HelloWorld,StudentName 30 C:方法或者变量 31 一个单词：首字母小写 32 举例：name,main 33 多个单词：从第二个单词开始，每个单词首字母大写 34 举例：studentAge,showAllNames() 35 D:常量 36 全部大写 37 一个单词：大写 38 举例：PI 39 多个单词：大写，并用_隔开 40 举例：STUDENT_MAX_AGE 41 42 3:注释(掌握) 43 (1)就是对程序进行解释说明的文字 44 (2)分类： 45 A:单行注释 // 46 B:多行注释 /**/ 47 C:文档注释(后面讲) /** */ 48 (3)把HelloWorld案例写了一个带注释的版本。 49 后面我们要写一个程序的过程。 50 需求： 51 分析： 52 实现： 53 代码体现： 54 (4)注释的作用 55 A:解释说明程序，提高了代码的阅读性。 56 B:可以帮助我们调试程序。 57 后面我们会讲解一个更高端的一个调试工具 58 59 4:常量(掌握) 60 (1)在程序执行的过程中，其值不发生改变的量 61 (2)分类： 62 A:字面值常量 63 B:自定义常量(后面讲) 64 (3)字面值常量 65 A:字符串常量 "hello" 66 B:整数常量 12,23 67 C:小数常量 12.345 68 D:字符常量 ‘a‘,‘A‘,‘0‘ 69 E:布尔常量 true,false 70 F:空常量 null(后面讲) 71 (4)在Java中针对整数常量提供了四种表现形式 72 A:二进制 由0，1组成。以0b开头。 73 B:八进制 由0，1，...7组成。以0开头。 74 C:十进制 由0，1，...9组成。整数默认是十进制。 75 D:十六进制 由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。 76 77 5:进制转换(了解) 78 (1)其他进制到十进制 79 系数：就是每一个位上的数值 80 基数：x进制的基数就是x 81 权：对每一个位上的数据，从右，并且从0开始编号，对应的编号就是该数据的权。 82 83 结果：系数*基数^权次幂之和。 84 (2)十进制到其他进制 85 除基取余，直到商为0，余数反转。 86 (3)进制转换的快速转换法 87 A:十进制和二进制间的转换 88 8421码。 89 B:二进制到八进制，十六进制的转换 90 91 6:变量(掌握) 92 (1)在程序的执行过程中，其值在某个范围内可以发生改变的量 93 (2)变量的定义格式： 94 A:数据类型 变量名 = 初始化值; 95 B:数据类型 变量名; 96 变量名 = 初始化值; 97 98 7:数据类型(掌握) 99 (1)Java是一种强类型语言，针对每种数据都提供了对应的数据类型。 100 (2)分类： 101 A:基本数据类型：4类8种 102 B:引用数据类型：类，接口，数组。 103 (3)基本数据类型 104 A:整数 占用字节数 105 byte 1 106 short 2 107 int 4 108 long 8 109 B:浮点数 110 float 4 111 double 8 112 C:字符 113 char 2 114 D:布尔 115 boolean 1 116 117 注意： 118 整数默认是int类型，浮点数默认是double。 119 120 长整数要加L或者l。 121 单精度的浮点数要加F或者f。 122 123 8:数据类型转换(掌握) 124 (1)boolean类型不参与转换 125 (2)默认转换 126 A:从小到大 127 B:byte,short,char -- int -- long -- float -- double 128 C:byte,short,char之间不相互转换，直接转成int类型参与运算。 129 (3)强制转换 130 A:从大到小 131 B:可能会有精度的损失，一般不建议这样使用。 132 C:格式： 133 目标数据类型 变量名 = (目标数据类型) (被转换的数据); 134 (4)思考题和面试题： 135 A:下面两种方式有区别吗? 136 float f1 = 12.345f; 137 float f2 = (float)12.345; 138 B:下面的程序有问题吗，如果有，在哪里呢? 139 byte b1 = 3; 140 byte b2 = 4; 141 byte b3 = b1 + b2; 142 byte b4 = 3 + 4; 143 C:下面的操作结果是什么呢? 144 byte b = (byte)130; 145 D:字符参与运算 146 是查找ASCII里面的值 147 ‘a‘ 97 148 ‘A‘ 65 149 ‘0‘ 48 150 151 System.out.println(‘a‘); 152 System.out.println(‘a‘ + 1); 153 E:字符串参与运算 154 这里其实是字符串的连接 155 156 System.out.println("hello"+‘a‘+1); 157 System.out.println(‘a‘+1+"hello"); 158 System.out.println("5+5="+5+5); 159 System.out.println(5+5+"=5+5");
01_算术运算符
1 /* 2 运算符： 3 就是对常量和变量进行操作的符号。 4 5 分类：算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三目运算符 6 7 算术运算符： 8 +,-,*,/,%,++,-- 9 10 注意事项： 11 A:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型 12 B:/获取的是除法操作的商，%获取的是除法操作的余数 13 */ 14 15 class OperatorDemo { 16 public static void main(String[] args) { 17 //定义变量 18 int x = 3; //把3赋值给int类型的变量x 19 int y = 4; 20 21 System.out.println(x+y); 22 System.out.println(x-y); 23 System.out.println(x*y); 24 System.out.println(x/y); //整数相除只能得到整数 25 26 //我就想得到小数，该肿么办呢? 27 //只需要把操作的数据中任意的一个数据变为浮点数 28 System.out.println(x*1.0/y); 29 30 //%的应用 31 System.out.println(x%y); //得到的是余数 32 } 33 } 34 35 /* 36 ++,--运算符的使用： 37 单独使用： 38 放在操作数的前面和后面效果一样。(这种用法是我们比较常见的) 39 参与运算使用： 40 放在操作数的前面，先自增或者自减，然后再参与运算。 41 放在操作数的后面，先参与运算，再自增或者自减。 42 43 作用：就是对变量进行自增1或者自减1。 44 */ 45 class OperatorDemo2 { 46 public static void main(String[] args) { 47 //定义两个变量 48 int x = 3; 49 int y = 4; 50 51 //字符串的拼接 52 //System.out.println("x:"+x); 53 //System.out.println("y:"+y); 54 55 System.out.println("x:"+x+",y:"+y); 56 57 //单独使用 58 //x++; 59 //y--; 60 ++x; 61 --y; 62 //System.out.println(x); 63 System.out.println("x:"+x+",y:"+y); 64 65 //意外的类型,常量是不可以这样做的 66 //System.out.println(10++); 67 68 System.out.println("-------------------"); 69 //参与运算使用 70 int a = 3; 71 int b = 4; 72 73 //int c = a++; 74 //int d = b--; 75 76 int c = ++a; 77 int d = --b; 78 79 System.out.println("a:"+a); //4, 4 80 System.out.println("b:"+b); //3, 3 81 System.out.println("c:"+c); //3, 4 82 System.out.println("d:"+d); //4, 3 83 } 84 } 85 86 87 /* 88 +的用法： 89 A:加法 90 B:正号 91 C:字符串连接符 92 */ 93 class OperatorDemo3 { 94 public static void main(String[] args) { 95 //加法 96 System.out.println(3+4); 97 98 //正号 99 System.out.println(+4); 100 101 System.out.println(‘a‘); 102 System.out.println(‘a‘+1); //这里是加法 103 104 //字符串连接符 105 System.out.println("hello"+‘a‘+1); 106 System.out.println(‘a‘+1+"hello"); 107 } 108 } 109 110 /* 111 ++,--的练习题 112 113 第一题： 114 int a = 10; 115 int b = 10; 116 int c = 10; 117 118 a = b++; 119 c = --a; 120 b = ++a; 121 a = c--; 122 请分别计算出a,b,c的值 123 124 第二题： 125 int x = 4; 126 int y = (x++)+(++x)+(x*10); 127 请分别计算出x,y的值 128 */ 129 class OperatorTest { 130 public static void main(String[] args) { 131 int a = 10; 132 int b = 10; 133 int c = 10; 134 135 a = b++; //a=10,b=11,c=10 136 c = --a; //a=9,b=11,c=9 137 b = ++a; //a=10,b=10,c=9 138 a = c--; //a=9,b=10,c=8 139 140 System.out.println("a:"+a); 141 System.out.println("b:"+b); 142 System.out.println("c:"+c); 143 System.out.println("--------------"); 144 145 int x = 4; 146 int y = (x++)+(++x)+(x*10); 147 //4+6+60 148 //x=5,6 149 150 System.out.println("x:"+x); 151 System.out.println("y:"+y); 152 } 153 }
02_赋值运算符
1 /* 2 赋值运算符： 3 基本的赋值运算符：= 4 把=右边的数据赋值给左边。 5 6 扩展的赋值运算符：+=,-=,*=,/=,%= 7 += 把左边和右边做加法，然后赋值给左边。 8 */ 9 class OperatorDemo { 10 public static void main(String[] args) { 11 //定义一个变量 12 int x = 10; 13 14 //其他用法 15 int a,b; 16 a = b = 10; 17 System.out.println(a); 18 System.out.println(b); 19 System.out.println("-----------"); 20 21 //定义一个变量 22 int y = 10; 23 24 y += 20; 25 26 System.out.println(y); 27 28 } 29 } 30 31 32 33 34 35 36 37 38 39 40 41 42 43 /* 44 面试题： 45 short s=1;s = s+1; 46 47 short s=1;s+=1; 48 上面两个代码有没有问题，如果有，那里有问题。 49 50 为什么第二个木有问题呢? 51 扩展的赋值运算符其实隐含了一个强制类型转换。 52 53 s += 1; 54 不是等价于 s = s + 1; 55 而是等价于 s = (s的数据类型)(s + 1); 56 */ 57 class OperatorTest { 58 public static void main(String[] args) { 59 //short s = 1; 60 //s = s + 1; 61 //System.out.println(s); 62 63 short s = 1; 64 s += 1; //好像是 s = s + 1; 65 System.out.println(s); 66 } 67 }
03_比较运算符
1 /* 2 比较运算符： 3 ==,!=,>,>=,<,<= 4 5 特点： 6 无论你的操作是简单还是复杂，结果是boolean类型。 7 8 注意事项： 9 "=="不能写成"="。 10 */ 11 class OperatorDemo { 12 public static void main(String[] args) { 13 int x = 3; 14 int y = 4; 15 int z = 3; 16 17 System.out.println(x == y); 18 System.out.println(x == z); 19 System.out.println((x+y) == (x+z)); 20 System.out.println("------------"); 21 22 System.out.println(x != y); 23 System.out.println(x > y); 24 System.out.println(x >= y); 25 System.out.println(x < y); 26 System.out.println(x <= y); 27 System.out.println("------------"); 28 29 int a = 10; 30 int b = 20; 31 32 //boolean flag = (a == b); 33 //boolean flag = (a = b); //这个是有问题的，不兼容的类型 34 //System.out.println(flag); 35 36 int c = (a = b); //把b赋值给a，然后把a留下来 37 System.out.println(c); 38 } 39 }
04_常量和进制问题
1 /* 2 常量： 3 在程序执行过程中，其值不发生改变的量。 4 5 分类： 6 A:字面值常量 7 B:自定义常量(后面讲) 8 9 字面值常量 10 A:字符串常量 用双引号括起来的内容。 11 举例："hello","world","HelloWorld" 12 B:整数常量 所有的整数 13 举例：100,200 14 C:小数常量 所有的小数 15 举例：10.23,110.11 16 D:字符常量 用单引号括起来的内容 17 举例：‘a‘,‘A‘,‘0‘ 18 错误的：‘ab‘ 19 E:布尔常量 比较特殊 20 举例：true,false 21 F:空常量 后面讲 22 举例：null 23 */ 24 class ConstantDemo { 25 public static void main(String[] args) { 26 //字符串常量的输出 27 System.out.println("hello"); 28 29 //整数常量的输出 30 System.out.println(100); 31 32 //小数常量的输出 33 System.out.println(100.10); 34 35 //字符常量的输出 36 System.out.println(‘a‘); 37 System.out.println(‘A‘); 38 System.out.println(‘0‘); 39 //这个是有问题的 40 //System.out.println(‘ab‘); 41 42 //布尔常量的输出 43 System.out.println(true); 44 System.out.println(false); 45 } 46 } 47 48 /* 49 不同进制的数据表现： 50 二进制：由0，1组成。以0b开头。 51 八进制：由0,1,...7组成。以0开头。 52 十进制：由0,1,...9组成。默认整数是十进制。 53 十六进制：由0,1,...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。 54 */ 55 class JinZhiDemo { 56 public static void main(String[] args) { 57 System.out.println(100); //十进制 58 59 System.out.println(0b100); //二进制 60 System.out.println(0100); //八进制 61 System.out.println(0x100); //十六进制 62 } 63 }
05_变量和数据类型
1 /* 2 数据类型：Java是一种强类型的语言，针对每一种数据都定义了明确的数据类型。 3 4 数据类型分类： 5 A:基本数据类型 6 B:引用数据类型(类,接口,数值) 7 8 基本数据类型:4类8种 9 A:整数 占用字节数 10 byte 1 11 short 2 12 int 4 13 long 8 14 15 B:浮点数 16 float 4 17 double 8 18 19 C:字符 20 char 2 21 D:布尔 22 boolean 1 23 24 注意： 25 整数默认是int类型 26 浮点数默认是double类型。 27 28 长整型后缀用L或者l标记。建议使用L。 29 单精度浮点数用F或者f标记。建议使用F。 30 */ 31 class DataTypeDemo { 32 public static void main(String[] args) { 33 //定义变量的格式： 34 //数据类型 变量名 = 初始化值; 35 36 //定义一个字节变量 37 byte b = 10; 38 System.out.println(10); 39 System.out.println(b); 40 41 //定义一个短整型变量 42 short s = 100; 43 System.out.println(s); 44 45 //定义一个整型变量 46 int i = 1000; 47 System.out.println(i); 48 49 //超过了int的范围 50 //int j = 1000000000000; 51 long j = 1000000000000L; 52 //long j = 100L; 53 System.out.println(j); 54 55 //定义浮点数据变量 56 float f = 12.345F; 57 System.out.println(f); 58 59 double d = 12.345; 60 System.out.println(d); 61 62 //定义字符变量 63 char ch = ‘a‘; 64 System.out.println(ch); 65 66 //定义布尔变量 67 boolean flag = true; 68 System.out.println(flag); 69 } 70 } 71 72 /* 73 使用变量的时候要注意的问题： 74 A:作用域 75 变量定义在哪个大括号内，它就在这个大括号内有效。 76 并且，在同一个大括号内不能同时定义同名的变量。 77 78 B:初始化值 79 没有初始化值的变量不能直接使用。 80 你只要在使用前给值就行，不一定非要在定义的时候立即给值。 81 推荐在定义的时候给值。 82 83 定义变量的格式： 84 a:数据类型 变量名 = 初始化值; 85 b:数据类型 变量名; 86 变量名 = 初始化值; 87 88 C:在一行上建议只定义一个变量 89 可以定义多个，但是不建议 90 */ 91 class DataTypeDemo2 { 92 public static void main(String[] args) { 93 //定义变量 94 int x = 100; 95 96 //错误，不能有同名的 97 //int x = 200; 98 99 //定义变量必须给值 100 //int y; 101 //System.out.println(y); 102 103 int z; 104 z = 100; 105 System.out.println(z); 106 107 //在一行上定义多个变量 108 //int a = 10; int b = 20; int c = 30; 109 //上面的写法可以，但是不建议。 110 int a = 10; 111 int b = 20; 112 int c = 30; 113 114 //int d, e; 115 //d = 40; 116 //e = 50; 117 118 //int f,int g; //错误 119 //int h; int i; //正确 120 } 121 } 122 123 /* 124 +是一个运算符(我们等会讲解)。做加法运算的。 125 126 一般来说，我们在运算的时候，要求参与运算的数据类型必须一致。 127 128 注意： 129 boolean类型不能转换为其他的数据类型 130 131 默认转换(从小到大的转换) 132 A:byte,short,char—int—long—float—double 133 B:byte,short,char相互之间不转换，他们参与运算首先转换为int类型 134 */ 135 class DataTypeDemo3 { 136 public static void main(String[] args) { 137 //直接输出的方式做加法 138 //System.out.println(3 + 4); 139 140 //两个int类型做加法 141 int x = 3; 142 int y = 4; 143 int z = x + y; 144 System.out.println(z); 145 146 //定义一个byte类型，一个int类型，做加法 147 byte a = 3; 148 int b = 4; 149 System.out.println(a + b); 150 151 //可能损失精度 152 //byte c = a + b; 153 int c = a + b; 154 System.out.println(c); 155 } 156 } 157 158 /* 159 强制转换： 160 从大的数据类型到小的数据类型。 161 162 格式： 163 目标数据类型 变量 = (目标数据类型) (被转换的数据); 164 165 注意： 166 不要随意的去使用强制转换，因为它隐含了精度损失问题。 167 */ 168 class DataTypeDemo4 { 169 public static void main(String[] args) { 170 byte a = 3; 171 int b = 4; 172 173 //这个肯定没有问题 174 //int c = a + b; 175 176 //byte c = 7; 177 //这个是有问题的 178 //byte c = a + b; 179 //用强制类型转换改进 180 byte c = (byte) (a + b); 181 System.out.println(c); 182 } 183 } 184 185 /* 186 思考题1：请问下面这个有没有问题 187 double d = 12.345; 188 float f = d; 189 190 思考题2：看看下面两个定义有没有区别呢? 191 float f1 = (float)12.345; 192 float f2 = 12.345f; 193 194 f1其实是通过一个double类型转换过来的。 195 而f2本身就是一个float类型。 196 */ 197 class DataTypeDemo5 { 198 public static void main(String[] args) { 199 //把double赋值给float，加了强制类型转换 200 double d = 12.345; 201 float f = (float)d; 202 203 //看看下面两个定义有没有区别呢? 204 float f1 = (float)12.345; 205 float f2 = 12.345F; 206 } 207 } 208 209 /* 210 面试题： 211 byte b1=3,b2=4,b; 212 b=b1+b2; 213 b=3+4; 214 哪句是编译失败的呢？为什么呢？ 215 b = b1 + b2;是有问题的。 216 因为变量相加，会首先看类型问题，最终把结果赋值的也会考虑类型问题。 217 常量相加，首先做加法，然后看结果是否在赋值的数据类型范围内，如果不是，才报错。 218 */ 219 class DataTypeDemo6 { 220 public static void main(String[] args) { 221 //定义了三个byte类型的变量，b1，b2，b3 222 //b1的值是3，b2的值是4，b没有值 223 byte b1 = 3,b2 = 4,b; 224 225 //b = b1 + b2; //这个是类型提升，所有有问题 226 227 b = 3 + 4; //常量，先把结果计算出来，然后看是否在byte的范围内，如果在就不报错。 228 } 229 } 230 231 232 /* 233 byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢? 234 235 练习：byte b = (byte)300; 236 */ 237 class DataTypeDemo7 { 238 public static void main(String[] args) { 239 //因为byte的范围是：-128到127。 240 //而130不在此范围内，所以报错。 241 //byte b = 130; 242 243 //我们可以使用强制类型转换 244 byte b = (byte) 130; 245 246 //结果是多少呢? 247 System.out.println(b); 248 } 249 } 250 /* 251 分析过程： 252 我们要想知道结果是什么，就应该知道是如何进行计算的。 253 而我们又知道计算机中数据的运算都是补码进行的。 254 而要得到补码，首先要计算出数据的二进制。 255 256 A:获取130这个数据的二进制。 257 00000000 00000000 00000000 10000010 258 这是130的原码，也是反码，还是补码。 259 B:做截取操作，截成byte类型的了。 260 10000010 261 这个结果是补码。 262 C:已知补码求原码。 263 符号位 数值位 264 补码： 1 0000010 265 266 反码： 1 0000001 267 268 原码： 1 1111110 269 */ 270 271 /* 272 看程序写结果 273 274 通过字符和一个整数相加，我们给出一张表：ASCII码表。 275 通过看完这张表以后，我们要记住三个值： 276 ‘a‘ 97 277 ‘A‘ 65 278 ‘0‘ 48 279 */ 280 class DataTypeDemo8 { 281 public static void main(String[] args) { 282 //直接输出一个字符 283 System.out.println(‘a‘); //a 284 //输出一个字符和一个整数做加法 285 System.out.println(‘a‘+1); //98 286 } 287 } 288 289 /* 290 看程序写结果 291 字符串数据和其他数据做+，结果是字符串类型。 292 这里的+不是加法运算，而是字符串连接符。 293 */ 294 class DataTypeDemo9 { 295 public static void main(String[] args) { 296 System.out.println("hello"+‘a‘+1); //helloa1 297 System.out.println(‘a‘+1+"hello"); //98hello 298 299 System.out.println("5+5="+5+5); //5+5=55 300 System.out.println(5+5+"=5+5"); //10=5+5 301 } 302 }
小结：
1 1:关键字(掌握) 2 (1)被Java语言赋予特定含义的单词 3 (2)特点： 4 全部小写。 5 (3)注意事项： 6 A:goto和const作为保留字存在。 7 B:类似于Notepad++这样的高级记事本会对关键字有特殊颜色标记 8 9 2:标识符(掌握) 10 (1)就是给类，接口，方法，变量等起名字的字符序列 11 (2)组成规则： 12 A:英文大小写字母 13 B:数字 14 C:$和_ 15 (3)注意事项： 16 A:不能以数字开头 17 B:不能是java中的关键字 18 C:区分大小写 19 (4)常见的命名规则(见名知意) 20 A:包 全部小写 21 单级包：小写 22 举例：liuyi,com 23 多级包：小写，并用.隔开 24 举例：cn.itcast,com.baidu 25 B:类或者接口 26 一个单词：首字母大写 27 举例：Student,Demo 28 多个单词：每个单词首字母大写 29 举例：HelloWorld,StudentName 30 C:方法或者变量 31 一个单词：首字母小写 32 举例：name,main 33 多个单词：从第二个单词开始，每个单词首字母大写 34 举例：studentAge,showAllNames() 35 D:常量 36 全部大写 37 一个单词：大写 38 举例：PI 39 多个单词：大写，并用_隔开 40 举例：STUDENT_MAX_AGE 41 42 3:注释(掌握) 43 (1)就是对程序进行解释说明的文字 44 (2)分类： 45 A:单行注释 // 46 B:多行注释 /**/ 47 C:文档注释(后面讲) /** */ 48 (3)把HelloWorld案例写了一个带注释的版本。 49 后面我们要写一个程序的过程。 50 需求： 51 分析： 52 实现： 53 代码体现： 54 (4)注释的作用 55 A:解释说明程序，提高了代码的阅读性。 56 B:可以帮助我们调试程序。 57 后面我们会讲解一个更高端的一个调试工具 58 59 4:常量(掌握) 60 (1)在程序执行的过程中，其值不发生改变的量 61 (2)分类： 62 A:字面值常量 63 B:自定义常量(后面讲) 64 (3)字面值常量 65 A:字符串常量 "hello" 66 B:整数常量 12,23 67 C:小数常量 12.345 68 D:字符常量 ‘a‘,‘A‘,‘0‘ 69 E:布尔常量 true,false 70 F:空常量 null(后面讲) 71 (4)在Java中针对整数常量提供了四种表现形式 72 A:二进制 由0，1组成。以0b开头。 73 B:八进制 由0，1，...7组成。以0开头。 74 C:十进制 由0，1，...9组成。整数默认是十进制。 75 D:十六进制 由0，1，...9,a,b,c,d,e,f(大小写均可)组成。以0x开头。 76 77 5:进制转换(了解) 78 (1)其他进制到十进制 79 系数：就是每一个位上的数值 80 基数：x进制的基数就是x 81 权：对每一个位上的数据，从右，并且从0开始编号，对应的编号就是该数据的权。 82 83 结果：系数*基数^权次幂之和。 84 (2)十进制到其他进制 85 除基取余，直到商为0，余数反转。 86 (3)进制转换的快速转换法 87 A:十进制和二进制间的转换 88 8421码。 89 B:二进制到八进制，十六进制的转换 90 91 6:变量(掌握) 92 (1)在程序的执行过程中，其值在某个范围内可以发生改变的量 93 (2)变量的定义格式： 94 A:数据类型 变量名 = 初始化值; 95 B:数据类型 变量名; 96 变量名 = 初始化值; 97 98 7:数据类型(掌握) 99 (1)Java是一种强类型语言，针对每种数据都提供了对应的数据类型。 100 (2)分类： 101 A:基本数据类型：4类8种 102 B:引用数据类型：类，接口，数组。 103 (3)基本数据类型 104 A:整数 占用字节数 105 byte 1 106 short 2 107 int 4 108 long 8 109 B:浮点数 110 float 4 111 double 8 112 C:字符 113 char 2 114 D:布尔 115 boolean 1 116 117 注意： 118 整数默认是int类型，浮点数默认是double。 119 120 长整数要加L或者l。 121 单精度的浮点数要加F或者f。 122 123 8:数据类型转换(掌握) 124 (1)boolean类型不参与转换 125 (2)默认转换 126 A:从小到大 127 B:byte,short,char -- int -- long -- float -- double 128 C:byte,short,char之间不相互转换，直接转成int类型参与运算。 129 (3)强制转换 130 A:从大到小 131 B:可能会有精度的损失，一般不建议这样使用。 132 C:格式： 133 目标数据类型 变量名 = (目标数据类型) (被转换的数据); 134 (4)思考题和面试题： 135 A:下面两种方式有区别吗? 136 float f1 = 12.345f; 137 float f2 = (float)12.345; 138 B:下面的程序有问题吗，如果有，在哪里呢? 139 byte b1 = 3; 140 byte b2 = 4; 141 byte b3 = b1 + b2; 142 byte b4 = 3 + 4; 143 C:下面的操作结果是什么呢? 144 byte b = (byte)130; 145 D:字符参与运算 146 是查找ASCII里面的值 147 ‘a‘ 97 148 ‘A‘ 65 149 ‘0‘ 48 150 151 System.out.println(‘a‘); 152 System.out.println(‘a‘ + 1); 153 E:字符串参与运算 154 这里其实是字符串的连接 155 156 System.out.println("hello"+‘a‘+1); 157 System.out.println(‘a‘+1+"hello"); 158 System.out.println("5+5="+5+5); 159 System.out.println(5+5+"=5+5");
01_算术运算符
1 /* 2 运算符： 3 就是对常量和变量进行操作的符号。 4 5 分类：算术运算符，赋值运算符，比较运算符，逻辑运算符，位运算符，三目运算符 6 7 算术运算符： 8 +,-,*,/,%,++,-- 9 10 注意事项： 11 A:整数相除只能得到整数。如果想得到小数，必须把数据变化为浮点数类型 12 B:/获取的是除法操作的商，%获取的是除法操作的余数 13 */ 14 15 class OperatorDemo { 16 public static void main(String[] args) { 17 //定义变量 18 int x = 3; //把3赋值给int类型的变量x 19 int y = 4; 20 21 System.out.println(x+y); 22 System.out.println(x-y); 23 System.out.println(x*y); 24 System.out.println(x/y); //整数相除只能得到整数 25 26 //我就想得到小数，该肿么办呢? 27 //只需要把操作的数据中任意的一个数据变为浮点数 28 System.out.println(x*1.0/y); 29 30 //%的应用 31 System.out.println(x%y); //得到的是余数 32 } 33 } 34 35 /* 36 ++,--运算符的使用： 37 单独使用： 38 放在操作数的前面和后面效果一样。(这种用法是我们比较常见的) 39 参与运算使用： 40 放在操作数的前面，先自增或者自减，然后再参与运算。 41 放在操作数的后面，先参与运算，再自增或者自减。 42 43 作用：就是对变量进行自增1或者自减1。 44 */ 45 class OperatorDemo2 { 46 public static void main(String[] args) { 47 //定义两个变量 48 int x = 3; 49 int y = 4; 50 51 //字符串的拼接 52 //System.out.println("x:"+x); 53 //System.out.println("y:"+y); 54 55 System.out.println("x:"+x+",y:"+y); 56 57 //单独使用 58 //x++; 59 //y--; 60 ++x; 61 --y; 62 //System.out.println(x); 63 System.out.println("x:"+x+",y:"+y); 64 65 //意外的类型,常量是不可以这样做的 66 //System.out.println(10++); 67 68 System.out.println("-------------------"); 69 //参与运算使用 70 int a = 3; 71 int b = 4; 72 73 //int c = a++; 74 //int d = b--; 75 76 int c = ++a; 77 int d = --b; 78 79 System.out.println("a:"+a); //4, 4 80 System.out.println("b:"+b); //3, 3 81 System.out.println("c:"+c); //3, 4 82 System.out.println("d:"+d); //4, 3 83 } 84 } 85 86 87 /* 88 +的用法： 89 A:加法 90 B:正号 91 C:字符串连接符 92 */ 93 class OperatorDemo3 { 94 public static void main(String[] args) { 95 //加法 96 System.out.println(3+4); 97 98 //正号 99 System.out.println(+4); 100 101 System.out.println(‘a‘); 102 System.out.println(‘a‘+1); //这里是加法 103 104 //字符串连接符 105 System.out.println("hello"+‘a‘+1); 106 System.out.println(‘a‘+1+"hello"); 107 } 108 } 109 110 /* 111 ++,--的练习题 112 113 第一题： 114 int a = 10; 115 int b = 10; 116 int c = 10; 117 118 a = b++; 119 c = --a; 120 b = ++a; 121 a = c--; 122 请分别计算出a,b,c的值 123 124 第二题： 125 int x = 4; 126 int y = (x++)+(++x)+(x*10); 127 请分别计算出x,y的值 128 */ 129 class OperatorTest { 130 public static void main(String[] args) { 131 int a = 10; 132 int b = 10; 133 int c = 10; 134 135 a = b++; //a=10,b=11,c=10 136 c = --a; //a=9,b=11,c=9 137 b = ++a; //a=10,b=10,c=9 138 a = c--; //a=9,b=10,c=8 139 140 System.out.println("a:"+a); 141 System.out.println("b:"+b); 142 System.out.println("c:"+c); 143 System.out.println("--------------"); 144 145 int x = 4; 146 int y = (x++)+(++x)+(x*10); 147 //4+6+60 148 //x=5,6 149 150 System.out.println("x:"+x); 151 System.out.println("y:"+y); 152 } 153 }
02_赋值运算符
1 /* 2 赋值运算符： 3 基本的赋值运算符：= 4 把=右边的数据赋值给左边。 5 6 扩展的赋值运算符：+=,-=,*=,/=,%= 7 += 把左边和右边做加法，然后赋值给左边。 8 */ 9 class OperatorDemo { 10 public static void main(String[] args) { 11 //定义一个变量 12 int x = 10; 13 14 //其他用法 15 int a,b; 16 a = b = 10; 17 System.out.println(a); 18 System.out.println(b); 19 System.out.println("-----------"); 20 21 //定义一个变量 22 int y = 10; 23 24 y += 20; 25 26 System.out.println(y); 27 28 } 29 } 30 31 32 33 34 35 36 37 38 39 40 41 42 43 /* 44 面试题： 45 short s=1;s = s+1; 46 47 short s=1;s+=1; 48 上面两个代码有没有问题，如果有，那里有问题。 49 50 为什么第二个木有问题呢? 51 扩展的赋值运算符其实隐含了一个强制类型转换。 52 53 s += 1; 54 不是等价于 s = s + 1; 55 而是等价于 s = (s的数据类型)(s + 1); 56 */ 57 class OperatorTest { 58 public static void main(String[] args) { 59 //short s = 1; 60 //s = s + 1; 61 //System.out.println(s); 62 63 short s = 1; 64 s += 1; //好像是 s = s + 1; 65 System.out.println(s); 66 } 67 }
03_比较运算符
1 /* 2 比较运算符： 3 ==,!=,>,>=,<,<= 4 5 特点： 6 无论你的操作是简单还是复杂，结果是boolean类型。 7 8 注意事项： 9 "=="不能写成"="。 10 */ 11 class OperatorDemo { 12 public static void main(String[] args) { 13 int x = 3; 14 int y = 4; 15 int z = 3; 16 17 System.out.println(x == y); 18 System.out.println(x == z); 19 System.out.println((x+y) == (x+z)); 20 System.out.println("------------"); 21 22 System.out.println(x != y); 23 System.out.println(x > y); 24 System.out.println(x >= y); 25 System.out.println(x < y); 26 System.out.println(x <= y); 27 System.out.println("------------"); 28 29 int a = 10; 30 int b = 20; 31 32 //boolean flag = (a == b); 33 //boolean flag = (a = b); //这个是有问题的，不兼容的类型 34 //System.out.println(flag); 35 36 int c = (a = b); //把b赋值给a，然后把a留下来 37 System.out.println(c); 38 } 39 }
04_逻辑运算符
1 /* 2 逻辑运算符： 3 &,|,^,! 4 &&,|| 5 6 特点： 7 逻辑运算符一般用于连接boolean类型的表达式或者值。 8 9 表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子。 10 算术表达式：a + b 11 比较表达式：a == b 12 13 结论： 14 &逻辑与:有false则false。 15 |逻辑或:有true则true。 16 ^逻辑异或:相同为false，不同为true。 17 举例：情侣关系。男男,男女,女男,女女 18 !逻辑非:非false则true，非true则false。 19 特点：偶数个不改变本身。 20 */ 21 class OperatorDemo { 22 public static void main(String[] args) { 23 int a = 3; 24 int b = 4; 25 int c = 5; 26 27 //&逻辑与 28 System.out.println((a > b) & (a > c)); //false & false = false 29 System.out.println((a > b) & (a < c)); //false & true = false 30 System.out.println((a < b) & (a > c)); //true & false = false 31 System.out.println((a < b) & (a < c)); //true & true = true 32 System.out.println("---------------"); 33 34 //|逻辑或 35 System.out.println((a > b) | (a > c)); //false | false = false 36 System.out.println((a > b) | (a < c)); //false | true = true 37 System.out.println((a < b) | (a > c)); //true | false = true 38 System.out.println((a < b) | (a < c)); //true | true = true 39 System.out.println("---------------"); 40 41 //^逻辑异或 42 System.out.println((a > b) ^ (a > c)); //false ^ false = false 43 System.out.println((a > b) ^ (a < c)); //false ^ true = true 44 System.out.println((a < b) ^ (a > c)); //true ^ false = true 45 System.out.println((a < b) ^ (a < c)); //true ^ true = false 46 System.out.println("---------------"); 47 //!逻辑非 48 System.out.println(!(a > b)); //!false = true 49 System.out.println(!(a < b)); //!true = false 50 System.out.println(!!(a > b)); //!!false = false 51 System.out.println(!!!(a > b)); //!!false = true 52 } 53 } 54 55 56 /* 57 &&和&的区别? 同理||和|的区别? 58 A:最终结果一样。 59 B:&&具有短路效果。左边是false，右边不执行。 60 61 开发中常用的逻辑运算符： 62 &&,||,! 63 */ 64 class OperatorDemo2 { 65 public static void main(String[] args) { 66 int a = 3; 67 int b = 4; 68 int c = 5; 69 //&&双与 70 System.out.println((a > b) && (a > c)); //false && false = false 71 System.out.println((a > b) && (a < c)); //false && true = false 72 System.out.println((a < b) && (a > c)); //true && false = false 73 System.out.println((a < b) && (a < c)); //true && true = true 74 System.out.println("----------------"); 75 int x = 3; 76 int y = 4; 77 //boolean b1 = ((x++ == 3) & (y++ == 4)); 78 //boolean b1 = ((x++ == 3) && (y++ == 4)); 79 //boolean b1 = ((++x == 3) & (y++ == 4)); 80 boolean b1 = ((++x == 3) && (y++ == 4)); 81 System.out.println("x:"+x); 82 System.out.println("y:"+y); 83 System.out.println(b1); 84 } 85 }
05_位运算符
1 /* 2 位运算符： 3 &,|,^,~ 4 <<,>>,>>> 5 6 注意： 7 要做位运算，首先要把数据转换为二进制。 8 */ 9 class OperatorDemo { 10 public static void main(String[] args) { 11 //&,|,^,~ 12 13 int a = 3; 14 int b = 4; 15 16 System.out.println(3 & 4); 17 System.out.println(3 | 4); 18 System.out.println(3 ^ 4); 19 System.out.println(~3); 20 } 21 } 22 /* 23 分析：因为是位运算，所以我们必须先把数据换算成二进制。 24 25 3的二进制：11 26 00000000 00000000 00000000 00000011 27 4的二进制：100 28 00000000 00000000 00000000 00000100 29 30 &位与运算：有0则0。 31 00000000 00000000 00000000 00000011 32 &00000000 00000000 00000000 00000100 33 ----------------------------------- 34 00000000 00000000 00000000 00000000 35 结果是：0 36 37 |位或运算：有1则1。 38 00000000 00000000 00000000 00000011 39 |00000000 00000000 00000000 00000100 40 ----------------------------------- 41 00000000 00000000 00000000 00000111 42 结果是：7 43 44 ^位异或运算：相同则0，不同则1。 45 00000000 00000000 00000000 00000011 46 &00000000 00000000 00000000 00000100 47 ----------------------------------- 48 00000000 00000000 00000000 00000111 49 结果是：7 50 51 ~按位取反运算符：0变1，1变0 52 00000000 00000000 00000000 00000011 53 ~11111111 11111111 11111111 11111100 (补码) 54 55 补码：11111111 11111111 11111111 11111100 56 反码：11111111 11111111 11111111 11111011 57 原码：10000000 00000000 00000000 00000100 58 结果是：-4 59 */ 60 61 /* 62 ^的特点：一个数据对另一个数据位异或两次，该数本身不变。 63 */ 64 class OperatorDemo2 { 65 public static void main(String[] args) { 66 int a = 10; 67 int b = 20; 68 69 System.out.println(a ^ b ^ b); //10 70 System.out.println(a ^ b ^ a); //20 71 } 72 } 73 74 75 /* 76 <<:左移 左边最高位丢弃，右边补齐0 77 >>:右移 最高位是0，左边补齐0；最高为是1，左边补齐1 78 >>>:无符号右移 无论最高位是0还是1，左边补齐0 79 80 面试题： 81 请用最有效率的方式写出计算2乘以8的结果? 82 2 * 8 83 84 2 << 3 85 86 */ 87 class OperatorDemo3 { 88 public static void main(String[] args) { 89 //<< 把<<左边的数据乘以2的移动次幂 90 System.out.println(3 << 2); //3*2^2 = 3*4 = 12; 91 92 //>> 把>>左边的数据除以2的移动次幂 93 System.out.println(24 >> 2); //24 / 2^2 = 24 / 4 = 6 94 System.out.println(24 >>> 2); 95 96 System.out.println(-24 >> 2); 97 System.out.println(-24 >>> 2); 98 } 99 } 100 /* 101 计算出3的二进制：11 102 00000000 00000000 00000000 00000011 103 (00)000000 00000000 00000000 0000001100 104 105 >>的移动： 106 计算出24的二进制：11000 107 原码：10000000 00000000 00000000 00011000 108 反码：11111111 11111111 11111111 11100111 109 补码：11111111 11111111 11111111 11101000 110 111 11111111 11111111 11111111 11101000 112 1111111111 11111111 11111111 111010(00) 补码 113 114 补码：1111111111 11111111 11111111 111010 115 反码：1111111111 11111111 11111111 111001 116 原码：1000000000 00000000 00000000 000110 117 118 结果：-6 119 120 >>>的移动： 121 计算出24的二进制：11000 122 原码：10000000 00000000 00000000 00011000 123 反码：11111111 11111111 11111111 11100111 124 补码：11111111 11111111 11111111 11101000 125 126 11111111 11111111 11111111 11101000 127 0011111111 11111111 11111111 111010(00) 128 129 结果： 130 */ 131 /* 132 面试题： 133 请自己实现两个整数变量的交换 134 注意：以后讲课的过程中，我没有明确指定数据的类型，默认int类型。 135 */ 136 class OperatorTest { 137 public static void main(String[] args) { 138 int a = 10; 139 int b = 20; 140 141 System.out.println("a:"+a+",b:"+b); 142 143 //方式1：使用第三方变量(开发中用的) 144 /* 145 int c = a; 146 a = b; 147 b = c; 148 System.out.println("a:"+a+",b:"+b); 149 System.out.println("------------"); 150 */ 151 152 //方式2：用位异或实现(面试用) 153 //左边：a,b,a 154 //右边：a ^ b 155 /* 156 a = a ^ b; 157 b = a ^ b; //a ^ b ^ b = a 158 a = a ^ b; //a ^ b ^ a = b 159 System.out.println("a:"+a+",b:"+b); 160 */ 161 162 //方式3：用变量相加的做法 163 /* 164 a = a + b; //a=30 165 b = a - b; //b=10 166 a = a - b; //a=20 167 System.out.println("a:"+a+",b:"+b); 168 */ 169 170 //方式4：一句话搞定 171 b = (a+b) - (a=b); //b=30-20=10,a=20 172 System.out.println("a:"+a+",b:"+b); 173 } 174 }
06_三目运算符
1 /* 2 单目运算符：~3 3 双目运算符：3 + 4 4 5 三目运算符： 6 格式：比较表达式?表达式1:表达式2; 7 8 比较表达式:结果是一个boolean类型。 9 10 执行流程： 11 根据比较表达式的计算返回一个true或者false。 12 如果是true，就把表达式1作为结果。 13 如果是false，就把表达式2作为结果。 14 */ 15 class OperatorDemo { 16 public static void main(String[] args) { 17 int x = 100; 18 int y = 200; 19 20 int z = ((x > y)? x: y); 21 22 //int z = ((x < y)? x: y); 23 24 //int z = ((x == y)? x: y); 25 26 //报错 27 //int z = ((x = y)? x : y); 28 29 System.out.println("z:"+z); 30 } 31 } 32 33 34 35 36 37 /* 38 练习： 39 获取两个整数中的最大值 40 获取三个整数中的最大值 41 比较两个整数是否相同 42 */ 43 class OperatorTest { 44 public static void main(String[] args) { 45 //获取两个整数中的最大值 46 int x = 100; 47 int y = 200; 48 49 int max = (x > y? x: y); 50 System.out.println("max:"+max); 51 System.out.println("--------"); 52 53 //获取三个整数中的最大值 54 int a = 10; 55 int b = 30; 56 int c = 20; 57 58 //分两步： 59 //A:先比较a,b的最大值 60 //B:拿a,b的最大值在和c进行比较 61 int temp = ((a > b)? a: b); 62 //System.out.println(temp); 63 int max1 = (temp > c? temp: c); 64 System.out.println("max1:"+max1); 65 66 //一步搞定 67 //int max2 = (a > b)?((a > c)? a: c):((b > c)? b: c); 68 //这种做法不推荐。 69 //int max2 = a > b?a > c? a: c:b > c? b: c; 70 //System.out.println("max2:"+max2); 71 System.out.println("--------"); 72 73 //比较两个整数是否相同 74 int m = 100; 75 int n = 200; 76 77 //boolean flag = (m == n)? true: false; 78 boolean flag = (m == n); 79 System.out.println(flag); 80 } 81 }
07_键盘录入
1 /* 2 为了让程序的数据更符合开发的数据，我们就加入了键盘录入。 3 让程序更灵活一下。 4 5 那么，我们如何实现键盘数据的录入呢? 6 A:导包 7 格式： 8 import java.util.Scanner; 9 位置： 10 在class上面。 11 B:创建键盘录入对象 12 格式： 13 Scanner sc = new Scanner(System.in); 14 C:通过对象获取数据 15 格式： 16 int x = sc.nextInt(); 17 */ 18 import java.util.Scanner; 19 20 class ScannerDemo { 21 public static void main(String[] args) { 22 //创建键盘录入数据对象 23 Scanner sc = new Scanner(System.in); 24 25 System.out.println("请你输入一个数据："); 26 int x = sc.nextInt(); 27 28 System.out.println("你输入的数据是："+x); 29 } 30 } 31 32 /* 33 键盘录入练习： 34 键盘录入两个数据，并对这两个数据求和，输出其结果 35 */ 36 import java.util.Scanner; 37 38 class ScannerTest { 39 public static void main(String[] args) { 40 //键盘录入两个数据，并对这两个数据求和，输出其结果 41 //创建键盘录入对象 42 Scanner sc = new Scanner(System.in); 43 44 System.out.println("请输入第一个数据："); 45 int x = sc.nextInt(); 46 47 System.out.println("请输入第二个数据："); 48 int y = sc.nextInt(); 49 50 //把键盘录入的数据进行相加即可 51 int sum = (x + y); 52 System.out.println("sum:"+sum); 53 } 54 } 55 56 /* 57 键盘录入练习：键盘录入两个数据，获取这两个数据中的最大值 58 */ 59 60 import java.util.Scanner; 61 62 class ScannerTest2 { 63 public static void main(String[] args) { 64 //创建键盘录入对象 65 Scanner sc = new Scanner(System.in); 66 67 System.out.println("请输入第一个数据："); 68 int a = sc.nextInt(); 69 70 System.out.println("请输入第二个数据："); 71 int b = sc.nextInt(); 72 73 //获取这两个数据中的最大值 74 int max = (a > b? a: b); 75 System.out.println("max:"+max); 76 } 77 } 78 79 80 81 82 /* 83 练习： 84 键盘录入三个数据，获取这三个数据中的最大值 85 键盘录入两个数据，比较这两个数据是否相等 86 */ 87 import java.util.Scanner; 88 89 class ScannerTest3 { 90 public static void main(String[] args) { 91 //键盘录入三个数据，获取这三个数据中的最大值 92 93 //创建键盘录入对象 94 Scanner sc = new Scanner(System.in); 95 96 System.out.println("请输入第一个数据："); 97 int a = sc.nextInt(); 98 99 System.out.println("请输入第二个数据："); 100 int b = sc.nextInt(); 101 102 System.out.println("请输入第三个数据："); 103 int c = sc.nextInt(); 104 105 //获取这三个数据中的最大值 106 int temp = ((a > b)? a: b); 107 int max = (temp > c? temp : c); 108 System.out.println("max:"+max); 109 System.out.println("------------------"); 110 111 //键盘录入两个数据 112 System.out.println("请输入第一个数据："); 113 int x = sc.nextInt(); 114 115 System.out.println("请输入第二个数据："); 116 int y = sc.nextInt(); 117 118 //比较这两个数据是否相等 119 boolean flag = (x == y); 120 System.out.println("flag:"+flag); 121 } 122 }
08_顺序结构
1 /* 2 流程控制语句：可以控制程序的执行流程。 3 4 分类： 5 顺序结构 6 选择结构 7 循环结构 8 9 顺序结构： 10 从上往下，依次执行。 11 */ 12 class ShunXuJieGouDemo { 13 public static void main(String[] args) { 14 System.out.println("程序开始了"); 15 16 System.out.println("我爱Java"); 17 18 System.out.println("程序结束了"); 19 } 20 }
09_选择结构(if语句)
1 /* 2 选择结构： 3 if语句 4 switch语句 5 6 if语句： 7 格式1 8 格式2 9 格式3 10 11 if语句的格式： 12 if(比较表达式) { 13 语句体; 14 } 15 16 执行流程： 17 先计算比较表达式的值，看其返回值是true还是false。 18 如果是true，就执行语句体； 19 如果是false，就不执行语句体； 20 */ 21 class IfDemo { 22 public static void main(String[] args) { 23 int x = 10; 24 25 if(x == 10) { 26 System.out.println("x等于10"); 27 } 28 29 if(x == 20) { 30 System.out.println("x等于20"); 31 } 32 33 System.out.println("over"); 34 } 35 } 36 37 /* 38 if语句的注意事项： 39 A:比较表达式无论简单还是复杂，结果必须是boolean类型 40 B:if语句控制的语句体如果是一条语句，大括号可以省略； 41 如果是多条语句，就不能省略。建议永远不要省略。 42 C:一般来说：有左大括号就没有分号，有分号就没有左大括号 43 */ 44 class IfDemo2 { 45 public static void main(String[] args) { 46 int x = 10; 47 48 if(x == 10) { 49 System.out.println("x等于10"); 50 } 51 52 if((x > 5) || (x == 10)) { 53 System.out.println("x大于或者等于10"); 54 } 55 System.out.println("-------------------"); 56 57 int a = 100; 58 59 /* 60 if(a == 100) { 61 System.out.println("a的值是100"); 62 } 63 */ 64 if(a != 100) { 65 System.out.println("a的值是100"); 66 System.out.println("over"); 67 } 68 System.out.println("-------------------"); 69 70 int b = 100; 71 if(b != 100); //这里其实是有语句体的，只不过是空语句体。 72 //代码块 73 { 74 System.out.println("b的值是100"); 75 System.out.println("over"); 76 } 77 } 78 } 79 80 /* 81 if语句格式2： 82 if(比较表达式) { 83 语句体1; 84 }else { 85 语句体2; 86 } 87 执行流程： 88 首先计算比较表达式的值，看其返回值是true还是false。 89 如果是true，就执行语句体1； 90 如果是false，就执行语句体2； 91 92 注意：else后面是没有比较表达式的，只有if后面有。 93 */ 94 class IfDemo3 { 95 public static void main(String[] args) { 96 //判断两个数据是否相等 97 98 int a = 10; 99 int b = 20; 100 101 if(a == b) { 102 System.out.println("a等于b"); 103 }else { 104 System.out.println("a不等于b"); 105 } 106 } 107 } 108 109 /* 110 由于if语句的第二种格式刚才也完成了三元运算符可以完成的效果。 111 所以，我们就认为他们可以完成一样的操作。 112 但是，他们就一点区别没有吗?肯定不是。 113 114 区别： 115 三元运算符实现的，都可以采用if语句实现。反之不成立。 116 117 什么时候if语句实现不能用三元改进呢? 118 当if语句控制的操作是一个输出语句的时候就不能。 119 为什么呢?因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出。 120 */ 121 class IfDemo4 { 122 public static void main(String[] args) { 123 //获取两个数据的最大值 124 int a = 10; 125 int b = 20; 126 127 //用if语句实现 128 int max1; 129 if(a > b) { 130 max1 = a; 131 }else { 132 max1 = b; 133 } 134 System.out.println("max1:"+max1); 135 136 //用三元改进 137 int max2 = (a > b)? a: b; 138 System.out.println("max2:"+max2); 139 System.out.println("----------"); 140 141 //判断一个数据是奇数还是偶数,并输出是奇数还是偶数 142 int x = 100; 143 144 if(x%2 == 0) { 145 System.out.println("100是一个偶数"); 146 }else { 147 System.out.println("100是一个奇数"); 148 } 149 150 //用三元改进 151 //这种改进是错误的。 152 //String s = (x%2 == 0)?System.out.println("100是一个偶数");:System.out.println("100是一个奇数");; 153 } 154 } 155 156 /* 157 if语句的格式3： 158 if(比较表达式1) { 159 语句体1; 160 }else if(比较表达式2) { 161 语句体2; 162 }else if(比较表达式3) { 163 语句体3; 164 } 165 ... 166 else { 167 语句体n+1; 168 } 169 170 执行流程： 171 首先计算比较表达式1看其返回值是true还是false， 172 如果是true，就执行语句体1，if语句结束。 173 如果是false，接着计算比较表达式2看其返回值是true还是false， 174 175 如果是true，就执行语句体2，if语句结束。 176 如果是false，接着计算比较表达式3看其返回值是true还是false， 177 ... 178 179 如果都是false，就执行语句体n+1。 180 */ 181 import java.util.Scanner; 182 183 class IfDemo5 { 184 public static void main(String[] args) { 185 //需求：键盘录入一个成绩，判断并输出成绩的等级。 186 /* 187 90-100 优秀 188 80-90 好 189 70-80 良 190 60-70 及格 191 0-60 不及格 192 */ 193 194 //创建键盘录入对象 195 Scanner sc = new Scanner(System.in); 196 197 //录入数据 198 System.out.println("请输入你的考试成绩："); 199 int score = sc.nextInt(); 200 201 /* 202 if(score>=90 && score<=100) { 203 System.out.println("优秀"); 204 }else if(score>=80 && score<90) { 205 System.out.println("好"); 206 }else if(score>=70 && score<80) { 207 System.out.println("良"); 208 }else if(score>=60 && score<70) { 209 System.out.println("及格"); 210 }else { 211 System.out.println("不及格"); 212 } 213 */ 214 //这样写已经满足我的基本要求，但是可能别人在使用的时候，不会按照你要求的数据给出了。 215 //在做一个程序的基本测试的时候，一定要考虑这样的几个问题： 216 //正确数据，错误数据，边界数据。 217 //而我们刚才写的程序并没有处理错误数据，所以这个程序不是很好，要改进 218 /* 219 if(score>=90 && score<=100) { 220 System.out.println("优秀"); 221 }else if(score>=80 && score<90) { 222 System.out.println("好"); 223 }else if(score>=70 && score<80) { 224 System.out.println("良"); 225 }else if(score>=60 && score<70) { 226 System.out.println("及格"); 227 }else if(score>=0 && score<60){ 228 System.out.println("不及格"); 229 }else { 230 System.out.println("你输入的成绩有误"); 231 } 232 */ 233 234 //另一种判断改进 235 if(score<0 || score>100) { 236 System.out.println("你输入的成绩有误"); 237 }else if(score>=90 && score<=100) { 238 System.out.println("优秀"); 239 }else if(score>=80 && score<90) { 240 System.out.println("好"); 241 }else if(score>=70 && score<80) { 242 System.out.println("良"); 243 }else if(score>=60 && score<70) { 244 System.out.println("及格"); 245 }else { 246 System.out.println("不及格"); 247 } 248 } 249 } 250 251 252 253 254 255 /* 256 if语句格式2的练习： 257 A:获取两个数据中较大的值 258 B:判断一个数据是奇数还是偶数,并输出是奇数还是偶数 259 */ 260 import java.util.Scanner; 261 262 class IfTest { 263 public static void main(String[] args) { 264 //创建键盘录入对象 265 Scanner sc = new Scanner(System.in); 266 267 //获取两个数据中较大的值 268 System.out.println("请输入第一个数据："); 269 int a = sc.nextInt(); 270 271 System.out.println("请输入第二个数据："); 272 int b = sc.nextInt(); 273 274 //定义一个变量接收最大值 275 int max; 276 277 if(a > b) { 278 max = a; 279 }else { 280 max = b; 281 } 282 283 System.out.println("max:"+max); 284 System.out.println("----------------"); 285 286 //判断一个数据是奇数还是偶数 287 System.out.println("请输入你要判断的数据："); 288 int x = sc.nextInt(); 289 290 if(x%2 == 0) { 291 System.out.println(x+"这个数据是偶数"); 292 }else { 293 System.out.println(x+"这个数据是奇数"); 294 } 295 } 296 } 297 298 /* 299 三种if语句分别适合做什么事情呢? 300 格式1：适合做单个判断 301 格式2：适合做两个判断 302 格式3：适合做多个判断 303 304 需求： 305 键盘录入x的值，计算出y的并输出。 306 307 x>=3 y = 2x + 1; 308 -1<=x<3 y = 2x; 309 x<=-1 y = 2x – 1; 310 311 分析： 312 A:由于数据要键盘录入，所以必须使用Scanner。 313 B:由于是三种判断，所以我们选择if语句格式3。 314 */ 315 import java.util.Scanner; 316 317 class IfTest2 { 318 public static void main(String[] args) { 319 //创建键盘录入对象 320 Scanner sc = new Scanner(System.in); 321 322 System.out.println("请输入x的值："); 323 int x = sc.nextInt(); 324 325 //定义一个y 326 int y; 327 328 //用if语句格式3进行判断 329 if(x >= 3) { 330 y = 2*x + 1; 331 }else if(x>=-1 && x<3) { 332 y = 2*x; 333 }else { 334 y = 2*x - 1; 335 } 336 337 System.out.println("y:"+y); 338 } 339 } 340 341 /* 342 键盘录入月份的值，输出对应的季节。 343 344 春 3,4,5 345 夏 6,7,8 346 秋 9,10,11 347 冬 12,1,2 348 349 分析： 350 A:键盘录入月份的值，所以我们要使用Scanner。 351 B:我们应该判断这个月份在那个季节，而这个判断情况较多，所以，用if语句格式3。 352 353 if语句的使用场景： 354 A:针对表达式是一个boolean类型的判断 355 B:针对一个范围的判断 356 */ 357 import java.util.Scanner; 358 359 class IfTest3 { 360 public static void main(String[] args) { 361 //创建键盘录入对象 362 Scanner sc = new Scanner(System.in); 363 364 //录入数据 365 System.out.println("请你输入一个月份:"); 366 int month = sc.nextInt(); 367 368 //第三种格式实现即可 369 if(month<1 || month>12) { 370 System.out.println("你输入的月份有误"); 371 }else if(month == 1) { 372 System.out.println("冬季"); 373 }else if(month == 2) { 374 System.out.println("冬季"); 375 }else if(month == 3) { 376 System.out.println("春季"); 377 }else if(month == 4) { 378 System.out.println("春季"); 379 }else if(month == 5) { 380 System.out.println("春季"); 381 }else if(month == 6) { 382 System.out.println("夏季"); 383 }else if(month == 7) { 384 System.out.println("夏季"); 385 }else if(month == 8) { 386 System.out.println("夏季"); 387 }else if(month == 9) { 388 System.out.println("秋季"); 389 }else if(month == 10) { 390 System.out.println("秋季"); 391 }else if(month == 11) { 392 System.out.println("秋季"); 393 }else { 394 System.out.println("冬季"); 395 } 396 System.out.println("--------------"); 397 398 //这个程序确实是符合了我们的需求，但是就是看起来比较麻烦 399 //那么，我们能不能改进一下呢? 400 //month == 3 401 //month == 4 402 //month == 5 403 //我们发现，上面三个都是春季。 404 //而他们本身每一个都是一个boolean表达式 405 //所以，我们就可以考虑使用逻辑运算符给他们连接起来改进 406 if(month<1 || month>12) { 407 System.out.println("你输入的月份有误"); 408 }else if(month==3 || month==4 || month==5) { 409 System.out.println("春季"); 410 }else if(month==6 || month==7 || month==8) { 411 System.out.println("夏季"); 412 }else if(month==9 || month==10 || month==11) { 413 System.out.println("秋季"); 414 }else { 415 System.out.println("冬季"); 416 } 417 System.out.println("--------------"); 418 419 //这个时候，程序代码以及可以了。 420 //但是呢，假如我要求你输入一个月份，判断是上半年还是下半年。 421 //这个时候，我们的判断条件连接就是6个boolean表达式 422 //我们可能还有更多的连接 423 //这个时候，其实我们还有另外的一种改进方案： 424 //month == 3 425 //month == 4 426 //month == 5 427 //month>=3 && month<=5 428 //用范围也是可以改进的。 429 if(month<1 || month>12) { 430 System.out.println("你输入的月份有误"); 431 }else if(month>=3 && month<=5) { 432 System.out.println("春季"); 433 }else if(month>=6 && month<=8) { 434 System.out.println("夏季"); 435 }else if(month>=9 && month<=11) { 436 System.out.println("秋季"); 437 }else { 438 System.out.println("冬季"); 439 } 440 System.out.println("--------------"); 441 } 442 } 443 444 445 /* 446 获取三个数据中的最大值 447 由此案例主要是为了讲解if语句是可以嵌套使用的。而且是可以任意的嵌套。 448 */ 449 class IfTest4 { 450 public static void main(String[] args) { 451 int a = 10; 452 int b = 30; 453 int c = 20; 454 455 //三元实现 456 //int temp = (a>b)? a: b; 457 //int max = (temp>c)? temp: c; 458 //System.out.println("max:"+max); 459 //System.out.println("--------"); 460 461 //用if语句实现 462 int max; 463 if(a > b) { 464 if(a > c) { 465 max = a; 466 }else { 467 max = c; 468 } 469 }else { 470 if(b > c) { 471 max = b; 472 }else { 473 max = c; 474 } 475 } 476 System.out.println("max:"+max); 477 } 478 }
小结：
1 1:运算符(掌握) 2 (1)算术运算符 3 A:+,-,*,/,%,++,-- 4 B:+的用法 5 a:加法 6 b:正号 7 c:字符串连接符 8 C:/和%的区别 9 数据做除法操作的时候，/取得是商，%取得是余数 10 D:++和--的用法 11 a:他们的作用是自增或者自减 12 b:使用 13 **单独使用 14 放在操作数据的前面和后面效果一样。 15 a++或者++a效果一样。 16 **参与操作使用 17 放在操作数的前面：先自增或者自减，再参与操作 18 int a = 10; 19 int b = ++a; 20 放在操作数的后面：先参与操作，再自增或者自减 21 int a = 10; 22 int b = a++; 23 (2)赋值运算符 24 A:=,+=,-=,*=,/=,%=等 25 B:=叫做赋值运算符，也是最基本的赋值运算符 26 int x = 10; 把10赋值给int类型的变量x。 27 C:扩展的赋值运算符的特点 28 隐含了自动强制转换。 29 30 面试题： 31 short s = 1; 32 s = s + 1; 33 34 short s = 1; 35 s += 1; 36 请问上面的代码哪个有问题? 37 (3)比较运算符 38 A:==,!=,>,>=,<,<= 39 B:无论运算符两端简单还是复杂最终结果是boolean类型。 40 C:千万不要把==写成了= 41 (4)逻辑运算符 42 A:&,|,^,!,&&,|| 43 B:逻辑运算符用于连接boolean类型的式子 44 C:结论 45 &:有false则false 46 |:有true则true 47 ^:相同则false，不同则true。 48 情侣关系。 49 !:非true则false，非false则true 50 51 &&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。 52 ||:结果和|是一样的，只不过有短路效果。左边是true，右边不执行。 53 (5)位运算符(了解) 54 A:^的特殊用法 55 一个数据针对另一个数据位异或两次，该数不变 56 B:面试题 57 a:请实现两个变量的交换 58 **采用第三方变量 59 **用位异或运算符 60 左边a,b,a 61 右边a^b 62 b:请用最有效率的方式计算出2乘以8的结果 63 2<<3 64 (6)三元运算符 65 A:格式 66 比较表达式?表达式1:表达式2; 67 B:执行流程： 68 首先计算比较表达式的值，看是true还是false。 69 如果是true，表达式1就是结果。 70 如果是false，表达式2就是结果。 71 C:案例： 72 a:比较两个数据是否相等 73 b:获取两个数据中的最大值 74 c:获取三个数据中的最大值 75 76 2:键盘录入(掌握) 77 (1)实际开发中，数据是变化的，为了提高程序的灵活性，我们加入键盘录入数据。 78 (2)如何实现呢?目前就记住 79 A:导包 80 import java.util.Scanner; 81 位置：在class的上边 82 B:创建对象 83 Scanner sc = new Scanner(System.in); 84 C:获取数据 85 int x = sc.nextInt(); 86 (3)把三元运算符的案例加入键盘录入改进。 87 88 3:流程控制语句 89 (1)顺序结构 从上往下，依次执行 90 (2)选择结构 按照不同的选择，执行不同的代码 91 (3)循环结构 做一些重复的代码 92 93 4:if语句(掌握) 94 (1)三种格式 95 A:格式1 96 if(比较表达式) { 97 语句体; 98 } 99 100 执行流程： 101 判断比较表达式的值，看是true还是false 102 如果是true，就执行语句体 103 如果是false，就不执行语句体 104 105 B:格式2 106 if(比较表达式) { 107 语句体1; 108 }else { 109 语句体2; 110 } 111 112 执行流程： 113 判断比较表达式的值，看是true还是false 114 如果是true，就执行语句体1 115 如果是false，就执行语句体2 116 117 C:格式3 118 if(比较表达式1) { 119 语句体1; 120 }else if(比较表达式2){ 121 语句体2; 122 } 123 ... 124 else { 125 语句体n+1; 126 } 127 128 执行流程： 129 判断比较表达式1的值，看是true还是false 130 如果是true，就执行语句体1 131 如果是false，就继续判断比较表达式2的值，看是true还是false 132 如果是true，就执行语句体2 133 如果是false，就继续判断比较表达式3的值，看是true还是false 134 ... 135 如果都不满足，就执行语句体n+1 136 (2)注意事项 137 A:比较表达式无论简单还是复杂，结果是boolean类型 138 B:if语句控制的语句体如果是一条语句，是可以省略大括号的；如果是多条，不能省略。 139 建议：永远不要省略。 140 C:一般来说，有左大括号，就没有分号，有分号，就没有左大括号。 141 D:else后面如果没有if，是不会出现比较表达式的。 142 E:三种if语句其实都是一个语句，只要有一个执行，其他的就不再执行。 143 (3)案例： 144 A:比较两个数是否相等 145 B:获取两个数中的最大值 146 C:获取三个数中的最大值(if语句的嵌套) 147 D:根据成绩输出对应的等级 148 E:根据月份，输出对应的季节 149 F:根据x计算对应y的值并输出 150 (4)三元运算符和if语句第二种格式的关系 151 所有的三元运算符能够实现的，if语句的第二种格式都能实现。 152 反之不成立。 153 154 如果if语句第二种格式控制的语句体是输出语句，就不可以。 155 因为三元运算符是一个运算符，必须要有一个结果返回，不能是一个输出语句。
以上是关于黑马java代码01-03.docx的主要内容，如果未能解决你的问题，请参考以下文章