java 类型转换和点号运算符的执行顺序_JavaSE（二）之变量与常量、运算符、类型转换...

一、常量

1.1、什么是常量

在程序执行的过程中其值不可以发生改变

1.2、常量的分类

字面值常量

字符串常量 用双引号括起来的内容

整数常量所有整数

小数常量所有小数

字符常量用单引号括起来的内容,里面只能放单个数字,单个字母或单个符号

布尔常量较为特殊，只有true和false

空常量 null(数组部分讲解)

自定义常量(面向对象部分讲)

二、变量

1.1、变量的介绍

程序的基本功能是处理数据

程序用变量来接收并表示数据；

程序中必须先定义变量才能使用；

定义变量是指设定变量的数据类型和变量的名字，Java语言要求变量遵循先定义，再初始化，然后使用的规则。

变量的使用有一个作用域的问题，作用域是指它的存在范围，只有在这个范围内，程序代码才能访问它。

其次，作用域决定了变量的生命周期。变量的生命周期是指从一个变量被创建并分配内存空间开始，到这个变

量被销毁并清除其所占用内存空间的过程。当一个变量被定义时，它的作用域就被确定了。按照作用域的不同，

变量可分为以下类型：

成员变量：在类中声明，它的作用域是整个类；

成员变量又叫做属性/实例变量

局部变量：在一个方法的内部或方法的一个代码块的内部声明。如果在一个方法内部声明，它的作用域是整个方法；如果在一个方法的某个代码块的内部声明，它的作用域是这个代码块。代码块是指位于一对大括号"{}"以内的代码。

方法参数：方法或者构造方法的参数，它的作用域是整个方法或者构造方法。

异常处理参数：和方法参数很相似，差别在于前者是传递参数给异常处理代码块，而后者是传递参数给方法或者构造方法。异常处理参数是指catch(Exception e)语句中的异常参数"e"，它的作用域是紧跟着catch(Exception e)语句后的代码块。

1.2、局部变量与实例变量

1.2.1、局部变量

1) 定义在方法的内部或方法的一个代码块的内部；

public void method1() {

int a = 0; //局部变量，作用域meth为整个od01方法；

if(a==0){

int b = 0; //局部变量，作用域为所处的代码块；

b = a;

}

b = 20; //编译出错，b不能被访问

}

2) 局部变量没有默认值，使用之前必须先初始化；

3) 生命周期

从声明开始,到这个局部变量直接所在的代码块结束为止

public class Sample {

public int add() {

int addResult = 1;

addResult = addResult+2;

return addResult;

}

public static void main(String[] args) {

Sample s = new Sample();

s.add();

s.add();

}

}

1.2.2、实例变量

1) 在类中声明，它的作用域是整个类；

class Test {

private int n1=0;

private int n2=0;

public int add() {

int result = n2 + n2;

return result;

}

}

2) 实例变量有默认值，使用之前可无须初始化；

注意每种变量的默认值

基本类型中的:

整型变量默认值都为0

浮点型默认值都为0.0

char默认值‘\u0000‘

boolean默认值false

引用类型的默认值都为null

3) 生命周期

从类的一个对象被创建开始,到这个对象被销毁

class Test {

private int n1=0;

private int n2=0;

public int add() {

int result = n2 + n2;

n1 = n1+1;

n2 = n2+2;

return result;

}

public static void main(String[] args) {

Test t1 = new Test();

Test t2 = new Test();

t1.add();

t1.add();

t2.add();

}

}

三、操作符

一般情况下，不用去刻意记住操作符的优先级，当不能确定操作符的执行顺序时，可以使用圆括号来显示指定运算顺序。

3.1、 赋值操作符：

= : int x=0,i=1,j=1;

*= : a*=b 等价于 a=a*b

/= : a/=b 等价于 a=a/b;

%= : a%=b 等价于 a=a%b;

+=

-=

...

3.2、 比较操作符

> : 大于

>= : 大于等于

< : 小于

<= : 小于等于

以上操作符只适用于整数类型和浮点数类型；

int a=1,b=1;

double d=1.0;

boolean result1 = a>b; //result1的值为false;

boolean result2 = a

boolean result3 = a>=d; //result3的值为true;

boolean result4 = a<=b; //result4的值为true;

instanceof: 判断一个引用类型所引用的对象是否是一个类的实例。该操作符左边是一个引用类型，右边是一个类

名或接口名。形式如下：

obj instanceof ClassName

或者

obj instanceof InterfaceName

3.3、 相等操作符

== : 是否等于

!= : 是否不等于

既可以是基本类型，也可以是引用类型：

a. 基本类型：

int a=1,b=1;

float c=1.0f;

double d=1.0;

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

System.out.println(a==c); //输出true;

System.out.println(a==d); //输出true;

System.out.println(c==d); //输出true;

b. 引用类型：

这两个引用变量必须都引用同一个对象，结果才为true.

Student s1 = new Student("zs",25,100);

Student s2 = new Student("zs",25,100);

Student s3 = s1;

System.out.println(s1 == s2); //输出false;

System.out.println(s1 == s3); //输出true;

System.out.println(s2 == s3); //输出false;

3.4、 数学运算操作符

+ : 数据类型值相加或字符串连接;

a. 数据类型值相加；

int a=1+2; //a值为3;

double b=1+2; //b值为3.0;

double b=1+2.0; //c值为3.0;

b. 字符串连接；

System.out.println(1+2+"a"); //输出3a

