学习目标
- 自动类型转换
- 强制类型转换
- 基本数据类型常见错误 - 移除
- 使用 Scanner 获得键盘输入 - 1
- 控制语句（if，swith，while，for）
- break 与 continue
- 方法的定义
- 方法的重载
- 递归算法
自动类型转换
定义：容量小的转换为容量大的
图中虚线表示可能有精度的丢失
boolean 类型不能与 图中任一类型 进行 类型转换
/**
* 自动类型转换
*
* 容量小的转容量大的
*
* @author zwq
*
*/
public class AutoChange {
public static void main(String[] args) {
// byte b = 128; //错误 超出数字存储范围
byte b1 = 127; //错误 超出数字存储范围
short s = 32767; // 正确
// short s1 = 32768; // 32768 错误，超出数字存储范围 -32768 ~ 32767
/**
* char 是用来表示在 unicode编码中的字符，unicode是万国码，统一处理各国语言的编码，
* 它占2个字节，可允许有2^16=65536个字符，unicode只有从0到65536之间的编码
* 它们通常从【'\u0000'】 到'【\uFFFF'】之间的十六进制表示
*
*/
// 测试 0到65536
char c = 32767;
char c1 = 32768; //
// char c2 = 65536; // 65536错误 超出数字存储范围 0 ~ 65535
// char c3 = -11; // -11错误 超出数字存储范围 0 ~ 65535
char c4 = 65535; // 正确
// 测试 \u0000 ~ \uFFFF
char c5 = '\uFFFF'; // 正确 也可以用十六进制表示 存储范围 \u0000 ~ \uFFFF
char c6 = '\u0000'; // 正确 也可以用十六进制表示 存储范围 \u0000 ~ \uFFFF
System.out.println("c="+c); // c=翿
System.out.println("c1="+c1); // c1=耀
System.out.println("c4="+c4); // c4=?
System.out.println("c5="+c5); // c5=?
System.out.println("c6="+c6); // c6=
int i = 1;
long x = 7300000000L;
// 1. long 转 float ，double
float fl = x;
double dl = x;
// 2. float 转 double ; int 转 double
float fd = 1111.1f;
double df = 111;
df = fd; // float 转 double
df = i; // int 转 double
// 3. byte,short,char 转int
i = b1;
i = s;
i = c;
i = c4;
i = c5;
System.out.println(i); // 65535
}
}
强制类型转换
与 自动类型转换 方向相反 的转换，需要强制指明 目标数据类型， 容量大的转容量小的
语法： (type) variable
说明：type 指想要转换成的目标数据类型，varibale 指变量人
/**
* 强制类型转换
* 与 自动类型转换 方向相反 的转换，需要强制指明 目标数据类型
*
* 语法： (type) variable
*
* 说明：type 指想要转换成的目标数据类型，varibale 指变量
*
* 容量大的转容量小的
* @author zwq
*
*/
public class CoerciveChange {
public static void main(String[] args) {
// 自动转 int long float double 顺序
int i =11;
long l = 11L;
float f = 22.1f;
double d = 232;
// 强转 double float long int 顺序
i = d; // 错误 必须指明 目标类型 int
i = l; // 错误 必须指明 目标类型 int
i = f; // 错误 必须指明 目标类型 int
i = (int)f; //正确
f = d; // 错误 必须指明 目标类型 float
f = (float)d; //正确
}
}
基本数据类型常见错误 - 溢出
/**
* 基本类型常见错误 - 溢出
*
* 操作比较大的数据时，要留意是否有溢出，尤其是整数类型的数据
*
* 注意：整型数据类型进行计算时，默认是int类型，而int类型的数值范围是约 正负的 21亿+
* 当计算结果超出 约21亿+ 时，会发生溢出的情况，如下面的例子出现了负数的错误情况
*
* 解决方案：将默认的int型转换成long,long 的数据值范围是约 正负的 74亿
* 一般计算比较大的数据时不会用int 而是用long！！！
*
* @author zwq
*
*/
public class UsualFault {
public static void main(String[] args) {
int money = 1000000000; // 10亿
int years = 20;
// 返回的 total 是负数，超过了 int 的最大数值范围
int total = money*years;
System.out.println("total="+total); // total=-1474836480 与 预期的正确结果不符
// 返回的 totalL 仍是负数，默认是 int，因此结果会转成int值再转成long，但是已经发生了数据丢失？
long totalL = money*years;
System.out.println("totalL="+totalL); // totalL=-1474836480
// 返回的total2 正确,先将一个因子转换成long，整个表达式会发生提升，全部用long计算
long total2 = money*((long)years);
System.out.println("total2="+total2); // total2=20000000000
long total3 = (long)money*years;
System.out.println("total3="+total3); // total3=20000000000
}
}
使用 Scanner 获得键盘输入 - 1
import java.util.Scanner;
/**
* 测试 Scanner ：获取键盘输入
*
* @author zwq
*
*/
public class ScannerUsed {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("Please your name:");
String name = scanner.nextLine();
System.out.println("Please your age:");
int age = scanner.nextInt();
System.out.println("Please your score:");
double score = scanner.nextDouble();
System.out.println("###################");
System.out.println(name);
System.out.println(age);
System.out.println(score);
}
}
///结果输出
Please your name:
zwq
Please your age:
18
Please your score:
99.99
###################
zwq
18
99.99
控制语句（if，swith，while，for）
分类
- 顺序结构：java中的代码都是按顺序执行，先执行a，再执行b
- 选择结构：如果xxxx，则xxxx
- 循环结构：如果xxxx，则继续xxxx
顺序结构：四种
顺序结构 1：if 略
顺序结构 2：if-else
package com.zwq.base01;
/**
* 测试
* 1.随机数 Math.random()
* 2.顺序结构 2：if-else
*
* @author zwq
*
*/
public class MathTest {
public static void main(String[] args) {
double d = Math.random();
int i = (int)(d*100); //获取100以内的随机数
System.out.println(i);
if( i>= 60) {
System.out.println("及格");
}else {
System.out.println("不及格");
}
}
}
顺序结构 3：if-else if-else if -else
package com.zwq.base01;
/**
* 顺序结构 3 ：if -else if - else if -else 结构
* @author zwq
*
*/
public class TestIfElseif {
public static void main(String[] args) {
double d = Math.random();
int age = (int)(d*100); //获取100以内的随机数
System.out.println(age);
if( age <= 15) {
System.out.println("儿童");
}else if(age <= 25){
System.out.println("青年");
}else if(age < 45){
System.out.println("中年");
}else if(age <= 65){
System.out.println("中老年");
}else if(age <= 85){
System.out.println("老年");
}else {
System.out.println("老寿星");
}
}
}
顺序结构 4：switch
package com.zwq.base01;
/**
* 测试 顺序结构 4 ：switch
*
* 注意： switch 中的 break 具有终止，结束的意思，遇到break，跳出swith结构
*
* @author zwq
*
*/
public class SwitchTest {
public static void main(String[] args) {
char c = 'a';
double d = Math.random();
int rand = (int)(d*26); //获取26以内的随机数
char c2 = (char)(c+rand);
System.out.println(rand);
System.out.println(c2);
switch(c2) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
System.out.println("元音");
break;
case 'y':
case 'l':
System.out.println("半元音");
break;
default:
System.out.println("辅音");
}
/**
* switch 括号中的表达式 可以是任意基本数据类型，也可以是String
*
* 一般用于固定的数据匹配，如性别，月份，字母表
*/
String str = "男";
switch(str) {
case "男":
System.out.println("男");
break;
case "女":
System.out.println("女");
break;
default:
System.out.println();
}
}
}
循环结构 1：while
package com.zwq.base01;
/**
* 循环结构 1 ：while
* @author zwq
*
*/
public class WhileTest {
public static void main(String[] args) {
// 计算从1+2+3+……+100 的总和
int i =1; // 循环要素：计数器
int sum = 0; //存放总和
// while(i <= 100) { // 循环要素：结束条件
// sum = sum + i;
// i++;
// }
// System.out.println(sum);
/**
* do-while 与 while的区别就是 do-while 会先执行一次，条件不满足再跳出循环
*
*/
do {
sum = sum + i;
i++;
}while(i <= 100);
System.out.println(sum);
}
}
循环结构 2：for
package com.zwq.base01;
/**
* 循环结构 ：for
* 1.执行初始化语句
* 2.判断条件 i<100
* 3.执行循环体
* 4.步进迭代：i++
* 5.回到第2步继续判断条件
*
*
* @author zwq
*
*/
public class ForTest {
public static void main(String[] args) {
int sum = 0;
for(int i =1;i<=100;i++) {
sum = sum + i;
}
System.out.println(sum);
for(int i =1,j=i+10;i<5;i++,j=j*2) {
System.out.println("i="+i+",j="+j);
}
//对比 while
// int i =1; // 循环要素1：初始化语句
// int sum = 0; //存放总和
// while(i <= 100) { // 循环要素2：判断条件
// sum = sum + i; // 循环要素3：循环体
// i++; // 循环要素4：步进迭代
// }
// System.out.println(sum);
}
}
循环结构 -嵌套
package com.zwq.base01;
/**
* 测试 嵌套循环
* @author zwq
*
*/
public class QiantaoTest {
public static void main(String[] args) {
/**
* 打印
1
2
3
4
5
*/
for(int i=1;i<=5;i++) {
System.out.println(i);
}
System.out.println("###### eg2:");
/**
* 打印
* 1 2 3 4 5
*/
for(int i=1;i<=5;i++) {
System.out.print(i+"\t");
}
System.out.println("\n###### eg3:");
/**
* 打印
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
1 2 3 4 5
*/
for(int i=1;i<=5;i++) {
for(int j=1;j<=5;j++) {
System.out.print(j+"\t");
}
System.out.println();
}
/**
* 打印 九九乘法表
1*1=1 2*1=2 3*1=3 4*1=4 5*1=5 6*1=6 7*1=7 8*1=8 9*1=9
1*2=2 2*2=4 3*2=6 4*2=8 5*2=10 6*2=12 7*2=14 8*2=16 9*2=18
1*3=3 2*3=6 3*3=9 4*3=12 5*3=15 6*3=18 7*3=21 8*3=24 9*3=27
1*4=4 2*4=8 3*4=12 4*4=16 5*4=20 6*4=24 7*4=28 8*4=32 9*4=36
1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 6*5=30 7*5=35 8*5=40 9*5=45
1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 7*6=42 8*6=48 9*6=54
1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 8*7=56 9*7=63
1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 9*8=72
1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81
*/
System.out.println("\n###### eg4:");
for(int i=1;i<10;i++) {
for(int j=1;j<10;j++) {
System.out.print(j+"*"+i+"="+(j*i)+"\t");
}
System.out.println();
}
/**
* 去除 重复 的
1*1=1
2*1=2 2*2=4
3*1=3 3*2=6 3*3=9
4*1=4 4*2=8 4*3=12 4*4=16
5*1=5 5*2=10 5*3=15 5*4=20 5*5=25
6*1=6 6*2=12 6*3=18 6*4=24 6*5=30 6*6=36
7*1=7 7*2=14 7*3=21 7*4=28 7*5=35 7*6=42 7*7=49
8*1=8 8*2=16 8*3=24 8*4=32 8*5=40 8*6=48 8*7=56 8*8=64
9*1=9 9*2=18 9*3=27 9*4=36 9*5=45 9*6=54 9*7=63 9*8=72 9*9=81
*/
System.out.println("\n###### eg5:");
for(int i=1;i<10;i++) {
for(int j=1;j<=i;j++) {
System.out.print(i+"*"+j+"="+(i*j)+"\t");
}
System.out.println();
}
/**
* 用 while 计算出 100 以内的 奇数 及 偶数 的和，并输出
*
* 1.执行初始化语句：int i =1;
* 2.判断条件: i<=100
* 3.执行循环体：累计奇数的和 累计偶数的和
* 4.步进迭代：i++
* 5.回到第2步继续判断条件
*
* 要知道奇数的表达式如何写：(i%2)==1
* 要知道偶数的表达式如何写：(i%2)==0
*
*
* 结果
* 100 以内的偶数和=2550
* 100 以内的奇数和=2500
*
*/
System.out.println("\n###### eg6:");
int i =1;
int jiSum = 0;
int ouSum = 0;
while(i<=100) {
if((i%2)==0) {//偶数
ouSum = ouSum + i;
}else{//奇数
jiSum = jiSum + i;
}
i++;
}
System.out.println("100 以内的偶数和="+ouSum); //100 以内的偶数和=2550
System.out.println("100 以内的奇数和="+jiSum); //100 以内的奇数和=2500
/**
* 用 while或其它循环 输出 1-10000 之间能被5整除的数，且每行输出5个
* 1.执行初始化语句：int i =1;
* 2.判断条件: i<=10000
* 3.执行循环体：五个能被5整除的数
* 4.步进迭代：i++
* 5.回到第2步继续判断条件
*
* 难点：10000被5整除的表达式如何写：10000%5==0 10000是1-10000的任意数
*/
System.out.println("\n###### eg7:");
// 方式一
for(int k=1;k<=10000;k++) {
if(k%5==0) {
System.out.print(k+"\t"); // 输出全部
}
if(k%25==0) {
System.out.println();
}
}
// 方式二
int c= 0 ;
for(int k=1;k<=10000;k++) {
if(k%5==0) {
System.out.print(k+"\t"); // 输出全部
c++;
}
if(c==5) { // 每五个换行
System.out.println();
c=0; //清0
}
}
}
}
break 与 continue
package com.zwq.base01;
/**
* continue 与 break
* 1. continue：结束本次循环，继续下一次循环
* 2. break：直接跳出循环体
* @author zwq
*
*/
public class BreakTest {
public static void main(String[] args) {
for(int i =1;i<=5;i++) {
if(i==3) {
System.out.println("遇到小三退出");
break;// 直接跳出循环体
}
System.out.println("打印，"+i);// 打印 1，2
}
System.out.println("循环体外");
// 测试 continue
for(int i =1;i<=5;i++) {
if(i==3) {
continue;// 直接跳出循环体
}
System.out.println("打印，"+i);// 打印 1，2，4，5
}
System.out.println("循环体外");
}
}
方法
定义：一段用来完成特定功能的代码片段
语法： 修饰符 返回值类型 方法名(形式参数列表){ 方法体 }
eg: public int addSum(int a,int b){ int c = a+b ;}
调用：
1.静态方法
同一个类中：方法名(实参列表);
不同类中：A.方法名(实参列表);
2.普通方法
对象 对象名 = new 对象();
对象名.方法名(实参列表);
package com.zwq.base01;
/**
* 方法
* 定义：一段用来完成特定功能的代码片段
* 语法： 修饰符 返回值类型 方法名(形式参数列表){ 方法体 }
* eg: public int addSum(int a,int b){ int c = a+b ;}
* 调用：
* 1.静态方法
同一个类中：方法名(实参列表);
* 不同类中：A.方法名(实参列表);
*
* 2.普通方法
* 对象 对象名 = new 对象();
* 对象名.方法名(实参列表);
*
* 注意：
* 1.形式参数列表与 实参列表需要一一对应；
* 2.修饰符：常用(public, private ,默认的)
* 3.返回值类型：分 无返回值（void） 和有 返回值（基本数据类型，对象类型，String，集合）
* 4.形式参数列表（顺序，个数，数据烈性）不同，构成了方法的重载，且能否重载与返回值类型无关
* 5.java中进行方法调用中传递参数时，遵循值传递（传递的都是数据的副本）——待后续理解
* 6.基本数据类型传递的是该数据值的copy值——待后续理解
* 7.引用数据类型传递的是该对象引用的copy值，但是指向的是同一个对象——待后续理解
*
* @author zwq
*
*/
public class MethodTest {
public static void main(String[] args) {
// 方法调用 - 普通方法
MethodTest mt = new MethodTest();
System.out.println(mt.addSum(1, 3));
// 方法调用 - 静态方法
System.out.println(addSum(2.2f, 3));
// 重载方法的调用
hello("jane");
hello(88);
hello(99,"tom");
}
// 定义一个普通方法 ：用于计算两个数之和
int addSum(int a,int b) {
return a+b;
}
// 定义一个静态方法 ：用于计算两个数之和
static int addSum(float a,int b) {
return (int)a+b;
}
// 测试方法重载
static void hello(String a) {
System.out.println("hello:"+a);
}
static void hello(int a) {
System.out.println("hello:"+a);
}
static String hello(int a,String name) {
System.out.println("hello:"+a);
return name;
}
}
* 注意：
* 1.形式参数列表与 实参列表需要一一对应；
* 2.修饰符：常用(public, private ,默认的)
* 3.返回值类型：分 无返回值（void） 和有 返回值（基本数据类型，对象类型，String，集合）
* 4.形式参数列表（顺序，个数，数据烈性）不同，构成了方法的重载，且能否重载与返回值类型无关
* 5.java中进行方法调用中传递参数时，遵循值传递（传递的都是数据的副本）——待后续理解
* 6.基本数据类型传递的是该数据值的copy值——待后续理解
* 7.引用数据类型传递的是该对象引用的copy值，但是指向的是同一个对象——待后续理解
递归算法
定义：自己调用自己
递归结构：
1.递归头：什么时候不调用自身方法
2.递归体：什么时候需要调用自身方法
递归效率：查看 System.currentTimeMillis(); 观察调用时间
package com.zwq.base01;
/**
* 递归
* 定义：自己调用自己
* 递归结构：
* 1.递归头：什么时候不调用自身方法
* 2.递归体：什么时候需要调用自身方法
*
* 递归效率：查看 System.currentTimeMillis(); 观察调用时间
*
* @author zwq
*
*/
public class DiguiTest {
public static void main(String[] args) {
// 使用 递归求阶乘
long d1 = System.currentTimeMillis();
System.out.printf("%d阶乘的结果：%s%n",10 ,calc(10));
long d2 = System.currentTimeMillis();
System.out.printf("递归效率：%s%n",d2-d1);
// 使用 循环求阶乘
long dd1 = System.currentTimeMillis();
System.out.printf("阶乘的结果：%s%n",sumA(10));
long dd2 = System.currentTimeMillis();
System.out.printf("循环效率：%s%n",dd2-dd1);
}
// 定义一个方法 :求 阶乘 的方法
static long calc(int n) {
if(n==1) {//1.递归头
return 1;
}else {
return n*calc(n-1); //2.递归体
}
}
// 复习 使用 循环 求5的阶乘 先定义一个方法
static int sumA(int a) {
int sum = 1;// 从1开始
for(int i=1;i<=a;i++) {
sum = sum *i;
}
System.out.print("5!="+sum+"\t");
return sum;
}
}
1051
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
