java数据类型
一、进制及其转换 （了解）
- 软件
把事先编排好的数据跟用户交互。
- 计算机的数据的单位
数据：文本、音频、视频、图片
数据最小的单位是 byte字节
1024byte = 1kb
1024k = 1m
1024m = 1g
1024g = 1t
...
- 二进制 10101100
- 八进制 123457
- 十进制 257989
- 十六进制
十六进制超过9就开始用字母表示
10----A
11----B
12----C
13----D
14----E
15----F
- 十进制转换二进制
- 二进制转换十进制
- 打开计算器
二、关键字和标识符 （理解）
- 关键字
系统赋予一些单词特定含义，这些单词就是关键字！
例如：
class 类的定义
public 修饰类，类名和源文件名必须一致
特点：全小写，且在editplus工具中都是蓝色字体！
- 保留字
保留字是系统已经占用，但是不让程序员使用！
goto const 背会
- 标识符
取名字的部分就叫标识符
例如：类名
标识符命名官方的规定！
1.标识符是字母数字下划线_美元符$号组成！
2.数字不能开头
3.关键字和保留字不能作为标识符
国内类名命名规范：每一个单词的首字母大写
以下选项中哪些可以作为标识符（A E）
A.Class B.public C.goto D.const E.HelloWorld
三、进制和E （掌握）
//定义类
public class Demo01{
//定义主函数
public static void main(String[] args){
//输出语句
//二进制 前缀0b
System.out.println(0b10101010);
//八进制 前缀0
System.out.println(07777);
//十进制
System.out.println(7777);
//十六进制 前缀0x
System.out.println(0x4e2d);
//E
System.out.println(3.14E2);
System.out.println(314E-2);
}
}
四、变量和常量 （掌握）
- 字面值（数值）
他今年 10岁了 --------- 10 --- 整数
他体重 78.6kg --------- 78.6 --- 小数
他叫 “小明” --------- “小明” --- 字符串
- 变量语法
标准语法：数据类型 变量名 = 字面值;
java中
整数用int表示
小数用double表示
字符串用String表示
变量名：标识符，自己取。 第一个单词小写，第二个单词开始首字母大写！
- 变量理解
理解：一个变量是一个容器，它存储一个数据！
在java中只要有 = 号，代码一定是从右边往左边读！
把10这个字面值数据赋值给age,age是int类型的容器。
int age = 10;
把20这个字面值数据赋值给age,age本来的10被覆盖掉。
age = 20;
public class Demo01{
public static void main(String[] args){
//他今年 10岁了 --------- 10 --- 整数
//他体重 78.6kg --------- 78.6 --- 小数
//他叫 “小明” --------- “小明” --- 字符串
int age = 10;
double weight = 78.6;
String name = "小明";
System.out.println("年龄："+age);
System.out.println("体重："+weight);
System.out.println("名字："+name);
}
}
- 常量
常量是一旦赋值，就是最终值！
用final修饰变量就是常量！
public class Demo02{
public static void main(String[] args){
//a是常量
//常量有两种表示：第一种，变量用final修饰 ！
// 第二种，直接表示的字面值都是常量！
final int A = 10;
System.out.println(A);
System.out.println(10);
}
}
练习题：
他今年25岁，他体重57.6kg,他叫“小明”！
他今年28岁，他体重77.5kg,他叫“小红”！
提取这里面的数据，定义变量，并输出！
输出的效果：
名字：小明
年龄：25
体重：57.6
-----------------------------
名字：小红
年龄：28
体重：77.5
五、八大基本数据介绍 （掌握）
- 整数类型
数据类型 占用字节数 有符号表示整数的范围不同 大概范围
byte 1 -2^7 ~ 2^7-1 -128~127
short 2 -2^15 ~ 2^15-1 正负3万
int 4 -2^31 ~ 2^31-1 正负21亿
long 8 -2^63 ~ 2^63-1
系统默认int类型，任何的整数，都先默认存储到int容器
- 小数类型/浮点数
数据类型 占用的字节数 精确度 表示的小数位
float 4 单精度 7
double 8 双精度 15
系统默认double类型，任何的小数，都先默认存储到double容器
- boolean类型/布尔类型/逻辑类型
boolean 表示是最基本的逻辑
字面值：true 对、真 、成立
false 错、假、不成立
boolean a1 = true;
a1 = false;
-
char类型/字符类型
char 字符类型 占用2个字节 char两种表示形式 第一种：表示字符 String 字符串类型 “abc” char 字符类型 ‘a’ 第二种：无符号表示整数 范围 0 ~ 2^16-1 大概 65535 char a1 = 97;
注意：整个java语言只有两种类型，一种基本数据类型，一种是引用数据类型！
基本数据类型：byte short int long float double boolean char
引用数据类型：String
六、八种基本数据类型的详解（掌握）
//定义类
public class Demo01{
//定义主函数
public static void main(String[] args){
//整数类型
//byte short int long
byte a1 = 20;
System.out.println("a1:"+a1);
//字面值后面加L/l,直接存储到long容器
//建议：只要用long类型就加L一定不错！
long a2 = 2200000000L;
System.out.println("a2:"+a2);
//小数类型
//float double
float a3 = 3f;
System.out.println("a3:"+a3);
//字面值后面加F/f,直接存储到float容器
//建议：只要用float类型就加f一定不错！
float a4 = 3.14f;
System.out.println("a4:"+a4);
double a5 = 3.14;
System.out.println("a5:"+a5);
//精确度问题
float a6 = 3.123456789123456789f;
double a7 = 3.123456789123456789d;
System.out.println("a6:"+a6);
System.out.println("a7:"+a7);
//所有的小数表示都是近似值！
System.out.println(2.0-1.1);
//boolean类型
boolean flag = true;
flag = false;
System.out.println(flag);
//char 类型
//第一种：表示字符 单引号，单个！
char c1 = 'a';
System.out.println("c1:"+c1);
//第二种：无符号表示整数 0~65535
char c2 = 97;
System.out.println("c2:"+c2);
}
}
七、变量五种定义方式 （掌握）
package com.bjpowernode.javastudy.day04.demo01;
public class Demo01 {
public static void main(String[] args) {
//1.声明变量 直接赋值
int a1 = 10;
System.out.println("a1:"+a1);
//2.先声明，后赋值
//变量必须给初始值
int a2;
a2 = 20;
System.out.println("a2:"+a2);
//3.声明多个变量，直接赋值
int a3 = 30,a4 = 40;
System.out.println("a3:"+a3);
System.out.println("a4:"+a4);
//4.先声明多个变量，后赋值
int a5,a6;
a5 = 50;
a6 = 60;
System.out.println("a5:"+a5);
System.out.println("a6:"+a6);
//5.混合
int a7 = 70,a8,a9 = 90;
a8 = 80;
System.out.println("a7:"+a7);
System.out.println("a8:"+a8);
System.out.println("a9:"+a9);
}
}
八、基本数据类型的类型转换 （掌握）
基本数据类型：byte short int long float double boolean char
能参与类型转换的只有7种：byte short int long float double char
容量正序排行：byte -> short(char) -> int -> long -> float -> double
- 自动类型转换
把小容器的数据转换到大容器（小转大）
- 强制类型转换
把大容器的数据转换到小容器（大转小）
只要是强制类型转换，就必须加强制类型转换符！
- char和short之间转换问题
- 常量和变量的转换问题
在强制类型转换中，如果是常量转换，不需要强制类型转换符，如果是变量才需要强制类型转换符！
-
byte short char 三者只要运算，先提升为int运算，结果也是int类型
-
相同类型运行结果是相同类型，不同类型运算，结果是大的类型
package com.bjpowernode.javastudy.day04.demo02;
public class Demo01 {
public static void main(String[] args) {
//自动类型转换=============================
//a1在等号左边表示变量a1，是容器的名字
//a1在等号右边表示a1容器的数据
//10放入a1这个容器
int a1 = 10;
//从a1这个容器取出10这个数据，存储到a2这个容器
double a2 = a1;
System.out.println("a2:" + a2);
//强制类型转换=============================
int a3 = 20;
byte a4 = (byte) a3;
System.out.println("a4:" + a4);
//强制类型转换的两个问题
//问题1：溢出
int a5 = 200;
byte a6 = (byte) a5;
System.out.println("a6:" + a6);
//问题2：精度缺失
double b1 = 3.9999;
int b2 = (int) b1;
System.out.println("b2:" + b2);
//char和short之间转换问题
char c1 = 'a';
short c2 = (short) c1;
System.out.println("c2:" + c2);
short c3 = 97;
char c4 = (char) c3;
System.out.println("c4:" + c4);
//常量和变量的转换问题
//常量转换不需要强制类型转换符
byte d1 = 20;
final int e1 = 10;
byte d2 = e1;
//变量转换需要强制类型转换符
// int e2 = 10;
// byte d3 = e2;
//byte short char 三者只要运算，先提升为int运算，结果也是int类型
byte m1 = 10;
char m2 = 20;
int sum1 = m1 + m2;
System.out.println(sum1);
//相同类型运行结果是相同类型，不同类型运算，结果是大的类型
int m3 = 10;
int m4 = 4;
int m5 = m3/m4;
System.out.println("m5:"+m5);
int m6 = 10;
double m7 = 20;
double m8 = m6+m7;
System.out.println("m8:"+m8);
//课堂练习:下面输出什么？-------溢出
int i1 = 2100000000;
int i2 = 2100000000;
int rs = i1 + i2;
System.out.println(rs);
}
}
一、算术运算符
+ - * / % ++ --
package com.bjpowernode.javastudy.day04.demo03;
public class Demo01 {
public static void main(String[] args) {
//+ - * / %
//+有三种使用方式
//1.计算
int a = 10,b = 20;
System.out.println(a+b);
//2.正负的正
int a2 = +5;
System.out.println(a2);
//3.连接符
//字符串 和 其他类型相加，结果还是字符串类型
String s1 = "年龄:";
int age = 18;
String s2 = s1 + age;
System.out.println(s2);
System.out.println(s1+age);
System.out.println("年龄:"+18);
//练习：定义两个变量，x=10,y=20 连接出10+20=30
int x = 10,y = 20;
System.out.println(x+"+"+y+"="+(x+y));
System.out.println("--------------------输出语句到底能输出什么？------------");
//问题：输出语句到底能输出什么？
//回答：输出的只要是符合某种数据类型的字面值就可以！
System.out.println("HelloWorld");
System.out.println(10);
System.out.println(3.14);
int a5 = 10;
System.out.println(a5);
System.out.println("abc"+"xyz");
System.out.println('z');
System.out.println(true);
System.out.println("中国");
System.out.println("-------------------------------------------------");
//2. - 减号
//2.1 计算
System.out.println(6-7);
//2.2 负
System.out.println(-7);
//3. * 乘以
System.out.println(6*5);
//4. / 除以
System.out.println(10/3);
System.out.println(10.0/3);
//System.out.println(5/0);
//Infinity
//System.out.println(5/0.0);
//5. % 求余数
System.out.println(7%5);
System.out.println(7.2%5.7);
System.out.println(8%8);
System.out.println(3%8);
System.out.println(0%8);
}
}
- ++和--
package com.bjpowernode.javastudy.day04.demo03;
public class Demo02 {
public static void main(String[] args) {
//++在变量之前或者之后，这个变量本身都自增1
int a1 = 5;
a1++;
System.out.println("a1:"+a1);
int b1 = 5;
++b1;
System.out.println("b1:"+b1);
}
}
package com.bjpowernode.javastudy.day04.demo03;
public class Demo03 {
public static void main(String[] args) {
//总结规律：++在变量之前，变量先自增1，然后其他操作
// ++在变量之后，先其他操作，再自增1
// 小括号不影响！
int a1 = 5;
//运算过程：a1先赋值给b1，然后a1再自增1
int b1 = (a1++);
System.out.println("a1:"+a1);//6
System.out.println("b1:"+b1);//5
System.out.println("-------------------------------");
int a2 = 5;
//运算过程：a2先自增1，然后赋值给b2
int b2 = ++a2;
System.out.println("a2:"+a2);//6
System.out.println("b2:"+b2);//6
}
}
package com.bjpowernode.javastudy.day04.demo03;
public class Demo04 {
public static void main(String[] args) {
int a = 5;
System.out.println(++a);//6
System.out.println(a--);//6
System.out.println(a);//5
}
}
package com.bjpowernode.javastudy.day04.demo03;
public class Demo05 {
public static void main(String[] args) {
int a = 5;
//a++变为6，但是把a原来的值5赋值a,所以a还是5
a=a++;
System.out.println(a);
}
}
package com.bjpowernode.javastudy.day04.demo03;
public class Demo07 {
public static void main(String[] args) {
int m = 2,n = 5;
/*
* 到底是m++ +n 还是m+ ++n?
* 如果是m++ +n 那么 m=3 n=5 x=7
* 如果是m+ ++n 那么 m=2 n=6 x=8
* */
int x = m+++n;
System.out.println("m:"+m);
System.out.println("n:"+n);
System.out.println("x:"+x);
}
}
package com.bjpowernode.javastudy.day04.demo03;
public class Demo06 {
public static void main(String[] args) {
int m = 2,n = 5;
/*
* int x = m++ +n x=7 m=3 n=5
* int x = - ++m - n-- x=-2 m=4 n=4
* int x = -m + --m; x=-3 m=3 n=4
*
* */
int x = m+++n-++m-n---m+--m;
System.out.println("m:"+m);//3
System.out.println("n:"+n);//4
System.out.println("x:"+x);//-3
}
}
二、赋值运算符 （掌握）
= += -= *= /= %=
package com.bjpowernode.javastudy.day04.demo04;
public class Demo01 {
public static void main(String[] args) {
// = += -= *= /= %=
int a = 5;
int b = a = 10;
System.out.println(b);
System.out.println(b);
//+=
int a1 = 5;
a1+=2;
System.out.println("a1:"+a1);//7
System.out.println(a1*=3);//21
System.out.println(a1-=6);//15
System.out.println(a1/=4);//3
System.out.println(a1%=1);//0
System.out.println("------------注意的问题----------------");
//问题：a+=b;可以理解为这么运算 a=a+b;
byte m1 = 5;
m1+=2;
System.out.println(m1);
byte m2 = 5;
m2=(byte)(m2+2);
System.out.println("-------------------------------------");
//问题：+= 和 =+
int x = 5,y = 5;
x+=2;
y=+2;
System.out.println(x);//7
System.out.println(y);//2
System.out.println("-------------------------------------");
//问题：+=还赋值
int x1 = 5;
int y1 = x1+=2;
System.out.println(x1);//7
System.out.println(y1);//7
}
}
三、比较运算符 （掌握）
> >= < <= == !=
比较运算符的结果都是boolean类型，要么是true,要么是false
package com.bjpowernode.javastudy.day04.demo04;
public class Demo02 {
public static void main(String[] args) {
//> >= < <= == !=
int a = 5,b = 7;
boolean flag = a>b;
System.out.println(flag);
System.out.println(a<b);
System.out.println(++a>=--b);//a = 6 b = 6
System.out.println(++a<=--b);//a = 7 b = 5
System.out.println(1==1);
System.out.println(true==true);
System.out.println(1!=1);
System.out.println(3.14 == 10);
System.out.println(0 == 0.00000);
System.out.println(3 == 3.4);
}
}
四、逻辑运算符 （掌握）
至少两个比较运算连接用逻辑运算符，所以逻辑运算符最终的结果一定还是boolean类型的，true ? false
| & ^ !
package com.bjpowernode.javastudy.day04.demo05;
public class Demo01 {
public static void main(String[] args) {
// | 或者 -- 更偏向成立
// 左边一个条件，右边一个条件，只要有一个条件成立，结果就成立！true
// 除非两个条件都不成立结果不成立！false
System.out.println(false | true);//true
System.out.println(1 == 1 | 1 > 7);//true
//& 与，并且 -- 更偏向不成立
//左边一个条件，右边一个条件，只要有一个条件不成立，结果就不成立！false
//除非两个条件都成立结果成立！true
System.out.println(true & false);//false
System.out.println(1 == 1 & 1 > 7);//false
//^异或
//左边一个条件，右边一个条件，只要两个条件不同（异），结果就成立！true
//两个条件相同，结果是成立，true！
//一个true一个false一定是true ,两个true，或者两个false一定是false
System.out.println(true ^ false);//true
System.out.println(false ^ true);//true
System.out.println(true ^ true);//false
System.out.println(false ^ false);//false
System.out.println(1 > 7 ^ 3 < 6);//true
//! 非 取反
System.out.println(!true);
System.out.println(!!!!!!!!(5>3));
}
}
-
短路或|| 短路与&&
package com.bjpowernode.javastudy.day04.demo05; public class Demo02 { public static void main(String[] args) { // 短路或|| // 短路或|| 和 或| 最终结果是一样的，只是运算过程不同！ // 或|,无论第一个条件是否能判断最终的结果，第二个条件都必须执行！ // 短路或|| ,如果第一个条件已经能判断最终的结果，第二个条件就不执行！ // 或| int a = 5; System.out.println(1==1 | a++>5);//true System.out.println("a最终:"+a); // 短路或|| int b = 5; System.out.println(1==1 || b++>5);//true System.out.println("b最终:"+b); int c = 5; System.out.println(1==2 || c++>5);//false System.out.println("c最终:"+c); System.out.println("--------------------------------------"); //短路与&& // 短路与&& 和 与& 最终结果是一样的，只是运算过程不同！ // 或&,无论第一个条件是否能判断最终的结果，第二个条件都必须执行！ // 短路与&& ,如果第一个条件已经能判断最终的结果，第二个条件就不执行！ int x = 5; System.out.println(1!=1 & x++>5);//false System.out.println("x:"+x); int y = 5; System.out.println(1!=1 && y++>5);//false System.out.println("y:"+y); int z = 5; System.out.println(1==1 && z++>5);//false System.out.println("z:"+z); } }
五、三目运算 （掌握）
语法：数据类型 变量名 = 条件表达式 ？ 字面值1 ： 字面值2；
数据类型：任意类型
变量名: 自己取名字
条件表达式: 结果是boolean类型
注意：字面值要和数据类型匹配！
理解：条件表达式成立true,那么字面值1赋值给变量，条件表达式不成立false,那么字面值2赋值给变量。
package com.bjpowernode.javastudy.day04.demo06;
public class Demo01 {
public static void main(String[] args) {
//语法：数据类型 变量名 = 条件表达式 ？ 字面值1 ： 字面值2；
String s1 = false ? "哈哈" : "呵呵";
System.out.println(s1);
System.out.println(true ? "哈哈" : 10);
//三目运算应用
//小明考试，考试及格，小明爸带他去游乐场，否则，小明爸带他去补习班！
double score = 59.9;
String rs = score>=60 ? "小明爸带他去游乐场" : "小明爸带他去补习班";
System.out.println(rs);
//求两个整数的最大值？
int a = 10, b = 20;
int max = a>b ? a : b;
System.out.println("最大值："+max);
}
}
六、位运算符 （了解）
- 按位运算符
| & ^ ~
左边或者右边都是数值，不是条件，用来计算的，结果也不是boolean类型，结果是数值！
package com.bjpowernode.javastudy.day05.bitwiseoperation01;
public class Demo01 {
public static void main(String[] args) {
// 按照位运算的，把每一个十进制整数转换为32位的二进制然后进行计算
// |或者，只要有一个是1，结果就是1
/*
* 00000000-00000000-00000000-00001001 --------- 9
* |
* 00000000-00000000-00000000-00000111 --------- 7
* ----------------------------------------------------------
* 00000000-00000000-00000000-00001111
* */
System.out.println(9 | 7);
// &并且，两个都是1，结果就是1
/*
* 00000000-00000000-00000000-00001001 --------- 9
* &
* 00000000-00000000-00000000-00000111 --------- 7
* ----------------------------------------------------------
* 00000000-00000000-00000000-00000001
* */
System.out.println(9 & 7);
// ^异或，一个是0一个是1，结果是1，两个都是0或者两个都是1结果是0
/*
* 00000000-00000000-00000000-00001001 --------- 9
* ^
* 00000000-00000000-00000000-00000111 --------- 7
* ----------------------------------------------------------
* 00000000-00000000-00000000-00001110
* */
System.out.println(9 ^ 7);
// ~非，取反
/*
* ~ 00000000-00000000-00000000-00001001 --------- 9
* ----------------------------------------------------------
* 11111111-11111111-11111111-11110110
* */
System.out.println(~9);
}
}
- 位移运算符
<< 左移
>> 有符号右移
>>> 无符号右移
package com.bjpowernode.javastudy.day05.bitwiseoperation01;
public class Demo02 {
public static void main(String[] args) {
/*
* <<左移 左边移动，右边补0
* 规律：a<<b 相当于 a*2^b
* 00000000-00000000-00000000-00000101 ------5
* 2<<
* 00000000-00000000-00000000-00101000
* */
System.out.println(5<<3);
/*
* >>有符号右移 右边移动，这个数值是正数，左边补0，这个数值是负数，左边补1
* 规律：a>>b 相当于 a/2^b
* 如果a是负数，但是不能整除，a>>b 相当于 a/2^b-1
* 00000000-00000000-00000000-00101000 ------40
* >>3
* 00000000-00000000-00000000-00000101
* */
System.out.println(41>>3);
/*
*
* 11111111-11111111-11111111-11011000 -40
* >>3
* 11111111-11111111-11111111-11111011
*
* */
System.out.println(-41>>3);
/*
* >>>无符号右移 右边移动，无论这个数值是正数还是负数，左边都补0
* 00000000-00000000-00000000-00101000 ------40
* >>>3
* 00000000-00000000-00000000-00000101
* */
System.out.println(40>>>3);
/*
*
* 11111111-11111111-11111111-11011000 -40
* >>>3
* 00011111-11111111-11111111-11111011
*
* */
System.out.println(-40>>>3);
}
}
3.控制流程
print和println 掌握
转义符 掌握
if单选结构 掌握
if双选结构 掌握
if多选结构 掌握
switch选择结构 掌握
for循环结构 掌握
while循环结构 掌握
do-while循环结构 掌握
嵌套问题 掌握
break和continue关键字 掌握
带标签的break和continue 了解
二、print和println区别（掌握）
区别一：
print 不换行输出
println 输出后换行
区别二：
print()的小括号不写内容就报错
println()的小括号不写内容表示换行的意思
三、转义符（掌握）
\ 反斜杠---转义符
package com.bjpowernode.javastudy.day05.escapecharacter;
public class Demo01 {
public static void main(String[] args) {
//System.out.println(""");
//System.out.println(''');
System.out.println('"');
System.out.println("'");
//转义符：把歧义转换
//我想： 输出 “
//系统想：结尾的”
System.out.println("\"");
System.out.println('\'');
System.out.println(10+"\t"+20);
System.out.println(10+"\n"+20);
System.out.println('\u4e2d');
}
}
四、选择语句（掌握）
if语句
- 语法
if(条件表达式){ if执行体 }
条件表达式：结果是boolean
执行体：任意内容（输出语句、定义变量、选择语句...）
理解：条件表达式成立，执行if执行体，条件表达式不成立，不执行if执行体
- 案例
考试成绩不及格，爸爸带我去补习班！
package com.bjpowernode.javastudy.day05.if_demo;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
System.out.println("程序开始。。。");
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入您的考试成绩？");
//3.接收
double score = sc.nextDouble();
//4.判断
if(score<60){
System.out.println("系统：考试不及格，去补习班学习！");
}
System.out.println("程序结束。。。");
}
}
- if语句其他问题
1. { }可以规范变量的作用域
作用域：一个变量可使用的最大范围
作用域的范围：从变量的声明开始，一直到它所在的大括号结尾！
2.省略大括号
只能有执行下一句话，以分号结尾，且不能定义变量，可以省略大括号（一个分号）
3.大括号后面不能加分号
if-else语句
- 语法
if(条件表达式){if执行体}else{else执行体}
理解：条件表达式成立，执行if执行体，条件表达式不成立（否则），执行else执行体
- 案例
考试成绩及格，爸爸带我去游乐场，考试成绩不及格，爸爸带我去补习班！
package com.bjpowernode.javastudy.day05.if_else_demo;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入您的考试成绩？");
//3.接收
double score = sc.nextDouble();
//4.判断 if-else
if(score>=60){
System.out.println("系统：考试及格，去游乐场！");
}else {
System.out.println("系统：考试不及格，赶紧去补习班！");
}
//System.out.println(score>=60?"系统：考试及格，去游乐场！":"系统：考试不及格，赶紧去补习班！");
}
}
- if-else其他问题
1. { }可以规范变量的作用域
2. 省略大括号
只有一句话，且不能定义变量，可以省略大括号（一个分号）
if-else-if语句
- 语法
if(条1){if执1}
else if(条2){if执2}
else if(条3){if执3}
...
else{else执行体}
理解：如果条件表达式1不成立，判断条件表达式2，如果还不成立，继续判断条件表达式3...直到所有的条件表达式都不成立，最终执行else执行体
在判断期间，只要有一个条件表达式成立，执行它对应的执行体，程序结束
- 案例
90~100 优秀
80~90 良好
70~80 中等
60~70 及格
~60 不及格
小明考试后查询等级？
package com.bjpowernode.javastudy.day05.if_else_if_demo;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入您的考试成绩0~100？");
//3.接收
double score = sc.nextDouble();
//4.判断等级
if(90<= score){
System.out.println("优秀！");
}else if(80<= score){
System.out.println("良好！");
}else if(70<= score){
System.out.println("中等！");
}else if(60<= score){
System.out.println("及格！");
}else {
System.out.println("不及格！");
}
}
}
- if-else-if其他问题
1. { }可以规范变量的作用域
2. 省略大括号
只有一句话，且不能定义变量，可以省略大括号（一个分号）
switch语句
- 语法
switch(字面值){
case 字面值1:
语句1
break;
case 字面值2:
语句2
break;
...
default:
结束语句
}
关键字
switch: 开关语句
case：一种情况，一种可能
break：结束switch语句
default：以上所有情况都不执行，执行default语句，类似于else
理解：switch的字面值 和 哪一个case的字面值相同，执行那个case语句，如果都不相同，执行default语句。
- 案例
日计划
第一天--------------爬山
第二天--------------游泳
第三天--------------聚餐
第四天--------------打游戏
第五天--------------睡觉
查询哪一个干什么？
package com.bjpowernode.javastudy.day05.switch_demo;
import java.util.Scanner;
public class Demo01 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入1~5，查询日计划！");
//3.接收
int day = sc.nextInt();
//4.判断查询
switch (day){
case 1:
System.out.println("系统：放假第1天，去爬山，哈哈哈！");
break;
case 2:
System.out.println("系统：放假第2天，去游泳，哈哈哈！");
break;
case 3:
System.out.println("系统：放假第3天，去聚餐，哈哈哈！");
break;
case 4:
System.out.println("系统：放假第4天，去打游戏，哈哈哈！");
break;
case 5:
System.out.println("系统：放假第5天，去睡觉，哈哈哈！");
break;
default:
System.out.println("系统：输入有误，放假只有五天，请输入1~5");
}
}
}
- switch的其他问题
1. 作用域问题
不能直接在{}中定义变量。
不建议在case中定义变量。
2.case穿透（忘记写break）
package com.bjpowernode.javastudy.day05.switch_demo;
public class Demo02 {
public static void main(String[] args) {
switch (33){
case 1:
System.out.println(1);
case 2:
System.out.println(2);
case 3:
System.out.println(3);
default:
System.out.println("输入有误。。。");
case 4:
System.out.println(4);
case 5:
System.out.println(5);
}
}
}
3.case并列
3 4 5 ------ 春天
6 7 8 ------ 夏天
9 10 11------ 秋天
12 1 2 ------ 冬天
package com.bjpowernode.javastudy.day05.switch_demo;
import java.util.Scanner;
public class Demo03 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入月份
System.out.println("系统：请输入月份，我可以告诉你季节？");
//3.接收
int month = sc.nextInt();
//4.判断
switch (month){
case 3: case 4: case 5:
System.out.println("系统：春天！");
break;
case 6: case 7: case 8:
System.out.println("系统：夏天！");
break;
case 9: case 10: case 11:
System.out.println("系统：秋天！");
break;
case 12: case 1: case 2:
System.out.println("系统：冬天！");
break;
default:
System.out.println("系统：输入有误，请输入地球的1~12个月！");
}
}
}
4.版本问题jdk8支持的类型
required: 'char, byte, short, int, Character, Byte, Short, Integer, String, or an enum'
五、循环语句（掌握）
for
1.语法
for(初始表达式;条件表达式;迭代语句){ 循环体 }
初始表达式：定义一个有初始值的变量。 int a = 1;
迭代语句：i++ i+=2 i*=5 ...
循环体：任何语句（输出语句，变量...）
理解：先执行初始表达式，然后条件判断，如果成立，执行循环体，然后再执行迭代语句，然后继续条件判断...
直到条件表达式不成立为止！
- 案例
打印1~5!
package com.bjpowernode.javastudy.day05.for_demo;
public class Demo01 {
public static void main(String[] args) {
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
}
}
- for的其他问题
1. 扩大初始表达式的作用域
package com.bjpowernode.javastudy.day05.for_demo;
public class Demo01 {
public static void main(String[] args) {
int i;
for (i = 1; i <= 5; i++) {
System.out.println(i);
}
System.out.println("i最终值："+i);
System.out.println("------------------");
int j = 5;
for (; j >=1; j--) {
System.out.println(j);
}
System.out.println("j最终的值："+j);
}
}
2.省略大括号
package com.bjpowernode.javastudy.day05.for_demo;
public class Demo02 {
public static void main(String[] args) {
for (int i = 5; i > 0; i--)
System.out.println(i);
}
}
3.死循环问题
package com.bjpowernode.javastudy.day05.for_demo;
public class Demo03 {
public static void main(String[] args) {
// for (int i = 0; true; i++) {
// System.out.println(i);
// }
for (int i = 0; ; i++) {
System.out.println(i);
}
}
}
4.小括号后面没有分号
package com.bjpowernode.javastudy.day05.for_demo;
public class Demo04 {
public static void main(String[] args) {
for (int i = 0; i < 5; i++); {
System.out.println("我要变有钱~~~");
}
}
}
5.迭代语句的位置可以放循环体
package com.bjpowernode.javastudy.day05.for_demo;
public class Demo05 {
public static void main(String[] args) {
for (int i = 0; i < 5; ) {
i+=2;
System.out.println(i);
}
}
}
6.多个初始表达式多个迭代语句
package com.bjpowernode.javastudy.day05.for_demo;
public class Demo06 {
public static void main(String[] args) {
for(int i=1,j=10;i<j;i++,j--){
System.out.println(i+"-----------------"+j);
}
}
}
while
- 语法
while(条件表达式){ 循环体 }
理解：条件表达式成立，执行循环体...
- 案例
打印1~5的循环
package com.bjpowernode.javastudy.day05.while_demo;
public class Demo01 {
public static void main(String[] args) {
int i=1;
while (i<=5){
System.out.println(i);
i++;
}
}
}
- while的其他问题
1.省略大括号
2.死循环
do-while
- 语法
do{循环体}while(条件表达式);
理解：先执行循环体，再条件判断，如果成立再执行循环体，在条件判断...
- 案例
1~5的循环
package com.bjpowernode.javastudy.day05.do_while_demo;
public class Demo01 {
public static void main(String[] args) {
int i=1;
do {
System.out.println(i);
i++;
}while (i<=5);
}
}
- do-while的其他问题
1.省略大括号
2.死循环
六、嵌套问题 （掌握）
- if-else嵌套
登录 用户名是 1234 密码也是1234
package com.bjpowernode.javastudy.day05.if_else_if_else;
import java.util.Scanner;
public class Login {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入用户名
System.out.println("系统：请输入用户名？");
//3.接收
int username = sc.nextInt();
//4.判断用户名
if(username == 1234){
//5.提示输入密码
System.out.println("系统：请输入密码？");
//6.接收
int password = sc.nextInt();
//7.判断密码
if(password == 1234){
System.out.println("系统：登录成功，正在调整主界面...");
}else {
System.out.println("系统：密码错误，程序结束！");
}
}else {
System.out.println("系统：用户名错误，程序结束！");
}
}
}
- for循环嵌套if
练习：打印1~100，能被2整除的数字？
package com.bjpowernode.javastudy.day05.for_if;
public class Demo01 {
public static void main(String[] args) {
for(int i=1;i<=100;i++){
if(i%2==0){
System.out.println(i);
}
}
}
}
- for循环嵌套
*
System.out.println("*");
*****
package com.bjpowernode.javastudy.day05.for_for;
public class Demo01 {
public static void main(String[] args) {
//*****
//打印一行*，换行
System.out.print("*");
System.out.print("*");
System.out.print("*");
System.out.print("*");
System.out.print("*");
System.out.println();
System.out.println("------------------------");
//打印一行*，换行
for (int i = 0; i < 5; i++) {
System.out.print("*");
}
System.out.println();
}
}
*****
*****
*****
package com.bjpowernode.javastudy.day05.for_for;
public class Demo02 {
public static void main(String[] args) {
//打印一行*，换行 *****
for (int i = 0; i < 5; i++) {
System.out.print("*");
}
System.out.println();
//打印一行*，换行 *****
for (int i = 0; i < 5; i++) {
System.out.print("*");
}
System.out.println();
//打印一行*，换行 *****
for (int i = 0; i < 5; i++) {
System.out.print("*");
}
System.out.println();
System.out.println("-----------------------------");
//从内往外看！
for(int j=1;j<=3;j++){
//打印一行*，换行 *****
for (int i = 0; i < 5; i++) {
System.out.print("*");
}
System.out.println();
}
}
}
七、break和continue关键字 （掌握）
continue:只能用于循环语句，跳出当次循环，继续进行下一次循环！
break:
1.用于switch语句，结束switch语句
2.用于循环语句，结束整个循环语句
return:
用于方法，结束方法体
package com.bjpowernode.javastudy.day05.keyword;
public class Demo01 {
public static void main(String[] args) {
System.out.println("程序开始。。。");
for (int i = 1; i <=10; i++) {
if(i==5){
continue;
//break;
//return;
}
System.out.print(i+"\t");
}
System.out.println();
System.out.println("程序结束。。。");
}
}
八、带标签的break和continue （了解）
package com.bjpowernode.javastudy.day05.lable;
public class Demo01 {
public static void main(String[] args) {
haha:for (int i = 0; i < 5; i++) {
for (int j = 0; j < 5; j++) {
System.out.println("j:"+j);
break haha;
}
System.out.println("i:"+i);
}
}
}
综合练习
（1）将两个变量的值进行交换
int a = 10;
int b = 20;
//经过一些操作
System.out.println("a:"+a);//20
System.out.println("b:"+b);//10
package com.bjpowernode.javastudy.day06;
public class Demo01_01 {
public static void main(String[] args) {
int a = 10,b = 20;
int temp = a;
a = b;
b = temp;
System.out.println("a:"+a);
System.out.println("b:"+b);
}
}
package com.bjpowernode.javastudy.day06;
public class Demo01_02 {
public static void main(String[] args) {
int a = 10,b = 20;
int sum = a+b;
a = sum-a;
b = sum-b;
System.out.println("a:"+a);
System.out.println("b:"+b);
}
}
（2）从键盘接收一个整数，判断该数字的正负。
三种情况：if-else-if语句
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Demo02_01 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入一个整数？");
//3.接收
int number = sc.nextInt();
//4.判断
if(number>0){
System.out.println("系统：这是正数！");
}else if(number<0){
System.out.println("系统：这是负数！");
}else {
System.out.println("系统：这是零！");
}
}
}
多个if语句
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Demo02_02 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入一个整数？");
//3.接收
int number = sc.nextInt();
//4.判断
if(number>0){
System.out.println("系统：这是正数！");
}
if(number<0){
System.out.println("系统：这是负数！");
}
if(number==0){
System.out.println("系统：这是零！");
}
}
}
（3）从键盘接收一个整数，判断该数字的奇偶。
两种情况：if-else语句 或者 三目运算
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Demo03_01 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入一个整数？");
//3.接收
int number = sc.nextInt();
//4.判断
if(number%2==0){
System.out.println("系统：偶数！");
}else{
System.out.println("系统：奇数！");
}
}
}
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Demo03_02 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入一个整数？");
//3.接收
int number = sc.nextInt();
//4.判断
System.out.println(number%2==0?"系统：偶数！":"系统：奇数！");
}
}
（4）打车问题
打车起步价8元（3KM以内）
超过3KM，超出的每公里1.2元
超过5KM，超出的每公里1.5元
请在键盘上接收公里数，得出总价。
定义打车公里数是x公里
第一种：x <= 3 8
第二种：3<x<=5 8 + (x-3)*1.2
第三种：x>5 8 + (5-3)*1.2 + (x-5)*1.5
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Demo04_01 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入您的打车公里数？");
//3.接收
double x = sc.nextDouble();
//4.判断
if(x<=3){
System.out.println("系统：您的打车费用是："+(8)+"元！");
}else if(x<=5){
System.out.println("系统：您的打车费用是："+(8 + (x-3)*1.2)+"元！");
}else {
System.out.println("系统：您的打车费用是："+(8 + (5-3)*1.2 + (x-5)*1.5)+"元！");
}
}
}
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Demo04_02 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入您的打车公里数？");
//3.接收
double x = sc.nextDouble();
//怎么判断一个x是整数还是小数？
if(x%1!=0){
//强转int加1
x = (int) x + 1;
}
System.out.println("测试："+x);
//4.判断
if(x<=3){
System.out.println("系统：您的打车费用是："+(8)+"元！");
}else if(x<=5){
System.out.println("系统：您的打车费用是："+(8 + (x-3)*1.2)+"元！");
}else {
System.out.println("系统：您的打车费用是："+(8 + (5-3)*1.2 + (x-5)*1.5)+"元！");
}
}
}
（5）键盘输入月份，打印该月份所属的季节。
3,4,5 春季
6,7,8 夏季
9,10,11 秋季
12, 1, 2 冬季
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Demo05 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入一个月份？");
//3.接收
int month = sc.nextInt();
if(month<1 || month>12){
System.out.println("系统：输入有误，请输入1~12！");
return;
}
//4.判断
if(month == 3 || month == 4 || month == 5){
System.out.println("系统：春天到了！");
}
if(month == 6 || month == 7 || month == 8){
System.out.println("系统：夏天到了！");
}
if(month == 9 || month == 10 || month == 11){
System.out.println("系统：秋天到了！");
}
if(month == 12 || month == 1 || month == 2){
System.out.println("系统：冬天到了！");
}
}
}
（8）通过符号”*”, 输出如下信息
**********
**********
**********
**********
**********
package com.bjpowernode.javastudy.day06;
public class Demo08_01 {
public static void main(String[] args) {
for(int j=1;j<=5;j++){
for(int i=1;i<=10;i++){
System.out.print("*");
}
System.out.println();
}
}
}
012345678910
1**********
2**********
3**********
4**********
5**********
package com.bjpowernode.javastudy.day06;
public class Demo08_02 {
public static void main(String[] args) {
for(int j=1;j<=6;j++){
System.out.print(j-1+"\t");
for(int i=1;i<=10;i++){
if(j==1){
System.out.print(i+"\t");
}else {
System.out.print("*\t");
}
}
System.out.println();
}
}
}
（9）编写java 程序，打印如下的数值列表：
1 10 100 1000
2 20 200 2000
3 30 300 3000
4 40 400 4000
1 10 100 1000
package com.bjpowernode.javastudy.day06;
public class Demo09_01 {
public static void main(String[] args) {
//1 10 100 1000
int i = 1;
System.out.println(i+"\t"+i*10+"\t"+i*100+"\t"+i*1000);
}
}
1 10 100 1000
2 20 200 2000
3 30 300 3000
4 40 400 4000
package com.bjpowernode.javastudy.day06;
public class Demo09_02 {
public static void main(String[] args) {
for (int i=1;i<=4;i++) {
System.out.println(i+"\t"+i*10+"\t"+i*100+"\t"+i*1000);
}
}
}
1 10 100 1000
package com.bjpowernode.javastudy.day06;
public class Demo09_03 {
public static void main(String[] args) {
//1 10 100 1000
int sum = 1;
for(int i=1;i<=4;i++){
System.out.print(sum+"\t");
sum*=10;
}
System.out.println();
}
}
1 10 100 1000
2 20 200 2000
3 30 300 3000
4 40 400 4000
package com.bjpowernode.javastudy.day06;
public class Demo09_04 {
public static void main(String[] args) {
//1 10 100 1000
for (int j=1;j<=4;j++) {
int sum = j;
for(int i=1;i<=4;i++){
System.out.print(sum+"\t");
sum*=10;
}
System.out.println();
}
}
}
package com.bjpowernode.javastudy.day06;
public class Demo09_05 {
public static void main(String[] args) {
for (int j=1;j<=4;j++) {
for(int i=j;i<=4000;i*=10){
System.out.print(i+"\t");
}
System.out.println();
}
}
}
（10）打印2 到100 的所有质数，每行显示5 个质数。
质数定义：除了1和它本身，不能被其他数整除！
7是不是质数？--- 拿着7除以2~6看看能不能除尽，只要有一个能除尽，说明7不是质数！
计算过程：
7除以2 ？ false
7除以3 ？ false
...
7除以6 ？ false
控制台输入2~100的任意一个整数？判断它是不是质数？如果是，打印“它是质数！”如果不是，打印“它不是质数！”
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Demo10_01 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入2~100的一个整数？");
//3.接收
int x = sc.nextInt();
//试纸，初始状态是0
int m = 0;
//4.判断x是不是质数？
// x除以 2 ~ x-1 如果有一个能除尽，说明x不是质数？除非所有的2 ~ x-1 都除不尽，说明x是质数！
//2 ~ x-1 是连续的数据，可以循环出来
for(int i=2;i<x;i++){
if(x%i==0){
m = 1;
break;
}
}
if(m == 0){
System.out.println("系统：是质数！");
}else {
System.out.println("系统：不是质数！");
}
}
}
package com.bjpowernode.javastudy.day06;
public class Demo10_02 {
public static void main(String[] args) {
int count = 0;
for (int x = 2; x <= 100; x++) {
//求x是不是质数？
boolean flag = true;
for(int i=2;i<x;i++){
if(x%i==0){
flag=false;
break;
}
}
if(flag){
System.out.print(x+"\t");
count++;
if(count%5==0){
System.out.println();
}
}
}
}
}
（11）编写程序，计算5 的阶乘。
1*2*3*4*5
package com.bjpowernode.javastudy.day06;
public class Demo11 {
public static void main(String[] args) {
int var = 1;
for (int i =1; i <=5; i++) {
var*=i;
}
System.out.println(var);
System.out.println("---------1~100的和------------");
int sum = 0;
for (int i = 1; i <=100; i++) {
sum+=i;
}
System.out.println(sum);
}
}
（12）编写程序输出下图：
*
***
*****
*******
*********
图形 行号 星星个数
* 1 1
*** 2 3
***** 3 5
******* 4 7
********* 5 9
规律：行号*2-1 等于 星星个数
package com.bjpowernode.javastudy.day06;
public class Demo12_01 {
public static void main(String[] args) {
for (int j=1;j<=5;j++) {
for(int i=1;i<=j*2-1;i++){
System.out.print("*");
}
System.out.println();
}
}
}
图形 行号 空格个数 一共5行
&&&& 1 4
&&& 2 3
&& 3 2
& 4 1
0 5 0
规律：行数 - 行号 等于 空格个数
package com.bjpowernode.javastudy.day06;
public class Demo12_02 {
public static void main(String[] args) {
for (int j=1;j<=5;j++) {
for(int i=1;i<=5-j;i++){
System.out.print("&");
}
System.out.println();
}
}
}
*
***
*****
*******
*********
package com.bjpowernode.javastudy.day06;
public class Demo12_01_02 {
public static void main(String[] args) {
for (int j=1;j<=5;j++) {
for(int i=1;i<=5-j;i++){
System.out.print(" ");
}
for(int i=1;i<=j*2-1;i++){
System.out.print("*");
}
System.out.println();
}
}
}
*********
*******
*****
***
*
图形 倒行号 星星个数
********* 5 9
******* 4 7
***** 3 5
*** 2 3
* 1 1
规律：倒行号*2-1 等于 星星个数
package com.bjpowernode.javastudy.day06;
public class Demo12_03 {
public static void main(String[] args) {
for (int j=5;j>=1;j--) {
for(int i=1;i<=2*j-1;i++){
System.out.print("*");
}
System.out.println();
}
}
}
图形 空格个数 倒行号
0 0 5
& 1 4
&& 2 3
&&& 3 2
&&&& 4 1
规律：行数 - 倒行号 等于 空格个数
package com.bjpowernode.javastudy.day06;
public class Demo12_04 {
public static void main(String[] args) {
for (int j=5;j>=1;j--) {
for(int i=1;i<=5-j;i++){
System.out.print("&");
}
System.out.println();
}
}
}
package com.bjpowernode.javastudy.day06;
public class Demo12_01_02_03_04 {
public static void main(String[] args) {
int high = 5;
for (int j=1;j<=high;j++) {
for(int i=1;i<=high-j;i++){
System.out.print(" ");
}
for(int i=1;i<=j*2-1;i++){
System.out.print("*");
}
System.out.println();
}
for (int j=high-1;j>=1;j--) {
for(int i=1;i<=high-j;i++){
System.out.print(" ");
}
for(int i=1;i<=2*j-1;i++){
System.out.print("*");
}
System.out.println();
}
}
}
（13） 篮球问题
篮球从5 米高的地方掉下来，每次弹起的高度是原来的30%，经过几次弹起，篮球的高度小于等于0.1 米。
double high = 5.0;
第一次：high*=0.3;
第二次：high*=0.3;
...
思路1：不确定循环多少次，那么就假设无限次，达到条件让循环停止。
package com.bjpowernode.javastudy.day06;
public class Demo13_01 {
public static void main(String[] args) {
double high = 5.0;
int count = 0;
while (true){
high*=0.3;
count++;
if(high<=0.1){
break;
}
}
System.out.println("经过计算弹起"+count+"次小于等于0.1");
}
}
思路2：只要高度大于0.1，就继续循环！
package com.bjpowernode.javastudy.day06;
public class Demo13_02 {
public static void main(String[] args) {
double high = 5.0;
int count = 0;
while (high>0.1){
high*=0.3;
count++;
}
System.out.println("经过计算弹起"+count+"次小于等于0.1");
}
}
（14）打印出所有的"水仙花数"
所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。
package com.bjpowernode.javastudy.day06;
public class Demo14 {
public static void main(String[] args) {
for(int i=100;i<1000;i++){
//求153的个位、十位、百位 ？
//求个位
int x=i%10;
//求十位
int y = i / 10 % 10;
//求百位
int z = i / 100;
if(x*x*x + y*y*y + z*z*z == i){
System.out.println(i);
}
}
}
}
（15）题目：兔子问题
有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，控制台输入x个月后，输出兔子多少对？
月 兔子对数
1 1
2 1
3 2
4 3
5 5
6 8
7 13
8 21
9 34
10 55
...
斐波那契数列
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Demo15 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入月份？");
//3.接收
int month = sc.nextInt();
//4.判断
//定义第一个月和第二个月的兔子
int one = 1,two = 1,temp = 0;
if(month == 1 || month == 2){
System.out.println("系统：兔子有1对！");
}else {
//从第三个月开始，这个时候需要计算！
for(int i=3;i<=month;i++){
temp = one+two;
one = two;
two = temp;
}
System.out.println("系统：兔子有"+temp+"对！");
}
}
}
（16）完成以下九九乘法表
package com.bjpowernode.javastudy.day06;
public class Demo16 {
public static void main(String[] args) {
for(int i=1;i<=9;i++){
for(int j=1;j<=i;j++){
System.out.print(j+"×"+i+"="+i*j+"\t");
}
System.out.println();
}
}
}
随机数问题
package com.bjpowernode.javastudy.day06;
import java.util.Random;
public class Demo17_01 {
public static void main(String[] args) {
//1.创建Random类的对象
Random rd = new Random();
//2.随机0~9
int x = rd.nextInt(10);
System.out.println(x);
}
}
- 随机点名
冯鹏举 --- 0
郭义 --- 1
贺吉祥 --- 2
（17）猜数字游戏
预先随机产生一个100以内的正整数x，从键盘接收一个正整数，对x进行猜测， 如果大了则提示大了，小了则提示小了，等于则提示猜测成功
package com.bjpowernode.javastudy.day06;
import java.util.Random;
import java.util.Scanner;
public class Demo17 {
public static void main(String[] args) {
//1.创建Random类的对象
Random rd = new Random();
//2.随机1~100的任意一个整数x
int x = rd.nextInt(100)+1;
while (true) {
//3.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//4.提示输入
System.out.println("系统：请输入一个1~100之内整数？");
//5.接收
int y = sc.nextInt();
//6.判断
if(y>x){
System.out.println("系统：猜的大了！");
}else if(y<x){
System.out.println("系统：猜的小了！");
}else {
System.out.println("系统：恭喜你，猜对了！");
break;
}
}
}
}
附加练习1
等额本金：借支付宝借呗10万，年化率3.8%，借10个月，每个月怎么还款？
本金=总借款/月份; 1万
第一个月：本金：1万，利息：10万*(3.8%/12)
第二个月：本金：1万，利息： 9万*(3.8%/12)
第三个月：本金：1万，利息： 8万*(3.8%/12)
...
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Test01 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示用户输入 贷款
System.out.println("系统：请输入贷款金额？(万)");
//3.接收 贷款
double loan = sc.nextDouble()*10000;
//4.提示输入贷款时间
System.out.println("系统：请输入贷款年限？");
//5.接收 年限，要转换为月
int month = sc.nextInt()*12;
//6.提示输入利率
System.out.println("系统：请输入利率？(%)");
//7.接收 月利率
double rate = sc.nextDouble()/100/12;
//8.计算本金
double principal = loan / month;
//9.计算利息
double interest = 0.0;
//10.循环出还款计划同时计算利息
System.out.println("还款计划表：=========================================");
for(int i=1;i<=month;i++){
interest = loan*rate;
System.out.println("第"+i+"个月,本金："+principal+"元，利息："+interest+"元，合计："+(principal+interest)+"元！");
loan-=principal;
}
}
}
附加练习2
求1~10000的完全数
package com.bjpowernode.javastudy.day06;
public class Test02 {
public static void main(String[] args) {
for(int x=1;x<=10000;x++){
int sum = 0;
//求x是不是完美数？
for(int y=1;y<=x/2;y++){
if(x%y==0){
sum+=y;
}
}
if(x == sum){
System.out.println(x);
}
}
}
}
附加练习3
package com.bjpowernode.javastudy.day06;
import java.util.Scanner;
public class Test03 {
public static void main(String[] args) {
//1.创建Scanner类的对象
Scanner sc = new Scanner(System.in);
//2.提示输入
System.out.println("系统：请输入您的出生年份？");
//3.获取
int year = sc.nextInt();
//4.计算
switch (year%12){
case 0:
System.out.println("系统：您的生肖是---猴！");
break;
case 1:
System.out.println("系统：您的生肖是---鸡！");
break;
case 2:
System.out.println("系统：您的生肖是---狗！");
break;
case 3:
System.out.println("系统：您的生肖是---猪！");
break;
case 4:
System.out.println("系统：您的生肖是---鼠！");
break;
case 5:
System.out.println("系统：您的生肖是---牛！");
break;
case 6:
System.out.println("系统：您的生肖是---虎！");
break;
case 7:
System.out.println("系统：您的生肖是---兔！");
break;
case 8:
System.out.println("系统：您的生肖是---龙！");
break;
case 9:
System.out.println("系统：您的生肖是---蛇！");
break;
case 10:
System.out.println("系统：您的生肖是---马！");
break;
case 11:
System.out.println("系统：您的生肖是---羊！");
break;
}
}
}