003-Java基础
程序员文章站
2022-04-22 11:41:01
Java基础1.注释2.关键字3.数据类型3.1 数据类型之间的转换4.标识符5.常量变量6.运算符1.注释2.关键字3.数据类型3.1 数据类型之间的转换4.标识符5.常量变量6.运算符...
Java基础
源码项目地址: https://gitee.com/jack0240/JavaSE.git
/ src / chapter003 包下面
1.Java注释
/**
* 这个是文档注释, 对类/方法/常量等的说明
* JavaSE 第三章
*/
public class Chapter003 {
/**
* 程序执行入口
*/
public static void main(String[] args) {
// 单行注释 对语句/变量等进行说明, 一般在语句上方
System.out.println("这是单行注释:// 前面有个空格哟");
/*
这是多行注释 使用比较少
*/
System.out.println("这是单行注释:/*注释内容在里面*/");
System.out.println("这是文档注释:/**注释内容在里面*/");
}
}
2.Java关键字
引用菜鸟教程https://www.runoob.com/java/java-basic-syntax.html
这里大概有个印象, 后面代码会有讲解
类别 | 关键字 | 说明 |
---|---|---|
访问控制 | 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 | 字符型 | |
short | 短整型 | |
int | 整型 | |
long | 长整型 | |
float | 单精度浮点 | |
double | 双精度浮点 | |
变量引用 | super | 父类,超类 |
this | 本类 | |
void | 无返回值 | |
保留关键字 | goto | 是关键字,但不能使用 |
const | 是关键字,但不能使用 | |
null | 空 |
3.Java基本数据类型
参考菜鸟教程:https://www.runoob.com/java/java-basic-datatypes.html
public class Point02 {
/**
* 程序执行入口
*/
public static void main(String[] args) {
dateType();
}
// 类变量不需要初始化值, 在加载类时会填充默认值
boolean defaltBoolean;
/**
* Java里面的变量需要申请内存进行存储的, 和C/C++一样
* 每个类型的变量所需的内存不一样, 所有导致存储的大小和能力不同
* Java 分为两大数据类型(这里我们先讨论基本数据类型)
* 1.基本数据类型
* 2.引用数据类型
*/
public static void dateType(){
/**
* byte
* 8位二进制
* 最小值是 -128(-2^7)
* 最大值是 127(2^7-1)
* 默认值是 0
*/
System.out.println("基本类型:byte 二进制位数:" + Byte.SIZE);
System.out.println("包装类:java.lang.Byte");
System.out.println("最小值:Byte.MIN_VALUE=" + Byte.MIN_VALUE);
System.out.println("最大值:Byte.MAX_VALUE=" + Byte.MAX_VALUE);
System.out.println();
/**
* short
* 16 位二进制
* 最小值是 -32768(-2^15)
* 最大值是 32767(2^15 - 1)
* 默认值是 0
*/
System.out.println("基本类型:short 二进制位数:" + Short.SIZE);
System.out.println("包装类:java.lang.Short");
System.out.println("最小值:Short.MIN_VALUE=" + Short.MIN_VALUE);
System.out.println("最大值:Short.MAX_VALUE=" + Short.MAX_VALUE);
System.out.println();
/**
* int
* 32 位二进制
* 最小值是 -2,147,483,648(-2^31)
* 最大值是 2,147,483,647(2^31 - 1)
* 默认值是 0
*/
System.out.println("基本类型:int 二进制位数:" + Integer.SIZE);
System.out.println("包装类:java.lang.Integer");
System.out.println("最小值:Integer.MIN_VALUE=" + Integer.MIN_VALUE);
System.out.println("最大值:Integer.MAX_VALUE=" + Integer.MAX_VALUE);
System.out.println();
/**
* long
* 64 位二进制
* 最小值是 -9,223,372,036,854,775,808(-2^63)
* 最大值是 9,223,372,036,854,775,807(2^63 -1)
* 默认值是 0L
*/
System.out.println("基本类型:long 二进制位数:" + Long.SIZE);
System.out.println("包装类:java.lang.Long");
System.out.println("最小值:Long.MIN_VALUE=" + Long.MIN_VALUE);
System.out.println("最大值:Long.MAX_VALUE=" + Long.MAX_VALUE);
System.out.println();
/**
* float
* 32 位二进制
* 默认值是 0.0f
*/
System.out.println("基本类型:float 二进制位数:" + Float.SIZE);
System.out.println("包装类:java.lang.Float");
System.out.println("最小值:Float.MIN_VALUE=" + Float.MIN_VALUE);
System.out.println("最大值:Float.MAX_VALUE=" + Float.MAX_VALUE);
System.out.println();
/**
* double
* 64 位二进制
* 默认值是 0.0
*/
System.out.println("基本类型:double 二进制位数:" + Double.SIZE);
System.out.println("包装类:java.lang.Double");
System.out.println("最小值:Double.MIN_VALUE=" + Double.MIN_VALUE);
System.out.println("最大值:Double.MAX_VALUE=" + Double.MAX_VALUE);
System.out.println();
/**
* boolean
* 1 位二进制
* 默认值是 false
*/
// 方法里面的变量必须初始化值分配空间, 不然编译器无法通过
boolean defaltBoolean = false;
System.out.println("基本类型:boolean 默认值 : " + defaltBoolean);
/**
* char
* 16 位 Unicode 字符(可以是中文)
* Java采用的就是Unicode编码 也就是说变量名可以是中文 但是没人这么做
* 最小值是 \u0000(即为0)
* 最大值是 \uffff(即为65,535)
*/
System.out.println("基本类型:char 二进制位数:" + Character.SIZE);
System.out.println("包装类:java.lang.Character");
// 以数值形式而不是字符形式将Character.MIN_VALUE输出到控制台
System.out.println("最小值:Character.MIN_VALUE=" + (int) Character.MIN_VALUE);
// 以数值形式而不是字符形式将Character.MAX_VALUE输出到控制台
System.out.println("最大值:Character.MAX_VALUE=" + (int) Character.MAX_VALUE);
}
}
3.1 Java数据类型之间的转换
public class Point03 {
/**
* 程序执行入口
*/
public static void main(String[] args) {
/**
* 类型转换分为 自动类型转换 和 强制类型转换
* 转换从低级到高级:
* byte,short,char—> int —> long—> float —> double
*/
byte byteVar = 1;
// 自动转换, 小容器倒进大容器, 值还是不变的.
int intVar = byteVar;
// byte-->int====1
System.out.println("byte-->int====" + intVar);
// 强制转换, 大容器倒进小容器, 会导致精度丢失.
float floatVar = 666.666f;
intVar = 666;
byteVar = (byte) intVar;
intVar = (int) floatVar;
// int-->byte====-102
System.out.println("int-->byte====" + byteVar);
// float-->int====666
System.out.println("float-->int====" + intVar);
}
}
4. Java标识符
Java中取类名, 变量名, 方法名等时需要注意的规则,名字不是乱取的。
开头 : 所有的标识符都应该以字母(A-Z 或者 a-z),美元符($)、或者下划线(_)开头
结尾 : 首字符之后可以是字母(A-Z 或者 a-z),美元符($)、下划线(_)或数字的任何字符组合结尾
关键字不能用作标识符
标识符是大小写敏感的
- 标识符可以是中文, 但没人这么干
/***********标识符举例***********/
int 你好 = 1;
double _i_ = 10;
float aaaaaaaaaaa = 88f;
char $$$$hhhhhh$$$ = 99;
boolean hh6666 = false;
5. Java常量变量
Java 变量/常量
- 局部变量/常量
- 类变量/常量(静态)
- 成员变量/常量(非静态)
带
final
关键字的就是常量, 一般用大写字母 下划线分隔
public class Point04 {
/**
* 成员变量(非静态变量)
*/
int memberVar;
/**
* 类变量(静态变量)
*/
static int memberStaticVar;
/**
* 声明成员常量
* 必须要赋初值
*/
final int MEMBER_VAR = 1;
/**
* 静态常量
* 必须要赋初值
*/
public static final double MEMBER_STATIC = 0;
public static void main(String[] args) {
/***********常量变量***********/
// 局部变量, 使用时需要初始化
int localVar = 0;
// 声明局部常量
final double LOCAL_VAR = 0;
// 成员变量必须要new出一个对象来使用
Point04 p = new Point04();
System.out.println("memberVar===" + p.memberVar);
System.out.println("memberStaticVar===" + memberStaticVar);
System.out.println("localVar===" + localVar);
System.out.println("MEMBER_VAR===" + p.MEMBER_VAR);
System.out.println("MEMBER_STATIC===" + MEMBER_STATIC);
System.out.println("LOCAL_VAR===" + LOCAL_VAR);
}
}
6. Java运算符
参考博客https://blog.csdn.net/shuaigexiaobo/article/details/88535745
初始化 a = 10, b = 20;
6.1 算数运算
操作符 | 描述 | 例子 |
---|---|---|
+ | 加法 | a+ b 等于 30 |
- | 减法 | a– b 等于 -10 |
* | 乘法 | a* b等于200 |
/ | 除法 | b / a等于2 |
% | 取余 - 左操作数除以右操作数的余数 | b%a等于0 |
++ | 自增: 操作数的值增加1 | a++ 或 ++a 等于 11 |
– | 自减: 操作数的值减少1 | b-- 或 --b 等于 19 |
6.2 关系运算
操作符 | 描述 | 例子 |
---|---|---|
== | 检查如果两个操作数的值是否相等,如果相等则条件为真。 | (A == B)为假。 |
!= | 检查如果两个操作数的值是否相等,如果值不相等则条件为真。 | (A != B) 为真。 |
> | 检查左操作数的值是否大于右操作数的值,如果是那么条件为真。 | (A> B)为假。 |
< | 检查左操作数的值是否小于右操作数的值,如果是那么条件为真。 | (A <B)为真。 |
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是那么条件为真。 | (A> = B)为假。 |
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是那么条件为真。 | (A <= B)为真。 |
6.3 逻辑运算
操作符 | 描述 | 例子 |
---|---|---|
&& | 称为逻辑与运算符。当且仅当两个操作数都为真,条件才为真。 | (true && false)为假。 |
|| | 称为逻辑或操作符。如果任何两个操作数任何一个为真,条件为真。 | (true || false)为真。 |
! | 称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true,则逻辑非运算符将得到false。 | !(false && true)为真。 |
6.4 位运算
操作符 | 描述 | 例子 |
---|---|---|
& | 按位与, 如果相对应位都是1,则结果为1,否则为0 | (A&B),得到12,即0000 1100 |
| | 按位或, 如果相对应位都是0,则结果为0,否则为1 | (A |
^ | 异或, 如果相对应位值相同,则结果为0,否则为1 | (A ^ B)得到49,即 0011 0001 |
〜 | 按位取反运算符翻转操作数的每一位,即0变成1,1变成0。 | (〜A)得到-61,即1100 0011 |
<< | 按位左移运算符。左操作数按位左移右操作数指定的位数。 | A << 2得到240,即 1111 0000 |
>> | 按位右移运算符。左操作数按位右移右操作数指定的位数。 | A >> 2得到15即 1111 |
>>> | 按位右移补零操作符。左操作数的值按右操作数指定的位数右移,移动得到的空位以零填充。 | A>>>2得到15即0000 1111 |
public class Point05 {
public static void main(String[] args) {
int a = 10;
int b = 20;
// 算数运算
System.out.println("a + b = " + (a + b));
System.out.println("a - b = " + (a - b));
System.out.println("a * b = " + (a * b));
System.out.println("a / b = " + (a / b));
System.out.println("a % b = " + (a % b));
System.out.println("a++ = " + a++ + ", ++a = "+ ++a);
System.out.println("a-- = " + a-- + ", --a = "+ --a);
// 关系运算
System.out.println("a == b is " + (a == b));
System.out.println("a != b is " + (a != b));
System.out.println("a > b is " + (a > b));
System.out.println("a < b is " + (a < b));
System.out.println("a >= b is " + (a >= b));
System.out.println("a <= b is " + (a <= b));
// 逻辑运算
boolean flagA = true;
boolean flagB = false;
System.out.println("true && false is " + (flagA && flagB));
System.out.println("true || false is " + (flagA || flagB));
System.out.println("!true is " + (!flagA));
// 位运算
System.out.println("a 的二进制: " + Integer.toBinaryString(a));
System.out.println("b 的二进制: " + Integer.toBinaryString(b));
System.out.println("a & b = " + (a & b));
System.out.println("a | b = " + (a | b));
System.out.println("a ^ b = " + (a ^ b));
System.out.println("~a = " + (~a));
System.out.println("a << 2 = " + (a <<2));
System.out.println("a >> 2 = " + (a >>2));
System.out.println("a >>> 2 = " + (a >>>2));
}
}
7. Java包装类
/**
* 包装类的使用介绍
* 参考链接: https://www.cnblogs.com/lyq-biu/p/10778109.html
*/
public static void packaging(){
//1.自动装箱
int t1=1;
Integer t2=t1;
//2.手动装箱
Integer t3=new Integer(t1);
System.out.println("int类型t1="+t1);
System.out.println("自动装箱,Integer类型对象t2="+t2);
System.out.println("手动装箱,Integer类型t3="+t3);
//1.自动拆箱
int t4=t2;
//2.手动拆箱
//通过intValue()方法返回int值,还可以利用其他方法装换为其他类型
int t5=t2.intValue();
System.out.println("自动拆箱,int型t4="+t4);
System.out.println("手动拆箱,int型t5="+t5);
//基本数据类型转换为字符串
String str=Integer.toString(t1);
System.out.println("int转换为String:"+str);
//字符串转换为基本数据类型
//通过paerInt方法
int it=Integer.parseInt(str);
//通过valeOf,先把字符串转换为包装类然后通过自动拆箱
int it1=Integer.valueOf(str);
Integer one=new Integer(100);
Integer two=new Integer(100);
//one和对two是两个不同的对象,==在比较对象时比较的是内存地址,两个是不同的空间,放的值相同
System.out.println("one==two:"+(one==two));
Integer three=100;//自动装箱
/* Integer three=Integer.valueOf(100);
* 这时缓存区没有,就会构造一个
*/
System.out.println("three==100:"+(three==100));//自动拆箱
Integer four=100;
/*实际执行的是 Integer four=Integer.valueOf(100); 这时缓存区有,就会直接取
* Java为了提高拆装箱效率,在执行过程中提供了一个缓存区(对象池)【类似于常量数组】,
* 如果传入的参数是,-128<参数<127会直接去缓存查找数据,如果有久直接产生,如果没有就隐式调用new方法产生
*/
System.out.println("three==four:"+(three==four));
Integer five=200;
System.out.println("five==200:"+(five==200));
Integer six=200;
//注:这里为200,超出了缓存区范围,所以都需要构建
System.out.println("five==six:"+(five==six));
/*
* 输出:
* one==two:false
three==100:true
three==four:true
five==200:true
five==six:false
*/
}
本文地址:https://blog.csdn.net/WeiHao0240/article/details/109106474