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
}
}