当前位置: 首页 > article >正文

java学习笔记2

 关键字与保留字

 标识符(Identifier)

Java中的名称命名规范

/*
标识符的使用
1.标识符:凡是自己可以起名字的地方都叫标识符。
   比如:类名、变量名、方法名、接口名、包名...

2.标识符的命名规则:--> 如果不遵守如下的规则,编译不通过!需要大家严格遵守

> 由26个英文字母大小写,0-9 ,_或 $ 组成  
> 数字不可以开头。
> 不可以使用关键字和保留字,但能包含关键字和保留字。
> Java中严格区分大小写,长度无限制。
> 标识符不能包含空格。

3. Java中的名称命名规范: --->如果不遵守如下的规范,编译可以通过!建议大家遵守

包名:多单词组成时所有字母都小写:xxxyyyzzz
类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz
变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz
常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ

4.
注意1:在起名字时,为了提高阅读性,要尽量有意义,“见名知意”。
注意2:java采用unicode字符集,因此标识符也可以使用汉字声明,但是不建议使用。 


*/
class IdentifierTest{

	public static void main(String[] args){
		
		//int myNumber = 1001;
		//System.out.println(myNumber);
		int mynumber = 1002;
		System.out.println(mynumber);

		//int 学号 = 1003;
		//System.out.println(学号);
		
	
	}


}

class Hello1_${

}
//class 1Hello{
//}
class staticpublic{
}
class Static{
}

class User{
}

class Account{
}

变 量

class VariableTest
{
	public static void main(String[] args){
		//定义变量的方式1:
		char gender; // 过程1:变量的声明
		gender = '男'; // 过程2:变量的赋值(或初始化)

		gender = '女';
		// 定义变量的方式2:声明和初始化合并
		int age = 10;
		System.out.println(age);
		System.out.println("age = " + age);
		System.out.println("gender = " + gender);
		//在同一作用域内不能声明相同的变量
		//char gender = '女'; // 会报错
		gender = '女'; // 已声明的变量重新赋值不会报错
		//由于number前没有声明类型,即当前number变量没有提前定义,所以编译不通过
		//number = 10;
	}
	public static void mian123(String[] args){
		//直接输出变量gender会报错,该变量只在声明他的作用域生效
		
		//System.out.println("gender = " + gender);
		// 在不同的作用域声明相同的变量没有问题
		char gender = '女';
	}
}

整数类型 

浮点类型

class VariableTest1
{
	public static void main(String[] args){
		//1.测试整型变量的使用
		// byte(1字节=8bit)...
		byte b1 = 12;
		byte b2 = 127;
		//byte b3 = 128; //不兼容的类型: 从int转换到byte可能会有损失
		short s1 = 1234;
		
		int i1 = 123234123;

		long l1 = 123123123L;
		double d1 = 12.3;
		float f1 = 12.3f;
		System.out.println("f1 = " + f1);
		//测试浮点型变量的精度
		//结论:通过测试发现浮点型变量的精度不高,如果在开发中,需要极高的精度,需要使用BigDecimal类替换浮点型变量
		// 测试1
		System.out.println(0.1+0.2); // 0.30000000000000004
		//测试2
		float ff1 = 123123123f;
		float ff2 = ff1 + 1;
		System.out.println(ff1); //1.2312312E8
		System.out.println(ff2); //1.2312312E8
		System.out.println(ff1 == ff2); // true
	}
}


字符类型 char

ASCII码

 Unicode 编码

UTF-8

布尔类型:boolean

class VariableTest2
{
	public static void main(String[] args){
		char c1 = 'a';
		char c2 = '中';
		char c3 = '1';
		char c4 = '%';
		char c5 = 'γ'; // 错误: 空字符文字
		//编译不通过
		//char c6 = ''; // 错误: 空字符文字
		//char c7 = 'ab'; // 错误: 不是语句,两个字符了,内部有且仅有一个字符
		//表示形式2:直接使用 Unicode 值来表示字符型常量
		char c8 = '\u0036';
		System.out.println(c8); // 6
		// 表示形式3:使用转义字符
		char c9 = '\n';
		char c10 = '\t';
		System.out.println("hello" + c9 + "world");
		System.out.println("hello" + c10 + "world");
		//表示形式4:使用具体字符对应的数值(比如ASCII码)
		char c11 = 97;
		System.out.println(c11); // a
		char c12 = '1';
		char c13 = 1;
		//2.布尔类型:boolean
		//只有两个值:true,false
		boolean bo1 = true;
		boolean bo2 = false;
		//编译不通过
		//boolean bo3 = 0; // 错误: 不兼容的类型: int无法转换为boolean
		boolean isMarried = true;
		if(isMarried) {
			System.out.println("很遗憾,不能参加单身派对了");
		}else {
			System.out.println("可以多谈几个女朋友或男朋友");
		}

	}
}


