day4思维导图

课堂总结

算术运算符

单目（一元）：+ - ，++ –
双目（二元）：+ - * / %

%: 取余操作和取模操作的区别，在于商
取余操作：商向0取整
模操作：商向下取整

++：前置++ 后置++
无论是前置还是后置，都对原来的变量进行+1， 对于表达式的结果不同，后置++（会缓存变量之前的值）指向的是变量+1之前的结果。

关系运算符

< > >= <=
== !=
如果两侧都是基本数据类型，则比较的是值大小
如果两侧都是引用类型，则比较的是地址是否是同一个（对象是否是同一个）

Java不支持链式比较

逻辑运算符

&&：两个表达式的结果都是true，则返回true，否则，返回false
|| ：两个表达式的结果都是false，则返回false，否则返回true
! ：逻辑取反。注意，只针对布尔类型有效。

短路现象：&& 第一个表达式为false，则后面的表达式不执行
|| 第一个表达式为true，则后面表达式不执行

a<b<c
a<b && b<c

赋值运算符

= 含义赋值 ，将右侧的值赋予给左侧的变量。
自运算 += -= *= /= %=…
X=x+1
X+=1

位运算符

对于补码进行的按位操作
& :，如果两个都是1，则返回1，否则返回0
| : 如果两个都是0，则返回0，否则返回1
^（异或） : 如果两个相同，则返回0，否则 ，返回1
~（取反） ：一元运算符，对于某一个数的补码进行按位取反，包括符号位。

优先级：

()调整优先级
大体遵循规则：
算术运算符（ + - * / ）> 比较运算符（ < <= > >= == ) > 位运算符( & | ^ ~ )> 逻辑运算符( && || ! )> 赋值运算符( = )
！优先级别最高。

课堂笔记

上午部分

package day4;

//1.Java中的数据类型有哪些？
/*两种数据类型：基本数据类型、引用类型
* 基本数据类型中：8种   byte  char  boolean  short  int  long  float  double
* 引用类型：使用class来声明的类型都可以看成是引用类型，包括接口、数组
*        特殊提一下 String属于引用类型，只不过比其他的引用类型特殊在创建方式、存储可以存储在字符串常量池中。
*        字符串常量池：是在编译期的时候向常量池中加入数据。
*        其他的包装器类型，也有缓存技术。
*
*        new关键字创建，一定是只要有new存在，就会在堆内存中开辟一块新空间。
*        String  s="abc"
*        String s1="abc"
*        String s2=new String("abc");
*        String s3=new String("abc");
*/

//2.将十进制的17转换成2进制，8进制和16进制，使用手工计算，并使用数值的方法验证。
//十进制转换成其他进制：下除取余法
//10001
//public class Day3homework {
//	public static void main(String[] args) {
//		System.out.println(0b10001);
//		System.out.println(Integer.toBinaryString(17));
//		System.out.println(Integer.toOctalString(17));
//		System.out.println(Integer.toHexString(17));
//		System.out.println(0x11);
//   }
//}

//3.将二进制100110101转换成10进制，8进制和16进制，使用手工计算，并使用数值方法验证。
//二进制转换成十进制：乘幂，底数：2
//2^8+2^5+2^4+2^2+2^0=256+32+16+4+1=309

//public class Day3homework {
//	public static void main(String[] args) {
//		System.out.println(0b100110101);
//		System.out.println(Integer.toOctalString(0b100110101));
//		System.out.println(Integer.toHexString(0b100110101));
////		                                          4  6  5
//   }
//}

//4.手工计算-27的二进制原码、反码、补码，进行跟1进行相加。-27+1
//public class Day3homework {
//	public static void main(String[] args) {

//		System.out.println(Integer.toBinaryString(-27));
//		11111111111111111111111111100101  变成原码
//		1.........................011011 原码：-16-8-2-1=-27

//		27的原码
//		00011011
//		-27的原码 ，符号位取1
//		10011011
//		11100100  反码
//		11100101  补码
//		1111111111111111111111111111111 11111111111111111111111111100101

//		使用8位机模拟
//		11100101   -27
//		00000001   1
//		11100110 符号位是1，则说明是负数，
//		10011010 -16-8-4=-26

//		使用四位机模拟出现的问题
//		-4-4
//		1100  -4的原码
//		1100  -4的补码
//		1100
//	    1000
//	    0000  0

//		10000100  -4的 原码
//		11111100  -4的补码
//		11111100
//		11111000  补码
//		10001000 原码：-8
//	}
//}

