Day03类型转换和运算符

1. 变量的分类

变量按照声明的位置或作用范围分为成员变量局部变量

1.1 成员变量

1.1.1 成员变量概念:【掌握】

直接声明在类中的变量,都是成员变量,可以放在方法的上方或者下方,成员变量与方法是平级的。

1.1.2. 成员变量作用:了解

成员变量用来解释这个类中的属性(面向对象重点讲,先不管)

1.1.3. 成员变量特点:【掌握】

1) 作用域范围:

在整个类中都可以使用成员变量。

2) 成员变量使用之前,如果没有值,则系统会分配一个默认值。

不同的数据类型默认值不同:

整数类型默认值:0

小数类型默认值:0.0

布尔类型默认值:false

字符类型默认值:空字符(/u0000)

引用类型默认值:null

如果main主方法中使用到成员变量,成员变量必须加上static修饰;(因为静态区域不能引用非静态上下文的变量,面向对象会讲,先不管)

1.2 局部变量

1.2.1. 局部变量概念:掌握

就是声明位置在方法()内或者{}中,都是局部变量。【()表示方法的形参;{}表示方法主体或者代码块;后面会讲先不管】  

1.2.2. 局部变量作用:了解

局部变量就是为了辅助完成一个方法的功能(后面讲,先不管)

1.2.3. 局部变量特点:掌握

1) 作用域范围: 在声明位置下方,到}结束,都可以使用局部变量

2) 局部变量没有默认值,使用之前,必须有值,否则语法报错。

1.3 局部变量与成员变量区别

1. 声明位置

成员变量声明在类中,局部变量声明在方法或花括号{}结构体中;

  1. 作用范围

成员变量在整个类结构中均可使用,局部变量只能在当前声明的花括号{}结构体中有效;

  1. 初始值

成员变量使用之前可以不赋予初始值,系统根据数据类型分配默认值,

局部变量使用之前必须赋予初始值,没有默认值。

注意事项:

同一个类中,如果成员变量与局部变量重名,实际使用到的是就近的局部变量的值。

1.4 代码案例1【掌握】

/**

*

*  2. 变量的分类:(掌握)

2.1. 局部变量:

2.2. 成员变量:

局部变量在栈内存

成员变量在堆内存

静态static成员在静态区内存

*/

public class _01Var {

/** 声明一个int类型成员变量b,不赋值 */

int b;// 成员变量是堆内存中

/** 声明一个int类型static成员变量e,不赋值 */

static int e;// 静态成员变量是静态区内存

/** 声明一个static修饰String类型str成员变量,不赋值 */

static String str;

/**

* main方法有static修饰,被static修饰的成员都是静态成员,被修饰的方法都是静态区。

* 所有static成员都存放在 JVM的静态区中【堆中】,在静态区中只能使用静态成员

* @param args

*/

public static void main(String[] args) {// args就是局部变量

// 原来声明变量是在main方法中,在方法中都是局部变量

// 声明一个int类型变量a赋值1

int a = 1;// 作用域范围:从声明这一行到main}结束  ,在栈内存

System.out.println(a);// 1

// 声明一个int类型变量d,不赋值

int d;// 在栈内存

// System.out.println(d);// 局部变量d在使用前,必须被初始化

// 打印成员变量b

// System.out.println(b);// 报错,因为非静态成员变量b不能在静态区使用

// 打印static成员变量e

System.out.println(e);// 0

// 打印static成员变量str

System.out.println(str);// null 【该数据主要在数组那天讲】

}

{// 代码块,现在不管。【面向对象会讲,今天只是为了测试变量分类,代码块执行方式后面讲】

int c = 2;// 声明了一个int类型的局部变量c,并且赋值为2。在栈内存

// System.out.println(a);// 报错,因为出了局部变量a作用域范围了

// 打印static成员变量e

System.out.println(e);// 0

}

}

1.5 代码案例2【理解】

/**

* 3. 就近原则:(理解)

局部变量和成员变量名字可以相同,因为存放内存区域不同。

局部变量 在内存的栈中

static修饰的成员变量在 静态区

static修饰的成员变量在 堆

当使用一个变量的时候,优先从局部变量中查找,如果找不到,才从类中找成员变量。这就是就近原则   

局部变量在栈内存

成员变量在堆内存

静态static成员在静态区内存

关于内存区域:堆、栈、静态区先不管,后面讲

*/

