变量、运算符和分支

最新推荐文章于 2024-07-30 20:50:32 发布

LiZongShao

最新推荐文章于 2024-07-30 20:50:32 发布

阅读量43

点赞数

文章标签： java c++ jvm

本文链接：https://blog.csdn.net/LiZongShao/article/details/129467688

版权

1.变量

定义：在程序运行的过程中，可以改变的量的叫变量

语法格式: 数据类型变量的名字 = 初始化的值;

①数据类型: 对变量进行约束的

②变量的名字: 自己起的一个名字

③=: 赋值号

④初始化的值: 就是存储的一个数据

public class Demo1 {
	//写一个程序的入门  main主函数
	public static void main(String[] args) {
		//声明一个变量
		// 数据类型  变量名字 = 初始的值;
		int  a = 10;//将10 赋值给a
		//a  用来存储数据的   是10
		System.out.println(a);
		System.out.println("a");
		System.out.println(a + 20);//30
		//变量是一个可以变化的量
		a = 250;
		System.out.println(a);//250
		
		
		//声明变量的另外的一种方式
		int c,d;//先声明两个   c   d  变量名字
		
		c = 89;
		d = 98;
		
		System.out.println(c);
		System.out.println(d);
		
	}
}

2.Java中的数据类型

在Java中有两种数据类型：基本数据类型和引用数据类型

在Java中有8种基本数据类型：

整型（整数）： 4种 byte short int long

浮点型（小数）: 2种 float double

字符型 : 1种 char

布尔型(真假): 1种 boolean

2.1整数类型的数据

整数类型	数据范围	占用的内存字节数
byte	-128~127	1字节
short	-32768~32767	2字节
int	-2^31~2^31-1	4字节
long	-2^63~2^63-1	8字节

总结：开发中比例是 int 其次是long 再次是byte

public class Demo2 {

	public static void main(String[] args) {
		//声明一个byte类型的变量
		//数据类型  变量的名字 = 初始化的值;
		//byte 的数据范围  -128~127  如果超过范围是报错的
		byte a = 12;
		//byte a1 = 128;  报错了  因为超过了范围了
		System.out.println(a);//12
		
		
		//声明一个short类型的数据
		short s1 = 45;
		System.out.println(s1);//45
		//因为short 范围  -32768~32767   超过了这个范围就报错
		//short s2 = 32768;
		
		//声明一个int类型的数据
		int  i1 = 789637393;
		int age = 23;
		System.out.println(i1);
		
		
		//声明一个long类型的数据
		
		long  long1 = 27828L;
		long long2 = 789637393L;
		//注意  声明long类型的额数据的时候 加  L或者l 但是为啥 不写l  像1
		long long3 = 7896373939L;
		//注意： 如果值超过了int类型的范围必须加L 或者l   
		//如果没有超过int类型的范围  可以不加L或者l
		
		//总结：  开发中比例是 int  其次 是long   再次是byte
		
		
		
		
		
	}
}

2.2浮点类型的数据

浮点型	数据的范围	占用的字节数
float	-3.410^38 ~ 3.4 10^38	4字节
double	-1.7910^308 ~ 1.79 10 ^308	8字节

public class Demo3 {
	public static void main(String[] args) {
		//声明一个float类型的数据
		//注意: 声明float类型的时候 加 f或者F
		float f1 = 3.4f;
		System.out.println(f1);
		
		//Java中默认的浮点类型的数据就是double
		double d1 = 3.4;
		System.out.println(d1);
		
		//扩展一个知识点
		//精度数，有效的位数
		float f2 = 1.23456789f;
		System.out.println(f2);//1.2345679
		float f3 = 1.2345678911111111f;
		System.out.println(f3);//1.2345679
		float f4 = 123.123456789123f;
		System.out.println(f4);
		//float演示的有效的位数是7  但是多出来的是不准确的
		double d2 = 1.23456789123456789;
		System.out.println(d2);//1.234567891234568
		double d3 = 123.123456789123456789;
		System.out.println(d3);
		//double 有效的位数是  16位  其他多出来的都是不准确了
		//这个有效位数不用记 了解层次
		
		
		
		
		
		
		
	}
}

2.3字符类型的数据

字符	数据范围	占用的字节数
char	除了\ 其他都可以	2字节

