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