public class _02Var {

/** 声明一个int类型static成员变量a,赋值1 */

static int a = 1;// 静态成员变量a是静态区内存

public static void main(String[] args) {

// 声明一个int类型局部变量a赋值2

int a = 2;

// 打印变量a的时候,是用的局部变量a

System.out.println(a);// 2

}

}

2. 数据类型转换

2.1 类型转换概念

将数据从一种格式或结构转换为另一种格式或结构的过程。

2.2 类型转换作用

1.节约内存空间

byte short int long

2.将一些类型转换为项目所需要的类型

2.3 类型转换分类

2.3.1 自动隐式转换

定义:将小的数据类型转换大的数据类型

注意事项:

1.在Java中,boolean类型与所有其他7种类型都不能进行转换。

2.其他 7种数据类型,它们之间都可以进行转换,但是可能会存在精度损失或者其他一些变化。

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

char -> int  -> long-> float-> double

byte与char 不能自动转换  

char与short不能自动转换

由于小数(浮点数) 的存储方式,结构和整数不一样,所以,float哪怕是4个字节、long是8个字节,表示范围也大于long类型。知道就好无须深入研究..

自动转换案例

1.

short s = 10;
int num = 20;
int n = num + s;
System.out.println(n);

2.

int  num = 10;
double b = 10.01;
double  c = num + b;
System.out.println(c);

3.char类型向更高长度类型(例如整型)转换时,会转换为对应的ASCII码值,再做其他类型的自动转换

char  c = 'A';
int num = 10;
int a = c + num;
System.out.println(a);

特例:只看类型,不看值

// 示例1:
int a = 129;
byte b = (byte)a;// 编译器只看容器不看值
System.out.println(b);// 结果为-127
// 示例2:
byte b = 100;// 可以自动转换
float f = 1.3;// 不能自动转换
int a = 2147483647;
a = a + 1;
System.out.println(a);// 结果为-2147483648

2.3.2 强制转换【掌握】

定义:将大数据类型转为小数据类型

语法:小数据类型 变量名 = (小数据类型)大类型值/大类型变量名;

注意事项:

1. 高转低会导致精度丢失,有数据的溢出风险。溢出的时候,会以二进制进位。

2. 实际开发中:应该要知道被强制转换的数据,是在一个已知的范围。

3. 当int类型的具体的值,向byte、short、char类型转换的时候,值只要在其表示范围内,都会隐式转换。

代码案例:

int i1 = 123;
int i2 = 456;
float f1 = (float)((i1 + i2) * 1.2);// 类型大的转换为类型小的时,要加上强制转换符

short i = 99;
char c = (char)i;
System.out.println(c);  

byte b1 = 1;
byte b2 = 2;
byte b3 = (byte)(b1 + b2); // byte,short,char在计算时首先转换为int,大类型(int)转换为小类型的(byte)时要加强制转换

byte t = 127;// 不报错
int a = 127;
// 需要强制转换才不报错:编译器只看类型不看值
byte b = (byte)a;
System.out.println(b); // 结果为 127

2.3.3 代码案例【掌握】

/**

* 4. 类型转换:(掌握)

   byte  short(char)  int  long  float(单精度)  double(双精度) (只有数值类型才能相互转换)

   ----------------从左到右精度越来越高-------------------->

  1. 小转大,都是可以隐式转换  (从左到右)

  2. 大转小,必须强制转换  (从右到左) 强制转换有数据的溢出风险。溢出的时候,会以二进制进位

   强制转换语法:

   小的数据类型 小的变量 = (小的数据类型)大的变量/值;   

  

   int类型的具体的值,向byte、short、char类型转换的时候,值只要在其表示范围内,都会隐式转换   

 */

