day02.变量 数据类型转换 运算符
java
课前回顾:
1.计算机编程语言:计算机能看懂的语言
2.Java祖师爷:詹姆斯高斯林
3.字节:计算机存储数据的最小计量单位,用byte或者B表示
8bit = 1B
往后都是1024倍
4.常用dos命令:
切换盘符 盘符名:
查看 dir
进入指定文件夹 cd 文件夹名 或者 cd 文件夹名\文件夹名
退出上一级 cd..
退到根目录 cd\
创建文件夹 mkdir 文件夹名 或者 mkdir 文件夹名\文件夹名
删除文件 del 文件名.后缀名 del *.后缀名
清屏 cls
退出dos命令窗口 exit
5.java环境:
配置环境变量 -> JAVA_HOME
6.入门程序:
a.编写:
public class 类名{
public static void main(String[] args){
System.out.println();
}
}
b.编译:生成一个class文件
javac java文件名.java
c.运行:
java class文件名
7.注释:对代码的解释说明
a.单行注释://
b.多行注释: /**/
c.文档注释: /***/
8.关键字:
java提前定义好的,具有特殊含义的小写单词
9.println和print的区别:
a.相同点:都是输出语句
b.不同点:println自带换行效果 print没有换行效果
10.idea -> 自己操作
今日重点:
1.会定义变量
2.会使用变量
3.会强转
4.会各种运算符第一章.常量
java
1.概述:在代码运行的过程中值不会发生改变的数据,也叫做"字面值"
2.分类:
整数常量:所有整数
小数常量:所有带小数点的
2.5 2.0
字符常量:带单引号的 '' -> 单引号中必须有且只能有一个内容
'1'
'11' 不是字符
'a'
'a1' 不是字符
'' 不是字符
' ' 一个空格算一个内容,所以一个空格也算字符
' ' 两个空格算两个内容,所以不是字符
' '
字符串常量:带双引号的 "" -> 双引号中随意写
"" "1111" "helloworld"
布尔常量: true false
空常量:null 代表数据不存在 不能直接使用
给引用数据类型初始化的时候用nulljava
public class Demo01ChangLiang {
public static void main(String[] args) {
//整数常量
System.out.println(10);
//小数常量
System.out.println(10.5);
//字符常量
System.out.println('a');
System.out.println(' ');
//字符串常量
System.out.println("hello world");
System.out.println("");
System.out.println("dsfasfa");
System.out.println("涛哥金莲的故事");
//布尔常量
System.out.println(true);
System.out.println(false);
//空常量
//System.out.println(null);
}
}java
public class Demo02ChangLiang {
public static void main(String[] args) {
System.out.println(10+3);//13
System.out.println(10-3);//7
System.out.println(10*3);//30
/*
/前后都是整数,结果取整数部分
/前后一旦有一个是小数,结果就是正常小数
*/
System.out.println(10/3);//3
System.out.println(10/3.0);//3.3333333333333335
}
}第二章.变量
配眼镜:潘家园 -> 北京眼镜城 ->3 楼
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 字节型 | byte | 1 个字节 | -128 至 127 定义 byte 变量时超出范围,废了 |
| 短整型 | short | 2 个字节 | -32768 至 32767 |
| 整型 | int（默认） | 4 个字节 | -2^31^ 至 2^31^-1 正负 21 个亿 -2147483648——2147483647 |
| 长整型 | long | 8 个字节 | -2^63^ 至 2^63^-1 19 位数字 |
| 单精度浮点数 | float | 4 个字节 | 1.4013E-45 至 3.4028E+38 |
| 双精度浮点数 | double（默认） | 8 个字节 | 4.9E-324 至 1.7977E+308 |
| 字符型 | char | 2 个字节 | 0 至 2^16^-1 |
| 布尔类型 | boolean | 1 个字节 | true，false(可以做判断条件使用) |
1.变量的介绍以及使用
java
1.概述:在代码的运行过程中值会随着不同的情况随时发生改变的数据
double price = 10 -> 少了5元 -> price-5
如果将一个数据用一个变量接收,后续什么时候想用这个数据,什么时候直接拿这个变量即可
2.作用:一次存储一个数据
3.定义格式:
a.数据类型 变量名 = 值 -> 一定是先看等号右边的,然后将等号右边的值赋值给等号左边的变量
即使等号右边是一个运算,咱们都得先将右边的算出来,然后将结果赋值给等号左边的变
量
b.数据类型 变量名;
变量名 = 值;
4.java中变量的数据类型
基本类型:4类8种
整型: byte short int long
浮点型:float double
字符型:char
布尔型:boolean
引用类型:
类 数组 接口 枚举 注解 Record
5.注意:
a.String字符串不是一个单独的类型.所以以后说数据类型的时候不要单独将String拎出来,因为String字符串属于类的一种
b.整数默认类型 -> int
小数默认类型 -> double
6.按照取值范围排序(从小到大) -> byte,short,char -> int -> long -> float -> doublejava
public class Demo01Var {
public static void main(String[] args) {
//byte
byte num1 = 10;
System.out.println(num1);
//short
short num2 = 20;
System.out.println(num2);
//int
int num3 = 100;
num3 = 200;
System.out.println(num3);
/*
long -> 在定义long型变量的时候,值后面一般加个L
因为整数默认类型为int,所以long类型值后面加个L,证明不是int型而是long型
*/
long num4 = 100L;
System.out.println(num4);
/*
float -> 在定义float型变量的时候,值后面一般加个F
因为小数默认类型为double,所以float类型值后面加个F,证明不是double型而是float型
*/
float num5 = 3.14F;
System.out.println(num5);
//double
double num6 = 3.14;
System.out.println(num6);
//char -> 在定义char型变量的时候,值前面加个单引号
char num7 = 'a';
System.out.println(num7);
//boolean
boolean num8 = true;
boolean num9 = false;
/*
将num8的值赋值给了num9
num9由false变成了true
*/
num9 = num8;
System.out.println(num9);
//字符串属于引用类型,但是定义格式和基本类型一样,String表示
String s = "涛哥";
System.out.println(s);
}
}java
public class Demo02Var {
public static void main(String[] args) {
int i = 10;
int j = 3;
System.out.println(i + j);
/*
推荐使用将结果重新赋值给一个变量
*/
int sum = i+j;
System.out.println(sum);
int sub = i-j;
System.out.println(sub);
int mul = i*j;
System.out.println(mul);
int div = i/j;
System.out.println(div);
}
}java
public class Demo03Var {
public static void main(String[] args) {
/*
\:转义字符
a.可以将普通的字符转成具有特殊含义的字符
b.将含有特殊含义的字符转成普通的字符
*/
/*
n:普通字符
\n:换行
*/
System.out.println("hello\nworld");
/*
t:普通字符
\t:制表符,相当于tab键
*/
System.out.println("hello\tworld");
/*
\:具有特殊含义的转义字符
\\:普通的\
*/
String path = "F:\\idea";
System.out.println(path);
}
}2.变量使用时的注意事项
java
1.变量不初始化(第一次赋值)不能直接使用
2.在同一个作用域(一对大括号)中不能定义重名的变量
3.不同的作用域中的数据不要随意互相使用
a.在小作用域中能直接使用大作用域中的数据
b.在大作用域中不能直接使用小作用域中的数据java
public class Demo04VarNotice {
public static void main(String[] args) {
int i;
//System.out.println(i);
int j = 10;
//double j = 20;
{
int k = 20;
System.out.println(j);
}
//System.out.println(k);
}
}3.练习
java
定义一个人类,用变量表示 姓名 性别 年龄 身高 体重java
public class Demo05Person {
public static void main(String[] args) {
//姓名
String name = "和珅";
//年龄
int age = 36;
//身高
double height = 1.75;
//体重
double weight = 145.5;
//性别
char gender = '男';
System.out.println(name);
System.out.println(age);
System.out.println(height);
System.out.println(weight);
System.out.println(gender);
}
}第三章.标识符
java
1.概述:给类,方法,变量取的名字
2.硬性规定(必须遵守)
a.名字中可以包含: 字母,数字,_,$
b.不能以数字开头
c.不要是关键字
软性建议(可遵守可不遵守,建议遵守)
a.给类取名字 : 大驼峰式 (每个单词首字母大写)
b.给方法,变量取名字:小驼峰式(从第二个单词开始首字母大写)第四章.数据类型转换
java
1.什么时候会发生数据类型转换
等号左右两边的类型不一致
2.数据类型转换都有哪些转法:
a.自动类型转换
b.强制类型转换(强转)按照取值范围大小为基本类型排序(从小到大):
byte,short,char -> int -> long -> float -> double
1.自动类型转换->小转大
java
1.发生的条件:
a.取值范围大的数据类型 变量名 = 取值范围小的数据类型 -> 小提升为大的类型
b.取值范围大的数据类型和取值范围小的数据类型做运算 -> 小提升为大的类型java
public class Demo01DataType {
public static void main(String[] args) {
/*
等号左边是long类型的变量,等号右边是整数,整数默认类型为int
相当于将取值范围小的赋值给取值范围大的
所以发生了自动类型转换 -> 小转大
*/
long num1 = 100;
System.out.println("num1 = " + num1);
/*
等号左边是double类型的变量,等号右边是整数,整数默认类型为int
相当于将取值范围小的赋值给取值范围大的
所以发生了自动类型转换 -> 小转大
*/
double num2 = 100;
System.out.println("num2 = " + num2);
double num3 = 2.5;
int num4 = 10;
/*
double = double+int
double = double+double
*/
double sum = num3+num4;
System.out.println("sum = " + sum);
}
}2.强制类型转换
java
1.发生的条件:
取值范围小的数据类型 变量名 = 取值范围大的数据类型 -> 报错
2.怎么强转:
取值范围小的数据类型 变量名 = (取值范围小的数据类型)取值范围大的数据类型java
public class Demo02DataType {
public static void main(String[] args) {
/*
等号左边是int型,等号右边是long型数据
相当于将取值范围大的赋值给取值范围小的
需要强转
*/
//int num = 100L;
int num = (int)100L;
System.out.println(num);
/*
等号左边是float类型的变量,等号右边是double类型
相当于将取值范围大的赋值给取值范围小的
需要强转
*/
float num2 = (float)2.5;
System.out.println("num2 = " + num2);
}
}3.强转的注意事项
java
1.写代码的时候不要故意写成强转的形式,除非没有办法,否则容易出现数据溢出以及精度损失现象
2.byte和short接受的值如果是字面值,且没有超出byte和short的范围,jvm会自动强转
但是byte和short接收的值如果有变量参与,结果重新赋值给byte或者short变量,byte和short会提升为int型,需要我们手动强转
3.char类型一旦做运算,会自动提升为int型,char类型数据一旦提升为int型,会自动去ASCII码表中找此字符对应的int值,如果ASCII码表中找不到,会自动去Unicode码表(万国码)中去找java
public class Demo03DataType {
public static void main(String[] args) {
int num1 = (int) 2.9;
System.out.println("num1 = " + num1);//2
/*
int型占4个字节,一个字节是8个二进制位 -> int型最多能用32位二进制表示
100亿 -> 36位二进制
*/
int num2 = (int) 10000000000L;
System.out.println("num2 = " + num2);//1410065408
System.out.println("=========================");
byte num3 = 100;
System.out.println(num3);
byte sum = (byte)(num3+1);
System.out.println(sum);
System.out.println("===============");
char num4 = 'A';
System.out.println(num4+0);
int num5 = 'a';
System.out.println(num5);
System.out.println('中'+0);//20013
}
}
温馨小提示:
将来如果算钱的时候,千万不要直接用 float 和 double 算,因为 float 和 double 直接参与运算也会出现精度损失现象
解决:将来会学 BigDecimal,它会解决 float 或者 double 直接参与运算而出现的精度损失问题
第五章.运算符
1.算数运算符
| 符号 | 说明 |
|---|---|
| + | 加法 |
| - | 减法 |
| * | 乘法 |
| / | 除法 |
| % | 模(取余) |
java
public class Demo01SuanShu {
public static void main(String[] args) {
int i = 10;
int j = 3;
int sum = i+j;
System.out.println("sum = " + sum);
int sub = i-j;
System.out.println("sub = " + sub);
int mul = i*j;
System.out.println("mul = " + mul);
int div = i/j;
System.out.println("div = " + div);
int mod = i%j;
System.out.println("mod = " + mod);
}
}java
+:
a.加法
b.字符串拼接符号 -> 任意类型遇到字符串都会变成字符串 -> 直接往后拼接java
public class Demo02SuanShu {
public static void main(String[] args) {
int i = 10;
int j = 3;
String result = i+j+"";
System.out.println("result = " + result);
System.out.println(i+""+j);
System.out.println(""+i+j+1);
System.out.println(""+(i+j)+1);
System.out.println("i和j相加的结果为:"+(i+j));
}
}2.自增自减运算符(也算算数运算符的一种)
java
1.符号:
++ --
2.格式:
变量名++ 后自加
++变量名 前自加
变量名-- 后自减
--变量名 前自减
3.使用:
a.单独使用:++ -- 单独为一句,没有和其他的语句掺和使用 -> 符号在前在后都是直接运算
b.混合使用:++ --和其他语句掺和使用 (打印语句,赋值语句等)
符号在前:先运算,再使用运算后的值
符号在后:先使用原值,再加减java
public class Demo03SuanShu {
public static void main(String[] args) {
int i = 10;
//i++;//单独使用
++i;//单独使用
System.out.println("i = " + i);
System.out.println("=============");
int j = 100;
//int result = ++j;
int result = j++;
System.out.println("result = " + result);
System.out.println(j);
System.out.println("============");
int c = 100;
c = c++;
System.out.println("c = " + c);
System.out.println("c = " + c);
System.out.println("============");
}
}
以后都是单独使用
3.赋值运算符
java
1.基本赋值运算符
= -> 先看等号右边的,将右边的结果赋值给等号左边的变量
2.复合赋值运算符
+=
int i = 10;
i+=2; //i = i+2
-=
*=
/=
%=
3.注意:
byte,short如果使用复合赋值运算符,jvm会自动强转java
public class Demo04FuZhi {
public static void main(String[] args) {
int i = 10;
i+=10;//i = i+10
System.out.println("i = " + i);
i-=1;//i = i-1
System.out.println("i = " + i);
System.out.println("=================");
byte b = 10;
b+=1;
//b = b+1;
System.out.println("b = " + b);
}
}4.关系运算符(比较运算符)
java
1.作用:做条件判断使用
2.结果:boolean结果| 符号 | 说明 |
|---|---|
| == | 判断符号前后结果是否相等,如果相等,返回 true;否则返回 false |
| > | 判断符号前面的是否大于符号后面的结果,如果大于,返回 true;否则返回 false |
| < | 判断符号前面的是否小于符号后面的结果,如果小于,返回 true;否则返回 false |
| >= | 判断符号前面的是否大于或者等于符号后面的结果,如果大于或者等于,返回 true;否则返回 false |
| <= | 判断符号前面的是否小于或者等于符号后面的结果,如果小于或者等于,返回 true;否则返回 false |
| != | 判断符号前后结果是否不相等,如果不相等返回 true,否则返回 flase |
java
public class Demo05Compare {
public static void main(String[] args) {
int i = 10;
int j = 20;
int k = 10;
boolean result01 = i==j;
System.out.println("result01 = " + result01);
System.out.println(i>j);
System.out.println(i<j);
System.out.println(i>=k);
System.out.println(i<=k);
System.out.println(i!=k);
}
}5.逻辑运算符
java
1.作用:连接多个boolean结果的
2.结果:boolean的结果| 符号 | 说明 |
|---|---|
| &&(与,并且) | 有假则假,符号前后有一个结果为 false,结果就是 false |
| ||(或者) | 有真则真,符号前后有一个结果为 true,结果就是 true |
| !(非,取反) | 不是真,就是假;不是假,就是真 |
| ^(异或) | 符号前后结果一样为 false;不一样为 true true^true -> false true^false -> true false^false -> false false^true -> true |
java
public class Demo06LuoJi {
public static void main(String[] args) {
int i = 10;
int j = 20;
int k = 10;
boolean result = (i>j)&&(i==k);
System.out.println("result = " + result);
System.out.println((i>j)||(i==k));
System.out.println(!(i>j));
System.out.println((i>j)^(i==k));
boolean b = true && false;
System.out.println("b = " + b);
}
}java&:有假则假,但是符号前面为false,符号后面依然执行,而且符号前后都是数字,就算是位运算符 &&:有假则假,但是符号前面为false,符号后面不执行了-> 短路效果 |:有真则真,但是符号前面为true,符号后面依然执行,而且符号前后都是数字,就算是位运算符 ||:有真则真,但是符号前面为true,符号后面不执行了 -> 短路效果javapublic class Demo07LuoJi { public static void main(String[] args) { int a = 10; int b = 20; //boolean result = (++a >= 100) && (++b <= 100); boolean result = (++a >= 100) & (++b <= 100); System.out.println("result = " + result); System.out.println(a); System.out.println(b); } }java问题:定义一个变量x,表示分数,判断分数是否在1-100之间 x>=1 && x<=100
6.三元运算符
java
1.格式:
boolean表达式?表达式1:表达式2
2.执行流程:
先走boolean表达式判断,如果结果为true,就执行?后面的表达式1,否则就执行:后面的表达式2java
public class Demo08SanYuan {
public static void main(String[] args) {
int score = 60;
String result = score >= 60 ? "及格" : "不及格";
System.out.println("result = " + result);
}
}java
需求:有两个和尚,分别身高为150 , 170 获取两个和尚的最高身高java
public class Demo09SanYuan {
public static void main(String[] args) {
int heShang1 = 150;
int heShang2 = 170;
int max = heShang1 > heShang2 ? heShang1 : heShang2;
System.out.println("max = " + max);
}
}java
需求:有三个和尚,分别身高为150 210 170 获取三个和尚的最高身高java
public class Demo10SanYuan {
public static void main(String[] args) {
int heShang1 = 150;
int heShang2 = 210;
int heShang3 = 170;
int temp = heShang1 > heShang2 ? heShang1 : heShang2;
int max = temp > heShang3 ? temp : heShang3;
System.out.println("max = " + max);
}
}第六章.进制的转换(了解)
| 十进制 | 二进制 | 八进制 | 十六进制 |
|---|---|---|---|
| 0 | 0 | 0 | 0 |
| 1 | 1 | 1 | 1 |
| 2 | 10 | 2 | 2 |
| 3 | 11 | 3 | 3 |
| 4 | 100 | 4 | 4 |
| 5 | 101 | 5 | 5 |
| 6 | 110 | 6 | 6 |
| 7 | 111 | 7 | 7 |
| 8 | 1000 | 10 | 8 |
| 9 | 1001 | 11 | 9 |
| 10 | 1010 | 12 | a 或 A |
| 11 | 1011 | 13 | b 或 B |
| 12 | 1100 | 14 | c 或 C |
| 13 | 1101 | 15 | d 或 D |
| 14 | 1110 | 16 | e 或 E |
| 15 | 1111 | 17 | f 或 F |
| 16 | 10000 | 20 | 10 |
3.1 十进制转成二进制
java
辗转相除法-> 循环除以2,取余数
3.2 二进制转成十进制
java
8421规则
3.3 二进制转成八进制
java
将二进制分开(3位为一组)
3.4 二进制转成十六进制
java
二进制分为4个为一组
第七章.位运算符(了解)
java
1代表true 0代表false
我们要知道计算机在存储数据的时候都是存储的数据的补码,而计算的也是数据的补码
1.正数二进制最高位为0;负数二进制最高位是1
2.正数的原码,反码,补码一致
如:5的原码,反码,补码为:
0000 0000 0000 0000 0000 0000 0000 0101->二进制最高位是0,因为是正数
3.负数的话原码,反码,补码就不一样了
反码是原码的基础上最高位不变,其他的0和1互变
补码是在反码的基础上+1
如:-9
原码:1000 0000 0000 0000 0000 0000 0000 1001
反码:1111 1111 1111 1111 1111 1111 1111 0110
补码:1111 1111 1111 1111 1111 1111 1111 0111（1）左移：<<
运算规则：左移几位就相当于乘以 2 的几次方
**注意：**当左移的位数 n 超过该数据类型的总位数时，相当于左移（n-总位数）位
java
2<<2 等于8
相当于:2*(2的2次方)
java
-2<<2 等于-8
相当于:-2*(2的2次方)
（2）右移：>>
快速运算：类似于除以 2 的 n 次，如果不能整除，向下取整
java
9>>2 等于 2
相当于:9除以(2的2次方)
java
-9>>2 等于-3
相当于:-9除以(2的2次方)
（3）无符号右移：>>>
运算规则：往右移动后，左边空出来的位直接补 0，不管最高位是 0 还是 1 空出来的都拿 0 补
正数：和右移一样
java
9>>>2 等于 2
相当于:9除以(2的2次方)负数：右边移出去几位，左边补几个 0，结果变为正数
java
-9>>>2
结果为:1073741821笔试题:8>>>32 位->相当于没有移动还是 8
8>>>34 位->相当于移动 2 位
（4）按位与：&
小技巧:将 0 看成为 false 将 1 看成 true
运算规则：对应位都是 1 才为 1,相当于符号左右两边都为 true,结果才为 true
1 & 1 结果为 1 相当于 true&true
1 & 0 结果为 0
0 & 1 结果为 0
0 & 0 结果为 0
java
比如: 5&3 结果为1
（5）按位或：|
运算规则：对应位只要有 1 即为 1,相当于符号前后只要有一个为 true,结果就是 true
1 | 1 结果为 1
1 | 0 结果为 1
0 | 1 结果为 1
0 | 0 结果为 0
比如: 5|3 结果为:7
（6）按位异或：^
运算规则：对应位一样的为 0,不一样的为 1
1 ^ 1 结果为 0 false
1 ^ 0 结果为 1 true
0 ^ 1 结果为 1 true
0 ^ 0 结果为 0 false
java
比如: 5^3 结果为6
（7）按位取反
运算规则：~0 就是 1
~1 就是 0
java
~10 -> 结果为-11
第八章.运算符的优先级(了解)
java
提示说明：
（1）表达式不要太复杂
（2）先算的使用(),记住,如果想让那个表达式先运行,就加小括号就可以了
i<(n*m)