public class Demo4 {
	public static void main(String[] args) {
		//注意事项:  char类型的数据必须使用  ''  单引号 引住  而且引号中只能放一个元素
		char c1 = 'a';//英文的字符
		char c2 = '国';//中文的字符
		char c3 = '4';//数字字符
		char c4 = '&';//特殊的符号
		//char c5 = '\';  除了  \  不行其他都是
		//char c5 = ''';  英文的单引号也不行
		char c5 = '’';
		
		
	}
}

2.4布尔类型的数据

布尔	数据范围	占用的字节数
boolean	true或false	1字节

public class Demo5 {
	public static void main(String[] args) {
		//boolean  声明的变量的值只能true 或者 false
		
		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b1);
		System.out.println(b2);
	}
}

2.5关于类和变量的命名规则

2.5.1.类的名字的命名

①首字母要大写

②采用大驼峰的命名规则，当一个类由两个英文单词组成的时候，每个英文单词首字母要大写的。比如一个类的名字叫hello 和world组成的那么这个类名字可以命名成为 HelloWorld

③类的名字可以由字母，数字，下划线等组成的，但是不能以数字开头

2.5.2变量的名字名字的命名

①首字母不能大写

②变量的名字的命名可以由数字，字母，下划线，$ 等组成的但是不能以数字开头

③变量的名字要见名知意

④变量的命名采用小驼峰的命名规则或者两个单词中间可以使用_连接

⑤已经被Java使用的关键字是不能作为变量的名字的

3.运算符

①算术运算符；②关系运算符；③逻辑运算符

3.1算术运算符

数学中的 + （加） - （减） *（乘） / (除) % （取余）

public class Demo8 {
	public static void main(String[] args) {
		int num1 = 20;
		int num2 = 10;
		//System.out.println(num1 + num2);//30
		//一定要有一个思想:  =右边赋值给左边
		//1.num1 + num2 为30
		//2.num1 = 30
		num1 = num1 + num2;
		System.out.println(num1);//30
		System.out.println(num2);//10
		//变量是变化着的量
		
		
		int a = 5;
		int b = 2;
		//System.out.println(a / b);//a除以b
		int c = a / b;//除法的结果是整数
		System.out.println(c);
		
		//取余
		System.out.println(a % b);//1
		
		//在java中 先乘除后加减  如果有小括号先算小括号里面的
		int d = 3 - 4 * 6;
		System.out.println(d);//-21
		int f = (8 - 2) / 4;
		System.out.println(f);//1
		
	}
}

自增和自减：可以让一个变量自身增加1或者减去1

语法格式：

变量++; 先执行当前的操作，然后自身在增加1
a++;
++变量;先自身加1，然后再执行其他的操作
++a;

变量--; 先执行当前的操作，然后执行自身减1
a--;
--变量; 先自身减1，然后再执行其他的操作
--a;

public class Demo1 {
	public static void main(String[] args) {
		//关于自增和自减的代码
		int num1 = 10;
		//num1++   ++在变量的后面，先执行当前的操作（输出语句），然后再自身加1
		System.out.println(num1++);//10
		System.out.println(num1);//11
		
		int num2 = 5;
		//++num2   ++在变量的前面，先自身增加1 然后再执行接下来的操作
		System.out.println(++num2);//6
		System.out.println(num2);//6
		
		int num3 = 4;
		System.out.println(num3--);//4
		System.out.println(num3);//3
		
		
		int num4 = 3;
		int ret = num4++ * num4;
		System.out.println(ret);//12
		System.out.println(num4);//4
		
		int num5 = 3;
		int ret1 = num5 * num5++;
		System.out.println(ret1);//9
		
		int num6 = 2;
		int ret2 = ++num6 * num6;
		System.out.println(ret2);//9
		
		int num7 = 2;
		int ret3 = num7 * ++num7;
		System.out.println(ret3);//6
		//总结：  真实不会有这么麻烦  就是一个简单的自身增加1或者自身减1效果而已
		
		
	}
}

3.2关系运算符

> (大于) <(小于) >=(大于等于) <= (小于等于) ==(是否等于) !=(是否不等于)
变量1 > 变量2 例如: a > b
常量1 > 常量2 例如: 2 > 3
他们结果是个啥？是布尔类型的数据 true or false