public class _03TypeChange {

public static void main(String[] args) {

// 1. 小转大,都是可以隐式转换  (从左到右)

byte byt = 1;// 声明一个byte类型变量byt 赋值1

short s = byt;// 声明一个short类型变量s 赋值一个byte类型变量byt

int i = s;// 声明一个int类型变量i 赋值一个short类型变量s

long lon = i;// 声明一个long类型变量lon 赋值一个int类型变量i

float f = lon;// 声明一个float类型变量f 赋值一个long类型变量lon

double doub = f;// 声明一个double类型变量doub 赋值一个float类型变量f

// 2. 大转小,必须强制转换  (从右到左) 强制转换有数据的溢出风险。溢出的时候,会以二进制进位

// 强制转换语法:小的数据类型 小的变量 = (小的数据类型)大的变量/值;

float f2 = (float)doub;// 声明一个float类型变量f2,赋值为一个强制转换的double类型变量 doub

long lon2 = (long)f2;

byte byt2 = (byte)128;// 128是int类型,强制转换有可能发生溢出,溢出时会以二进制进位

System.out.println(byt2);// -128

int a = 1;

// byte byt3 = a;// 报错,int类型a值是1,因为在编译期程序只看右边的数据类型,而不看变量中的值

byte byt4 = 1;// 不报错

}

}

3. 表达式

3.1表达式概念

由一系列的常量、变量、运算符括号()等组成的一个算术式,按照一定的运算规则计算出一个结果值。

3.2 表达式示例

例如:3 + 2;3 + 5 * (2 + 3)

注:括号可以提高运算的优先级

3.3 表达式规律:【掌握】

1) 当表达式中所有的变量类型小于int的时候,运算后的结果都会自动提升为int类型。

2) 当表达式中有变量类型大于int的时候,运算后的结果以表达式中精度最高的为主。

3.4 表达式代码案例【掌握】

/**

* 表达式:(掌握)

1. 概念:就是一个算术式。 例如: 1 + 1 + 2*3

2. 规律:

1.当表达式中所有的变量类型小于 int的时候,运算后的结果都会自动提升为int类型

2.当表达式中有变量类型大于 int的时候,运算后的结果以表达式中精度最高的为主

*/

public class _04Expression {

public static void main(String[] args) {

byte byt = 1;

short s = 2;

int i = 3;

long lon = 5L;

float f = 1.0f;

double doub = 3.14;

// 将上面所有变量相加,得到一个表达式

// 2.当表达式中有变量类型大于 int的时候,运算后的结果以表达式中精度最高的为主

double sum = byt + s + i + lon + f + doub;

System.out.println(sum);

// 1.当表达式中所有的变量类型小于 int的时候,运算后的结果都会自动提升为int类型

int sum2 = byt + s;

System.out.println(sum2);

}

}

4. 运算符

4.1 算数运算【掌握】

算数运算(Arithmetic Operation)(掌握)

+ :加号。只有String字符串参与的加法运算,才有拼接功能,在String之前,表示加法 运算,之后,才表示连接

-:减号。

*:乘号。

/:除号。不能除0

特殊情况:

1) 10 / 3 = 3

2) 10.0 / 3 = 3.33333…

3) 0 / 0

4) 0.0 / 0.0 结果是NaN ,任何的NaN都不等于自己(面试题)

5) 1.0 / 0.0 结果:Infinity,表示无穷大

%:模(也叫取余)相当于求余数。例如:10 % 3 ,表示求10除3的余数,结果是1

作用:1. 求余数    2. 找一个数的倍数    3. 可以拆分一个多位的数字

代码案例:

public class _05ArithmeticOperation {

public static void main(String[] args) {

System.out.println("============= 除法 / ==============");

System.out.println(10 / 1);// 10

System.out.println(10 / 2);// 5

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

System.out.println(10 / 4);// 2

System.out.println(10 / 5);// 2

System.out.println(10 / 6);// 1

System.out.println(10 / 7);// 1

System.out.println(10 / 8);// 1

System.out.println(10 / 9);// 1

System.out.println(10 / 10);// 1

System.out.println(10 / 11);// 0

// System.out.println(10 / 0);// ArithmeticException算术异常

System.out.println("============= 特殊情况 ==============");

/*

 * 特殊情况:【了解】

 1) 10/3 =3;

 2) 10.0/3=3.33333…

 3) 0/0

 4) 0.0/0.0  

 结果是NaN ,任何的NaN都不等于自己(面试题)not a number不是一个数字

 5) 1.0/0.0   结果:Infinity,表示无穷大

 */

System.out.println(10.0 / 3);

System.out.println(0.0 / 0.0);// NaN

System.out.println(1.0 / 0.0);// Infinity表示无穷大

System.out.println("============== % 模(取余) ==============");

System.out.println(10 % 1);// 0

System.out.println(10 % 2);// 0

System.out.println(10 % 3);// 1

System.out.println(10 % 4);// 2

System.out.println(10 % 5);// 0

System.out.println(10 % 6);// 4

System.out.println(10 % 7);// 3

System.out.println(10 % 8);// 2

System.out.println(10 % 9);// 1

System.out.println(10 % 10);// 0

System.out.println(10 % 11);// 10

// System.out.println(10 % 0);// ArithmeticException算术异常

// 请求出个十百位的值  / %

int a = 127;

// 求个位

int ge = a % 10;

// 求十位

int shi = a / 10 % 10;

// 求百位

int bai = a / 100;

System.out.println(ge + " : " + shi + " : " + bai);

}

}

