总结week01
1.什么是Java
java是一门编程语言，人与计算机沟通的一种桥梁
2. Java的发展
创始人：1991由SUN公司James Gosling（Java之父）以及团队开发完成；
1995年命名为Java，目前使用较多的版本为8版本
3. Java三大平台体系
JavaSE：标准版本，平台应用的基础
JavaEE：企业版本，为企业开发进行环境解决
JavaME：微型版，嵌入式开发
4. Java的语言特点
面向对象（贴近人类思维，解决现实问题）
简单性（自动内存管理，简化流程处理，语义清晰）
跨平台（编译完成后可在配置了JDK的不同操作系统上运行）
5. Java搭建与配置
5.1几个概念
Jvm：Java的虚拟机
jre：Java的运行环境
jdk：Java的开发工具
jdk里面包含了jvm和jre
5.2 jdk的安装及环境变量配置
5.2.1jdk安装
选择8版本的jdk点击安装即可；
5.3.2环境变量配置
此电脑 -- 属性 -- 高级系统设置 -- 环境变量 -- 系统变量 -- 新建
变量名： JAVA_HOME 变量值： jdk安装的路径
系统变量 -- 选中Path -- 编辑 -- 新建 -- %JAVA_HOME%\bin -- 确定
系统变量 -- 新建
变量名： JRE_HOME 变量值： JDK中集成的jre的路径
系统变量 -- 选中Path -- 编辑 -- 新建 -- %JRE_HOME%\bin -- 确定
6. DOS命令
dir 查看当前目录下所有文件夹及文件
cd 路径：cd.. 切换到上一级目录
cd 文件夹路径 切换到指定文件夹
切换盘符：直接写相应盘符即可
rd 删除指定非空目录
del 删除指定文件
cls 清除屏幕
mkdir 创建文件夹
7.编写第一个hello world代码
当我们安装了jdk并且已经配置好环境变量以后就可以尝试编写第一个代码了
首先创建一个文本文档Hello输入这一串代码：(tab是缩进哦，不要再按空格了)
public class HelloWorld {
public static void main(String[] args){
System.out.println("Hello World !");
}
}
选择显示文本格式，把后缀名Hello.txt改成Hello.java;并且将编写的文件保存放在一个英文命名的文件夹中，这里我们可以命名为test;
然后window+r 输入cmd打开黑屏终端；
我们直接进入文件所在盘符，比如文件在C盘，那么我们直接输入cd c:/test；
然后输入：javac Hello.java(这一步是编译文件，一定要输入后缀名.java)；
完成后在输入java Hello 就会输出Hello World !(这一步是运行编译文件)；
这个时候你返回文件夹可以发现里面多了一个 Hello.class 文件，这是我们前面javac 之后的编译文件，可被执行的文件，而.java文件则是源文件；
7.1了解代码
public class HelloWorld {
//这是一个输出HelloWorld的代码
public static void main(String[] args){
System.out.println("Hello World !");
}
}
class：类
public：公开的
static：静态的
void：无返回值
main：主要的 他是程序的入口
String：字符串类型
[]：数组
args ： 参数
System：系统的
out：输出
println：换行打印
7.1.1注释符
// 单行注释 "CTRL + /" 快捷键注释
/**/ 多行注释
/** doc注释
*/
7.2 中文乱码问题
将文件另存为ANSI编码文件即可
8. 安装Java编辑工具
下载并解压eclipse.zip文件（大家可以去官网下载哦）
打开解压的eclipse文件，找到exe后缀名的文件，创建快捷方式放到我们方便找到的地方；
打开后会默认一个工程存放的文件路径，这个是可以自己选择的，注意要放在英文命名的文件夹里面哦
接着创建Java工程：左上File-new-project-Java Project
工程名就是这个项目的名称，可以简单明了，见名知意，英文加数字找到左边工程名字 点击src - new - packges;
（这里注意一下包名的命名规则哦，域名后置比如：com.公司.项目.xx
这里的每一个 "." 都是一个文件夹哦;）
之后创建类，点击：new - class - Hello（首字母大写哦）之后点击Finish
到这一步就完成了！
8.1 字体大小设置
windows -> perferences - >General - > Appearance ->Colors and Fonts
右边下拉找到Text Font - >Edit 设置就好了
一定要点击 apply and close 哦！
8.2 代码自动补全设置
window - > perferences - >Java ->Editor - > Conrent Assist -> Enable auto activation -> Auto activation triggers for Java(在这后面把键盘上每个英文字母都输入上就搞定啦！)
不要忘记Apply哦；
9.了解存储方式及数据类型
1 bit = 1 位；（位就是计算机中的二进制码0或者1）
1 byte = 8 bit；（1 byte等于1字节，是计算机中最小的存储单位）
1024 byte = 1 KB
1024 KB = 1 MB
1024 MB = 1 GB
1024 GB = 1 TB
这里就不继续列举啦
9.1进制单位表示的数据
进制单位基数范围规则二进制0~1逢2进1，以0B或0b开头；八进制0~7逢8进1，以数字0开头十进制0~9逢10 进1十六进制0~9 a(10)~f(15)逢16进1，以0x 或 0X 开头表示，此处A-F不区分大小写
例如：int n1 = 0b1010;//二进制10
int n2 = 1010;//十进制
int n3 = 01010;//八进制520
int n4 = 0x10101; //16进制 65793
1个字节=00001010；（10的二进制表示）
进制之间是可以转换的哦，喜欢计算的小伙伴可以手算一下！
9.2其他进制转换十进制：
1）二进制转十进制
按权相加：把二进制数首先写成加权系数展开式，然后按十进制加法规则求和。
原码0b1011.01=1*2^3+0*2^2+1*2^1+1*2^0+0*2^-1+1*2^-2=11.25
（从最低位（右边最低，左边最高）开始，将每个位上的数提取出来，乘以2的（位数-1）次方，然后求和相加)
2）八进制转十进制
规则：从最低位（右）开始，将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和
例如：将0234转成十进制
0234 = 4×8^0+3×8^1+2×8^2+0+8^3 = 156
3)十六进制转十进制
规则：从最低位（右）开始，将每个位上的数提取出来，乘以16的（位数-1）次方，然后求和
例如：0x23A = 10×16^0+3×16^1+2×16^2 = 570;
9.3 十进制转换其他进制：
1）十转二：
整数部分：“除2取余，逆序排列”法；(一直除到比2小或者整除为止，最后一个结果也作为一位，加上余数从后往前排列。正数前面补0负数补1)
小数部分：“乘2取整，顺序排序法”；(用取完整剩下的小数乘2)
例如：34转换为二进制：34 - ->0b100010 --> 一个字节8位，所以左边填充2位--》0b00100010
2）十转八
整数部分：“除8取余，逆序排列”法；(一直除到比8小或者整除为止，最后一个结果也作为一位，加上余数从后往前排列。)
小数部分：“乘8取整，顺序排序法”；(用取完整剩下的小数乘8)
例如：131 - -> 0203
3)十转十六
整数部分：“除16取余，逆序排列”法；(一直除到比16小或者整除为止，最后一个结果也作为一位，加上余数从后往前排列。)
小数部分：“乘16取整，顺序排序法”；(用取完整剩下的小数乘16)
例如：237 - -> 0xED
9.4 二进制转其他剩余进制
1）二转八
规则：从低位开始，将二进制每三位一组，转成对应的八进制数即可
例如：0b11010101--> 八进制-->11(3) 010(2) 101(5) -- > 0325
2)二转十六
规则：从低位开始，将二进制的每四位一组，转成对应的十六进制数即可
例如：0b11010101--> 16进制 --> 0x1101（d） 0101（5） --> 0xD5
9.5 八进制，16进制转二进制
1）八转二
规则：将八进制每1位，转成对应的一个3位的二进制数即可
2）十六转二
规则：将十六进制每1位，转成对应的一个4位的二进制数即可
9.6 原码，反码，补码（重点）
精简解释
对于有符号的来说：
1.二进制的最高位是符号位：0表示正数，1表示负数（0->0；1->-）
2.正数的原码，反码，补码都一样（三码合一）
3.负数的反码 = 他的原码符号位不变，其他位取反（0变1，1变0）
4.负数的补码 = 他的反码 + 1，负数的反码 = 负数的补码 - 1
5.0的反码，补码都是0
6.java没有无符号位，换言之，java中的数都是有符号的
7.在计算机运算的时候，都是 以补码的方式 来运算的
8.当我们看运算结果的时候，要看他的原码！
10.变量
变量：没有固定的值并且可以改变的数，能一般化描述指令的方式，与常量相反
变量就是系统为内存分配的一块存储单元，简而言之就是用来在程序中存储数据的！！！
10.1 Java中的变量
在程序中可以改变的量；
语法格式：
数据类型 变量的名字 = 初始化的值
数据类型: 对变量进行约束的
变量的名字: 自己起的一个名字
=: 赋值号
初始化的值: 就是存储的一个数据
public class Demo1 {
//main程序入口
public static void main(String[] args) {
// 数据类型 变量名字 = 初始的值;
int a = 10;//将10 赋值给a
//a 用来存储数据的 是10
System.out.println(a);
System.out.println(a + 20);//30
//变量是一个可以变化的量
a = 250;
System.out.println(a);//250
//声明变量的另外的一种方式
int c,d;//先声明两个 c d 变量名字
c = 89;
d = 98;
System.out.println(c);
System.out.println(d);
}
}
变量声明的三种方式：
边声明边赋值
数据类型 变量的名字 = 初始化的值
先声明再赋值
数据类型 变量名字;
变量名字 = 初始化的值;
连续声明赋值：
数据类型 变量名1 = 值1， 变量名2 = 值2，变量名3 = 值3;
10.2 Java中的数据类型
在Java中有两种数据类型： 基本数据类型和引用数据类型
在Java中有8种基本数据类型：
整型（整数）： 4种 byte short int long
浮点型（小数）: 2种 float double
字符型 : 1种 char
布尔型(真假): 1种 boolean
10.2.1整数类型
整数类型数据的范围占用的内存的字节数byte-128~1271字节short-32768~327672字节int （常用的）-2^31 ~ 2^31 - 14字节long-2^63 ~ 2^63-18字节
总结： 开发中使用比例是 int 其次 是long 再次是byte
注意！！---->计算机中，整数数据类型总是默认 int 类型！
public class Demo2 {
public static void main(String[] args) {
//声明一个byte类型的变量
//byte 的数据范围 -128~127 如果超过范围是报错的
byte a = 12;
//byte a1 = 128; 报错了 因为超过了范围了
System.out.println(a);//12
//声明一个short类型的数据
short s1 = 45;
System.out.println(s1);//45
//因为short 范围 -32768~32767 超过了这个范围就报错
//short s2 = 32768;
//声明一个int类型的数据
int i1 = 789637393;
int age = 23;
System.out.println(i1);
//声明一个long类型的数据
long long1 = 27828L;
long long2 = 789637393L;
//注意 声明long类型的额数据时 加 L或者l 为区分l和1尽量用大写的L
long long3 = 7896373939L;
//注意： 如果值超过了int类型的范围必须加L 或者l
//如果没有超过int类型的范围 可以不加L或者l
//总结： 开发中比例是 int 其次 是long 再次是byte
}
}
10.2.2 浮点类型数据
浮点类型数据的范围占用的字节数float（单精度的）-3.4*10^38 ~ 3.4 * 10^384字节double（双精度的）（Java中默认的）-1.79*10^308 ~ 1.79 * 10 ^3088字节
注意！！---->计算机中，浮点数据类型总是默认 double 类型！
public class Demo3 {
public static void main(String[] args) {
//声明一个float类型的数据
//注意: 声明float类型的时候 加 f或者F
float f1 = 3.4f;
System.out.println(f1);
//Java中默认的浮点类型的数据就是double
double d1 = 3.4;
System.out.println(d1);
//精度数，有效的位数
float f2 = 1.23456789f;
System.out.println(f2);//1.2345679
float f3 = 1.2345678911111111f;
System.out.println(f3);//1.2345679
float f4 = 123.123456789123f;
System.out.println(f4);
//float演示的有效的位数是7 但是多出来的是不准确的
double d2 = 1.23456789123456789;
System.out.println(d2);//1.234567891234568
double d3 = 123.123456789123456789;
System.out.println(d3);
//double 有效的位数是 16位 其他多出来的都是不准确了
//这个有效位数不用记 了解层次
}
}
10.2.3字符类型数据
字符数据范围占用的字节char除了\ 其他都可以2个
public class Demo4 {
public static void main(String[] args) {
//注意事项: char类型的数据必须使用 '' 单引号 引住 而且引号中只能放一个元素
//"\"这是个转义符，可以把无意义的字符转成有意义的字符，或者反之
char c1 = 'a';//英文的字符
char c2 = '国';//中文的字符
char c3 = '4';//数字字符
char c4 = '&';//特殊的符号
//char c5 = '\'; 除了 \ 不行其他都是
//char c5 = '''; 英文的单引号也不行
char c5 = '’';
}
}
10.2.4布尔类型数据
布尔数据范围占用的字节数booleantrue 或者 false1字节
public class Demo5 {
public static void main(String[] args) {
//boolean 声明的变量的值只能true 或者 false
boolean b1 = true;
boolean b2 = false;
System.out.println(b1);//true
System.out.println(b2);//false
}
}
10.2.5 引用数据类型String
String str = "引用数据类型"；//String类型必须用双引号，表示字符串
10.3标识符的命名规则
标识符：Java对各种变量，方法类等命名时使用的字符序列称为标识符；
标识符不能包含空格！并且区分大小写！
关于类和变量的命名的规则：
类的命名规则：1.首字母大写；
2.驼峰命名法：（例如由两个单词组成时：HelloWorld）
3.可以由字母，数字，下划线，组成，但不能以数字开头
4.严格区分大小写
变量的命名规则：1.首字母不能大写，从第二个单词开始首字母大写（xxxYyyZzz等）
2.可以由数字，字母，下划线，￥/$符组成
3.小驼峰命名法如（homeWork 或者 home_work）;
4.见名知意（尽量以英文代替，一眼能分辨）
5.不能用java中的关键字和保留字命名，但可以包含关键字和保留字
包名：域名倒置比如：com.baidu.Demo等等，一个”.“ 代表一个文件夹
类名，接口名：多单词组成时，所有单词的首字母大写。比如：HelloWord；
常量名：所有字母都大写！多单词时用下划线连接，如：XXX_YYY_ZZZ等。
10.4数据类型转换
自动类型转换：当java程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型；
具体数值赋值不会转换类型，但变量赋值则会先判断类型；
大转小会报错，反之则自动转换；
数据类型按精度（容量）大小排序为：
char ——>int——>long ——>float——>double
byte——>short——>int——>long——>float——>double
int a1 = 'c';//正确的
int n1 = 10;
float d1 = n1 + 1.1;//错，因为结果是默认double类型，不能转给更小的float；
double d1 = n1 + 1.1;//正确
float d1 = n1 + 1.1f;//正确
//byte ，short，char 不会互相转换，他们三者在运算后，首先会转换成int类型；
byte a = 1;
byte b = 2;
short c = 3;
short sum = a+c//报错，a+c转换成int类型
byte = a + b;//报错，因为变量a+b在运算后转换成了int类型
//自动提升原则：表达式结果的类型自动提升为 操作数中最大的类型；
//int s = 1;
//shor d = 2;
//byte b1 = 3;
//double d11 = 1.1;
//double d12 = s + d + b1 + d11;正确的，换成上述其他任何一种类型都会报错
强制类型转换：类型 变量=（类型）变量；
比如：
short sum = 5;
float f1 = (float)sum
强制转换会做成精度丢失或者数值溢出；
强转符号只对最近的符号有效，通常要使用小括号提升优先级；
//int a = （int）10×3.5+6×3.2;//报错；
int a = (int) (10 * 3.5 + 6 * 3.20)//通过
//字符串转其他类型 ：这里String的值必须是int范围内的值，转其他类型也是如此，不然会报错；
int num = Integer.parseInt("转Int类型");
//字符串转char类型：
Syetem.out.println(变量名.charAt(0));//charAt里面的数字代表取字符串的第几个字符，第一个是0，以此类推;
//其他类型转String类型：
char c01 = '家';
String str = c01 + "";
11.转义符
目地：将一个无意义的字符转换成一个有意义的字符，或者反之
语法格式：
\字符
几个特殊符号：
\n :换行，使光标下移一格
\t :制表符 tab
\r :是回车，return；使光标到行首
例如：
public class Demo7 {
public static void main(String[] args){
//打印一个 ' 字符 语法格式 \字符
System.out.println('\'');
//打印一个 \ 字符
System.out.println('\\');
//打印一个" 的字符串
System.out.println("\"");
//\n 和 \t 只能在字符串中有效果
System.out.println("昨夜风\n吹进窗中");
System.out.println("\t绫罗绸缎\t巧做霓裳");
}
}
12.运算符
1.算术运算符
2.关系运算符
3.逻辑运算符
4.位运算符
12.1 算术运算符
数学中的 + （加） - （减） *（乘） / (除) % （取余）++(自增) --（自减）
重点：在java中，%的本质，看一个公式：a % b = a - a / b × b;（若a为小数，则会自动把a强转为int类型，a%b = a - int(a)/b×b有小数时得到的是近似值
变量++: 先执行当前的操作，然后自增1**
++变量: 先自身加1然后再执行接下来的操作
变量--: 先执行当前的操作，然后自身减1
--变量: 先自身减1 ，然后再执行其他操作
重点：当++作为独立语句使用的时候，两者的输出是一样的，前加后加一样；作为表达式使用时：前++：先自增，再赋值；后++：先赋值，在自增
public class Demo8 {
public static void main(String[] args){
int num1 = 7;
int num2 = 3;
System.out.println(num1+num2);//10
int num3 = num1/num2;
System.out.println(num3);//2,除在java中代表的是取整
float f = (float)(10.0 / 4);//f=2.5
double d1 = 10.0 / 4;//d1 = 2.5
double d2 = 10 / 4;//d2 = 2.0
//在java中，%的本质，看一个公式：a % b = a - a / b × b;
//10%-3 => 10 - 10/(-3) * 3 = 1
System.out.println(10 % -3);// 输出1
//-10%3 => -10 - (-10)/3 * 3 = -1
System.out.println(-10 % 3);//-1
System.out.println(-10 % -3);//-1
int num4 = num%num2;
System.out.println(num4);//1,%在java中代表的取余
//顺便一提，在java中，先乘除后加减，若有小括号则优先
int n = 3-4*2;
System.out.println(n);//-5 先计算-4*2 再加3
int n1 = (3-2)*2;
System.out.println(n1);//2
int num5 = 6;
int num6 = num5++;//num6 = 6;因为是先赋值后自增
int num7 = ++num6;//num7 = 7这次是自增后赋值
int i = 10;
//i++;等价于i=i+1
// System.out.println(i);//i=11;
++i;//等价于i=i+1
System.out.println(i);//i=11;
//当++作为独立语句使用的时候，两者的输出是一样的，前加后加一样；
//练习一下自增自减
int a = 5;
int b = (a++) + (--a) + (++a);//输出为16，从左往右为5+5+6
}
}
12.1.2 算数运算符面试题
1.面试题1：
int i = 1;
i = i++;//解析：计算机使用了临时变量保存i：(1)temp=i(2)i=i+1(3)i=temp 所以输出还是1；
System.out.println(i);//i=1
面试题2：
int i = 1;
i = ++1;//计算机使用了临时变量保存i：(1)i=i+1(2)temp=i(3)i=temp 所以才输出2
System.out.println(i);//2
12.2赋值运算符
+= -= *= /=
public class Demo9{
public static void main(String[] args){
int a = 1;
int a += 3;//相当于a=a+3;直接给a运算且赋值
System.out.println(a);//4
//其他都是一样的
//值得一提的是左边的值必须是变量，不能是一个常量
int b = 2;
//24 += b;24是一个固定的值，因此这是不可以的
//减乘除可以自己试一下
}
}
12.3关系运算符
(大于) <(小于) >=(大于等于) <= (小于等于) ==(是否等于) !=(是否不等于) 变量1 > 变量2 例如: a > b 常量1 > 常量2 例如: 2 > 3 他们的结果总是布尔类型的数据 true or false
public classs Demo10{ public static void main(String[] args){ //布尔类型的数据通常是表达式 boolean ret1 = 3 < 4; System.out.println(ret1);//true int a = 1; int b = 2; System.out.println(a>b);//false System.out.println(a != b);//true } }
12.4逻辑运算符
返回的数值总是布尔类型；
运算符 描述 示例 结果
& 与 false&true false（两个表达式都要成立即为真）
| 或 false|true true（一个表达式为真即为真）
^ 异或 false^true true（两个相同为false不同为true）
! 非 ！true false
&& 短路与 false&&true false（计算第一个为假即假直接输出false，为真再继续下个表达式）
|| 短路或 false||true true（第一个即真直接输出为true，第一个为假再继续下个表达式）
在计算机中：非0即真，0为假；
逻辑或：或1则1；
逻辑与：全1才1；
表达式1 && 表达式2 && ...
关系运算符的表达式 && 关系运算符的表达式
3 > 4 && 5 < 6；
public class Demo11{
int a = 3;
int b = 5;
int c = 4;
boolean res1 = a > b && b > c;//false有假即假
boolean res2 = a > c || b > a;//true有真即真
}
12.5三目运算符
数据类型 变量 = 关系表达式 ？ Value1 : Value2;
当关系表达式为true时，将Value的值赋给变量，为false时，将Value2的值赋给变量；
public class Demo {
public static void main(String[] args){
int a = 5;
int b = a > 10 ? 2 : 3;
}
}
12.6位运算符
java中有7个位运算符（&，|，^，~，>>，<<，和 >>>）
位运算符运算规则算术右移 >>低位溢出，符号位不变，并用符号位补溢出的高位算术左移<<符号位不变 低位补0逻辑右移<<<（特别说明：没有<<<符号）也叫无符号右移，低位溢出，高位补0
总结：前四种运算都是先把原码变成补码，然后进行运算，最后结果在从补码转变成原码；
后两种：
int a = 1>>2;//输出为0，本质上是1/2/2=0（位移几位就是几个2）
int b = 1<<2;//输出为4，本质上是1*2*2=4（位移几位就是几个2）
12.7逻辑运算符的短路原则
表达式1 && 表达式2 &&...
若表达式1 为false ，则整体为false， 表达式2 和以后的表达式不再执行
逻辑或的短路原则:
表达式1 || 表达式2 || ...
若出现表达式为true，则为true，从为true的表达式开始后面的表达式不再执行
相比 & 和 | ，短路原则大大提升了java的运行效率；
puclic class Demo16 {
public static void main(String[] args){
int a = 5;
int b = 5;
if(a++ == 5 | ++b == 5){
a = 11;
}
//输出为a=11 b=6;| 逻辑或即使第一个判断为真，仍然会继续运行下一个表达式
System.out.println("a="+a+"b="+b);
}
}
puclic class Demo16 {
public static void main(String[] args){
int a = 5;
int b = 5;
if(a++ == 5 || ++b == 5){
a = 11;
}
System.out.println("a="+a+"b="+b);//输出为a=11 b = 5;短路或并不会运行第二个表达式，因此输出的还是5；逻辑& 以及 短路&& 两者同上；
}
}
13.分支
13.1 if -else分支
语法格式：
if(布尔表达式){
语句体1
}else{
语句体2
}
流程：如果表达式为true，则执行语句体1，否则执行语句体2；
public class Demo12{
public static void main(String[] args){
if(true){
Syetem.out.println("帅气");
}else{
Syetem.out.println("屌丝");
}
}
}
13.2 if - else if 分支
语法格式：
if(布尔表达式1){
语句体1
} else if(布尔表达式2){
语句体2
} else if(布尔表达式3){
语句体3
} else if(布尔表达式n){
语句体n
} else{
语句体n+1
}
执行流程:
如果碰到if语句后面的小括号的表达式为true的时候，就执行相对应的语句体；
其他语句体一概不执行；
13.2.1 利用Scanner 接收值
import java.util.Scanner;
Scanner input = new Scanner(System.in);
int sum = input.nextInt();//接收int类型
char c = input.next().charAt();//接收char类型
String str = input.next();//接收String类型
结合Scanner给 if else 语句举例：
/**
* 学生成绩的等级问题:
* 90~100 打印优秀
* 80~89 打印良好
* 70~79 打印一般
* 60~69 打印及格
* 60分以下 叫家长
* 结果是多个分支 用if-esle if
*/
import java.util.Scanner;
public class Demo13 {
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入您的成绩：");
int store = input.nextInt();
if(store >=90 && store <=100){
System.out.println("优秀");
}else if(store >= 80){
System.out.println("良好");
}else if(store >= 70){
System.out.println("一般");
}else if(store >= 60){
System.out.println("及格");
}else{
System.out.println("叫家长");
}
}
}
13.3 if 嵌套的写法
一个 if 语句中再写另外一个语句
//嵌套写法
//年龄满18岁，50体重达标 才能献血
import java.util.Scanner;
public class Demo14{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("请输入年龄：");
int age = input.nextInt();
System.out.println("请输入体重：");
int weight = input.nextInt();
if(age >= 18){
if(weight >= 50){
System.out.println("可以献血");
}else{
System.out.println("年龄达标，体重不够");
}
}else{
System.out.println("年龄不达标");
}
}
}
13.4 switch - case 分支
语法格式：
switch (表达式){
case 常量1:
语句体1;
break;
case 常量2:
语句体2;
break;
case 常量3:
语句体3;
break;
......
default:
语句体n;
break;
}
执行流程：switch后面的小括号中的表达式值去和case后面的常量进行匹配，一样就执行下面的语句体，其他就不再执行；
//使用switch-case 写
/**
* 按1 给妈妈打电话
* 按2 给爸爸打电话
* 按3 给奶奶打电话
* 按4给爷爷打电话
* 按其他键 个110
*/
import java.util.Scanner;
public class Demo15{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.println("输入一个键");
int num = input.nextInt();
switch(num){
case 1:
System,out.println("给妈妈打电话");
break;
case 2:
System,out.println("给爸爸打电话");
break;
case 3:
System,out.println("给奶奶打电话");
break;
case 4:
System,out.println("给爷爷打电话");
break;
default:
System,out.println("打给110");
break;
//总结： if-else if 和switch-case 的功能可以相互 转 可以实现相等的功能
//但是表示式不一样
}
}
}
13.5关于switch-case的一个关键点
switch (表达式){
case 常量1:
语句体1;
break;
......
default:
语句体n;
break;
}
表达式可以是什么类型的数据
byte short int char String 枚举
只要是能转为int类型的数据都可以；
不可以是浮点型和长整型long；
参考阅读
发表评论