/*
Java定义的数据类型

一、变量按照数据类型来分:

	基本数据类型:
		整型:byte \ short \ int \ long
		浮点型:float \ double
		字符型:char
		布尔型:boolean


	引用数据类型:
		类(class)
		接口(interface)
		数组(array)


二、变量在类中声明的位置:
		成员变量  vs  局部变量
*/
class VariableTest1 {
	public static void main(String[] args) {
		//1. 整型:byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
		//① byte范围:-128 ~ 127
		//
		byte b1 = 12;
		byte b2 = -128;
		//b2 = 128;//编译不通过
		System.out.println(b1);
		System.out.println(b2);
		// ② 声明long型变量,必须以"l"或"L"结尾
		// ③ 通常,定义整型变量时,使用int型。没有特殊情况的话
		short s1 = 128;
		int i1 = 1234;
		long l1 = 3414234324L;
		System.out.println(l1);

		//2. 浮点型:float(4字节) \ double(8字节)
		//① 浮点型,表示带小数点的数值
		//② float表示数值的范围比long还大

		double d1 = 123.3;
		System.out.println(d1 + 1);
		//③ 定义float类型变量时,变量要以"f"或"F"结尾
		float f1 = 12.3F;
		System.out.println(f1); // 运行结果12.3,不会带上f
		//④ 通常,定义浮点型变量时,使用double型。因为精度更高
		//float 类型表数范围要大于long类型的表数范围,但是精度不高

		//3. 字符型:char (1字符=2字节)
		//① 定义char型变量,通常使用一对'',内部只能写一个字符
		char c1 = 'a';
		//编译不通过
		//c1 = 'AB';
		System.out.println(c1);

		char c2 = '1';
		char c3 = '中';
		char c4 = 'ス';
		System.out.println(c2);
		System.out.println(c3);
		System.out.println(c4);

		//② 表示方式:1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
		char c5 = '\n';//换行符
		c5 = '\t';//制表符
		System.out.print("hello" + c5);
		System.out.println("world");

		char c6 = '\u0043';
		System.out.println(c6);

		//4.布尔型:boolean
		//① 只能取两个值之一:true 、 false
		//② 常常在条件判断、循环结构中使用,常常使用在流程控制语句中
		boolean bb1 = true;
		System.out.println(bb1);

		boolean isMarried = true;
		if(isMarried){
			System.out.println("你就不能参加\"单身\"party了!\\n很遗憾");
		}else{
			System.out.println("你可以多谈谈女朋友!");
		}
		//了解:我们不谈boolean类型占用空间的大小,但是,真正在内存中分配的话,使用的是4个字节
	}
}

练习题:

练习1
class FloatDoubleExer
{
	public static void main(String[] args){
		//定义圆周率变量
		double pi = 3.14;
		//定义三个圆的半径
		double radius1 = 1.2;
		double radius2 = 2.5;
		int radius3 = 6;
		//计算面积
		double area1 = pi * radius1 * radius1;
		double area2 = pi * radius2 * radius2;
		double area3 = pi * radius3 * radius3;
		//输出
		System.out.println("圆1的半径为:"+radius1+",面积为:" + area1);
		System.out.println("圆2的半径为:"+radius2+",面积为:" + area2);
		System.out.println("圆3的半径为:"+radius3+",面积为:" + area3);
		//圆1的半径为:1.2,面积为:4.521599999999999
		//圆2的半径为:2.5,面积为:19.625
		//圆3的半径为:6,面积为:113.03999999999999
	}
}

练习2
/*
	案例2:小明要到美国旅游,可是哪里的温度是以华氏度为单位记录的
	他需要一个程序将华氏温度(80度)转化为摄氏度,并以华氏度和摄氏度为单位分别显示该温度
	℃=(℉-32)/1.8
*/
class FloatDoubleExer1
{
	public static void main(String[] args){
		double hua = 80.0;
		double she = (hua - 32) / 1.8;
		System.out.println("华氏度" + hua + "℉ 对应的摄氏度为" + she + "℃");
		//华氏度80.0℉ 对应的摄氏度为26.666666666666664℃
	}
}

