晨写
1、什么是常量，常量的分类
常量：在程序的执行运行过程中，其值不发生改变的量
分类：字面值常量；自定义常量
字面值常量：
字符串常量
“HelloWorld” 字符串+任何数据=新的字符串 任何数据+字符串=新的字符串
“hello”+7=“hello7” 98+“=5+5”=“98=5+5”
字符常量
‘a’ System.out.println('A'+1) ‘A’+1:66
整数常量
100,65…
整数：默认十进制
进制：也属于常量范畴
任意进制——十进制（位权展开法）
十进制—任意进制（除基取余）
8421码：二进制和十进制的转换
小数常量
通用的小数
布尔常量
True/false
空常量
null:描述引用数据类型的默认值
String s = null;
System.out.println(s) ;
2、什么是变量，变量的三要素
变量：在程序执行过程中，其值发生改变的量
三要素：
数据类型 变量名 = 初始化值；//定义的时候就赋值了
数据类型 变量名；//先定义
变量名=初始化值；//然后初始化
声明限定数据类型
变量名遵循小驼峰命名法，见名知意
要有初始化值
格式：数据类型 变量名=初始化值
3、JAVA中数据的类型的划分，并且用使用代码举例（引用类型先不用列举）
分类：基本数据类型/引用数据类型
基本数据类型：（四类八种）
整数类型：默认类型int
byte字节类型 1个字节
short短整类型 2个字节
Int整数类型 4个字节
long长整类型 8个字节
浮点类型:默认类型double
float单精度类型 4个字节
double双精度类型 8个字节
字符类型
char ‘A’ 2个字节
布尔类型（不参与运算）
boolean 1个字节
引用数据类型：
类，数组，接口
回顾内容重点
1、常量分类
进制
2、变量三要素/变量的分类
今日内容
1、变量中的测试（定义变量注意事项）
/*
基本数据类型：（四类八种）
整数类型：默认类型int
byte字节类型 1个字节
short短整类型 2个字节
Int整数类型 4个字节
long长整类型 8个字节
浮点类型:默认类型double
float单精度类型 4个字节
double双精度类型 8个字节
字符类型
char 2个字节
布尔类型（不参与运算）
boolean 1个字节
定义变量的注意事项
1)定义long类型必须在值的后面加上标记L或l,这样就表示定义的是长整型的变量
2)浮点类型默认double，定义单精度float类型的时候，后面的值需要加上F或f即可！
*/
class DataYypeDemo{
public static void main(String[] args){
//byte类型
byte b = 100;
//byte b=120;//属于重复定义,已在方法main(String[])中定义了b 一个变量不能重复定义
System.out.println("b:"+b);//"b:值"//b:100
//重新赋值
b=20 ;//这样是可以的，重新赋值
System.out.println("b"+b);
System.out.println("---------------------");
//短整类型 short
short s =50;
s = 90 ;
System.out.println("s:"+s);
//整数默认类型：int
int i=10000;
//i=1000000000;//过大整数
System.out.println("i:"+i);
//当这个类型装不下了,此时就需要长整型定义
System.out.println("---------------------");
//long l = 1000000000;
System.out.println("l:"+i); //为什么还报错?因为100000000默认的是int,要在前面加标记,建议使用L:
//定义long类型必须在值的后面加上标记:L或l,这样就表示定义的是长整型的变量
System.out.println("---------------------");
//当这个类型装不下了，此时就需要长整型定义
//long l =100000000 定义long类型必须在值的后面加上标记
long l =100000000L;//建议使用L
System.out.println("i的值是："+b);
//long类型的应用场景:定义时间毫秒值的时候
//举例：使用到System类：里面有一个方法:获取当前系统时间毫秒值
//public static long currentTimeMillis()
long time = System.currentTimeMillis();
System.out.println(time);
System.out.println("--------------");
//浮点类型：默认double
//单精度类型float
//float f = 12.56;//报错,不兼容的类型,有损精度
//因为浮点类型默认double，定义单精度float类型的时候，后面的值需要加上F或f即可！,所以
float f = 12.56F ;
System.out.println("f:"+f);
//double类型
double d = 13.45;
System.out.println("d:"+d);
System.out.println("--------------");
//字符类型char
char ch='我';
ch = 'A';
ch = '0';
System.out.println("ch:"+ch);
//布尔类型 boolean 使用逻辑判断去用的，不参与运算
//一般情况变量 flag（标记）
}
}
/*
定义变量时的注意事项
1）同一个变量，不能被定义多次（重复定义），
因为Java是一个强类型语言
强类型语言：语法和格式时非常严谨的！（Java语言）
弱类型语言：JavaScript(前端Js)
2）实际开发中，不建议一行上多个变量（面试题/笔试题中出现居多）
3）方法定义中的变量——局部变量，它在使用之前必须进行初始化，否则报错
1）要么定义变量的时候就初始化了
数据类型 变量名 = 初始化值；
2）要么就先去定义，然后在使用之前必须初始化
数据类型 变量名;// 声明变量
变量名 = 初始化;//然后初始化了
4）语句结束，都是以“”分号结束;(分号是英文字符)
*/
class DataTypeDemo2{
public static void main(String[] args){
//定义变量a
int a = 10 ;
//int a = 20;//错误：已在方法main(String[]中定义了变量)
a = 20;
System.out.println(a) ;
System.out.println("----------------------") ;
//同一行当然可以定义多个变量（开发中使用很少，一般出现在笔试或面试题）
int x = 10, y = 20 ,z ;
z=30;
System.out.println("x:"+x,"y:"+y,"z:"+z);
//定义多个变量，建议
int x = 10 ;
int y = 20 ;
int z = 30 ;
y=60;
z = 100;
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
//定义两个变量
int m = 100 ,n ;//面试题，这个程序有什么问题？
System.out.println("m:"+m) ;
//原因:没有初始化变量n
//System.out.println("n:"+n) ;//可能尚未未初始化变量
n = 10;//赋值了
System.out.println("n:"+n) ;
}
}
2、Java中的基本数据类型——默认类型提升（隐式转换）
/*
定义两个变量
int a = 4 ;
byte b =3 ;
两个变量要进行求和-----数据在进行计算的时候，应该保持数据类型一致
Java中基本数据类型：存在一个概念——————默认类型提升
首先byte,short,char三者之间不转换，但是分别自己参与运算的时候
优先提升为int(考点)---long---float----double
booleean类型：不参与任何的运算！
它只是描述逻辑判断的结果（true/false）
*/
class DataTypeDemo{
public static void main (String[] args){
//定义变量
int a = 4 ;//int类型 4个字节 32个比特位
byte b =3 ;//byte类型 1个字节 8个比特位
//两个数据求和
int result = a + b ;//变量相加了,这时候,可以相加吗?可以,进行了隐式转换
//int result = a+ b//前面是int类型接受,所以它会先将一个字节的b---直接提升为int---变成了4个字节的3
//结果数据类型:是int类型 = 4个字节的7(int类型)
System.out.println("result:"+result);//,result:7
}
}
3、Java中的强转类型转换（强转）：不仅适用于基本类型还适用于引用类型（多态）
/*
定义两个变量
int a = 4 ;
byte b = 3 ;
现在接受的结果类型的变量是byte类型,而且a和b要进行变量相加
当变量相加计算时,如果接受的结果类型小于计算类型
需要使用java的强制类型转换-----让数据进行类型匹配,防止出现jvm提示不兼容
显示转换(强制类型转换)------不仅适用于基本类型,引用类型
格式:
目标数据类型 变量名=(目标数据类型)(结果);
实际开发中,尽量避免强制类型转换,可能会造成数据精度损失
*/
class DataTypeDemo4{
public static void main(String[] args){
//定义两个变量
int a = 4 ;
byte b = 3 ;
//结果类型byte
//byte result = a+ b ;//错误:不兼容的类型: 从int转换到byte可能会有损失
byte result = (byte)(a+b) ;
System.out.println("result:"+result);//resu lt结果是byte类型的7
}
}
题：
4、Java变量常见的面试题
考点：
默认类型提升（隐式转换）
强转类型转换（强转）
byte类型的取值范围：-128～127
+：
代表运算符
代表字符串拼接符号（考点：给一段程序，写出结果！））
代表数据为正数...
后期研究引用类型
Int——Integer引用类型
InterCacha 内部缓存区的范围 -128～127
题一：考点：默认类型提升（隐式转换）和 强转类型转换（强转）
/*
面试题
同一行定义了多个变量
byte b, b1=3,b2 =4;
1)b= b1+b2;//变量相加
2)b=3+4;//两个常量相加
输出b的值
问:
当前代码中 哪一句会编译失败,为什么?指出解决思路
1)编译失败
byte ,short,char三者之间不转换
一旦参与转换,优先提升为int
b1---->优先提升为int类型的3
b2---->优先提升为int类型的4
两个相加的结果为int类型的7,而b的类型是byte,接收不了
所以需要强制类型转换
*/
class DataTypeTest{
public static void main(String[] args){
//同一行定义了多个变量
byte b, b1=3,b2 =4;
//1)
//b = b1 + b2;错误:不兼容的类型: 从int转换到byte可能会有损失,,改为:
b = (byte)(b1+b2);//解决格式:强转
System.out.println("b:"+b);
//2)
b=3+4 ;//常量相加,先相加,然后看其的结果是否在byte取值范围内
//在的话,就直接赋值
//超过范围了(默认整数int类型--强转解决，下一道题看这个问题)
System.out.println("b:"+b);
}
}
题二：考点：byte类型的取值范围
/*
面试题（考点：byte类型的取值范围）
byte b = 129 ;
在程序中能编译通过吗？
如果不能，如何解决，结果是多少
byte类型的取值范围：-128~127
*/
class DataTypeTest2{
public static void main(String[] args){
//定义一个变量
//byte b= 129;//错误:不兼容的类型:从int转换到byte类型会有损失
//解决方案：强制类型转换
//格式：目标数据类型 变量名 = （目标数据类型）（结果）;
byte b= (byte)129;
System.out.println("b:"+b);//b:-127 程序运行出来的结果，那怎么来的？
}
}
/*
当前byte取值范围超出了---byte:-128~127,那么jvm的编译时就认为是int类型了
byte b = int类型的数据;---需要强制转换
byte b= (byte)129;b:-127怎么来的?
129---jvm---int类型 4个字节---二进制(原码):
00000000 00000000 00000000 10000001
最高符号位 数值位 因最高符号位是0,所以原码,反码,补码相同
0 0000000 00000000 00000000 10000001
byte b= (byte)129; 将补码进行截取三个字节,成为byte类型,一个字节
(0 0000000 00000000 00000000) 10000001
10000001 ---->截取后的补码结果,我们要通过补码--->反码--->求得原码
最高符号位 数值位 补码
1 0000001
- 1 (知道了补码,在末尾-1求得反码)
---------------------------------------------
1 0000000 反码 (知道了反码,符号位不变,数值位按位取反)
---------------------------------------------
1 1111111
- 64+32+16+8+4+2+1
=-(64+32+16+8+4+2+1)
=-127
二进制（原码）
题三：字符串拼接符号+的使用
*/
/*
面试题:
请描下面的代码的含义:
float f = 12.34F;
float f2 = （float）78.56;
double d = 12.78;
当前变量f:本身就定义的是一个单精度类型 加了一个标记F
f2:是通过强制类型转换来的，可能会造成数据的精度损失
目标类型 f2 =(目标类型)（结果）;
d变量：本身默认的double类型
2）关于字符串拼接符号
字符串+任何数据=“新的字符串”
任何数据+字符串="新的字符串"
看以下程序,写出结果!
*/
class DataTypeTest3{
public static void main(String[] args){
System.out.println("hello"+'a'+1);//helloa1
System.out.println('A'+1+"hello"+"world"+"JavaEE!"); //A1helloworldJavaEE!是错的
//正确的：66helloworldJavaEE!
System.out.println("5+5="+5+5);//"5+5=5"+5 = "5+5=55"
System.out.println(5+5+"=5+5");//10+"=5+5" = "10=5+5"
//把基础类型转成字符串怎么转?后面拼个空串就可以
//int a =10;
//System.out.println(a+"");//10+字符串就是一个新的字符串么
}
}
5、运算符
1）算术运算符
/*
有了变量的支持，这些变量如何操作呢？
比较两个变量是否相等,求连个变量中的最大值,计算他们对某个数据的求余数,三个数据如何进行获取最大值呢？
先学习运算符的概念
Java中的运算符：
算数运算符：+,-,*,/,%(模)
%(模):求余
赋值运算符：=
距离: int a = 10;将10赋值给int类型的变量a
关系（比较）运算符<,><=,>=,!=,==
!= 不等于 == 两个数据是否一样
逻辑运算符：
逻辑单与&,逻辑单或|,逻辑异或^,逻辑非!
位运算符：
基本位与&,位或|,位异或^
<<(左移),>>(右移), >>>无符号右移
三元(三目)运算符
先说
算数运算符：
基本的算数运算符号：
+,-,*,/,%(模)
/:默认取整
扩展的算术运算符：++和--
*/
class OperatorDemo{
public static void main(String[] args){
//定义两个变量
int a = 3;
int b =4 ;
//基本的算数运算符号：
System.out.println("a+b的结果是："+(a+b));
System.out.println("a-b的结果是："+(a-b));
System.out.println("a*b的结果是："+(a*b));
System.out.println("a/b的结果是："+(a/b));
System.out.println("a/b的结果是："+(a*1.0/b));//*1.0变成double类型
System.out.println("a%b的结果是："+(a%b));
/*
a+b的结果是：7
a-b的结果是：-1
a*b的结果是：12
a/b的结果是：0 // / 会默认取整
a/b的结果是：0.75
a%b的结果是：3
*/
//如果小数进行计算---计算机伪计算---需要精确计算：(尤其是小数除法)
//Java提供了一个类,后期可以使用：bigdecimal（常用类去使用一下）
}
}
/*
扩展的算术运算符：++和--的使用
场景1:
单独使用
结论:无论++或--在数据前面还是后面,
都是对数据的自增1或自减1
场景2:
参与运算使用(笔试题中出现)
参与运算:
++或--在数据的前面,先自增或自减,再参与运算
++或--在数据的后面,先运算,然后再自增或自减
*/
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int a = 3 ;
int b = 4 ;
//先分别输出a和b的值
System.out.println("a:"+a);
System.out.println("b:"+b);
System.out.println("----------------");
//单独使用
//1)如果++或--在数据前面
//++a ;
//--b ;
//System.out.println("a:"+a);//a:4 自增
//System.out.println("b:"+b);//b:3 自减
//2)如果++或--在数据后面
a++ ;
b-- ;
System.out.println("a:"+a);//a:4 还是自增
System.out.println("b:"+b);//b:3 还是自减
System.out.println("----------------");
//参与运算使用
//1)++或--在数据的前面
int x = 4 ;
int y = 5 ;
System.out.println("x:"+x+",y:"+y) ;
//int m = ++x ;//x先自增为5,再赋值给m,m是5
//int n = --y ;//y先自减为4,再赋值给n,n是4
//2)++或--在数据的后面
int m = x ++ ;//x先赋值给m,所以m是4 然后变量x再自增1,x变成5
int n = y -- ;//y先赋值给n,所以n是5 然后变量y再自减1,y变成4
System.out.println("x:"+x+",y:"+y) ;//x:5,y:4
System.out.println("m:"+m+",n:"+n) ;//m:4,n:5
}
}
/*
1)题1:
int a = 10;
int b = 10;
int c = 10;
a = b++;
c = --a;
b = ++a;
a = c--;
请分别计算出a,b,c的值
思路:先看谁变谁不变,不变就是没参与运算
a = b++;//c不变
c = --a;//b不变
b = ++a;//c不变
a = c--;//b不变
参与运算:
++或--在数据的前面,先自增或自减,再参与运算
++或--在数据的后面,先运算,然后再自增或自减
a = b++;//a=10,b=11,c=10
c = --a;//a=9,c=9,b=11
b = ++a;//a=10,b=10,c=9
a = c--;//a=9,c=8,b=10
答:a=9,c=8,b=10
2)题2:
int x = 4;
int y = (x++)+(++x)+(x*10);
y的值是多少?
*/
class OperatorTest{
public static void main(String[] args){
//定义了3个变量
int a = 10;
int b = 10;
int c = 10;
a = b++;
c = --a;
b = ++a;
a = c--;
System.out.println("a:"+a+",b:"+b+",c:"+c);//a:9,b:10,c:8
System.out.println("-----------------");
//看程序,写结果,y的值是多少?
int x = 4;
int y = (x++)+(++x)+(x*10);
//首先x是一直在变化的
//(x++),先给(x++)这个整体赋值为4,然后x自增为5
//(++x),先自增,x自增为6
//(x*10),6*10=60
//y=4+6+60=70
System.out.println("y:"+y);//y:70
}
}
2)赋值运算符
/*
赋值运算符:
基本的赋值运算符:=
将等号右边的数据赋值给等号左边的变量
注意事项:=不能写成==,==是比较
反之也不能,==不能写成=
扩展的赋值运算符:+=,-=,*=,/=,%=(它有自己的特点)
int x = 200 ;
x+= 100 ; += 将等号右边的数据和等号左边的变量x相加,然后将结果赋值给在等号左边的变量x,x:300
因为数据类型现在一致(现在的x就是int类型),所以类似于 x = x + 100 ;-=,*=,/=,%=这些都一样的
数据类型不一致,要考虑默认类型提升问题
+=举个例子
*/
class OperatorDemo{
public static void main(String[] args){
//定义一个变量a
int a = 120 ;
Syestem.out.println("将120赋值给了int类型的变量a");
//int x == 130 ;//错误,==是比较(true/false)
Syestem.out.println("--------------------");
//我们还有扩展的赋值运算符:+=.-=.*=./=.%=(它有自己的特点)
//用+=举个例子
int y = 120 ;
//y+=20 ;//y的值是:140
//类似于这种:
y = y + 20 ;
//此时要考虑数据类型(因为现在都是int,没问题;如果是其他数据类型,要考虑Java隐式类型提升)
System.out.println("y的值是:"+y)
}
}
/*
面试题:
有以下代码,下面哪一行会编译失败,请说明原因,并解决
short s = 1 ;//定义了一个变量
1)s = s + 1 ;
2)s +=1 ;
1)有问题,因为s是short类型,根据隐式类型转换,先提升为int
然后再参与运算,得到2---->这是一个结果int类型
而接受类型short,必须强转换
扩展的赋值运算符:特点 隐藏了强制类型转换
-=,*=,/=,%=都一样
*/
class OperatorDemo2{
public static void main(String[] args){
//定义一个变量s ,short类型
short s = 1 ;
//s = s + 1 ;//不兼容的类型,从int转到short可能会有损失
//s = (short)(s+1) ;
//System.out.println("s的值是:"+s) ;//s的值是:2
//2)
s +=1 ;// 扩展的赋值运算符:特点 隐藏了强制类型转换
// 等价于:s = (short)(s+1) ;
System.out.println("s的值是:"+s) ;//s的值是:2
}
}
比较运算符（关系运算符）
/*
关系(比较)运算符
<
>
<=
>=
!=
==
比较运算符的表达式无论简单还是复杂---
最终的结果都是一个boolean
数学表达式中:描述一个值的范围
3<=x<=5(数学表达式)
计算机语言中:Java语言
x>=3 &(逻辑并列,并且的意思) x<=5
注意:==不能写成=
*/
class OperatorDemo{
public static void main(String[] args){
//定义三个变量
int a = 3 ;
int b = 4 ;
int c = 5 ;
System.out.println(a==b) ;
System.out.println(a<=c) ;
System.out.println(b>=c) ;
System.out.println(a!=c) ;
System.out.println((a+b)<(b+c)) ;
//定义了两个变量
int m = 10 ;
int n =20 ;
//比较的是m和n的值是否相等
boolean flag = (m==n);
//boolean flag = (m=n);//n的值赋值给m,将m的值留下来赋值给flag
//错误: 不兼容的类型: int无法转换为boolean
System.out.println("flag:"+flag);//flag:false
}
}
逻辑运算符（重点：进行逻辑判断）
位运算符
三目（三元）运算符号
6、键盘录入数据—让程序更灵活一些
前期使用int
