昨日回顾：
介绍java
java是一门语言 95年高司令
java的三个方向
java的优点
jdk和jre和jvm的关系
jdk的下载和安装
HelloWorld案例
dos命令
配置环境变量
helloworld的编写编译运行
HelloWorld的解释
书写规范
notepad++
java语法
程序基本组成
注释 (非必须)
关键字
标识符
数据
常量
10
10.14
true
‘a’
“abbc”
null
变量
数据类型 变量名 = 常量值;
数据类型
基本类型
byte 1个
short 2
int 4
long 8
float 4
double 8
boolean 1个 true false bit 0 1 — java的官方文档 boolean类型没有明确的大小。
char 2
引用类型
类 String
接口
数组
注意事项：
符号
基本符号
{}；""’’.
运算符号
键盘录入
今日内容：
类型转换(☆☆☆☆☆)
隐式类型转换：
规则： 是从小范围的数据类型 直接转到 大范围的数据类型
范围的排序：
byte < short = char < int < long < float < double
举例：
int a =10;
long b = a;
用途： 比如两个软件进行交互， 对方发给你一个整数， 我就需要用long类型去接收。因为你不确定他给传的是一个多大的证书，
所以你应该 不管他发给你多大的证书， 你都应该接收， 你就可以用 最大的整数类型 long去接收。
运算中的隐式类型转换： （运算的原理： 不同的数据类型进行运算，必须先统一为同一种类型才可以运算，否则不能运算。）
1：比int大(或者等于)的类型， 在进行运算的时候， 小类型会自动提升为大类型进行运算：
class Demo {
public static void main(String[] args){
long lo = 10L;
double d = 3.14;
//long lon = lo + d; // 编译报错。 lo会先提升为 double类型。然后再和 double类型的d进行运算 最后的结果是double类型。
//long lon = (long) lo + d; // 编译报错
long lon = (long)(lo +d) ; // 正确
double d1 = lo + d; // 正确。
}
}
2：比int小的数据类型， 在进行运算的时候，所有的都要提升为 int类型 再去运算。
class Demo {
public static void main(String[] args){
byte b = 10;
short s= 20;
//short sh = b +s; // 编译报错 b 和s 都会提升为int类型 所以最后的结果也是int类型。
//short sh = (short) b + s ; // 编译报错
short sh = (short)(b+s); // 正确的
int a = b +s; // 正确的。
}
}
强制类型转换：
规则： 是从大范围的数据类型 强制转到 小范围的数据类型
1：明确能转过去，数据是正确的， 这时候可以强制类型转换。
int a = 10;
byte b = (byte)a;
2：不推荐你使用的， 明知道转过去 撑不了这么大的数据， 还要继续转
int a = 200;
byte b = (byte)a; // a 已经不是200了， 不确定的数字
3：强化去除小数点后面的数据
double d = 3.14;
int a = (int) d; // a 就是3了。
类型转换的注意事项：
1：boolean类型 不参与任何的类型转换
boolean b = true;
int a = b; // 编译报错。
int c = (int) b;
2:常量优化机制
写一个整数常量的时候， 整数常量也是有数据类型的， int类型，
System.out.println(10); // 10 是常量 同时也是int类型的数据
比int小的类型 才有常量优化机制：
byte a = 100; // 正确的。 100虽然是int类不假，依然可以赋值， 这就叫做常量优化机制。
// 底层 byte a = (byte)100;
// 只能是常量有 优化机制
int b = 100;
//byte c = b; // 编译错误 b 是变量 不是常量。
byte d = 100+20; // 正确的 常量的运算， 在编译成class期间， 就已经把 100+20 变成了120
// 也就是说 等这句话翻译到了class文件里面 就变成了 byte d = 120; // 就又符合常量优化机制了。
byte e = 100;
byte f = e+20 ; // 编译报错。 e是变量
写一个小数常量的时候，小数常量也是有数据类型的， double类型。
System.out.println(31.4); // 31.4 是常量 同时也是 double数据类型的。
double d = 31.4;
//float f = 31.4 ; // 编译报错。 比int大的类型 没有常量优化机制。 所以double类型不能直接赋值给 float类型。
float f = (float)31.4;
float fl = 31.4F; // 你31.4 默认是double类型， 能不能我们写一个小数的时候 让他默认是 float类型呢， 当然可以了， 你只要在小数后面加一个F 那么这个小数 就会被当做float类型啦。
3： long类型的数据后面 为什么要加L
class Demo {
public static void main(String[] args){
int a = 100;
long lo = a; // 正确 隐式类型转换
long lon = 100; // 正确。 既然是正确的 那么为什么老师一直说 让我在long类型的数据后面 加一个L呢 实在不懂。
System.out.println(100); // 100 是int类型
//System.out.println(10000000000); //100亿 int类型 （int类型的数据 最大到21亿左右）
// 此时 报错了， 100亿已经超过了int数据类型
// 但是 直接写一个 整数常量 确实就是int类型的啊， 所以肯定报错。
// 所以 我们就想 我们能不能写一个整数的时候 让jvm把他当做是一个long类型的数据呢，而不是int呢， 可以啊 你只需要在数据后面加一个 L就可以了。
System.out.println(10000000000L);
long lo = 100;
}
}
运算符号(☆☆☆☆☆)
算术运算符 ： + - * / %
+ :
System.out.println(10+10); // 加号
System.out.println(+10); // 正号
- ：
System.out.println(10-10); // 减号
System.out.println(-10); // 负号
/ :
System.out.println(10 / 4); //2
System.out.println(10.0 / 4); //2.5
System.out.println(10 / 4.0); //2.5
System.out.println(10.0 / 4.0); //2.5
//结论：整数相除得到整数 要想得到小数必须有小数参与运算。
// 原因： 两种不同的数据类型是没有办法运算的。 所以必须统一为同一种类型才可以运算。
System.out.println(10 / 4); // 2
System.out.println(10.0 / 4); //2.5
% ：
System.out.println(10%3); //1
System.out.println(-10%3); //-1
System.out.println(10%-3); //1
System.out.println(-10%-3); //-1
//结论：取到的余数的符号 取决去 % 号左侧的数的符号。
//原因：
System.out.println(10%3); //商3 10-3*3 = 1
System.out.println(-10%3); //商-3 -10 -(-3*3) = -10+9 = -1
System.out.println(10%-3); //商-3 10-(-3*-3) = 10-9 = 1
......
字符的运算：
System.out.println(10+20.14); //30.14
//System.out.println(true + 10); //编译报错
System.out.println('a' + 10);
//107 'a' 先提升为int 97 再和10进行相加。
ASCII
'a' --97
'A' --65
'0' --48
字符串的+预算：
System.out.println("a"+10);
// 字符串
// "" 双引号代表的是字符串 属于数据类型中的引用类型里面的类
// 字符串在和其他类型进行 + 运算的时候， 其他的类型一概转换为字符串类型 再运算。
// "" +10 10先转换为 "10" 然后在和“a”进行运算。
// 字符串的+运算 是拼接。
// a10
案例1：
System.out.println(10+10+20+"java"+20+20+"javaee"+(20+20)+"javaee"+10+("java"+10)+20);
// 10+10+20+"java"+20+20+"javaee"+40+"javaee"+10+"java10"+20
// 40java2020javaee40javaee10java1020
案例2：
键盘录入一个三位数。把数值进行再分，拆分出每一位上的数
int a = 389;
/*
3
8
9
*/
int ge = a%10;
int shi = a/10 %10;
int bai = a/10/10 %10;
案例3：
键盘录入两个数 根据录入的数 打印出如下效果
int a = 6;
int b = 3;
// 6 * 3 = 18
System.out.println(a+" * "+b+" = "+(a*b));
自增自减运算符： ++ --
代码演示：
public class Demo {
public static void main(String[] args) {
// ++ 变量才可以使用 常量是不可以使用的
// 一个变量经过++运算符运算之后 自身的值+1
// -- 一个变量经过了--运算符的运算之后 自身的值 -1
// ++ 和-- 是一元运算符
int a = 10;
a++;
System.out.println(a); //11
//100++;
// int 100 = 101;
//System.out.println(100);
int b = 10;
b--;
System.out.println(b);
System.out.println("-----------------");
// ++ 运算符 不仅可以写变量的后面， 还可以写在变量的前面。
int c = 10;
++c;
System.out.println(c); //11
// 总结上述内容： 一个数经过++ ，无论++放数的前面还是后面， 这个数 自身都会增加1
}
}
public class Demo1 {
public static void main(String[] args) {
// 表达式的概念
// 用运算符链接起来的式子 就是表达式
// 表达式会有如下的特点
//一个表达式 会有一个结果。
// 一般一个表达式 都不是完整的逻辑 不能独立成语句
// 表达式 不能被重新赋值。
int a = 10;
int b = 20;
int c = a+b; // a+b 这就是一个表达式
int d = a*b + b/a; //
System.out.println(c);
System.out.println(d);
//a+b;
//30;
//a*b + b/a;
//202
//a+b = 40; //30
// 既然 你说了 用运算符链接起来的式子 是表达式。
// ++ 是运算符， 用++连接数据的 这种式子 是表达式
System.out.println("-----------------");
int e = 10;
int f = e++;
System.out.println(e); //11
System.out.println(f); //10 ++放在后面 e++表达式的结果 取的是 e尚未+1的值。
int g = 10;
int h = ++g;
System.out.println(g); //11
System.out.println(h); //11 ++放在前面 ++e表达式的结果 取的是 e+1之后的值
}
}
案例1：
int a = 10;
int b = 20;
int c = 30;
int d = 40;
int e = a++ + ++b + --c + d--;
// 10 21 29 40
System.out.println(e); //100
案例2：
int a = 10;
int b = 20;
int c = 30;
// a=11 b=19 c=31 a=12 b=20 c=30
int d = a++ + --b + ++c + ++a + b++ + c--;
// 10 19 31 12 19 31
System.out.println(a); //12
System.out.println(b); //20
System.out.println(c); //30
System.out.println(d); //122
赋值运算符
普通赋值运算符 =
int a = 10;
复合赋值运算符
+= -= *= /= %=
int a = 10;
int b = 20;
a +=b; // a = a+b;
System.out.println(a); //30
注意事项：
short s = 10;
byte b = 20;
//s = s + b; // 编译报错 比int小的 计算的时候 会全部提升为int类型。
//s = (short)s +b; // 编译报错
s = (short)(s +b);
System.out.println(s); //30
//--------------------
short s1 = 10;
byte b1 = 20;
s1+=b1; // s1 = (short)(s1 +b1);
System.out.println(s1);
比较运算符 :
> < >= <= == !=
int a = 10;
int b = 5;
//a>b;
//true;
boolean c = a>b; // 比较运算符的 结果 全部都是 boolean类型
System.out.println(c);
// 定义变量a 判断这个a是属于 0-100的范围吗？ true false
int a = 180;
//boolean b = 0<a <100; //编译报错
boolean b = 0<a & a<100;
System.out.println(b);
逻辑运算符
a 在 0 - 100的范围吗？
System.out.println( 0<a & a<100 );
& : 并且的意思
一箱酒(两瓶)，里面有一瓶真酒 有一瓶假酒 ，请问你认为 这一箱酒是真的还是假的， 你肯定认为是假的 不买。
并且， 有假则假。 有false则false
| ： 或者的意思
我两只手 每一只收里面有一个苹果， 一个是好苹果 另一个是烂苹果， 请问你选哪一个。 肯定选好的。
或者， 有真则真， 有true 则true
^ : 异或 异 ：不同 ， 或：通假字 惑 疑惑。 意思：疑惑是否不同吗
如果是 不同， true， 不是 false
true ^ true ----false
false ^ true ---true
System.out.println(true != true); //false
System.out.println('a'!='b'); //true
System.out.println(10!=20); //true
//System.out.println("a" ^ "b"); //编译报错
System.out.println("a" != "b"); //true
! : 取反。
路逻辑运算符：
&& 和& 的结果是一样的。
&& 效率高。
并且， 有false则false。 如果左侧看到false了 右侧就不执行了。
|| 和| 的结果是一样的。
|| 效率高。
或者， 有true则true。 如果左侧看到true了 右侧就不执行了
int a = 10;
int b = 20;
//a>100 && b++; //编译报错。
//true;
//false;
//boolean c = a>100 && b++; //编译报错 逻辑运算符 只能算boolean类型 左右两侧 必须只能是boolean 否则编译报错
boolean c = a>100 && b++ > 0;
System.out.println(b); //20
三元运算符:
三 ：三个 元：元素
一元运算符：
System.out.println(+10);
System.out.println(-10);
int a = 10;
a++;
a--;
二元运算符：
System.out.println(10+10);
System.out.println(10>5);
三元运算符：
格式：
关系表达式 ? 表达式1 : 表达式2;
int a = 10;
int b = 20;
//a >b ? a+b : a-b; //编译报错 不是语句
int c = a >b ? a+b : a-b;
System.out.println(c);
案例： 键盘录入三个整数，最终打印这三个值中最大的那个数。
import java.util.Scanner;
public class Demo {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int c = sc.nextInt();
int temp = a>b ? a :b;
int max = temp > c ? temp : c;
System.out.println(max);
int max1 = a > b ? ( a>c ?a:c ) : (b>c ? b :c);
System.out.println(max1);
}
}
结构语句(☆☆☆☆☆)
顺序结构语句：
class Demo {
public static void main(String[] args){
// 从上往下从左往右
System.out.println("helloworld1");
System.out.println("helloworld2");
System.out.println("helloworld3");
System.out.println("helloworld4");
System.out.println("helloworld5");
}
}
选择(分支)结构语句
class Demo {
public static void main(String[] args){
// 依然是从上往下执行 只不过 有的语句 可以选择性的执行。
System.out.println("helloworld1");
System.out.println("helloworld2"); // 打印2 这一句话 我选择性的执行。
System.out.println("helloworld3");
System.out.println("helloworld4");
System.out.println("helloworld5");
}
}
if 来控制选择执行
if 第一种格式
if (条件表达式){
语句体;
}
案例：成绩合格查询系统。 你键盘输入你的成绩，我程序就给你显示是否及格。
import java.util.Scanner;
public class Demo4 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请您输入您的成绩 我来判定您是否及格");
int score = sc.nextInt();
if (score >=60){
System.out.println("及格");
}
//System.out.println("不及格");
System.out.println("结束");
}
}
if 的第二种格式
if (条件表达式){
语句体1;
}else{
语句体2;
}
案例：
import java.util.Scanner;
public class Demo4 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println("请您输入您的成绩 我来判定您是否及格");
int score = sc.nextInt();
/*
if (score >=60){
System.out.println("及格");
}
//System.out.println("不及格");
*/
if (score >=60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
System.out.println("结束");
}
}
if 的第三种格式：
if (条件表达式1){
语句体1;
}else if (条件表达式2){
语句体2;
}else if (条件表达式3){
语句体3;
}else if (条件表达式4){
语句体4;
}else if (条件表达式5){
语句体5;
}else{
语句体6;
}
举例1：
import java.util.Scanner;
public class Demo {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int score = sc.nextInt();
if (score >=90 && score <=100){
System.out.println("优秀");
}else if (score >=80 && score <=90){
System.out.println("良好");
}else if (score >=70 && score <=80){
System.out.println("差不多儿");
}else if (score >=60 && score <=70){
System.out.println("及格");
}else if (score >=50 && score <=60){
System.out.println("不太好");
}else{
System.out.println("太不好了");
}
System.out.println("结束");
}
}
举例2：
public class Test {
/*
需求：键盘录入学生考试成绩, 根据成绩程序给出不同的奖励。
95~100分 : 自行车一辆
90~94分 : 游乐场一次
80~89分 : 变形金刚一个
80分以下 : 挨顿揍, 这座城市又多了一个伤心的人~
步骤:
1. 使用Scanner录入考试成绩
2. 判断成绩是否在合法范围内 0~100
非法的话, 给出错误提示
3. 在合法的语句块中判断成绩范围符合哪一个奖励
并给出对应的奖励.
*/
public static void main(String[] args){
// 1. 使用Scanner录入考试成绩
Scanner sc = new Scanner(System.in);
System.out.println("请输入您的成绩:");
int score = sc.nextInt();
// 2. 判断成绩是否在合法范围内 0~100
if(score >=0 && score <= 100){
// 合法成绩
// 3. 在合法的语句块中判断成绩范围符合哪一个奖励
if(score >= 95 && score <= 100){
System.out.println("自行车一辆");
}else if(score >= 90 && score <= 94){
System.out.println("游乐场一次");
}else if(score >= 80 && score <= 89){
System.out.println("变形金刚一个");
}else {
System.out.println("挨顿揍, 这座城市又多了一个伤心的人~");
}
}else{
// 非法的话, 给出错误提示
System.out.println("您的成绩输入有误!");
}
}
}
switch 来控制选择执行
循环结构语句
class Demo {
public static void main(String[] args){
// 依然是从上往下执行 只不过 执行完一遍 接着返回最前面 继续重新执行。
System.out.println("helloworld1");
System.out.println("helloworld2");
System.out.println("helloworld3");
System.out.println("helloworld4");
System.out.println("helloworld5");
}
}
6131
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
