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

Java语言基础

字面量和常量
常量：程序中固定不变化的值。
常量分类:
字面值常量: 比如：整数常量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
		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 秒) - 正常终止

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