4.2 自增自减运算(重点)

自增自减运算符:++   --

注意事项:

1) 自增自减只能够用于变量,不能用于常量  

2) 自增自减运算的优先级比其他算术运算符

3) 一般用在循环语句中

使用要点:

把整个表达式看成是一个整体

如果变量名在前面,那么整个表达式的值就是原来值不变。

如果变量名在后面,那么整个表达式的值就是原来的值加1。

1. 变量在前

a++: 先赋值,再自增

运算步骤:

step1:先将a的值赋值给  a++ 这个整体

step2:再将a的值+1

2. 变量在后

++a:先自增,再赋值

运算步骤:

step1:先将a的值+1

step2:再将a的值赋值给  a++ 这个整体

下面我们就以自增运算案例演示,子减规律完全相同,就不做演示了。

代码案例:

public class _06AddAdd {

public static void main(String[] args) {

// ++不能运算常量

// System.out.println(1++);

// 声明一个int类型变量a,赋值1

int a = 1;

/*

 * 2. 变量在前

a++: 先赋值,再自增

运算步骤:

  step1:先将a的值赋值给  a++ 这个整体

  step2:再将a的值+1

 */

int b = a++;// 相当于将a++这个整体的值,赋值给int变量b

System.out.println("b = " + b);// 1

System.out.println("a = " + a);// 2

// 声明一个int类型变量i,赋值1

int i = 1;

/*

 * 3. 变量在后

++a:先自增,再赋值

运算步骤:

  step1:先将a的值+1

  step2:再将a的值赋值给  ++a 这个整体

 */

int j = ++i;// 相当于将a++这个整体的值,赋值给int变量b

System.out.println("j = " + j);// 2

System.out.println("i = " + i);// 2

}

}

练习题:

// 1.
int i = 3;
i = i++;
System.out.prinltn(i = ” + i);//3
// 2.
int i = 3;
i = ++i;
System.out.println(i = ” + i);//4
// 3.
int i = 3;
int a = i++ + i++ + i++;
int b = ++i + ++i + ++i;
System.out.println(i = ” + i);  9
System.out.println(a = ” + a);  12
System.out.println(b = ” + b);  24


int i = 5;
i++;
System.out.println(i = ” + i);//6
++i;
System.out.println(i = ” + i);//7
int a = ++i;
System.out.println(a = ”+ a);//8
a = a++;
System.out.println(a = ” + a);//8
a = ++a;
System.out.println(a = ” + a);//9
// 5.
int m = 3;
int n = 2 * ++m;
System.out.println(n = ”+ n);//8

public class _07AddAdd {

public static void main(String[] args) {

// 声明一个int类型变量a,赋值1

int a = 1;

int b = 2;

// a++: 先赋值再自增 ++a:先自增再赋值

int c = a++ + ++a + b--;

int d = c++ + c-- + a++ + ++b;

// a = ? b = ? c = ? d = ?

System.out.println("a = " + a);// a = 4

System.out.println("b = " + b);// b = 2

System.out.println("c = " + c);// c = 6

System.out.println("d = " + d);// d = 18

}

}

4.3 赋值运算【掌握】

赋值运算(Assignment Operation):是优先级最低的一种运算,等 = 后边的所有运算完毕后,才执行赋值运算。

赋值运算符的符号:

+= 累加

-= 累减

*=

/=

%=

=

以下了解即可

^=

&=

|=

..

语法:变量1 += 值/变量2;

赋值运算注意事项:

1. 从右到左,把符号右边的值赋值到左边的变量中

