02学习笔记
知识点1：变量
- 说明
1. java中的变量定义的规则：数据类型 变量名 = 变量值
2. 注意点：
① 变量必须在初始化之后，才能使用
② 每个变量都有其声明所在的作用域。在其作用域内都可以使用。出了作用域之后，就不能使用了。
③ 在同一个作用域内不允许定义两个同名的变量
- 代码演示
class VariableTest {
public static void main(String[] args) {
//编译错误：变量必须在声明之后才可以使用
//System.out.println(weight);
//1.1变量的声明
double weight;
//编译错误：变量必须在初始化之后，才能使用
//System.out.println(weight);
//1.2 变量的赋值
weight = 80.6;
//变量的声明和赋值操作同时完成
int myAge = 12;
System.out.println(weight);
System.out.println(myAge);
//编译错误
//System.out.println(score);
//编译错误：在同一个作用域内不允许定义两个同名的变量
//int myAge = 30;
System.out.println(myAge);
}
public static void show(){
int score = 98;
System.out.println(score);
int myAge = 30;
}
}
知识点2：8种基本数据类型
1. 变量的分类
- 变量按照数据类型来分：
- 变量按照在类中声明的位置来分：
2. 8种基本数据类型的使用
整型
//1.整型：byte(1个字节 = 8bit, 范围：-128 ~ +127) 、 short(2字节) 、 int(4字节) 、 long(8字节)
//① 变量的赋值不能超出数据类型的表数范围
byte b1 = 12;
//b1 = 128;//编译不通过
//② 给long类型变量赋值时，需要以"l" 或"L"结尾
long l1 = 123L;
long l2 = 432l;
System.out.println(l1);//123
System.out.println(l2);//432
//③ 开发中，通常定义整型为int
浮点型
//2.浮点型:float(4字节,单精度)、double(8字节，双精度)
//① float定义的变量值必须以"f"或"F"结尾
//② 开发中，默认我们可以使用double类型来定义浮点类型的变量
double d1 = 123.43;
double d2 = 5436345234.235234;
float f1 = 123.43F;
System.out.println(f1);
字符型
//3.字符型:char
//一个字符占2个字节
//① 通常使用一对单引号表示一个字符。内部只能有一个字符
char c1 = 'a';
char c2 = '1';
char c3 = 'セ';
char c4 = '中';
System.out.println(c1);
System.out.println(c2);
System.out.println(c3);
System.out.println(c4);
//编译错误：内部只能声明一个字符
//char c5 = 'ab';
//char c6 = '123';
//char c7 = '';
//②其他表示方式：1.表示转义字符 2.使用Unicode值表示
char c8 = '\n';//换行符
char c9 = '\t';//制表符
System.out.println("hello" + c8 +"world");
System.out.println("hello" + c9 +"world");
char c10 = '\u0026';
char c11 = '&';
System.out.println(c10);
- 常用的字符集：ASCII 、GB2312、GBK、Unicode、UTF-8
布尔型
//4. 布尔型：boolean
// 只有两个取值：true 、 false
// 通常使用在条件判断、循环结构中
boolean isMarried = true;
if(isMarried){
System.out.println("好好珍惜自己的媳妇");
}else{
System.out.println("可以多谈谈女朋友");
}
/*
int myAge = 18;
if(myAge > 18){
}
*/
知识点3: 基本数据类型间的运算规则
1. 自动类型提升
基本数据类型变量间运算的规则
1. 此时的运算规则涉及到的是7种基本数据类型，不包含boolean
2. 容量小的和容量大的数据类型的变量间做运算时，满足：自动类型提升
> 容量小的和容量大的数据类型的变量间做运算时，结果的数据类型为容量大的数据类型。
> 特别的：如果byte、short、char三者之间做运算的话，结果为int类型。
总结：byte 、short、char -> int -> long -> float -> double
说明：容量大小指的是表数的范围。
- 代码演示
class VariableTest2 {
public static void main(String[] args) {
long l1 = 123L;
float f1 = 123.4F;
//编译失败
//long l2 = l1 + f1;
float f2 = l1 + f1;
byte b1 = 123;
int i1 = 432;
//编译失败
//short s = b1 + i1;
int i2 = b1 + i1;
float f3 = i1;
System.out.println(f3);//432.0
//##########################
char c1 = 'a';//97
int i3 = 1;
int i4 = c1 + i3;
System.out.println(i4);
//############################
byte bb1 = 12;
short ss1 = 13;
//编译失败
//short ss2 = bb1 + ss1;
char cc1 = 97;
//编译失败
//char cc2 = bb1 + cc1;
//编译失败
//short ss3 = ss1 + cc1;
byte bb2 = 32;
//编译失败
byte bb3 = bb1 + bb2;
}
}
2. 强制类型转换
自动类型提升规则的逆运算：强制类型转换
1. 强制类型转换，必须将容量大的数据类型的变量转换为容量小的数据类型的变量
2. 强制类型转换，需要使用强制类型转换符
- 代码演示
class VariableTest3 {
public static void main(String[] args) {
long l1 = 123L;
//编译失败
//int i1 = l1;
int i2 = (int)l1;
System.out.println(i2);
//损失精度的情况1：
double weight = 140.23;
int truncWeight = (int)weight;
System.out.println(truncWeight);//140
//损失精度的情况2：
int num = 128;
byte byteNum = (byte)num;
System.out.println(byteNum);//-128
}
}
3. 补充说明
//对于整型数据类型，常量的默认类型为：int
//对于浮点数据类型，常量的默认类型为：double
- 代码演示
class VariableTest4 {
public static void main(String[] args) {
long count = 2341234;
System.out.println(count);
//编译错误
//long count1 = 2423535443654564;
long count1 = 2423535443654564L;
//编译错误
//float f1 = 123.23;
float f1 = (float)123.23;
//
byte b1 = 12;
int i1 = b1 + 10;
//编译错误
//float f2 = b1 + 123.34;
}
}
知识点4：String与基本数据类型间的运算规则
1. String的基本使用
- String类型的变量使用一对""进行定义。
String info = "Hello World!";
System.out.println(info);
String s1 = "";//可以编译通过
2. String与8种基本数据类型间的运算规则
1. String 与 8种基本数据类型之间只能做连接运算： +
2. 运算的结果是String类型
- 代码演示
String info = "Hello World!";
System.out.println(info);
String s1 = "";//可以编译通过
int num = 2;
String s2 = info + num + true;
System.out.println(s2);
//######################
//编译失败
//String s3 = num;
String s4 = "123";
//编译失败
//int i1 = (int)s4;
//超纲内容：包装类时讲
int i2 = Integer.parseInt(s4);
System.out.println(i2 + 1);
- 练习
/*
练习1：
*/
char c1 = 'a';//97
int i = 1;
String str = "hello";
System.out.println(c1 + i + str);//98hello
System.out.println(c1 + str + i);//ahello1
System.out.println(c1 + (i + str));//a1hello
/*
练习2：
*/
//* *
System.out.println('*' + '\t' + '*');//93
System.out.println('*' + '\t' + "*");//51*
System.out.println("*" + '\t' + '*');//* *
System.out.println("*" + "\t" + '*');//* *
System.out.println("*\t*");//* *
System.out.println("芳芳老师很\"漂亮\"");//芳芳老师很"漂亮"
知识点5：进制间的运算（了解）
1. 了解常见的几种进制
/*
二进制(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 = 0b10;
int num2 = 010;
int num3 = 10;
int num4 = 0x10;
System.out.println(num1);
System.out.println(num2);
System.out.println(num3);
System.out.println(num4);
}
}
2. 熟悉二进制的情况
-
计算机的底层都是使用二进制表示数据的
-
对于数值型的变量，底层使用数值的二进制数据的补码表示数据
-
二进制原码、反码、补码的关系：
-
正数：原码、反码、补码，三码合一
-
负数：
负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。 负数的补码：其反码加1。
-
3. 二进制与十进制之间的转换
- 二进制转十进制
- 十进制转二进制：除2取余的逆
4. 与其他进制间的转换
- 二进制转换为八进制、十六进制
- 八进制、十六进制转换为二进制
知识6：运算符
1. 算术运算符
+ - + - * / % (前)++ (后)++ (前)-- (后)-- +
- 代码测试
class AriTest {
public static void main(String[] args) {
int num1 = 10;
float f1 = 1.2F;
float f2 = num1 * f1;
System.out.println("f2 = " + f2);
//关于除法：/
int num2 = 12;
int num3 = num2 / 5 * 5;
System.out.println("num3 = " + num3);
//关于取模： %
//常用来判断被模数是否能被模数除尽。比如：是否是一个偶数 num % 2 == 0
//取模运算结果的符号与被模数的符号相同
System.out.println(12 % 5);
System.out.println(12 % -5);
System.out.println(-12 % 5);
System.out.println(-12 % -5);
//(前)++ ： 先自增1，再运算
//(后)++ ：先运算，后自增1
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1);//a1 = 11
System.out.println("b1 = " + b1);//b1 = 11
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2);//a2 = 11
System.out.println("b2 = " + b2);//b2 = 10
//说明：++ 或 --的操作，并不会改变变量本身的数据类型
short s1 = 10;
//s1 = s1 + 1;//编译错误
//s1 = (short)(s1 + 1);//之前的做法
s1++;
System.out.println(s1);
//(前)-- ： 先自减1，再运算
//(后)-- ：先运算，后自减1
int a3 = 10;
int b3 = --a3;
//int b3 = a3--;
}
}
2. 赋值运算符
= , +=, -=, *=, /=, %=
- 代码演示
class SetValueTest {
public static void main(String[] args) {
byte num1 = 10;
int num2 = num1;//自动类型提升
float num3 = 10.4F;
num2 = (int)num3;//强制类型转换
int m = 10;
m += 5; //类似于 m = m + 5;
System.out.println("m = " + m);
short s1 = 10;
s1 += 5;//运算以后的结果，仍为原数据类型
System.out.println("s1 = " + s1);
/*
拓展1：
int i = 1;
i *= 0.1;
拓展2：
int n = 10;
n += (n++) + (++n);
拓展3：
int m = 2;
int n = 3;
n *= m++; //n = n * m++
System.out.println("m=" + m);
System.out.println("n=" + n);
*/
int n = 10;
n += (n++) + (++n); //n = n + (n++) + (++n)
System.out.println(n);//32
//开发场景1：定义了int型变量，想让此变量自增1,如何操作？
int i = 10;
//方法一：
//i = i + 1;
//方式二：推荐
//i++;
//方式三：
//i += 1;
//开发场景2：定义了int型变量，想让此变量自增2,如何操作？
int j = 10;
//方法一：
//j = j + 1;
//方式二：推荐。因为不改变数据类型
//j += 2;
//错误的
//(j++)++;
}
}
3. 比较运算符
== != > < >= <= instanceof(略)
说明：
① 运算的结果为boolean类型
② 特别小心== 和 = 的区别
- 代码演示
class CompareTest {
public static void main(String[] args) {
int a = 10;
int b = 20;
System.out.println(a == b);//false
System.out.println(a = b);//20
boolean b1 = true;
boolean b2 = false;
System.out.println(b1 == b2);//false
System.out.println(b2 = b1);//true
}
}
2800
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