//5.定义一个字符串s="    hello，world，"
// (1) 去掉字符串两的空格
//（2）截取hello
//（3）去掉字符串最后的逗号
//（4）将（3）结果中的逗号替换成-
public class Day3homework {
public static void main(String[] args) {
String s="    hello，world，";
s=s.trim();
System.out.println(s);
System.out.println(s.substring(0,5));//end-start=5
System.out.println(s.substring(0,s.indexOf("，")));
System.out.println(s.substring(0,s.lastIndexOf("，")));

String temp=s.substring(0,s.lastIndexOf("，"));
System.out.println(temp.replace("，", "-"));

}
}

下午部分

package day4;

/*
* 第三章    运算符
* 算术运算符
* 关系运算符
* 逻辑运算符
* 赋值运算符
* 位运算符
*
* 有一些资料会将instanceof作为特殊运算符
*
* 一、算术运算符
* 单目运算符：+取正  -取负、++ 、--
* 双目运算符：+ - * /  %取余
* 三目运算符（正课）
* 目（元）：将一个运算符涉及到的操作数的数量称为“元”
*
* 1.双目运算符
* + -  * /

* %取余
* 余数 = 被除数 - 除数*商
* 【取余操作的规则】：被除数%除数，商向0取整。
*              取余操作，符号同被除数，结果就是数学计算中的余数
* 取整：向上取整
*     向下取整
*     向0取整
*
* 10%3=1
* 3.33333----3
* 被除数-除数*商=10-3*（3）=1
*
* 10%-3=1
* -3.3333----- -3
* 被除数-除数*商=10-（-3）*（-3）=1
*
* -10%3= -10-(3)*(-3)=-1
* -10%-3=-10-(-3)*3=-1
*
*
* 【取模操作的规则】
* 也对于余数的操作
* 余数=被除数-除数*商，商向下取整
* 10  跟-3 取模：
* 10-（-3）*(-4)=-2
*
* 【取余操作和取模操作是两个操作】
* 区别：在于商的取法。
*
*/
//public class Day4_1_Operator {
//   public static void main(String[] args) {
//	  System.out.println(10+3);
//	  System.out.println(10-3);
//	  System.out.println(10*3);
//	  System.out.println(10/3);
//
//	  System.out.println(10%3);
//	  System.out.println(10%-3);
//	  System.out.println(-10%-3);
//	  System.out.println(-10%3);
//   }
//}

/*
* 2. 单目运算符
* （1）+取正(默认)    —取负
* +100
* -100
* （2）++  --： 前置  ++exp   后置 exp++
* 以++为例：
* 无论是前置++还是后置++，都会对变量本身进行+1，不同的是++exp和exp++的表达式结果不同
* 前置 ++exp：会对变量本身进行+1，表达式的结果是变量+1之后的结果
* 后置 exp++：会对变量本身进行+1，表达式的结果是变量+1之前的结果。
*/
//public class Day4_1_Operator {
//	public static void main(String[] args) {
////		 System.out.println(+100);
////		 System.out.println(-100);
//
//		int x=5;
//		int y=5;
//		System.out.println(x++);//当执行完这一句话，x已经被+1，存储成6，原来的5被缓存起来
//		System.out.println(++y);//当执行完这一句话，y已经被+1，存储成6
//
//		System.out.println(x);
//		System.out.println(y);
//
////		内存图。
//
////		练习：
//		int z=10;
//		z++;
//		++z;
//		System.out.println(z);//12
//		System.out.println(z++);//12
//		System.out.println(++z);//14
//		System.out.println(z);//14
//
//		System.out.println();
//	}
//}

//二、关系运算符
//又叫做比较运算符
//返回值一定是布尔类型的，要么true，要么false
//比较的是两个表达式，或者两个常数之间的关系
//>  <  >=  <=   ==等于   !=不等于
//== 等于：
//两侧的值，如果两侧是基本数据类型，则比较的就是值的大小
//       如果两侧是引用类型，则比较的是地址是否相同
//       本质上，比较的就是数据域中存储的内容。
//public class Day4_1_Operator {
//	public static void main(String[] args) {
//		System.out.println(3<=5);
//		System.out.println(5<=5);
//		int a=1;
//		int b=2;
//		int c=2;
//		System.out.println(a==b);
//		System.out.println(c==b);
//
//		String s1="abc";
//		String s2="abc";
//		System.out.println(s1==s2);//返回true的原因，是因为s1和s2都是指向字符串常量池中的地址
//
//		String s3 =new String("abc");
//		String s4 =new String("abc");
//		System.out.println(s3==s4);//返回false，是因为s3和s4分别在堆内存中心创建字符串。
//
//		System.out.println(s1!=s2);//!=  ==的取反
//
////		【链式比较】java中不支持链式比较。
////		3<x<5
////		System.out.println(3<4<5);
//
//	}
//}