2. 上面符号看成是一个整体: 例如 += 看成是一个符号,不要看成两个。

3. 赋值运算有强制转换功能,可以避免类型提升.会有溢出风险

示例:
int i= 3;
i += 2;// 表示把2 累加到变量 i 中
i -= 1;
i *= 3;
i /= 3;
i %= 3;
// 特例
short s = 3;
s += 2;// 存在隐式转换
short s = 3;
s = s + 2;// 报错,因为结果值是int,int不能自动转换为short

public class _08AssignmentOperation {

public static void main(String[] args) {

// 声明一个int类型变量a赋值1

int a = 1;

a += 5;// 表示将变量a的值累加上5,相当于a = (int)(a + 5);

System.out.println(a);// 6

byte b = 127;

b += 1;// b += 1相当于 : b = (byte)(b + 1);

System.out.println(b);// -128

// b = b + 1;// 报错, b + 1表达式结果是int类型

a += 1 + 3 + 5;// 会先计算 += 右边所有的运算,再执行 += 赋值运算

System.out.println(a);

}

}

4.4 比较运算【掌握】

比较运算(Compare Operation):结果一定是boolean类型

>

<

>=

<=

==: 双等于或者恒等于

1. 比较基本类型,比较的是值是否相等

例如:

int a = 1;

int b = 1;

System.out.println(a == b); //true

2. 比较引用类型,比较的是地址是否相等

!=: 不等于

1. 比较基本类型,比较的是值是否不相等

2. 比较引用类型,比较的是地址是否不相等

instanceof:只能比较引用类型,一般配合条件语句使用(面向对象重点讲,今天不管)

表示判断一个变量或者值是否属于某一个引用数据类型

语法: 值/变量 instanceof 引用数据类型

例如:

1.System.out.println("约" instanceof String);

2.String str = "不约";

System.out.println(str instanceof String);

public class _09CompareOperation {

public static void main(String[] args) {

// 声明2个int类型变量,随便赋值

int a = 1;

int b = 2;

// == 比较这两个变量的值是否相等

System.out.println(a == b);// false

// != 比较这两个变量的值是否  不相等

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

// 声明一个String变量str

String str = "某菲";

// 使用 instanceof

System.out.println(str instanceof String);//  true ,判断String变量str是否属于String类型

System.out.println("某飞扬" instanceof String);// true ,判断String变量str是否属于String类型

}

}

4.5 三目运算【掌握】

三目(三元)运算(Binocular Operation)

语法: x ? y : z;// 表示如果x为true,执行y,x为false则执行z。

x: 是boolean类型值或者boolean表达式。

y、z: 可以是表达式,也可以是值或者变量。

y和z可以是不同的数据类型,但是如果要接收三目运算的结果,必须要求y和z的类型完全一致

三目运算可以嵌套使用

示例:

// 1.找出两个整型变量中的最大值
int a = 6, b = 9;
int c = a > b ? a : b;
System.out.println(c);
//2.判断一个数是 奇数 还是 偶数
int j = 11;
String result = j % 2 == 0 ? "偶数" : "奇数";
System.out.println(result);

代码案例

public class _10BinocularOperation {

public static void main(String[] args) {

String result = 2 > 3 ? "我请你们馒头" : "你们请我吃帝王蟹!";

System.out.println(result);

// 需求:求两个int变量中的最大值或者最小值

int a = 3;

int b = 5; 

/*

 *  用三目运算求最大值

 *  语法: x ? y : z;

x: 是boolean类型值或者boolean表达式。

y、z: 可以是表达式,也可以是值或者变量。y和z可以是不同的数据类型

 */

int max = a > b ? a : b;

System.out.println(max);

// 求三个int类型变量的最小值    三目嵌套使用:(看不懂就用单层的)

int i = 1;

int j = 2;

int k = 3;

/*

 * 先求出i和j的最小值min

 * 再求min和第三个变量k的最小值,将结果重新赋值给变量min 

*/

int min = i < j ? i : j;

min = min < k ? min : k;// 求min和第三个变量k的最小值,将结果重新赋值给变量min 

System.out.println(min);

// 三目嵌套使用:(看不懂就用单层的)

int min2 = i < j ? (i < k ? i : k) : (j < k ? j : k);

System.out.println(min2);

}

}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值