JAVA基础----常量变量运算符

1. 常量

  1. 在程序运行的过程,其值不发生改变 
   2. 分类:

 1. 字面值常量
   2. 自定义常量
 3. 字面值常量

1. 字符串
2. 整数
3. 小数
4. 字符
5. 布尔
6. 空

  如下:

/*

常量:在程序运行时不发生改变的值

分类:字面值常量

自定义常量

字面值常量:

字符串:  " "

举例: "HelloWorld" , "吃多了"

整数:

举例: 0,123,

小数:

2.5 ,4.5 

字符: ''

'a','0' 字符只能表示一个

'ab' 错误的

布尔:

true 真

false 假 

空:

null 

*/

class ConstantDemo{

public static void main(String[] args){

//定义常量

//字符串

System.out.println("我们来认识常量");

//整数

System.out.println(100);

//小数

System.out.println(3.14159265);

//字符

System.out.println('a');

System.out.println('0');

System.out.println('ab');

//布尔

System.out.println(true);

System.out.println(false);

//空

//System.out.println(null);

}

}

   4. 进制:人为规定的进位的方式

   5. 二进制 八进制 十进制 十六进制

1. 二进制的由来,开关的状态

2. 二进制的简化-->8进制,16进制

3. 表示方式

1. 0b100

2. 0100

3. 100

4. 0x100

4. 进制的转换

1. x进制转到10进制-->系数*基数^权值之和

2. 10进制转到x进制-->除除除x,直到0,余数反转

3. 8421码--每一个二进制1表示一个十进制值

4. 任意进制相互转换靠8421快速转换

5. 有符号的表示方式(了解)

1. 符号位    数值位

2. 正数 0  值,原反补一样

3. 负数 1  值 

4. 反码,取反(数值位取反)

5. 补码,补1

如下:

/*

进制不同的表现形式

二进制: 0b    0 1 

八进制: 0     0-7

十进制:       0-9

十六进制: 0x  0-9 a,b,c,d,e,f

*/

class ConstantDemo2{

public static void main(String[] args){

//输出不同进制  100 

//二进制

System.out.println(0b100); //4

//八进制

System.out.println(0100); //64

//十进制

System.out.println(100); //100

//十六进制

System.out.println(0x100); //256 

}

}

/*

带符号的表示法

1  010 0101

符号位      数值位

1       0100101

原码: 符号位  0表示正 ,1表示负

数值位表示的是大小

反码:    符号不变   数值位取反  0-->1  1--> 

符号位  数值位

 1      1011010

补码:     就是在 数值位补1 

符号位  数值位

 1      1011011

    符号位   数值位

原码:+7        0      0000111

反码: 同上

补码: 同上

符号位  数值位

原码:-7        1      0000111

反码:          1      1111000

补码:          1      1111001  

+7 补码   0      0000111

-7 补码   1      1111001  

--------------------------

         10      0000000  

*/

2. 变量

  1. 变量:在程序运行时,其值可以发生改变
  2. 数据类型 变量名 = 初始化值;
  3. 数据类型

    1. 限制初始化值的变化的范围
    2. 四类八种

1. 整数--byte,short,int,long
2. 浮点--float(单精度) ,double(双精度)
3. 字符--char (0~65535)
4. 布尔--true false

如下 : 

 

/*

变量的格式:

数据类型 变量名 = 初始化值;

price = 5999;

分类:

基本数据类型 : 四类八种 

整数-- byte   1字节   8位   -128~ 127

short  2字节   16位  -32768 ~ 32767

int   4字节   32位  -2147483648 ~ 2147483647

long   8字节   64位  

浮点数--

float  4字节   32位

double 8字节   64位

字符

char   2字节  16位     0~65535

布尔 

boolean 1字节  true  false 

引用数据类型

类 

接口

数组

1.整数赋值的过程当中,默认的类型int,那么如果数值太大,超出范围,那么报错.

long 类型,在数值后面 l 或者 L 

2.浮点数赋值,默认的类型是double,那么如果赋值不精准,那么报错.

float类型,在数组后面 f 或者 F 

*/

class BianLiangDemo{

public static void main(String[] args){

//定义变量

//整数类型

byte b = 10;

System.out.println(b);

short s = 5999;

System.out.println(s);

//int i= 100000;

//int i = 10000000000000; //过大的整数  

long l = 10000000000000L;  //错误: 过大的整数: 10000000000000

System.out.println(l); 

//浮点数

float  f  = 3.14F;

System.out.println(f);   //错误: 可能损失精度

double  d  = 3.1434456;

System.out.println(d);   //错误: 可能损失精度

//字符

char c = 'a';

char c2 = 'a';

System.out.println("----------"); 

System.out.println(c2+1); 

//布尔

boolean bo = false;

boolean bo2 = false;

System.out.println(bo); 

System.out.println(bo2); 

}

}

3. 数据类型的转换

    1. 隐式转换

