系列文章目录
提示:阅读本章之前,请先阅读目录
文章目录
前言
本章用于Java SE的学习的记录,最基础
Hello world
安装
- java jdk
- vscode
- 配置好java环境变量
编写代码
public class Test {
public static void main(String[] args) {
System.out.print("Hello world!!!");
}
}
运行
PS D:\java_code\test> javac .\Test.java
PS D:\java_code\test> java Test
Hello world!!!
注意事项
- 文件名要和class的类名一致
- 注意大小写
注释
public class Test {
public static void main(String[] args) {
System.out.print("Hello world!!!");
// 单行注释
/*
多行注释
*/
/**
* 文档式注释
*/
}
}
关键字
变量命名
public class Test {
public static void main(String[] args) {
// 以大小写字母开头 a~z A~Z 下划线_ $
String abc = "1";
String Abc = "2";
String _abc123 = "3";
String $abc123 = "4";
// 也可以使用中文
String 测试看看 = "ok";
// 以下不合法
String class = "使用关键字";
String void = "使用关键字";
String 123 = "使用数字开头";
// 测试输出
System.out.print(测试看看);
}
}
强类型语言
public class demo01 {
public static void main(String[] args) {
// 尚未初始化变量a
String a;
System.out.printf(a);
// 不兼容的类型: int无法转换为java.lang.String
String a = 10;
System.out.printf(a);
}
}
八大数据类型
public class demo02 {
public static void main(String [] args) {
// 八大数据类型
// 整数 byte short int long
byte num1 = 127;
short num2 = 12345;
int num3 = 1234567899;
long num4 = 1234567890987000006L; // long 类型的,要加L标识
// 浮点数 float double
float f1 = 1.25F;
double f2 = 123456789.123466088888888888888888888;
// 字符
char c1 = '我';
char c2 = '1';
String c3 = "大家好啊"; // 要用双引号,String 不是关键字,而是类,大写字母开头,几乎都是类
// 布尔 boolean
boolean b1 = true;
boolean b2 = false;
}
}
字节类型和单位
1 bit = 1 位
1 byte = 1 字节
1 byte = 8 bit
1 B = 8 b
1024 B = 1 M
1024 M = 1 G
1024 G = 1 T
进制转换
public class demo03 {
public static void main(String[] args) {
// 8进制 0开头
int num01 = 010;
// 10进制 正常
int num02 = 10;
// 16进制 0x 开头 0~9 A~F A为10,F为16
int num03 = 0x10;
System.out.println(num01);
System.out.println(num02);
System.out.println(num03);
}
}
运行结果
8
10
16
完全避免使用浮点数进行比较运算
public class demo04 {
public static void main(String[] args) {
// float 有限 离散 舍入误差 大约 接近但不等于1
// double
// 最好完全避免浮点数进行比较
// 最好完全避免浮点数进行比较
// 最好完全避免浮点数进行比较
// 可以使用BigDecimal工具类
// 诡异比较,结果都是0.1,但是比较完结果为false
float f1 = 0.1f;
double f2 = 1.0/10;
System.out.println(f1==f2);
// 诡异比较,结果完全不一样,但是比较结果为true
float d1 = 2333333333333333f;
float d2 = d1 + 1;
System.out.println(d2);
System.out.println(d2==d1);
}
}
运行结果
false
true
2.33333333E15
强制转换and转义字符
public class demo05 {
public static void main(String[] args) {
// 强制转换
char c1 = 'A';
char c2 = '我';
System.out.println((int)c1);
System.out.println((int)c2);
// unicode 编码
char c3 = '\u0055';
System.out.println(c3);
// 转义符
System.out.println("大家好\t你好,我要换行了\n啊啊啊");
}
}
运行结果
65
25105
U
大家好 你好,我要换行了
啊啊啊
字符比较实验,指针
public class demo06 {
public static void main(String[] args) {
// string 对象,不相同是因为指针的问题,这里创建了两个不同的对象
String s1 = new String("hello");
String s2 = new String("hello");
System.out.println(s1==s2);
// string 因为已经被分配了一个对象,所以内容一样的话,其实是指向同一个指针地址
String s3 = "hello";
String s4 = "hello";
System.out.println(s3==s4);
}
}
运行结果
false
true
类型转换
public class demo07 {
public static void main(String[] args) {
/*
规则一,不能对布尔值转换,原因是布尔值只有1位,1个字节=8位
规则二,不能把对象类型转换为不相干的类型
规则三,高容量转低容量,强制转换
规则四,低容量转高容量,自动转换
规则五,转换的时候,可能会存在内存溢出,或者精度问题
*/
// 内存溢出的情况,高转低
int i = 128; // byte最大是127
byte c = (byte)i;
System.out.println(c); // 输出-128
// 低转高,自动转换
int i1 = 1000;
double d1 = i1;
System.out.println(d1); // 输出1000.0
// 精度问题
System.out.println((int)1.23F); // 输出1
System.out.println((int)45.1); // 输出45
System.out.println((int)-45.123F); // 输出-45
System.out.println((int)-45.123); // 输出-45
// char和int相加
char c3 = 'a';
int i3 = c3 + 1;
System.out.println(i3); // 输出98
System.out.println((char)i3); // 输出b
// JDK7新特性,数字太长时,可以用下划线区分,并且输出的时候不会带上
int i4 = 10_0000_0000;
System.out.println(i4); // 输出1000000000
// 内存溢出,原因,超过int最大数值
int year = 20;
System.out.println(year*i4);// 输出-1474836480
// 如果用long类型来接收结果,也是同样的会溢出,因为计算结果之前就已经存在问题
long d3 = year*i4;
System.out.println(d3);// 输出-1474836480
// 解决内存溢出,可以对某个数值进行强制转换
System.out.println((long)year*i4);// 输出20000000000
// 在long类型的数据,大小写的L都可以表示,但是用小写的l,容易看错数字1,所以建议还是用大写L
long l1 = 12345678111L; // 大写L
long l2 = 12345678111l; // 小写L
}
}
变量命名规范和作用域
public class Demo08 {
// 初始化类的属性
String s1 = "hello";
int i1;
// 定义常量
final double D2 = 123.1234F;
// 可以直接拿到
static int i2 = 123;
// static (静态,可以直接调用,无需通过实例化) 和 final (常量的变量) 是修饰符,不分先后顺序
static final String s2 = "world";
public static void main(String[] args) {
// 通过实例化拿到类的属性
Demo08 demo08 = new Demo08();
System.out.println(demo08.s1); // hello
System.out.println(demo08.i1); // 0
System.out.println(demo08.D2); // 123.12339782714844
// 通过static 直接拿到
System.out.println(i2);
System.out.println(s2);
}
}
基本运算符
package operator;
public class Demo01 {
public static void main(String[] args) {
// 加减乘除
int a = 10;
int b = 20;
int c = 31;
System.out.println(a*b); // 输出200
System.out.println(a-b); // 输出-10
System.out.println(a+b); // 输出30
System.out.println((double)a/b); // 如果不加double,那么就会输出0,因为结果是0.5
System.out.println(c%a); // 输出1
// 关系运算符
System.out.println(a>b); // 输出false
System.out.println(a<b); // 输出true
System.out.println(a==b); // 输出false
System.out.println(a>=b); // 输出false
System.out.println(a<=b); // 输出true
System.out.println(a!=b); // 输出true
// 关于整数的运算,结果验证
byte a1 = 2;
short a2 = 33;
int a3 = 34560;
long a4 = 123456789L;
System.out.println(a1+a2+a3+a4); // 输出123491384 类型是long
System.out.println(a2+a3+a4); // 输出123491382 类型是int
System.out.println(a3+a4); // 输出123491349 类型是int
System.out.println((double)a1+a4); // 输出1.23456791E8 类型是double
}
}
自增运算符和自减运算符
package operator;
public class Demo02 {
public static void main(String[] args) {
// 自增运算符 ++ ,自减运算符 --
int a = 1;
int b = a++;
int c = ++a;
System.out.println(a); // 输出3,因为调用了两次自增
System.out.println(b); // 输出1,因为提前把a赋值了,然后a才自增
System.out.println(c); // 输出3,因为把a自增了,才赋值给c
// 关于幂运算
double d = Math.pow(2,3);
System.out.println(d); // 输出8.0
}
}
逻辑运算符和位运算符
package operator;
public class Demo03 {
public static void main(String[] args) {
// && || !
boolean a = true;
boolean b = false;
System.out.println(a&&b); // 输出false
System.out.println(a||b); // 输出true
System.out.println(!(a&&b)); // 输出true
// 短路运算
int c = 5;
int d = 10;
int f = 20;
boolean g = (d<f) && (++c>5);
boolean h = (d<f) && (c++>5);
boolean k = (d>f) && (c++>5);
System.out.println(g); // 输出true,因为++c先进行自增,再进行比较
System.out.println(h); // 输出false,因为++c先进行比较,再进行自增
System.out.println(k); // 输出false,因为d>f为false,所以后面的语句没有执行
System.out.println(c); // 输出7
// 位运算符 & | ~ ^ ,主要是进行位的比较
/*
A = 0011 1100
B = 0000 1101
--------------------------------
A&B = 0000 1100 两个必须为1
A|B = 0011 1101 其中一个为1
A^B = 0011 0001 都为0,或,都为1,输出0,其中一个为1,则输出1
~A = 1100 0011 取反
~B = 1111 0010 取反
*/
// 左移 << 右移 >>
/*
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
2<<3 相当于2像左移动3位,结果等于16
16<<3 相当于16像右移动3位,结果等于2
*/
System.out.println(2<<3); // 输出16
System.out.println(16>>3); // 输出2
}
}
三元运算符和扩展运算符
public class Demo04 {
public static void main(String[] args) {
// 扩展运算符 += -= /= *=
int a = 1;
int b = 2;
int c = 3;
int d = 4;
System.out.println(a+=b); // 输出3 a = a + b
System.out.println(c-=b); // 输出1 c = c - b
System.out.println(b*=d); // 输出8 b = b * d
System.out.println(b/=d); // 输出2 b = b / d
// 字符串连接符 +
System.out.println("" + a + b); // 输出32 先转为string,然后就是变成拼接
System.out.println(a + b + ""); // 输出5 先进行加法运算,再变成string
// 三元运算符
int score = 50;
String type = score > 30 ? "大于了" : "小于了";
System.out.println(type); // 输出大于了
}
}
包机制
以公司域名,倒着写,作为规范,比如:www.baidu.com,包名就是com.baidu.com
如果创建包的时候,不会自动分层,把这个选项取消掉即可
如果是在包里面,都必须引用包名
这种其实也是包,import导入包,import必须写在package下面
导入包下面全部的类
导入包下面,某个类
生成java doc
命令行生成
javadoc -encoding UTF-8 -charset UTF-8 demo01.java
通过idea
生成之后
更新日志
提示:将会持续优化更新