知识点1：关键字和保留字
关键字(keyword)的定义和特点
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EPFW0Kpt-1593436595211)(assets/1592816716644.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FkOJRLMc-1593436595212)(assets/1592816725113.png)]
Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字
比如：goto 、const知识点2：标识符
- 概念
1. java中定义的变量名、方法名、类名、接口名、常量名、包名等都是标识符
2. 技巧：凡是可以自己命名的地方，都是标识符- 命名规则
3. 定义合法标识符规则：
> 由26个英文字母大小写，0-9 ，_或 $ 组成
> 数字不可以开头。
> 不可以使用关键字和保留字，但能包含关键字和保留字。
> Java中严格区分大小写，长度无限制。
> 标识符不能包含空格。
小结：凡是不满足上述规则的命名，都会报编译的错误！- 命名规范
4. 标识符命名规范：
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz （大驼峰）
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz （小驼峰）
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
小结：如果不满足上述的规范，编译、运行仍可正常执行。
要求大家在开发时，要遵循上述的规范！- 注意点
5. 给标识符命名时，要见名知意。- 对应的代码测试
class IdentifierTest {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
class _8hello1
{
}
class public1{
}
class Goto{
}
class Ren{
}
class staticvoid{
}
class Hello123{
}
/*
class hello123{
}
*/知识点3：变量
- 说明
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;
}
}知识点4：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){
}
*/知识点5: 基本数据类型间的运算规则
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;
}
}知识点6：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("芳芳老师很\"漂亮\"");//芳芳老师很"漂亮"知识点7：进制间的运算（了解）
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. 与其他进制间的转换
- 二进制转换为八进制、十六进制
- 八进制、十六进制转换为二进制
知识点8：运算符
1. 逻辑运算符
- 说明
& && | || ! ^
说明：
1. 逻辑运算符操作的都是boolean类型的变量
2. 逻辑运算符的运算结果也是boolean类型- 代码演示
class LogicTest {
public static void main(String[] args) {
//& 和 &&相同点：当符号左边是true时，都执行符号右边的操作
//不同点：
//& : 当符号左边是false时,继续执行符号右边的操作
//&& : 当符号左边是false时,不再执行符号右边的操作
//& 与 && 表达的都是且的关系。但是，在开发中我们使用&&的频率高一些。
boolean b1 = true;
b1 = false;
int n1 = 10;
if(b1 & (n1++) > 0){
System.out.println("今天天气稍微闷热一些~");
}else{
System.out.println("明天预计天气稍微闷热一些~");
}
System.out.println("n1 = " + n1);
//#################################
boolean b2 = true;
b2 = false;
int n2 = 10;
if(b2 && (n2++) > 0){
System.out.println("今天天气稍微闷热一些~");
}else{
System.out.println("明天预计天气稍微闷热一些~");
}
System.out.println("n2 = " + n2);
//###############################
//| 和 || 相同点：当符号左边是false时，都执行符号右边的操作
//不同点：
//| : 当符号左边是true时,继续执行符号右边的操作
//|| : 当符号左边是true时,不再执行符号右边的操作
//| 与 || 表达的都是或的关系。但是，在开发中我们使用||的频率高一些。
boolean b3 = false;
b3 = true;
int n3 = 10;
if(b3 | (n3++) > 0){
System.out.println("今天天气稍微闷热一些~");
}else{
System.out.println("明天预计天气稍微闷热一些~");
}
System.out.println("n3 = " + n3);
//###################
boolean b4 = false;
b4 = true;
int n4 = 10;
if(b4 || (n4++) > 0){
System.out.println("今天天气稍微闷热一些~");
}else{
System.out.println("明天预计天气稍微闷热一些~");
}
System.out.println("n4 = " + n4);
}
}2. 位运算符
- 说明
<< >> >>> & | ^ ~
总结：
<< ： 在一定范围内，每左移一位，数值*2
>> : 在一定范围内，每右移一位，数值 / 2
"过犹不及"
>>> : 不管是正数还是负数，右移之后，高位都补0
总结：我们在开发中使用位运算的机会不多。
具体说到如果使用的话，主要是为了提升运算的效率。
经典的面试题：
最高效的方式计算 2 * 8
2 << 3
8 << 1- 举例
- 代码演示
class BitTest {
public static void main(String[] args) {
System.out.println("13 << 2 : " + (13 << 2));
System.out.println("-13 << 2 : " + (-13 << 2));
System.out.println("13 << 27 : " + (13 << 27));
System.out.println("13 << 28 : " + (13 << 28));
System.out.println("13 >> 2 : " + (13 >> 2));
System.out.println("-13 >> 2 : " + (-13 >> 2));
System.out.println("-13 >>> 2 : " + (-13 >>> 2));
//练习：如何交换两个int型变量的值
int m = 10;
int n = 20;
System.out.println("m = " + m + ", n = " + n);
//交换两个变量的值(重点)
//方式一：推荐！
//int temp = m;
//m = n;
//n = temp;
//方式二：使用有局限性：① 可能会超出int的范围 ② 数据类型的局限性
//m = m + n;//10 + 20
//n = m - n;//30 - 20
//m = m - n;//30 - 10
//方式三：使用有局限性：数据类型的局限性
m = m ^ n;
n = m ^ n;
m = m ^ n;
System.out.println("m = " + m + ", n = " + n);
}
}3. 三元运算符
- 说明
格式： (条件表达式)? 表达式1 : 表达式2
说明1： ① 条件表达式的结果为boolean
② 如果条件表达式的结果为true,则返回表达式1。反之，如果条件表达式的结果为false,则返回表达式2
③ 表达式1和表达式2满足一致性。
说明2：三元运算符可以嵌套使用
说明3：凡是可以使用三元运算符的地方，都可以改写成if-else结构。反之，不成立。
凡是既可以使用三元运算符，又可以使用if-else结构的地方，建议使用三元运算符。因为执行效率高一些。- 代码演示
class SanYuanTest {
public static void main(String[] args) {
//获取两个数的较大值
int m = 10;
byte n = 15;
int max = (m > n)? m : n;
System.out.println("较大值为：" + max);
//String s = 12;//编译不通过
String maxString = (m > n)? "m大" : "n大";
n = 10;
String maxString1 = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
System.out.println(maxString);
System.out.println(maxString1);
//练习：获取三个数的最大值
int a = 10;
int b = 43;
int c = 5;
int max1 = (a > b)? a : b;
int max2 = (max1 > c)? max1 : c;//不建议： int max2 = (((a > b)? a : b) > c)? ((a > b)? a : b) : c;
System.out.println(max2);
}
}4. 运算符的优先级
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