基本数据类型转换

1
/*
基本数据类型之间的运算规则:

前提:这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。

1. 自动类型提升:
    结论:当容量小的数据类型的变量与容量大的数据类型的变量做运算时,结果自动提升为容量大的数据类型。
	byte 、char 、short --> int --> long --> float --> double 

	特别的:当byte、char、short三种类型的变量做运算时,结果为int型
	
2. 强制类型转换:见VariableTest3.java


说明:此时的容量大小指的是,表示数的范围的大和小。比如:float容量要大于long的容量
*/
class VariableTest2 {
	public static void main(String[] args) {
		
		byte b1 = 2;
		int i1 = 129;
		//编译不通过
		//byte b2 = b1 + i1;
		int i2 = b1 + i1;
		long l1 = b1 + i1;
		System.out.println(i2);

		float f = b1 + i1;
		System.out.println(f);

		short s1 = 123;
		double d1 = s1;
		System.out.println(d1);//123.0

		//***************特别地*********************
		char c1 = 'a';//97
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);

		short s2 = 10;
		//char c2  = c1 + s2;//编译不通过

		byte b2 = 10;
		//char c3 = c1 + b2;//编译不通过

		//short s3 = b2 + s2;//编译不通过

		//short s4 = b1 + b2;//编译不通过
		//****************************************

	}
}

2
class VariableTest3
{
	public static void main(String[] args){
		int i1 = 10;
		int i2 = i1;
		long l1 = i1;
		float f1 = l1;
		byte b1 = 12;
		int i3 = b1+i1;
		//编译不通过
		//byte b2 = b1 + i1; // 错误: 不兼容的类型: 从int转换到byte可能会有损失
		byte b3 = 12;
		short s1 = 10;
		//编译不通过
		//short s2 = b3 + s1; //错误: 不兼容的类型: 从int转换到short可能会有损失
		i3 = b3 + s1;
		byte b4 = 10;
		//编译不通过
		// 错误: 不兼容的类型: 从int转换到byte可能会有损失
		//byte b5 = b3 + b4; //byte与byte之间做运算,short与short之间做运算很容易超过byte或short这个范围,char同理,或者两者交叉运算
		// 特别的:byte,short,char类型的变量之间做运算,结果为int类型
		//特殊情况2: char
		char c1 = 'a';
		//编译不通过
		//char c2 = c1 + b3;  //错误: 不兼容的类型: 从int转换到char可能会有损失
		int i4 = c1 + b3;


		//**********************************
		//练习1:
		long l2 = 123L;
		long l3 = 123; //理解为自动类型提升 (int ---> long)
		//错误: 整数太大
		//long l4 = 123123123123; //123123123123理解为int类型,因为超出了int范围,所以报错
		long l5 = 123123123123L; //此时123123123123L就是使用8个字节存储的long类型的值

		//练习3:
		float f2 = 12.5F;
		//编译不通过
		//错误: 不兼容的类型: 从double转换到float可能会有损失
		//float f3 = 12.3;  //不满足自动类型提升的规则(double ---> float),所以报错

		//练习3:
		// 规定1:整型常量规定为int类型
		byte b5 = 10;
		//byte b6 = b5 + 1; // 错误: 不兼容的类型: 从int转换到byte可能会有损失
		int ii1 = b5 + 1;
		//规定2:浮点型的常量规定是double类型
		double dd1 = b5 + 12.3;
		//练习4:说明为什么不允许变量名是数字开头的,为了“自洽”
		/*int 123L = 12; //错误: 不是语句
		long l6 = 123L; //这样不太确定123L是变量,还是定义的数字类型
		*/
	}
}

字符串类型:String

视频代码
class StringTest
{
	public static void main(String[] args){
		String str1 = "Hello World!";
		System.out.println("str1"); //str1
		System.out.println(str1); //Hello World!

		String str2 = "";
		String str3 = "a";  // char c1 = 'a';
		//测试连接运算
		int num1 = 10;
		boolean b1 = true;
		String str4 = "hello";
		System.out.println(str4 + b1); //hellotrue
		String str5 = str4 + b1;
		String str6 = str4 + b1 + num1;
		System.out.println(str6); //hellotrue10
		//思考:如下的声明编译能通过吗?不能
		//错误: 二元运算符 '+' 的操作数类型错误, 第一个类型:  boolean,第二个类型: int
		//String str7 = b1 + num1 + str4;
		//如何将String类型的编码转化为基本数据类型?
		String str8 = "abc"; //不能考虑转换为基本数据类型的
		int num2 = 10;
		String str9 = num2 + ""; // "10"
		//编译不通过
		//int num3 = (int)str9; // 错误: 不兼容的类型: String无法转换为int
		//如何实现呢?使用Integer
		int num3 = Integer.parseInt(str9);
		System.out.println(num3 + 1); //11
	}
}