public class Demo2 {
	public static void main(String[] args) {
		
		//将 3 > 4的结果赋值给   ret1 变量
		boolean ret1 = 3 > 4;
		System.out.println(ret1);//false
		
		int a = 3;
		int b = 4;
		System.out.println(a < b);//true
		
		
		System.out.println(a++ >= b);//false
		System.out.println(a >= b);//true
		
		
		int c = 8;
		int d = 7;
		System.out.println(--c <= d);//true
		
		
		System.out.println(c++ == d);//true
		
		
		System.out.println(1 != 1);//fasle
		
	}
}

3.3逻辑运算符

语法格式：

        表达式1 && 表达式2 && ...
        关系运算符的表达式 && 关系运算符的表达式
        3 > 4 && 5 < 6

表达式都为true的时候，整体的结果就为true。只要有一个为false，整体就为false

public class Demo3 {
	public static void main(String[] args) {
		//逻辑运算符：由关系运算符的表达式和&&  组成的
		//ret = true && true  整体就为true
		boolean ret = (4 > 1) && (7 < 8);
		System.out.println(ret);//true
		//ret1 = true  && false && true   只有有一个为false 中整体的结果就为false
		boolean ret1 = 1 < 3 && 2 > 4 && 7 > 1;
		System.out.println(ret1);
		int a = 20;
		int b = 30;
		int c = 10;
		int d = 80;
		//ret2 = false && false    整体为false
		boolean ret2 = (a > b) && (c > d);
		System.out.println(ret2);//false
		
		
		
		
		
		
	}
}

或：||

语法格式：

关系运算符表达式1 || 关系运算符表达式2 || ...

表达式都为false的时候整体结果就为false。如果有一个为true，整体就为true。

public class Demo4 {
	public static void main(String[] args) {
		//逻辑或
		//ret = false || true
		boolean ret = 2 > 3 || 6 > 1;
		System.out.println(ret);//true
		boolean ret1 = 1 > 3 || 3 > 7 || 8 > 9 || 10 > 8;
		System.out.println(ret1);//true
		
	}
}

非：!

语法格式：

!关系运算符

如果关系运算符为true，整体结果就为false。反之就为true

public class Demo5 {
	public static void main(String[] args) {
		
		boolean ret = !(3 > 4);
		System.out.println(ret);//true
		
		
		//ret1 = true && false
		// false || true 
		boolean ret1 = (3 > 2) && (4 > 5) || (5 > 3);
		System.out.println(ret1);//true
		//false || false 
		//从这个地方可以说下  与优先级高于或的优先级
		boolean ret2 = !(((8 > 7) || (7 > 9)) && (8 < 4) || (6 > 7) && (6 > 7));
		System.out.println(ret2);
		
	}
}

3.4逻辑运算符的短路原则

逻辑与的短路原则:

表达式1 && 表达式2 &&...

如果表达式1 为false 的话，整体就为false了，表达式2 和以后的表达式就不再执行了

为啥？逻辑与只要有一个为false，整体就为false了。表达式1位f已经为false了。已经决定了

整体的结果了。Jav为了执行的效率的问题，所以短路了

逻辑或的短路原则:

表达式1 || 表达式2 || ...

如果出现表达式为true的，整体就为true，从为true的表达式开始后面的表达式就不再执行了

public class Demo6 {
	public static void main(String[] args) {
		
		//逻辑与的短路原则：  一旦碰到表达式为false  后面的表达式不再执行
		int num1 = 10;
		boolean ret = (3 < 1) && (++num1 > 8);
		System.out.println(ret);//false
		System.out.println(num1);//10
		
		
		
		int a = 11;
		//false || false ||  true
		boolean ret1 = (3 < 1 ) ||(a++ > 12) || (a++ >=11);
		System.out.println(ret1);//true
		System.out.println(a);//13
	}
}

4.分支【重要】

4.1if 分支

语法格式：

        if (布尔表达式) {
            语句体
        }

执行流程: 如果布尔表达式为true，就执行大括号里面的语句体。如果布尔表达式为false，就跳过大括号里面的语句体，接着往下执行。

public class Demo7 {
	public static void main(String[] args) {
		if (false) {
			System.out.println("嘻嘻 执行了");
		}
		System.out.println("呵呵，来啊");
	}
}

public class Demo8 {
	public static void main(String[] args) {
		
		//如果成绩大于80分，输出奖励一个宝剑
		int score = 50;
		if (score > 80) {
			System.out.println("奖励一个宝剑");
		}
		System.out.println("嘻嘻 结束了");
	}
}

4.2if-else 分支

语法格式：

        if (布尔表达式) {
            语句体1
        } else {
            语句体2
        }

