Java语言基础{Java_se(02)}-字面量和常量-变量的基本定义和使用-Java表达式-数据类型和分类-基本数据类型的转换-算数运算符-赋值运算符-比较运算符-三元运算符-逻辑运算符

Java语言基础{Java_se(02)}

字面量和常量

常量：程序中固定不变化的值。

常量分类:

字面值常量: 比如：整数常量1，2，3，小数常量3.14，布尔常量false，true等.

字面量,就表示直接给出的一个值(可以是整数,小数,true,false等等).

变量的基本定义和使用

(1)在程序的执行过程中，其值在某个范围内可以发生改变的量

(2)变量的定义格式：

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

b:数据类型 变量名;

c:变量名 = 初始化值;

(3)变量的特点:

a:占据着内存中的某一块存储区域；

b:该区域有自己的名称（变量名）和类型（数据类型）；

c:可以被重复使用;

d:该区域的数据可以在同一类型范围内不断变化；

(4)局部变量:

a:先声明,再初始化,最后使用.

b:可以重复使用.

(5)变量的使用规则

a:变量必须先声明，并且初始化后才能使用；

b:声明变量必须有数据类型

c:同一作用域内变量名不能重复定义

我们写一段代码来看看变量的使用:

public class  StepInVarDemo
{
public static void main(String[] args)
{
int x = 6;
int y = 3;
//求加减乘除
System.out.println(x + y);
System.out.println(x - y);
System.out.println(x * y);
System.out.println(x / y);

//把操作数改成2和5
4000
x = 2;
y = 5;
System.out.println(x + y);
System.out.println(x - y);
System.out.println(x * y);
System.out.println(x / y);

}
}

输出结果为:

---------- 运行 ----------
9
3
18
2
7
-3
10
0

输出完成 (耗时 0 秒) - 正常终止

变量例子2:

//变量的操作
public class Demo
{
public static void main(String[] args)
{

int age;//定义了一个int类型的变量,变量名为age

age = 17;//表示把17这个常量值,付给age变量,
System.out.println(age);//打印变量,其实打印的是该变量当前所赋予的值

age = 18;//把18这个常量,赋值给age变量
System.out.println(age);//18

}
}

输出结果为:

---------- 运行 ----------
17
18

输出完成 (耗时 0 秒) - 正常终止

Java表达式

表达式(expression):是由数字、运算符、数字分组符号（括号）、常量、变量等以能求得结果的有意义排列的组合。

用运算符号连接的变量/常量可称为表达式。那么也就是说表达式是由常量、变量、运算符、括号组成能求得值的有意义结果的语句。

如：

a + b;
3 + a;
(x + y) * z + 100;

我们写一个表达式:

//表达式
public class ExpressionDemo  //1.创建一个类
{
public static void main(String[] args)   //2.编写一个main方法
{
System.out.println(6 + 5 + 4);
System.out.println("---------------------");
int result = 1 + 2 + 3;  //定义一个result的变量
System.out.println(result);
System.out.println("---------------------");
int a = 12;
int b  = 3;
int c  = 5;
result = (a + b) / c + 10;
System.out.println(result);//打印输出变量的值
}
}

输出结果为:

---------- 运行 ----------
15
---------------------
6
---------------------
13

输出完成 (耗时 0 秒) - 正常终止

数据类型和分类

整数类型(byte-short-int-long):

byte、short、int、long类型：

整型常量的四种表示形式：

a:二进制整数：0B或0b开头（Java7的新特性），如：int a = 0B110;

b:八进制整数：要求以0开头，如 int a = 012;

c:十进制整数：如：int a = 17;

d:十六进制整数：要求0X或0x开头，如int a = 0x12;

小数类型(float-double):

float、double类型：

表示小数类型又称为浮点类型，其中float表示单精度类型，double表示双精度类型，但是二者都不能表示精确的小数。

例子:

class Demo
{
public static void main(String[] args)
{
//小数常量(默认是double类型的)
System.out.println(3.14);//double类型的常量
System.out.println(3.14F);//float类型的常量
System.out.println(3.14E2);//314.0
//小数变量
//小数类型 变量名 = 小数常量;
double pi = 3.14;

float pi2 = 3.14F;

double a  = 1.000000000000000001;
double b  = 1.0000000001234;
System.out.println(a + b);//2.0000000001234

}
}

输出结果为:

---------- 运行 ----------
3.14
3.14
314.0
2.0000000001234

输出完成 (耗时 0 秒) - 正常终止

字符类型(char):字符,字母和符号.

char类型：表示16位的无符号整数或者Unicode字符，Java对字符采用Unicode字符编码。

例子:

class CharDemo
{
public static void main(String[] args)
{
//字符
char c1 = 'A';//直接表示符号
System.out.println(c1);
char c2 = 65;//表示符号对应的10进制顺序
System.out.println(c2);
char c3 = '\u0041';//使用16进制的顺序
System.out.println(c3);

char data = '好';
System.out.println(data);
}
}

输出结果为:

---------- 运行 ----------
A
A
A
好

输出完成 (耗时 0 秒) - 正常终止

boolean类型：通常用于逻辑运算和程序流程控制(条件选择/循环)。

该类型的值只能是true 或 false，表示真或假。

例子:

/*
需求：
创建一个boolean类型 赋值为true
然后把值修改为flase
*/
class BooleanDemo
{
//boolean数据类型  常量:true/false
public static void main(String[] args)
{
//boolean类型的变量
//数据类型  变量名 = 该类型的常量值;
boolean isMan = true;
System.out.println(isMan);
//给isMan变量重新赋值
isMan = false;
System.out.println(isMan);

}
}

输出:

---------- 运行 ----------
true
false

输出完成 (耗时 0 秒) - 正常终止

基本数据类型的转换

在8大基本数据类型中,boolean不属于数值类型,不参与转换.

(1)默认转换

A:从小到大

B:byte,short,char – int – long – float – double

C:byte,short,char之间不相互转换，直接转成int类型参与运算。

public class HomeWork3 {

例子:

public static void main(String[] args) {
double rent = 800;
double mealCost = 900;
double clothingCosts = 300;
double  other = 300;
double sum = (rent + mealCost + clothingCosts + other)*5;
int i = (int)sum;
System.out.println(i);
}

}

输出结果:

---------- 运行 ----------
11500

输出完成 (耗时 0 秒) - 正常终止

(2)强制转换

A:从大到小

B:可能会有精度的损失，一般不建议这样使用。

C:格式：

目标数据类型 变量名 = (目标数据类型) (被转换的数据);

例子:

public class TypeConvertDemo
{
public static void main(String[] args)
{
long l = (long)3.14;
System.out.println(l); //输出3 精度丢失
int i = (int)123l;
System.out.println(i); //输出123不丢失精度

}
}

输出结果:

---------- 运行 ----------
3
123

输出完成 (耗时 0 秒) - 正常终止

算数运算符

加减乘除例子:

class OperatorDemo {
public static void main(String[] args) {
//定义变量
int x = 3;  //把3赋值给int类型的变量x
int y = 4;

System.out.println(x+y);
System.out.println(x-y);
System.out.println(x*y);
System.out.println(x/y); //整数相除只能得到整数
System.out.println(x%y); //得到的是余数
}
}

输出结果:

---------- 运行 ----------
7
-1
12
0
0.75
3

输出完成 (耗时 0 秒) - 正常终止

自增,自减,前置和后置:

++和–详解: 都只能操作变量,不能操作常量.

++: 表示当前操作变量自己累加1.表示当前操作变量自己减去1.

自增：++，递增操作符，使变量值增加1，有前置和后置之分，只能操作变量。

自减： – ，递减操作符，使变量值减去1，有前置和后置之分，只能操作变量。

自增和自减具体操作是一样的，仅仅是一个是加1，一个是减1而已，现在单讲++：

代码 result ++和 ++result，都将使result变量的值加1。

唯一的区别是：

前置（++result）: 表示对result加1之后的结果进行运算，

后置（result++）: 表示对result变量加1之前的值（原始值）进行运算。

如果仅仅执行简单的递增操作（只写result++或++result），那么选用任意一个都可以。

例子:

class Demo2
{
public static void main(String[] args)
{
int a1 = 2;  //定义一个变量
int b1 = ++a1;
System.out.println(b1); //输出3
int a2 = 2;
int b2 = a2++;
System.out.println(b2);  //输出为2说明是先输出再加

}
}

输出结果:

---------- 运行 ----------
3
2

输出完成 (耗时 0 秒) - 正常终止

赋值运算符

A:=,+=,-=,*=,/=,%=等