原代码
/*
String类型变量的使用
1. String属于引用数据类型,翻译为:字符串
2. 声明String类型变量时,使用一对""
3. String可以和8种基本数据类型变量做运算,且运算只能是连接运算:+
4. 运算的结果仍然是String类型
5.String声明的字符串可以包含0个,1个或多个字符

*/
class StringTest {
	public static void main(String[] args) {
		
		String s1 = "Hello World!";

		System.out.println(s1);

		String s2 = "a";
		String s3 = "";

		//char c = '';//编译不通过

		//***********************
		int number = 1001;
		String numberStr = "学号:";
		String info = numberStr + number;// +:连接运算
		boolean b1 = true;
		String info1 = info + b1;// +:连接运算
		System.out.println(info1);

		//***********************
		//练习1
		char c = 'a';//97   A:65
		int num = 10;
		String str = "hello";
		System.out.println(c + num + str);//107hello
		System.out.println(c + str + num);//ahello10
		System.out.println(c + (num + str));//a10hello
		System.out.println((c + num) + str);//107hello
		System.out.println(str + num + c);//hello10a

		//练习2
		//*	*
		System.out.println("*	*");
		System.out.println('*' + '\t' + '*');
		System.out.println('*' + "\t" + '*');
		System.out.println('*' + '\t' + "*");
		System.out.println('*' + ('\t' + "*"));


		//***********************

		//String str1 = 123;//编译不通过
		String str1 = 123 + "";
		System.out.println(str1);//"123"
		
		//int num1 = str1;
		//int num1 = (int)str1;//"123"

		int num1 = Integer.parseInt(str1);
		System.out.println(num1);//123
	}
}


String与基本数据类型之间的转换

class StringExer1
{
	public static void main(String[] args){
		//练习1:
		//String str1 = 4; //判断对错:no
		String str2 = 3.5f + ""; //判断str2对错:yes
		System.out.println(str2); //输出:”3.5”
		System.out .println(3+4+"Hello!"); //输出:7Hello!
		System.out.println("Hello!"+3+4); //输出:Hello!34
		System.out.println("a"+1+"Hello!"); //输出:98Hello!
		System.out.println("Hello"+"a"+1); //输出:Helloa1
		//练习2:
		System.out.println("*    *"); 
		System.out.println("*\t*"); 
		System.out.println("*"+"\t"+"*"); 
		System.out.println('*'+"\t"+"*"); //char与string连接,再与char连接
		System.out.println('*'+'\t'+"*"); //cahr与char做加法运算,然后与string连接
		System.out.println('*'+"\t"+'*'); //char与string做拼接,在与char做拼接
		System.out.println("*"+'\t'+'*'); //字符串与char之间连接的结果是字符串,在与char做拼接
		System.out.println('*'+'\t'+'*'); //三个char做加法运算
		/*
			*    *
			*       *
			*       *
			*       *
			51*
			*       *
			*       *
			93
			需要注意的是做加法等运算,还是做拼接,产生的结果不一样
		*/
	}
}

强制类型转换

s-2,b+4,s+b是int类型,原因:byte,short,char类型的变量之间做运算,结果为int类型

视频练习
class VariableTest4
{
	public static void main(String[] args){
		double d1 = 12; // 自动类型提升
		//编译不通过
		//int i1 = d1; //错误: 不兼容的类型: 从double转换到int可能会有损失
		int i2 = (int)d1;
		System.out.println(i2); //12
		long l1 = 123;
		//short s1 = l1; // 错误: 不兼容的类型: 从long转换到short可能会有损失
		short s2 = (short)l1;
		System.out.println(s2); // 123
		//练习
		int i3 = 12;
		float f1 = i3; //自动类型提升
		System.out.println(f1); //12.0
		float f2 = (float)i3; //编译可以通过,只不过可以省略而已,12.0
		System.out.println(f2);
		//精度损失的例子1:
		double d2 = 12.3;
		int i4 = (int)d2; 
		System.out.println(i4); //12
		//精度损失的例子2:
		int i5 = 128;
		byte b1 = (byte)i5;
		//编译通过,但是值为-128
		System.out.println(b1); //-128 
		
		//实际开发举例:
		byte b2 = 12;
		method(b2);

		long l2 = 12L;
		//编译不通过
		method((int)l2); //错误: 不兼容的类型: 从long转换到int可能会有损失
	}
	public static void method(int num){ //int num = b2;自动类型提升
		System.out.println("num = " + num);
	}
}