执行流程：如果布尔表达式为true 执行语句体1 ，如果布尔表达式为false 执行语句体2

public class Demo11 {
	public static void main(String[] args) {
		//口袋里面有39块钱, 如果你口袋里面的钱  超过了38  就可以吃大盘鸡小份
		//如果没有超过38  就可以大盘鸡拌面
		int money = 31;
		//分析完以后 选择  if-else
		if (money > 38) {
			System.out.println("可以吃大盘鸡小份");
		} else {
			System.out.println("可以大盘鸡拌面");
		}
		
		System.out.println("嘻嘻嘻 都是要吃饭的");
	}
}

4.3if-else if 分支

语法格式：

        if (布尔表达式1) {
            语句体1
        } else if (布尔表达式2) {
            语句体2
        } else if (布尔表达式n) {
           语句体n
        } else {
            语句体n+1
        }

执行流程：

如果碰到if语句后面的小括号中的表达式为true的时候，就执行相对应的大括号后面的语句体

其他语句体一概不执行

public class Demo13 {
	public static void main(String[] args) {
		
		/**
		 * 学生成绩的等级问题:
		 * 		90~100  打印优秀
		 * 		80~89  打印良好
		 * 		70~79  打印一般
		 * 		60~69 打印及格
		 * 		60分以下  叫家长
		 * 		结果是多个分支   用if-esle if
		 */
		int score = 31;
		
		
		if (score <= 100 && score >= 90) {
			System.out.println("优秀");
			
		} else if (score >= 80) {//代码能够执行到 这一步
			System.out.println("良好");
		} else if ( score >= 70) {
			System.out.println("一般");
		} else if (score >= 60) {
			System.out.println("及格");
		} else {
			System.out.println("叫家长");
		}
	}
}

4.4if嵌套的写法【了解】

一个if语句中再写另外一个if语句

public class Demo14 {

	public static void main(String[] args){
		//嵌套写法
		//年龄满18岁，体重达标   才能献血
		int age = 19;
		int weight = 80;
//		if (age >= 18 && weight >= 50) {
//			System.out.println("去献血");
//		}
		if (age >= 18) {
			//age >= 18 如果年龄达标  再判断体重
			if (weight >= 50) {
				System.out.println("可以去献血");
			} else {
				System.out.println("年龄达标，但是体重不达标");
			}
			
		} else {
			//age < 18
			System.out.println("未成年不能献血");
			
		}
	}
}

2.5switch-case 分支

也是一种选择，类似与 if-else if 分支

多种选择

语法格式：

swicth (表达式) {
	case 常量1:
		语句体1;
		break;
	case 常量2:
		语句体2;
		break;
	case 常量3:
		语句体3;
		break;
	...
	default:
		语句体n;
		break;
}

执行流程： switch后面小括号中的表达式值去和 case后面的常量进行匹配。如果他们两个一样的话，就执行当前的语句体，其他语句体不执行。

public class Demo15 {
	public static void main(String[] args) {
		
		//使用switch-case 写
		/**
		 * 按1 给妈妈打电话
		 * 按2 给爸爸打电话
		 * 按3 给奶奶打电话
		 * 按4给爷爷打电话
		 * 按其他键 个110
		 */
		int num = 1;
		switch (num) {
			case 1:
				System.out.println("给妈妈打电话");
				break;//终止  打断
			case 2:
				System.out.println("给爸爸打电话");
				break;
			case 3:
				System.out.println("给奶奶打电话");
				break;
			case 4:
				System.out.println("给爷爷打电话");
				break;
			default:
				System.out.println("110");
				break;
		}
		
		
		System.out.println("================");
		//使用if - else if形式来写
		if (num == 1) {
			System.out.println("给妈妈打电话");
		} else if (num == 2) {
			System.out.println("给爸爸打电话");
		} else if (num == 3) {
			System.out.println("给奶奶打电话");
		} else {
			System.out.println("110");
		}
		
		//总结：  if-else if  和switch-case 的功能可以相互转  可以实现相等的功能
		//但是表示式不一样
	}
}

LiZongShao

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
变量、运算符和分支

定义：在程序运行的过程中，可以改变的量的叫变量语法格式: 数据类型变量的名字 = 初始化的值;①数据类型: 对变量进行约束的②变量的名字: 自己起的一个名字③=: 赋值号④初始化的值: 就是存储的一个数据。
复制链接

扫一扫