B:=叫做赋值运算符，也是最基本的赋值运算符

int x = 10; 把10赋值给int类型的变量x。

C:扩展的赋值运算符的特点

隐含了自动强制转换。

class Demo
{
public static void main(String[] args)
{
//功能就是,给变量赋值.
String name;
name = "YSE";//赋值
System.out.println(name);

int age = 17; //1:声明int类型变量age;
System.out.println("----------------------------");

int a = 10; //变量
a += 5; //赋值
System.out.println(a);//打印15

short s = 30;
s = (short)(s + 5);
//s += 5;
System.out.println(s);
}
}

输出结果为:

---------- 运行 ----------
YSE
----------------------------
15
35

输出完成 (耗时 0 秒) - 正常终止

比较运算符

用于比较两个变量或常量之间的关系，比较运算符的结果是boolean类型,其操作格式为:

boolean result = 表达式A 比较运算符 表达式B;

例子:

class Demo
{
public static void main(String[] args)
{
//=:表示赋值,==表示比较是否相等
boolean b1 = 4 == 4;
System.out.println(b1);//true
System.out.println(4 != 4);//false
System.out.println(3 != 4);//true
System.out.println(100 > 5);//true
System.out.println(5 < 100);//true
System.out.println(100 > 100);//false
System.out.println(100 >= 100);//true
System.out.println(100 <= 100);//true
}
}

输出结果为:

---------- 运行 ----------
true
false
true
true
true
false
true
true

输出完成 (耗时 0 秒) - 正常终止

三元运算符

三元运算符，表示有三个元素参与的表达式，所以又称为三目运算符，其语义表示if-else.

语法格式：X ? Y ：Z， 其

中x为boolean类型表达式，先计算X的值，若X结果为true则整个三目运算表达式的结果是Y，否则就是Z。三目运算符结果的类型由Y和Z决定。

A:格式
比较表达式?表达式1:表达式2;
B:执行流程：
首先计算比较表达式的值，看是true还是false。
如果是true，表达式1就是结果。
如果是false，表达式2就是结果。
C:例子：
a:比较两个数据是否相等
b:获取两个数据中的最大值
c:获取三个数据中的最大值

例子:比如我们定义一个 int 变量(unfinishedCount)存放当前你作业未完成次数，定义一个 String 变量(result)存放三元元算法返回的结果，达到 3 次或以上就存放“开除”，否则存放“还在”。

public class HomeWork {
public static void main(String[] args) {
int unfinishedCount = 10;
String result = unfinishedCount >=3 ? "开除" : "不开除";
System.out.println(result);
}
}

输出结果为:

开除

逻辑运算符

A:&,|,^,!,&&,||

B:逻辑运算符用于连接boolean类型的式子

C:结论

&:有false则false

|:有true则true

^:相同则false，不同则true。

情侣关系。

!:非true则false，非false则true

&&:结果和&是一样的，只不过有短路效果。左边是false，右边不执行。

重点:

&：表示并且，当操作数A和B都为true结果才为true，否则结果result 是false。

|：表示或者，A和B都为false结果result为false，只要有A或B是true，结果就是true。

||：和|结果相同，具有短路效果，如果左边操作数A是true，result一定为true，且不运行B的运算。

例子:

class LogicanDemo
{
public static void main(String[] ages)
{
System.out.println(true & false);//false
System.out.println(true & true);//true
System.out.println(true & false);//false
System.out.println(false & false);//false
System.out.println("--------------");
System.out.println(true && false);//false
System.out.println(true && true);//true
System.out.println(true && false);//false
System.out.println(false && false);//false

}
}

---------- 运行 ----------
false
true
false
false
--------------
false
true
false
false

输出完成 (耗时 0 秒) - 正常终止

class LogicanDemo2
{
public static void main(String[] ages)
{
System.out.println(true | false);//true
System.out.println(true | true);//true
System.out.println(false | true);//true
System.out.println(false | false);//false
System.out.println("--------------------");

System.out.println(true || false);//true
System.out.println(true || true);//true
System.out.println(false || true);//true
System.out.println(false || false);//false

}
}

---------- 运行 ----------
true
true
true
false
--------------------
true
true
true
false

输出完成 (耗时 0 秒) - 正常终止

这个例子很好的说明了逻辑运算符的原理;一般我们都用短路类,效率比较高!