//原代码

/*
强制类型转换:自动类型提升运算的逆运算。
1.需要使用强转符:()
2.注意点:强制类型转换,可能导致精度损失。



*/
class VariableTest3 {
	public static void main(String[] args) {
		
		double d1 = 12.9;
		//精度损失举例1
		int i1 = (int)d1;//截断操作
		System.out.println(i1);
		
		//没有精度损失
		long l1 = 123;
		short s2 = (short)l1;
		
		//精度损失举例2
		int i2 = 128;
		byte b = (byte)i2;
		System.out.println(b);//-128

	}
}

进 制

二进制

第一位表示的是符号位,那么-1的二进制码也就是10000001,取反之后为11111110

进制间转化

视频练习代码
class BinaryTest
{
	public static void main(String[] args){
		int num1 = 103; // 十进制
		int num2 = 0b10; // 二进制
		int num3 = 023; // 八进制
		int num4 = 0X23a; //十六进制
		System.out.println(num1); //103
		System.out.println(num2); // 2
		System.out.println(num3); //19
		System.out.println(num4); //570
	}
}


原代码
/*
计算机中不同进制的使用说明

对于整数,有四种表示方式:
> 二进制(binary):0,1 ,满2进1.以0b或0B开头。
> 十进制(decimal):0-9 ,满10进1。
> 八进制(octal):0-7 ,满8进1. 以数字0开头表示。
> 十六进制(hex):0-9及A-F,满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。
    如:0x21AF +1= 0X21B0



*/
class BinaryTest {
	public static void main(String[] args) {
		
		int num1 = 0b110;
		int num2 = 110;
		int num3 = 0127;
		int num4 = 0x110A;

		System.out.println("num1 = " + num1);
		System.out.println("num2 = " + num2);
		System.out.println("num3 = " + num3);
		System.out.println("num4 = " + num4);

	}
}

运算符

算术运算符

//视频练习代码1
/*
	为了抵抗洪水,战士连续作战89小时,编程计算共多少天零多少小时?
*/
class AriExer1
{
	public static void main(String[] args){
		int hours = 89;
		int day = hours / 24;
		int hour = hours % 24;
		System.out.println("共奋战了:" + day + "天零" + hour + "小时"); //共奋战了:3天零17小时

		// 额外的练习1:
		System.out.println("5+5 = " + 5 + 5); //5+5=55
		System.out.println("5+5 = " + (5 + 5)); //5+5=10
		
		// 额外的练习2:
		byte bb1 = 127;
		bb1++;
		System.out.println("bb1 = " + bb1); //bb1 = -128

		// 额外的练习3:
		//int i = 1;
		//int j = i++ + ++i * i++;
		//       4  +  3  *  2  从左到右运算
		//System.out.println("j = " + j); //j = 10

		// 额外的练习4:
		int i = 2;
		int j = i++; // i先把值赋给别人,然后自己+1
		System.out.println("j = " + j); //2

		int k = 2;
		int z = ++k; //先增加,并把值赋给别人
		System.out.println(z); // 3
		// 额外的练习5:
		int m = 2;
		m = m++;
		System.out.println("m = " + m); //2
	}
}