1. byte,short,char -->int-->long-->float-->double

    2. 显示转换(强制转换)

1. 格式: 数据类型 变量名 = (目标数据类型) (数据)

2. 隐藏了损失精度的问题

3. float f =  2.1+5.5;

4. byte b = 300+4;

 如下: 

/*

类型的默认转换:

byte,short,char --> int --> long -->float -->double

顺序从小到大,隐式转换.向上提升 

byte ,short ,char 相互不转换 ,直接转换int类型

注意: boolean类型不能转换为其他的数据类型

*/

class BianLiangDemo2{

public  static void main(String[] args){

int x = 3;

byte y = 4 ;

//int z = x+y;

// byte z = x+y;   错误: 可能损失精度 

System.out.println(z);

}

}

/*

强硬手段: 强制转换 --(显示转换)

格式:

数据类型 变量名 = (目标数据类型)(数据);

在使用强制转换的时候,这里面隐含了可能损失精度的问题,会产生意想不到的效果,所以强转慎用 . 

*/

class BianLiangDemo3{

public  static void main(String[] args){

int x = 3;

//byte y = 4 ;

byte y = 126;

//强制转换

byte z =  (byte)(x+y);   

System.out.println(z);

}

}

________________________________________

/*

变量注意的小问题 

1.作用域,用大括号来限定变量的作用范围.

2.初始化值的问题,定义变量,不赋值可以,但是,不能使用它.

想要使用,必须在使用前赋值.

建议: 在定义变量的时候,就赋值.

3.一行一个变量,如果一行定义多个变量也行,但是,不建议.

建议:一行就一个变量,定义时就赋值.

*/

class BianLiangNotice{

public  static void main(String[] args){

//定义变量 

// int x =100;  作用域问题

// {

//

// System.out.println(x);

// }

// int x ;

// x=1000;

// System.out.println(x); // 可能尚未初始化变量x

int x,y ;

x=10;

y=20;

System.out.println(x);

System.out.println(y);

}

}

4. 字符和字符串

    1. 字符类型-->类型提升int 

    2. 字符串--> 连接符运算 (俄罗斯方块)

   3. 运算符--有运算就有结果

    1. 算术

      1. + - * / % 

      2. ++ --

        1. a++ :先赋值 再++          

        2. ++a :先++ 再赋值

如下 :  

/*

运算符:

算术运算符:

简单 + - * / % 

扩展  ++  -- 

*/

class YunSuanDemo{

public static void main(String[] args){

//演示 运算符

System.out.println(3+4);  //7

System.out.println(3-4);  //-1

System.out.println(3*4);  //12

System.out.println(3/4);  //0  整数运算结果只能是整数

System.out.println(3.0/4); 

System.out.println(3%4); //0 余数 3 

}

}

/*

++ -- 运算符

单独使用: ++ 加1的操作 

 -- 减1的操作

前后都一样.

运算使用:

a++ b-- ,先赋值,后去++ 

++a --b ,先++ , 后赋值 

*/

class YunSuanDemo2{

public static void main(String[] args){

//演示  ++ --运算符

int x =3;

int y =4;

// x++;

// y--;

++x;

--y;

System.out.println(x); // 4

System.out.println(y); // 3

System.out.println("------------");

int a =3; 

int b =4;

// int c = a++;

// int d = b--;

int c = ++a;

int d = --b;

System.out.println("c:"+c); // 3  4

System.out.println("d:"+d); // 4  3

}

}

    2. 赋值

   1. = 右边赋值给左边 

     2. += -= *= /= %=

1. 变量的理解

2. 左边和右边做运算,再赋值给左边

如下  : 

/*

赋值运算符:

简单   =   : 把右边的值 赋值给左边

int a = 7;

扩展:

+= -= *= /= %=

左边和右边做运算,再赋值给左边

*/

class YunSuanDemo3{

public static void main(String[] args){

// 扩展:

// += -= *= /= %=

int x =3;

int y =4;

//x+=y; 7

//x-=y;  //-1

System.out.println(x+=y); // 7

System.out.println("x:"+x+"y:"+y); // 7

System.out.println(x-=y); // -1

System.out.println("x:"+x+"y:"+y);

System.out.println(x*=y); // 12 

System.out.println("x:"+x+"y:"+y);

System.out.println(x/=y); // 0

System.out.println("x:"+x+"y:"+y);

System.out.println(x%=y); // 3

System.out.println("x:"+x+"y:"+y);

}

}

   3. 关系

     1. 大小关系,结果 boolean类型

     2. == != < > <= >=

     3. 举例: 3==4,   5>9 

如下 :

/*

关系运算符:

关系就指大小关系,运算结果 真或者假

注意:结果只能是 boolean 类型 true /false

== != < > <= >= 

*/

class YunSuanDemo4{

public static void main(String[] args){

//关系运算符 

int a =10;

int b =10;

boolean bo = (a=b);

System.out.println(bo);

System.out.println(a!=b);

}

}