System.out.println(1+2.0+"a"); //输出3.0a

System.out.println(1+2.0+"a"+true); //输出3.0atrue

System.out.println("a"+1+2); //输出a12

System.out.println(1+"a"+2); //输出1a2

/ : 整除, 如操作数均为整数，运算结果为商的整数部分

int a1=12/5; //a1变量的取值为2

int a2=13/5; //a2变量的取值为2

int a3=-12/5; //a3变量的取值为-2

int a4=-13/5; //a4变量的取值为-2

int a5=1/5; //a5变量的取值为0

double a6=12/5; //a6变量的取值为2.0

double a7=12/-5.0; //a7变量的取值为-2.4

% : 取模操作符, 如操作数均为整数，运算结果为商的整数部分

int a1=1%5; //a1变量的取值为1

int a2=13%5; //a2变量的取值为3

double a3=1%5; //a3变量的取值为1.0

double a4=12%5.1; //a4变量的取值为1.8000000000000007

3.5、 移位操作符

>> : 算术右移位运算，也称做带符号右移位运算。

int a1 = 12 >> 1; //a1变量的取值为6;

0000 1100 12

-----------

000 0110 >>1

-----------

0000 0110 补位 因为是正数所以补0 结果为6

int a2 = 128 >> 2; //a2变量的取值为32;

int a3 = 129 >> 2; //a3变量的取值为32;

int a5 = -12 >> 1; //a4变量的取值为-6;

0000 1100 12

---------

1111 0011 取反

---------

1111 0100 +1 这个就是-12的二进制形式

----------

111 1010 >>1

1111 1010 补位 因为是负数所以补1 这个负数就是最终结果

---------

1111 1001 -1

---------

0000 0110 取反 结果为6 所以上面的最终结果是 -6

int a6 = -12 >> 2; //a4变量的取值为-3;

0000 1100 12

---------

1111 0011 取反

---------

1111 0100 +1 这个就是-12的二进制形式

----------

11 1101 >>2

1111 1101 补位 因为是负数所以补1 这个负数就是最终结果

---------

1111 1100 -1

---------

0000 0011 取反 结果为3 所以上面的最终结果是 -3

注：a. 对12右移一位的过程为：舍弃二进制数的最后一位，在二进制数的开头增加一位符号位，由于12是正整数，因此增加的符号位为0;

b. 对-12右移俩位的过程为：舍弃二进制数的最后俩位，在二进制数的开头增加俩位符号位，由于-12是负整数,因此增加的符号位为1;

>>> : 逻辑右移位运算，也称为不带符号右移位运算。

int a1 = 12 >>> 1; //a1变量的取值为6;

int a2 = -12 >>> 2; //a2变量的取值为1073741821;

注：a. 对12右移一位的过程为：舍弃二进制数的最后一位，在二进制数的开头增加一个0;

b. 对-12右移二位的过程为：舍弃二进制数的最后二位，在二进制数的开头增加二个0;

<< : 左移位运算，也称为不带符号左移位运算。

int a1 = 12 << 1; //a1变量的取值为24;

int a2 = -12 << 2; //a2变量的取值为-48;

int a3 = 128 << 2; //a3变量的取值为512;

int a4 = 129 << 2; //a4变量的取值为516;

注：a. 对12左移一位的过程为：舍弃二进制数的开头一位，在二进制数的尾部增加一个0;

b. 对-12左移二位的过程为：舍弃二进制数的开头二位，在二进制数的尾部增加二个0;

3.6、位运算操作符

& : 与运算，对两个操作元的每个二进制位进行与运算，运算规则为：1&1->1, 1&0->0, 0&1->0, 0&0->0;

| : 或运算，对两个操作元的每个二进制位进行或运算，运算规则为：1|1->1, 1|0->1, 0|1->1, 0|0->0;

^ : 异或运算，对两个操作元的每个二进制位进行或运算，运算规则为：1^1->0, 0^0->0，1^0->1, 0^1->1,; 相同为0 不同位1 运算特点: a^0=a; a^a=0;

~ : 取反运算, ~1->0, ~0->1;

3.7、逻辑操作符

短路操作符，如果能根据操作左边的布尔表达式就能推算出整个表达式的布尔值，将不执行操作符右边

的布尔表达式；

&& : 左边的布尔表达式的值为false, 整个表达式值肯定为false, 此时会忽略执行右边的布尔表达式。

|| : 左边的布尔表达式的值为true, 整个表达式值肯定为true, 此时会忽略执行右边的布尔表达式。

3.8、 条件操作符

三目运算

布尔表达式 ? 表达式1 : 表达式2

如果布尔表达式的值为true, 就返回表达式1的值， 否则返回表达式2的值。

int score = 61;

String result = score>=60?"及格":"不及格";

四、类型转换

隐式转换:自动转换

基本类型:精度小可以自动转换为精度大的

byte b = 1;

int a = b;

引用类型:子类类类型可以自动转换为父类类型

Student s = new Student();

Object o = s;

显式转换:强制类型转换

基本类型:精度大的可以强制类型转换为精度小的,但是可能损失精度

int a = 1;

byte b = (byte)a;

引用类型:父类类型可以强制类型转换转换为子类类型，但是可能出现类型转换错误

Object类 是 Student类的父类

//这个是正确的

Object o = new Student();

Student s = (Student)o;

//这个会报错

Object o1 = new Object();

Student s1 = (Student) o1;

原文：http://www.cnblogs.com/cxyzyh2017/p/6973566.html