//视频练习代码2
/*
运算符之一:算术运算符
+ - + - * / % (前)++ (后)++ (前)-- (后)-- +


*/
class AriTest
{
	public static void main(String[] args){
		//除数:/
		int m1 = 12;
		int n1 = 5;
		int k1 = m1 / n1;
		System.out.println(k1); //2
		System.out.println(m1 / n1 * n1); // 10

		//取模(或取余):%
		int i1 = 12;
		int j1 = 5;
		System.out.println(i1 % j1); // 2
		//开发中,经常用来判断某个数num1能整除另一个数num2。 num1 % num2 == 0
		//开发中,经常使用%来判断能否被除尽的情况。
		//比如判断num1是否为偶数: num1 % 2 == 0
		//结果的符号与被模数的符号相同
		int i2 = -12;
		int j2 = 5;
		System.out.println(i2 % j2); //-2
		int i3 = 12;
		int j3 = -5;
		System.out.println(i3 % j3); //2
		int i4 = -12;
		int j4 = -5;
		System.out.println(i4 % j4); //-2
		
		//(前)++:先自增1,在运算
		//(后)++:先运算,后自增1,存储空间的值改变了
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1 + ",b1 = " + b1); // a1 = 11,b1 = 11 

		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2 + ",b2 = " + b2); // a1 = 11,b1 = 10 
		//练习1:
		int i = 10;
		//i++;
		++i;
		System.out.println("i = " + i); //11
		//练习2:
		short s1 = 10;
		//方式1:
		//编译不通过
		//s1 = s1 + 1;  // 错误: 不兼容的类型: 从int转换到short可能会有损失
		s1 = (short)(s1 + 1); //自增1不会改变本身变量的数据类型
		System.out.println(s1); 

		//方式2:
		s1++;
		System.out.println(s1); //12
		
		//***************************
		//(前)--:先自减1,在运算
		//(后)--:先运算,在自减1
		

		//+:连接符,只适用于String与其他类型的变量间的运算,而且运算的结果也是String类型
	}
}

//视频练习代码3
class AriExer
{
	public static void main(String[] args){
		int num = 153;
		int ge = num % 10; //个位
		int shi = num / 10 % 10; //十位  int shi = num % 100 / 10
		int bai = num / 100;
		System.out.println("个位是:" + ge);
		System.out.println("十位是:" + shi);
		System.out.println("百位是:" + bai);
		/*
			个位是:3
			十位是:5
			百位是:1
		*/
	}
}

 赋值运算符

/*
运算符之二:赋值运算符
=  +=  -=  *=  /=  %= 


*/
class SetValueTest
{
	public static void main(String[] args){
		int i = 5;
		long l = 10; //自动类型提升
		byte b = (byte)i; // 强制类型转换
		//操作方式1:
		int a1 = 10;
		int b1 = 10;
		//操作方式2:连续赋值
		int a2;
		int b2;
		//或合并:int a2,b2;
		a2 = b2 = 10;

		System.out.println(a2 + "," + b2); // 10,10

		//操作方式3:
		//int a3 = 10;
		//int b3 = 10;
		int a3 = 10,b3 = 20;
		System.out.println(a3 + "," + b3); //10,20

		//******************************
		//说明 += 的使用
		int m1 = 10;
		m1 += 5; // 类似于m1 = m1 + 5
		System.out.println(m1); //15

		byte by1 = 10;
		by1 += 5; // by1 = by1 + 5操作会编译报错,应该写为:by1 = (byte)(by1 + 5)
		System.out.println(m1); //15
		
		int m2 = 1;
		m2 *= 0.1; // 等价于m2 = (int)(m2 * 0.1)
		System.out.println(m2); //0

		//练习1:如何实现变量的值增加2
		//方式1:
		int n1 = 10;
		n1 = n1 + 2;

		//方式2:推荐
		int n2 = 10;
		n2 += 2;

		//练习2:如何实现变量的值增加1
		//方式1:
		int i1 = 10;
		i1 = i1 + 1;

		//方式2:
		int i2 = 10;
		i2 += 1;

		//方式3:推荐
		int i3 = 10;
		i3++; // ++i3
	}
}

针对于short类型的自增 

比较运算符

/*
运算符之三:比较运算符
1.==  !=  >  <  >= <=  instanceof
2.说明
instanceof 在面向对象的多态性的位置的讲解
==  !=  >  <  >=  <= 适用于除boolean类型之外的其他7种基本数据类型
运算的结果为boolean类型
了解: ==  !=  可以适用于引用数据类型
区分:==  与 =


结论:
1.比较运算符的结果是boolean类型
2.区分 ==  和  = 
*/
class CompareTest
{
	public static void main(String[] args){
		int m1 = 10;
		int m2 = 20;
		int compare1 = m1 > m2;
		System.out.println(compare1);

		int n1 = 10;
		int n2 = 20;
		System.out.println(n1 == n2); // false
		System.out.println(n1 = n2); // 20

		boolean b1 = false;
		boolean b2 = true;
		System.out.println(b1 == b2); // false
		System.out.println(b1 = b2); // true
	}
}

