笔记源于 视频教程Bilibili:狂神说Java 关注公众号:狂神说
Java基础语法1
注释、标识符、关键字
注释Comments
注释并不会被执行,是给我们写代码的人看的。
书写注释是个非常好的习惯,平时就要注意规范
-
单行注释 //
-
多行注释 /* */
-
文档注释 /** */
单行注释
只能注释一行文字
多行注释
可以注释一段文字 /* */
文档注释
使用文档注释时,需要在开始的 /** 之后,第一行或几行是关于类、变量和方法的主要描述。
之后,可以包含一个或多个何种各样的@ 标签。每一个@标签必须在一个新行的开始或者在一行的开始紧跟星号(*)。
多个相同类型的标签应该放成一组。
代码
public class HelloJava {
/**
* @param args
* @author Ljh
* 文档注释给某个类或方法解释说明
*/
public static void main(String[] args) {
//这是一个单行注释
System.out.println("Hello Java!");
/* 多行注释
_(\_/)
,((((^`
(((( (6
,((((( ,
,,,_ ,((((( /"._ ,`,
((((\ ,... ,(((( / `-.-'
))) ;' `"'"'""(((( (
((( / (((
)) | |
(( | . ' |
)) _ ' `t ,.')
( | y;- -,-""'"-. /
) / ./ ) / `
|./ ( ( / /'
|| \ //'|
|| \ _//'||
|| )) |_/ ||
\_ |_/ ||
`'" \_
*/
}
}
可以搜索有趣的代码注释
标识符
Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。
关于 Java 标识符,有以下几点需要注意:
- 所有的标识符都应该以字母(A-Z 或者 a-z),美元符($)、或者下划线(_)开始
- 首字符之后可以是字母(A-Z 或者 a-z),美元符($)、下划线(_)或数字的任何字符组合
- 关键字不能用作标识符
- 标识符是大小写敏感的
- 合法标识符举例:age、$salary、_value、__1_value
- 非法标识符举例:123abc、-salary 、#abc
- 可以使用中文命名,但不建议用,也不要用拼音,Low
public class TAG {
public static void main(String[] args) {
String A_ = "首大写字母开头";
String a_ = "首小写字母开头";
String _A= "下划线开头";
String $_ = "美元符号开头";
// 不允许数字或非法符号开头
// 非法符号:除了 _ $ 以外的任何符号
// String 1_ = "数字开头"; X
// String #_ = "非法符号开头"; X
String _1Aa$ = "首字母之后可任意组合";
// 不允许出现非法符号
// String _# = "出现非法符号"; X
}
}
关键字
下面列出了 Java 关键字。这些保留字不能用于常量、变量、和任何标识符的名称。
类别 | 关键字 | 说明 |
---|---|---|
访问控制 | private | 私有的 |
访问控制 | protected | 受保护的 |
访问控制 | public | 公共的 |
访问控制 | default | 默认 |
类、方法和变量修饰符 | abstract | 声明抽象 |
类、方法和变量修饰符 | class | 类 |
类、方法和变量修饰符 | extends | 扩充,继承 |
类、方法和变量修饰符 | final | 最终值,不可改变的 |
类、方法和变量修饰符 | implements | 实现(接口) |
类、方法和变量修饰符 | interface | 接口 |
类、方法和变量修饰符 | native | 本地,原生方法(非 Java 实现) |
类、方法和变量修饰符 | new | 新,创建 |
类、方法和变量修饰符 | static | 静态 |
类、方法和变量修饰符 | strictfp | 严格,精准 |
类、方法和变量修饰符 | synchronized | 线程,同步 |
类、方法和变量修饰符 | transient | 短暂 |
类、方法和变量修饰符 | volatile | 易失 |
程序控制语句 | break | 跳出循环 |
程序控制语句 | case | 定义一个值以供 switch 选择 |
程序控制语句 | continue | 继续 |
程序控制语句 | default | 默认 |
程序控制语句 | do | 运行 |
程序控制语句 | else | 否则 |
程序控制语句 | for | 循环 |
程序控制语句 | if | 如果 |
程序控制语句 | instanceof | 实例 |
程序控制语句 | return | 返回 |
程序控制语句 | switch | 根据值选择执行 |
程序控制语句 | while | 循环 |
错误处理 | assert | 断言表达式是否为真 |
错误处理 | catch | 捕捉异常 |
错误处理 | finally | 有没有异常都执行 |
错误处理 | throw | 抛出一个异常对象 |
错误处理 | throws | 声明一个异常可能被抛出 |
错误处理 | try | 捕获异常 |
包相关 | import | 引入 |
包相关 | package | 包 |
基本类型 | boolean | 布尔型 |
基本类型 | byte | 字节型 |
基本类型 | char | 字符型 |
基本类型 | double | 双精度浮点 |
基本类型 | float | 单精度浮点 |
基本类型 | int | 整型 |
基本类型 | long | 长整型 |
基本类型 | short | 短整型 |
变量引用 | super | 父类,超类 |
变量引用 | this | 本类 |
变量引用 | void | 无返回值 |
保留关键字 | goto | 是关键字,但不能使用 |
保留关键字 | const | 是关键字,但不能使用 |
保留关键字 | null | 空 |
数据类型
强类型语言
要求变量的使用要严格符合规定,所有变量都必须先定义后才能使用。
一旦一个变量被指定了某个数据类型,如果不经过强制转换,那么它就永远是这个数据类型了。
举个例子:如果你定义了一个整型变量 a,那么程序根本不可能将 a 当作字符串类型处理。强类型定义语言是类型安全的语言。
弱类型语言
它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。
所以Java是强类型语言,所有变量都必须先定义后才能使用。
Java的数据类型分为两大类
基本类型(primitive type)
Java语言提供了八种基本类型。六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。
byte:
- byte 数据类型是8位、有符号的,以二进制补码表示的整数;
- 最小值是 -128(-2^7);
- 最大值是 127(2^7-1);
- 默认值是 0;
- byte 类型用在大型数组中节约空间,主要代替整数,因为 byte 变量占用的空间只有 int 类型的四分之一;
- 例子:byte a = 100,byte b = -50。
short:
- short 数据类型是 16 位、有符号的以二进制补码表示的整数
- 最小值是 -32768(-2^15);
- 最大值是 32767(2^15 - 1);
- Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一;
- 默认值是 0;
- 例子:short s = 1000,short r = -20000。
int:
- int 数据类型是32位、有符号的以二进制补码表示的整数;
- 最小值是 -2,147,483,648(-2^31);
- 最大值是 2,147,483,647(2^31 - 1);
- 一般地整型变量默认为 int 类型;
- 默认值是 0 ;
- 例子:int a = 100000, int b = -200000。
long:
- long 数据类型是 64 位、有符号的以二进制补码表示的整数;
- 最小值是 -9,223,372,036,854,775,808(-2^63);
- 最大值是 9,223,372,036,854,775,807(2^63 -1);
- 这种类型主要使用在需要比较大整数的系统上;
- 默认值是
0L
; - 例子: long a = 100000L,Long b = -200000L。
"L"理论上不分大小写,但是若写成"l"容易与数字"1"混淆,不容易分辩。所以最好大写。
float:
- float 数据类型是单精度、32位、符合IEEE 754标准的浮点数;
- float 在储存大型浮点数组的时候可节省内存空间;
- 默认值是
0.0f
; - 浮点数不能用来表示精确的值,如货币;
- 例子:float f1 = 234.5f。
double:
- double 数据类型是双精度、64 位、符合IEEE 754标准的浮点数;
- 浮点数的默认类型为double类型;
- double类型同样不能表示精确的值,如货币;
- 默认值是
0.0d
;可省略 - 例子:double d1 = 123.4。
boolean:
- boolean数据类型表示一位的信息;
- 只有两个取值:true 和 false;
- 这种类型只作为一种标志来记录 true/false 情况;
- 默认值是 false;
- 例子:boolean one = true。
char:
- char类型是一个单一的 16 位 Unicode 字符;
- 最小值是 u0000(即为0);
- 最大值是 uffff(即为65,535);
- char 数据类型可以储存任何字符;
- 例子:char letter = 'A';
/**
* 介绍8大基本数据类型
*/
public class PrimaryType {
public static void main(String[] args) {
// 八大基本数据类型
// 整数
byte byte_num = 127; // 8位1字节 2^8=256 范围:-2^7 ~ 2^7 -1 (-128 ~ 127)
short short_num = 32767; // 2字节 范围:+-三万多
int int_num = 123456; // 最常用。 4字节,范围:正负21亿多
long long_num = 99999999999999L; //8字节! 当超过int范围时需要在数字后面加L
// 浮点数
float float_num = 0.1F; // 4字节,后面必须加F
double double_num = 0.1; // 8字节,结尾的d 可加可不加
//字符
char ch = '1'; // 单一的 16 位 Unicode 字符
String str = "123456"; // 字符串不是基本数据类型,而是一个类
//布尔类型
boolean flag = true;
boolean flag2 = false;
}
}
基本数据类型扩展
/**
* 数据类型面试题
*/
public class PrimaryTypeExt {
public static void main(String[] args) {
/* 二进制是Binary,简写为B
八进制是Octal,简写为O
十进制为Decimal,简写为D
十六进制为Hexadecimal,简写为H
*/
//整数扩展 进制: 2 8 10 16
int bin_num = 0b10; // 二进制 0b 开头
int oct_num = 010; // 八进制0开头
int dec_num = 10; // 十进制正常写
int hex_num = 0x10; // 十六进制 0x 开头
System.out.println(bin_num);//默认打印10进制
System.out.println(oct_num);
System.out.println(dec_num);
System.out.println(hex_num);
System.out.println("----------------");
//浮点数 精度有丢失
// 所以银行业务不用float,用BigDecimal
// 最好完全避免使用浮点数进行比较!!!
float num1 = 4.0f;
float num2 = 3.6f;
System.out.println(num1 - num2); //0.4000001
//如何解释出现4.0-3.6 =0.40000001
// 答:二进制的小数无法精确的表示10进制小数,
// 计算机在计算4.0 -3.6 时,先将两数转成2进制形式
// 用二进制计算后再将结果转成十进制,这期间出现了误差。
System.out.println("--------字符串扩展--------");
//字符串扩展
char ch = 'A'; // 底层原理 是 'u0041' 十进制的65 -> 十六进制41
char ch2 = '国';
System.out.println((int) ch);
System.out.println((int) ch2);
System.out.println('u0041');//Unicode编码
// 所有的字符本质还是数字
System.out.println("--------转义字符\--------");
// 转义字符
System.out.println("换行
tab 键");
System.out.println("--------布尔扩展--------");
// 布尔使用
boolean flag = true;
if (flag == true)
System.out.println("新手用法");
if (flag)
System.out.println("老手用法");
// 代码要精简易读
}
}
引用类型(reference type)
除了八大基本数据类型之外其他都是引用类型
如 类,接口,数组等
-
在Java中,引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象,指向对象的变量是引用变量。
这些变量在声明时被指定为一个特定的类型,比如 Employee、Puppy 等。变量一旦声明后,类型就不能被改变了。
-
对象、数组都是引用数据类型。
-
所有引用类型的默认值都是null。
-
一个引用变量可以用来引用任何与之兼容的类型。
浮点储存模型
二进制的科学计数法来保存浮点数,
例如:5.5,其二进制数为101.1,则用二进制的科学计数法可以表示为 1.011 * 2^2,这样小数点的位置就是固定的。
任何一个浮点数可以表示为下面的形式(国际标准IEEE 754):
(-1)^S * M * 2^E
(-1)^S表示符号位,当S=0时,为正;当S=1时,为负
M表示有效数字,M>=1且M<2
2^E表示指数位
上面的例子中,S=0,M=1.011,E=2。
所以当存储浮点数时,只需要将上述三个数字保存起来,就可以了。
对于但精度浮点数,其存储模型为:
类型转换
整型、实型(常量)、字符型数据可以混合运算。运算中,不同类型的数据先转化为同一类型,然后进行运算。
转换从低级到高级。
低 --------------------------------------> 高
byte,short,char—> int —> long—> float —> double
数据类型转换必须满足如下规则:
-
不能对boolean类型进行类型转换。
-
不能把对象类型转换成不相关类的对象。
-
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
-
转换过程中可能导致溢出或损失精度,例如:
int i =128; byte b = (byte)i;
因为 byte 类型是 8 位,最大值为127,所以当 int 强制转换为 byte 类型时,值 128 时候就会导致溢出。
-
浮点数到整数的转换是通过舍弃小数得到,而不是四舍五入,例如:
(int)23.7 == 23; (int)-45.89f == -45
自动类型转换(低到高)
必须满足转换前的数据类型的位数要低于转换后的数据类型,
例如: short数据类型的位数为16位,就可以自动转换位数为32的int类型,
同样float数据类型的位数为32,可以自动转换为64位的double类型。
强制类型转换(高到底)
- 条件是转换的数据类型必须是兼容的。
- 格式:(type)value type是要强制类型转换后的数据类型
隐含强制类型转换
- 整数的默认类型是 int。
- 浮点型不存在这种情况,因为在定义 float 类型时必须在数字后面跟上 F 或者 f。
public class TypeConversion {
public static void main(String[] args) {
int i = 128;
byte b = (byte)i;
System.out.println(b);//byte类型的范围是-128 ~ 127 ,强转128溢出。
// 强制转换(类型)变量名
double d = i;
System.out.println(d);
// 由低 -> 高 自动转换
System.out.println((int)23.7);//23 去掉小数,不是四舍五入哦
System.out.println((int)-45.89f);// -45
System.out.println('a'+1); //a -> 97
System.out.println("----------");
// jdk7 特性 _
int num = 10_0000_0000;
System.out.println(num);
System.out.println(num*20);// int 的范围21亿多,现在结果200亿溢出
System.out.println((long)num*20);//先转换再计算
System.out.println((long)(num*20));//先计算再转换
long l = 1l; //小写l 与数字1太像了,建议都用大写L
}
}
变量、常量
变量
在Java语言中,所有的变量在使用前必须声明。声明变量的基本格式如下:
type varName[ = value][, varName[= value] ...]
;
格式说明:type为Java数据类型。varName是变量名。可以使用逗号隔开来声明多个同类型变量(不建议)。
作用域:
- 类变量:独立于方法之外的变量,用 static 修饰。
- 实例变量:独立于方法之外的变量,不过没有 static 修饰。
- 局部变量:类的方法中的变量。
类变量(静态变量)
- 类变量也称为静态变量,在类中以 static 关键字声明,但必须在方法之外。
- 无论一个类创建了多少个对象,类只拥有类变量的一份拷贝。
- 静态变量除了被声明为常量外很少使用。常量是指声明为public/private,final和static类型的变量。常量初始化后不可改变。
- 静态变量储存在静态存储区。经常被声明为常量,很少单独使用static声明变量。
- 静态变量在第一次被访问时创建,在程序结束时销毁。
- 与实例变量具有相似的可见性。但为了对类的使用者可见,大多数静态变量声明为public类型。
- 默认值和实例变量相似。数值型变量默认值是0,布尔型默认值是false,引用类型默认值是null。变量的值可以在声明的时候指定,也可以在构造方法中指定。此外,静态变量还可以在静态语句块中初始化。
- 静态变量可以通过:ClassName.VariableName的方式访问。
- 类变量被声明为public static final类型时,类变量名称一般建议使用大写字母。如果静态变量不是public和final类型,其命名方式与实例变量以及局部变量的命名方式一致。
实例变量
- 实例变量声明在一个类中,但在方法、构造方法和语句块之外;
- 当一个对象被实例化之后,每个实例变量的值就跟着确定;
- 实例变量在对象创建的时候创建,在对象被销毁的时候销毁;
- 实例变量的值应该至少被一个方法、构造方法或者语句块引用,使得外部能够通过这些方式获取实例变量信息;
- 实例变量可以声明在使用前或者使用后;
- 访问修饰符可以修饰实例变量;
- 实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见;
- 实例变量具有默认值。数值型变量的默认值是0,布尔型变量的默认值是false,引用类型变量的默认值是null。变量的值可以在声明时指定,也可以在构造方法中指定;
- 实例变量可以直接通过变量名访问。但在静态方法以及其他类中,就应该使用完全限定名:ObejectReference.VariableName。
局部变量
- 局部变量声明在方法、构造方法或者语句块中;
- 局部变量在方法、构造方法、或者语句块被执行的时候创建,当它们执行完成后,变量将会被销毁;
- 访问修饰符不能用于局部变量;
- 局部变量只在声明它的方法、构造方法或者语句块中可见;
- 局部变量是在栈上分配的。
- 局部变量没有默认值,所以局部变量被声明后,必须经过初始化,才可以使用。
常量
常量在程序运行时是不能被修改的。
在 Java 中使用 final 关键字来修饰常量
,声明方式和变量类似:
final double PI = 3.1415927;
虽然常量名也可以用小写,但为了便于识别,通常使用大写字母表示常量
。
字面量可以赋给任何内置类型的变量。例如:
byte a = 68;
char a = 'A'
byte、int、long、和short都可以用十进制、16进制以及8进制的方式来表示。
当使用常量的时候,前缀 0 表示 8 进制,而前缀 0x 代表 16 进制, 例如:
int decimal = 100;
int octal = 0144;
int hexa = 0x64;
和其他语言一样,Java的字符串常量也是包含在两个引号之间的字符序列。下面是字符串型字面量的例子:
"Hello World"
"two
lines"
""This is in quotes""
字符串常量和字符常量都可以包含任何Unicode字符。例如:
char a = 'u0001';
String a = "u0001";
转义符
Java语言支持一些特殊的转义字符序列。
符号 | 字符含义 |
---|---|
换行 (0x0a) | |
回车 (0x0d) | |
f | 换页符(0x0c) |
退格 (0x08) | |