//三、逻辑运算符
//在计算机行业中涉及到的逻辑：与、或、非
// 第一个表达式    与/或   第二个表达式
//与&&：如果第一个表达式和第二个表达式同时返回true，则整个表达式返回true，否则返回false，代表并且。
//或||：如果两个表达式中，有任何一个表达式为true，则返回true，否则，返回false，代表或者。
//非!：原来是true，则变成false，如果原来是false，则变成true

//[使用场合]：在做比较的时候，作为条件。if(条件1 && 条件2);  if(条件1 || 条件2)
//[与和非]存在短路现象：
//与&& ：当第一个表达式为false，则第二个表达式不执行
//或|| ： 当第一个表达式为true，则第二个表达式不执行
//public class Day4_1_Operator {
//	public static void main(String[] args) {
//		int a=100;
//		int b=200;
//		int c=300;
//		System.out.println(true && true);
//		System.out.println(false && true);
//		System.out.println(a<b &&  b<c);
//		System.out.println(a<b &&  b>c);
//
//		System.out.println(true ||true);
//		System.out.println(true ||false);
//		System.out.println(false ||true);
//		System.out.println(false ||false);
//
//		System.out.println(a<b||c<a);
//
////		证明短路现象
//		System.out.println(false && (1/0)<2);
//		System.out.println(true || (1/0)<2);
//
////		非
//		System.out.println(!(a<b));
//
////		!运算符优先级很高。  与的优先级高于或。
//
//	}
//}

//四、赋值运算符
//=：第一个赋值运算符       变量名 = 变量值   ，运算的时候，都是先运行=右侧，将等号右侧的内容赋值给=左侧的变量名
//自运算：支持所有的算数运算符，还有位运算
//实际的本质上，效率上来说， 自运算的效率更高。访问x的内存次数少了。
//public class Day4_1_Operator {
//	public static void main(String[] args) {
//		int x=100;
////		int y=x+1;
////		x=x+1;//---自运算
//		x+=1;
//
////		int  a=1;
////		System.out.println(a=2);
//		System.out.println(x);
//	}
//}

//五、位运算符
//位运算就是对于数据的二进制存储的（补码）运算
/*
* & 按位与，左侧的操作数和右侧的操作数全部都转换成补码形式， 然后对位操作。
*       规则，两个同时为1的时候，则返回1，否则返回0
*
* | 按位或，规则，两个同时为0的时候，则返回0，否则返回1.
*             如果有任何一个返回1，则为1，否则返回0.
*
* ^ 异或，规则，判断两个数是否相同，如果相同，则返回0，否则返回1.
*
* ~ 按位取反，所有的位，包括符号位都取反。一元运算符。
*/
//public class Day4_1_Operator {
//	public static void main(String[] args) {
//		10001100
//		00100011
//		int a=0b100010;
//		int b=0b010001;
//		        000000
//		int a=10;
//		int b=3;
//		1010
//		0011
//		0010  2

//		int a=60;
//		System.out.println(Integer.toBinaryString(60));
//		int b=-3;
//		0011 1100
//		1111 1101
//		0011 1100

//		int a=0b100010;
//		int b=0b010001;
//		        110011; 32+16+2+1=51
//
//		int a=-10;
//		int b=-21;
//		1000 1010    1111 0110补码
//		1001 0101    1110 1011补码
//		             1111 1111-------如果全部位数都是1，一定是-1
//		             1000 0001

//		int a=0b100010;
//		int b=0b010001;
//		        110011;

//		int a=-10;
//		int b=-21;
//		1000 1010    1111 0110  -10的补码
//		1001 0101    1110 1011  -21的补码
//		             0001 1101  16+8+4+1=29
//		System.out.println(a^b);

//		int a=0b10001001;
////		   1..1101110110  补码----10...0010001010原码：- （128+8+2）=-138
//		int a=-60;
//		10111100 -----11000100---补码
//		              00111011---32+16+8+2+1=59
//
//		System.out.println(~a);
//
//
//
//	}
//}

//六、运算符的优先级
// 表达式中可以通过()来调整优先级
//算术运算符 >(左位移、右位移)> 比较运算符 > 位运算符 >逻辑运算符  >赋值运算符（大体的规则）
//! 优先级别最高
public class Day4_1_Operator {
public static void main(String[] args) {
boolean b = 3>5 || 5>2 && 5<4+5;
//		boolean b = 3>5 || 5>2 && 5<9;
//		boolean b = false || true && true;
//		boolean b = true;
System.out.println(b);
}
}