逻辑运算符

视频练习代码1
/*
运算符之四:逻辑运算符

&  && |  || ! ^

说明:
1.逻辑运算符操作的都是boolean类型的变量
2.逻辑运算符运算的结果也是boolean类型
3.逻辑运算符常使用条件判断结构,循环结构中

*/
class LoginTest
{
	public static void main(String[] args){
		//区分& 与 &&
		//相同点:两个符号表达的都是”且“的关系,只有当符号左右两边的类型值均为true时,结果才为true
		//相同点1:& 与  && 的运算结果相同
		//相同点2:当符号左边是true时,二者都会执行符号右边的运算
		//不同点:当符号左边是false时,&继续执行符号右边的运算。&&不再执行符号右边的运算。
		//开发中,推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("床前明月光");
		}else {
			System.out.println("我叫郭德纲");
		}
		System.out.println("num1 = " + num1);
		/*
				b1与b2值为true的结果:
				床前明月光
				num1 = 11
				床前明月光
				num2 = 11
		*/
		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){ //b2为false时,语法没有执行
			System.out.println("床前明月光");
		}else {
			System.out.println("我叫郭德纲");
		}
		System.out.println("num2 = " + num2);
		/*
			b1与b2值为false的结果:
			我叫郭德纲
			num1 = 11
			我叫郭德纲
			num2 = 10
		*/

		// 区分:| 与 || 
		//相同点1:| 与  || 的运算结果相同
		//相同点2:当符号左边是false时,二者都会执行符号右边的运算
		//不同点3:当符号左边是true时,|继续执行符号右边的运算,而||不再执行符号右边的运算
		//开发中,推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("床前明月光");
		}else {
			System.out.println("我叫郭德纲");
		}
		System.out.println("num3 = " + num3);
		/*
				b1与b2值为false的结果:
				床前明月光
				num3 = 11
				床前明月光
				num4 = 11
		*/
		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){ //b2为false时,语法没有执行
			System.out.println("床前明月光");
		}else {
			System.out.println("我叫郭德纲");
		}
		System.out.println("num4 = " + num4);
		/*
			b1与b2值为true的结果:
			床前明月光
			num3 = 11
			床前明月光
			num4 = 10
		*/
	}
}
视频练习代码2

/*
1.定义类 LogicExer
2.定义main方法
3.定义一个int类型变量a,变量b,都赋值为20;
4.定义boolean类型变量bo1,判断++a,是否被3整除,并且a++是否被7整除,将结果赋值给bo1
5.输出a的值,bo1的值
6.定义boolean类型变量bo2,判断b++是否被3整除,并且++b是否被7整除,将结果赋值给bo2
7.输出b的值,bo2的值
*/
class LoginExer {
	public static void main(String[] args) {
		int a,b;
		a = b = 20;

		boolean bo1 = (++a % 3 == 0) && (a++ % 7 == 0);
		System.out.println("a = " + a + ",bo1 = " + bo1); //a = 22,bo1 = true
		boolean bo2 = (b++ % 3 == 0) && (++b % 7 == 0);
		System.out.println("b = " + b + ",bo2 = " + bo2); //b = 21,bo2 = false
	}
}

位运算符

视频练习1
/*
运算符之五:位运算符 (了解)

结论:
1. 位运算符操作的都是整型的数据
2. << :在一定范围内,每向左移1位,相当于 * 2
   >> :在一定范围内,每向右移1位,相当于 / 2



面试题:最高效方式的计算2 * 8 ?  2 << 3  或 8 << 1
*/

class BitTest {
	public static void main(String[] args) {
		int num1 = 7;
		System.out.println("num1 << 1:" + (num1 << 1)); //num1 << 1:14
		System.out.println("num1 << 2:" + (num1 << 2)); //num1 << 2:28
		System.out.println("num1 << 3:" + (num1 << 3)); //num1 << 3:56
		System.out.println("num1 << 28:" + (num1 << 28)); //num1 << 28:1879048192
		System.out.println("num1 << 29:" + (num1 << 29)); //num1 << 29:-536870912  过犹不及,最高位会变成1,也就是负数了

		int num2 = -7;
		System.out.println("num2 << 1:" + (num2 << 1)); //num2 << 1:-14
		System.out.println("num2 << 2:" + (num2 << 2)); //num2 << 2:-28
		System.out.println("num2 << 3:" + (num2 << 3)); //num2 << 3:-56
		System.out.println(~9); -10
		System.out.println(~-10); 9
	}
}


