Java（二）
知识点1：关键字和保留字
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所有字母都为小写
- Java中定义的关键字如下：
- 保留字的理解
Java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字
。比如：goto 、const
知识点2：标识符(Identifier)
- 理解
1. 标识符：凡是自己可以起名字的地方都叫标识符。
比如：类名、变量名、方法名、接口名、包名等
- 命名的规则
【如果用户不遵守的话，编译不通过】
由26个英文字母大小写，0-9 ，_或 $ 组成
数字不可以开头。
不可以使用关键字和保留字，但能包含关键字和保留字。
Java中严格区分大小写，长度无限制。
标识符不能包含空格。
- 命名的规范
【如果用户不遵守的话，编译和运行都不受影响，能正常通过】
包名：多单词组成时所有字母都小写：xxxyyyzzz
类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz ---大驼峰
变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz ---小驼峰
常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ
- 注意点：在起名字时，为了提高阅读性，要尽量有意义，“见名知意”。
知识点3：变量的声明和初始化
/*
测试变量的定义
1. 变量的声明和赋值格式： 数据类型 变量名 = 变量值
2. 注意点：
① java是强类型的语言，声明的每个变量，一定要指名其变量类型。
② 变量一定需要在赋值之后才可以使用
③ 变量需要先声明，后赋值。
④ 变量都有其作用域，超出作用域范围后，就失效。
⑤ 在同一个作用域范围内，不可以定义同名的变量
*/
class VariableTest {
public static void main(String[] args) {
//myNumber = 1;
//变量的声明
int myNumber;
//变量的赋值
myNumber = 1;
//变量的声明和赋值同时进行
int count = 2;
System.out.println(myNumber + 1);
//编译不通过
//System.out.println(age);
//编译不通过：在同一个作用域范围内，不可以定义同名的变量
//int count = 3;
count = 3;//重新赋值
System.out.println(count);
int age = 20;
System.out.println(age);
}
public void method(){
int age = 10;
System.out.println(age);
}
}
知识点4： 8种基本数据类型
测试Java中的变量的分类
1. 变量的分类：按照数据类型区分
基本数据类型：整型： byte \ short \ int \ long
浮点型：float \ double
字符型：char
布尔型：boolean
引用数据类型：类 、 接口 、 数组
2. (了解)变量的分类：按照在类中声明的位置
成员变量 vs 局部变量
- 代码演示
class VariableTest1 {
public static void main(String[] args) {
//1. 整型： byte (1字节=8bit、-128~+127) \ short（2字节） \ int （4字节）\ long (8字节)
byte b1 = 12;
//b1 = 128;//编译不通过
System.out.println(b1);
short s1 = 1231;
int i1 = 324324;
//long类型的变量在赋值时，需要以"L"或"l"结尾
long l1 = 234324324L;
System.out.println(l1);
//开发中，从使用频率上来讲，一般整型定义为int
//2. 浮点型：float (4字节) \ double (8字节)
// 发现，float类型存储数据的范围，比long类型还要大。但是精度更低了。
// float类型的变量在赋值时，需要以"F"或"f"结尾
float f1 = 12.3F;
System.out.println(f1);
double d1 = 123.34;
//开发中，从使用频率上来讲，一般浮点型定义为double
//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 = '';
//char c6 = 'ab';
//此外，字符还可以有如下常见的表示：
//①使用转义字符来表示
char c7 = '\n';//换行
c7 = '\t';//制表符
System.out.print("hello");
System.out.print(c7);
System.out.print("world");
//② 使用unicode值的方式表示
char c8 = '\u0025';//%
System.out.println(c8);
//③ 使用ascii对应的数值表示
char c9 = 97;//'a'
c9 = 65;//'A'
System.out.println(c9);
//4. 布尔型：boolean
//只有两个值：true \ false
//常常在循环结构、条件判断结构中使用
boolean bo1 = true;
boolean bo2 = false;
if(bo2){
System.out.println("执行if结构");
}else{
System.out.println("执行else结构");
}
}
}
知识点5： 7种基本数据类型变量间的运算规则
1. 自动类型提升
- 说明
1. 运算涉及的类型：除了boolean型之外的，其他7种基本数据类型
2. 自动类型提升的规则：容量小的数据类型与容量大的数据类型的变量做运算时，结果的数据类型是容量大的数据类型
byte 、short 、char --> int --> long ---> float ---> double
特别的：byte 、short 、 char 三类数据类型之间做运算的话，结果为int类型。
说明：容量大小指的不是数据类型占用空间的大小，而是存储数据的范围的大小。
- 代码演示
class VariableTest2 {
public static void main(String[] args) {
byte b1 = 12;
int i1 = 10;
//编译不通过
//byte i2 = b1 + i1;
int i2 = b1 + i1;
float f1 = 12.3F;
float f2 = f1 + i1;
long l1 = 123L;
//编译不通过
//long l2 = f1 + l1;
float f3 = f1 + l1;
double d1 = f1 + l1;
double d2 = i1;
System.out.println(d2);//10.0
//#######################################################
byte bb1 = 10;
short s1 = 20;
//编译失败
//short s2 = bb1 + s1;
byte bb2 = 30;
//编译失败
//byte bb3 = bb1 + bb2;
short s2 = 40;
//编译失败
//short s3 = s1 + s2;
//################
char c1 = 'a';//97
int n1 = 10;
int n2 = c1 + n1;
int n3 = c1 + bb1;
System.out.println();
int n4 = c1;
int n5 = 'a';
//########举例#########
long lo1 = 123;//可以编译通过
//float f1 = 12.3;//编译不通过
}
}
2.强制类型转换
/*
测试基本数据类型变量间的运算规则
1. 运算涉及的类型：除了boolean型之外的，其他7种基本数据类型
2. 自动类型提升运算规则的逆运算：强制类型转换
3. 强制类型转换，需要使用强转符：()
4. 使用强制类型转换，可能会损失精度。
*/
class VariableTest3 {
public static void main(String[] args) {
int num = 10;
//编译失败
//byte b = num;
byte b = (byte)num;
System.out.println(b);
//产生了精度损失1
float f1 = 12.9F;
int num1 = (int)f1;
System.out.println(num1);
//产生了精度损失2
int num2 = 128;
byte b1 = (byte)num2;
System.out.println(b1);//-128
}
}
知识点6：String 与8种基本数据类型 之间的运算
- 说明
测试String与8种基本数据类型变量之间的运算
1. String：字符串，使用一对""表示。内部可以声明0个，1个或多个字符
2. String只能和8种基本数据类型的变量做连接运算：+
3. 运算的结果，仍为String类型
- 代码演示
class StringTest {
public static void main(String[] args) {
String info = "Hello World!";
String name = "tcliu";
System.out.println(info);
System.out.println(name);
String s1 = "";//编译通过
//####################################
int n1 = 10;
String s2 = "abc";
String s3 = n1 + s2;
System.out.println(s3);//10abc
boolean b1 = true;
String s4 = s2 + b1;
System.out.println(s4);//abctrue
System.out.println(s2 + n1 + b1);//abc10true
System.out.println(n1 + (b1 + s2));//10trueabc
//System.out.println(n1 + b1 + s2);//编译失败
//练习1：
//* *
System.out.println('*' + '\t' + '*');//no
System.out.println('*' + "\t" + '*');//yes
System.out.println('*' + '\t' + "*");//no
System.out.println("*" + '\t' + '*');//yes
//练习2：
int num = 10;
char c = 'a';//97
String s = "hello";
System.out.println(num + c + s);//107hello
System.out.println(s + c + num);//helloa10
System.out.println(num + (c + s));//10ahello
}
}
知识点7： 常量的理解
/*
关于常量的说明
*/
class ContantTest {
public static void main(String[] args) {
//###########################
//关于常量
int num1 = 10;
num1 = 20;
//对于整型常量而言，默认是int类型
int num2 = num1 + 30; //30:常量
byte b1 = 10;
int num3 = b1 + 30;
//对于浮点型常量而言：默认是double类型
double d1 = b1 + 12.3;
}
}
知识点8： 进制与进制间的转换（了解）
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 n1 = 0B1010;//二进制
int n2 = 1010;//十进制
System.out.println(n1);
System.out.println(n2);
int n3 = 0102;//八进制
System.out.println(n3);
int n4 = 0x123;//十六进制
System.out.println(n4);
}
}
2. 二进制转为十进制
2.1 二进制的原码、反码、补码的概念
> 无论是正数，还是负数，底层都是使用补码进行存储的。
> 对于正数而言，原码、反码、补码都相同。
>对于负数来说：
原码：直接将一个数值换成二进制数。最高位是符号位
负数的反码：是对原码按位取反，只是最高位（符号位）确定为1。
负数的补码：其反码加1。
2.2 二进制转为十进制
- 十进制转为二进制：除2取余的逆
3. 二进制与八进制、十六进制间的运算
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