视频练习2
/*
	案例2:如何交换两个int型变量的值? String呢?
*/

class BitExer {
	public static void main(String[] args) {
		int m = 10;
		int n = 20;
		System.out.println("m = " + m + ",n = " + n);  //m = 10,n = 20
		

		//交换两个变量的值
		//方式1:声明一个临时变量(推荐)
		int temp = m;
		m = n;
		n = temp;
		System.out.println("m = " + m + ",n = " + n); //m = 20,n = 10

		//方式2:优点:不需要定义临时变量,缺点:难,适用性差(不适用于非数值类型),可能超出int的范围
		m = m + n; // 30 = 10 + 20;
		n = m - n; // 10 = 30 - 20;
		m = m - n; // 20 = 30 - 10;
		System.out.println("m = " + m + ",n = " + n);//m = 10,n = 20

		//方式3:优点:不需要定义临时变量。优点:真难,适用性差(不适用于非数值类型)
		m = m ^ n;
		n = m ^ n; // (m ^ n) ^ n ---> m
		m = m ^ n;
		System.out.println("m = " + m + ",n = " + n);//m = 20,n = 10
	}
}

三元运算符

//视频练习题
/*
运算符之六:三元运算符
1.结构:(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假,决定执行表达式1,还是表达式2.
  如果表达式为true,则执行表达式1。
  如果表达式为false,则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用

3. 
凡是可以使用三元运算符的地方,都可以改写为if-else
反之,不成立。

4. 如果程序既可以使用三元运算符,又可以使用if-else结构,那么优先选择三元运算符。原因:简洁、执行效率高。
*/
class ConditionTest {
	public static void main(String[] args) {
		String info = (2 > 1) ? "表达式1" : "表达式2";
		System.out.println(info); // 表达式1
		double result = (2 > 1) ? 1 : 2.0; 
		System.out.println(result); //1.0

		//练习1:获取连个整数的较大值
		int m = 10;
		int n = 20;
		int max = (m > n) ? m : n;
		System.out.println("较大值为:" + max); //较大值为:20
		//练习2:获取三个整数的最大值
		int i = 20;
		int j = 30;
		int k = 23;
		int tempMax = (i > j) ? i : j;
		int finalMax = (tempMax > k) ? tempMax : k;
		System.out.println("较大值为:" + finalMax); //较大值为:30
		int finalMax1 = (((i > j) ? i : j) > k) ? (i > j) ? i : j : k;
		System.out.println("较大值为:" + finalMax1);  //较大值为:30
	}
}

/*
	今天是周二,10天后是周几?
	要求:控制台输出“今天是周2,10天后是周x”
*/
class ConditionExer {
	public static void main(String[] args) {
		int week = 2;
		//week = 4; //注意是整周的情况,除以7是0
		week += 10;
		week %= 7;
		
		System.out.println("今天是周2,10天后是周" + ((week == 0) ? "日" : week));  //今天是周2,10天后是周5
	}
}


http://www.kler.cn/a/586617.html

相关文章:

  • 告别XML模板的繁琐!Word文档导出,easy!
  • Kubernetes 单节点集群搭建
  • tcpdump剖析:入门网络流量分析实战指南
  • Ubuntu从源代码编译安装QT
  • 进程间通信--匿名管道
  • 【蓝桥杯】雪地工程核弹引爆控制器最小数量计算
  • Pytorch实现之最小二乘梯度归一化设计
  • 在离线情况下如何使用 Python 翻译文本
  • 【JVM】性能监控与调优概述篇
  • 基于RAGFlow本地部署DeepSpeek-R1大模型与知识库:从配置到应用的全流程解析
  • Spring Boot 中 BootstrapRegistryInitializer 的作用与示例
  • Ubuntu中为curl和Docker配置代理
  • Docker安装GitLab中文版详细流程,以及非80端口配置
  • 2025年渗透测试面试题总结-安恒 (题目+回答)
  • U盘提示格式化的深度解析与应对策略
  • 【新能源汽车研发测试能力建设深度解析:设备、趋势与行业展望】
  • 学习用WinDbg查看程序当前运行的堆栈
  • [C语言日寄] qsort函数的练习
  • css模拟雷达扫描动画
  • 用ST7789屏幕导致负片(反色)的问题