Java SE 基础 - 2023.9.15 -
一. 数据类型 及 运算符
❶. 常量
字符串常量
整数常量
小数常量
字符常量
布尔常量
空常量
println 输出格式
public class a {
public static void main(String[] xrgs){
System.out.println("您好");
System.out.println(123);
System.out.println(123.23);
System.out.println('9');
System.out.println(true);
System.out.println(false);
System.out.println(5 > 10);
}
}
双引号 字符串
单引号 只能存放单个字符
整数
小数
true
false
null 空常量 不能直接打印
❷. 变量
存储单元
bit 位 比特位 b表示 计算机存储设备(硬盘 内存)最小信息单元
byte 字节 B表示 计算机最小存储单元 由连续的 8个位 组成
数据类型
整数 默认为 int
byte 字节 1字节 -128~127
short 2 -32768~32767
int 4 -2的31次方 ~ 2的31次方-1
long 8 -2的63次方 ~ 2的63次方-1
浮点数 默认为 double
float 4 1.401298e-45 ~ 3.402823e+38 单精度
double 8 4.9e-324 ~ 1.797693e+308 双精度
字符
char 2 0 ~ 65535
布尔
boolean 1 true false
定义变量
数据类型 变量名 = 数据值
int a = 10; // 定义变量 一定要加 数据库类型
double b = 12.3;
char c = 'a'; // 字符 需要 单引号
boolean d = true;
a = 30; // 此为赋值 并不是定义 上面需要有定义才才能赋值
int a;
a = 10;
int a = 10 , b = 20 , c =30; // 一条语句定义多个变量
float e = 12.3f; // 必须加F 定义 浮点数 要加 大写F 或 小写f
float e = 12.3F;
long f = 1000l; // 可以不加L 定义 长整形 要加 大些L 或 小写l
long f = 1000L;
注:
变量名不允许重复定义
变量的作用域范围 只在它所在的大括号中有效
键盘录入
import java.util.Scanner;
public class b {
public static void main(String[] args) {
System.out.print("请输出数字：");
Scanner sc = new Scanner(System.in); // System.in 系统输入
int a = sc.nextInt(); // nextInt() 是Scanner已经写好的方法
System.out.println(a);
}
}
标识符
有数字 字母 下划线 美元符号 组成
1. 不能以数字开头
2. 不能是关键字
3. 区分大小写
方法 变量 命名使用 小驼峰
类 命名使用 大驼峰
❸. 数据类型转换
隐式转换
取值范围小的数据 给取值范围大的类型赋值 可以直接赋值
int a =10;
double b = a;
System.out.println(b); // 会输出 10.0
byte < short < int < long < float < double
char <
小的数据类型 和大的数据类型运算 小的会提升为大的之后 再进行运算
int a = 10;
double b = 12.3;
double c = a + b;
System.out.println(c);
byte short char 三种数据在运算的时候 不管是否有更高的数据类型 都会提升为int 在进行运算
byte a = 10;
byte b = 20;
int c = a + b;
System.out.println(c);
强制转换
int d = (int)c;
大范围 转换为 小范围
int a = 10;
byte b = (byte)a;
System.out.println(b);
double c = 12.3;
int d = (int)c; // 会把小数点后面的都干掉
System.out.println(c);
System.out.println(d);
byte d = 3 + 4; // 常量优化机制 先相加 如在byte范围内 通过 不在byte内 报错
long a = 123; // 不会报错 因为123默认为 int 类型 可以转换成 long 类型
long a = 12345645632156123123L // 不加L 会报错 因为 已经超过int的范围
short s = 1;
s = (short)(s + 1);
System.out.println(s);
实例1. 变量互换
public class D {
public static void main(String[] args){
int a = 3;
int b = 5;
System.out.println("a= "+a);
System.out.println("b= "+b);
a = a + b;
b = a - b;
a = a - b;
System.out.println("a= "+a);
System.out.println("b= "+b);
}
}
public class D {
public static void main(String[] args){
int a = 3;
int b = 5;
System.out.println("a= "+a);
System.out.println("b= "+b);
a = a ^ b;
b = a ^ b;
a = a ^ b;
System.out.println("a= "+a);
System.out.println("b= "+b);
}
}
❹. 运算符及表达式
运算符: 对常量或变量进行操作的符号
表达式: 用运算符把常量或者变了连接起来符号java语法的式子
int a = 10;
int b = 20;
int c = a + b;
+ 是运算符 并且是 算术运算符
a + b 是表达式 并且是 算术表达式
+ - * / %取余数
System.out.println(10 + 20);
System.out.println(10 - 20);
System.out.println(10 * 20);
System.out.println(10.0 / 3); // 两个整数相除 结果只能得到整数
System.out.println(10 / 3.0); // 如果想要得到带有小数的结果, 必须加入 浮点型 运算
System.out.println(5 % 2);
❺. 字符 + 操作
ASCII码 查询
public class F{
public static void main(String[] args){
int a = 0;
char b = 'a';
System.out.println(a + b); // 会先把 b 的值 按照 ASCII码进行转换 在相加
}
}
ASCII码
a 97
A 65
0 48
字符串 + 操作
对于字符串 +号 为 连接符
System.out.println(1 + 99 + "年");
System.out.println("5+5="+5+5 );
System.out.println("5+5=" + (5+5)); // 小括号为 提升优先级 先算
实例二： 数字拆分
键盘录入一个三位数 将其拆分为个位 十位 百位后 打印出来
import java.util.Scanner;
public class c {
public static void main(String[] args){
System.out.print("请输出三位数字: ");
Scanner sc = new Scanner(System.in);
int i = sc.nextInt();
System.out.println("您输入的个位是: " + (i % 10));
System.out.println("您输入的十位是: " + (i / 10 % 10));
System.out.println("您输入的百位是: " + (i / 100 % 10));
}
}
%10 取最后一位
/10 消最后一位
个位: 数值 % 10
十位: 数值 / 10 % 10
百位: 数值 / 10 / 10 % 10
千位: 数值 / 10 / 10 / 10 % 10
...
❻. 运算符
自增自减运算符
++i;
i--;
int a = 10;
int b = ++a; // 先加在赋值 b为11
int c = 10;
int d = a++; // 先赋值在加 d为10
赋值运算符
=
+= // 将符号左右两边的数据 做加法运算 结果赋值给左边
-=
*=
/=
%=
这些赋值运算符 隐含了强制类型转换
short s = 1;
ss += 1; // 相当于 s = (short)(s + 1);
System.out.println(s);
关系运算符 比较运算符
== // 比较 返回值 为 true 或 false
!=
>
>=
<
<=
逻辑运算符
& 并且 返回布尔类型 x > 5 & x < 15
| 或
! 非
^ 异或 true ^ true 返回 false 相同为假 不同为真
false ^ false 返回 false
true ^ false 返回 true
短路逻辑运算符
&& 与 有短路效果 左边为false 右边不执行
|| 或 有短路效果 左边为true 右边不执行
三元运算符
关系表达式 ? 表达式1 : 表达式2
int a = 10;
int b = 20;
int c = 30;
int max = a > b ? a:b; // 如果a大于b max取值a 否则max取值b
int max1 = max > c ? max : c;
int max2 = a > b ? a : b > c ? a > b ? a : b : c; // 结果与 max1 相同
二. 流程控制
❶. if语句
if (关系表达式){}
if (i >= 18){}
if (90 <= i & i <= 100){}
if (){}
else {}
if (){}
else if (){}
...
else{}
注: 如果if语句所控制的语句 是一条语句 大括号可以省略
if 语句的小括号后面不要写分号
❷. switch语句
switch(i){
case 1:
break;
case 2:
break;
default:
break;
}
注: case 穿透 如果switch语句中 case 省略了 break语句 就会开始 case 穿透
当开始case穿透 后续的case就不会具有匹配效果 内部的语句都会执行 知道看见break才停止
❸. for 循环
for(int i = 1; i <= 3; i++ ){}
for(int i = 0; i <=100; i = i + 2){} // 偶数
if(i % 2 == 0){} // 偶数
if(i % 2 == 1){} // 奇数
if (i % 2 == 0){ // 引入统计变量 如果是2的倍数 则 打印一个换行
System.out.println();
}
❹. while 循环 适合 不明确 循环次数
while(i <= 100){
sum += i;
i++;
}
do{
System.out.println(i);
i++;
}while(i <=10);
❺. 死循环 标号
for(;;){}
teo:while(true){ // 此 teo: 为循环 起的名字 可以使用 break teo; 跳出
break teo; // 跳出 teo 循环
continue teo;
}
do{}while(true)
continue; // 跳过一次循环
break; // 结束循环
❻. Random 随机数
import java.util.Random;
public class a {
public static void main(String[] args) {
Random r = new Random();
int i = r.nextInt(10); // 产生一个 0 - 9 之间的随机数 不包括10
System.out.println(i);
}
}
int i = r.nextInt(10) + 1; // 可以产生 1 - 10 之间的随机数
三. 数组
❶. 定义数组
数据类型[] 变量名
int[] array;
数据类型 变量名[]
int array[];
❷. 动态初始化
int[] arr = new int[3]; // 索引从0开始 为 0 1 2
arr[1] = 11; // 为 1 号索引位置 赋值
System.out.println(arr);
[I@119d7047 // 打印数组变量名 会出现 内存地址
@ : 分隔符
[ : 当前的空间是一个数组类型
I : 当前数组容器中所存储的数据类型 int
119d7047 : 十六进制内存地址
System.out.println(arr[0]); // 调取0号索引 默认初始值为 0
数组默认值
数据类型 默认值
整数 0
浮点数 0.0
布尔 false
字符 空字符
引用数据类型 null
int[] arr2 = arr1; // 定义数组arr2 和 arr1 相同
❸. 静态初始化
int[] arr = new int[]{1,2,3}; // 定义数组并直接赋值
int[] arr = {1,2,3};
arr.length // 数组中的元素个数 就是个 int 的 整数
for(int i = 0; i < arr.length; i++){ // 打印所有数组中的元素
System.out.println(arr[i]);
}
int[] arr = new int[5];
for(int i = 0; i < arr.length; i++){
// arr[i] = 10;
arr[i] = sc.nextInt();
}
❹. 数组命令整理
int[] arr; // 定义数组 动态初始化
int arr[]; // 定义数组 动态初始化
int[] arr = new int[3]; // 定义数组并赋值 索引从0开始 为 0 1 2
arr[0] = 11; // 为 0 号索引 赋值
System.out.println(arr[0]); // 调取0号索引 如果不赋值 默认初始值为 0
System.out.println(arr); // 打印数组 会出现内存地址
int[] arr2 = arr1; // 定义数组arr2 和 arr1 相同
int[] arr = new int[]{1,2,3}; // 定义数组并直接赋值 静态初始化
int[] arr = {1,2,3}; // 定义数组并直接赋值 静态初始化
arr.length // 数组中的元素 个数 获取数组arr的长度 就是个 int 的整数
for(int i = 0; i < arr.length; i++){ // 打印所有数组中的元素
System.out.println(arr[i]);
}
for (int i = 0; i < arr.length; i++) { // 键盘录入 存放到 数组中
System.out.println("第" + (i + 1) + "个数");
arr[i] = sc.nextInt();
}
四. 方法
public static void teo(){ // 定义一个方法 void 空白 没有返回值
}
teo(); // 调用
public static void teo(int a, int b){} // 定义一个 带参数的方法
teo(5,7); // 调用 方法
形参 方法定义中的参数
实参 方法调用中的参数
public static int teo4(int a,int b){ // 定义 int 类型 返回值的 方法
int i = a + b;
return i; // 返回值 i
}
int num = teo4(5,6); // 定义 num 变量 接收 返回值
return; // 结束方法 也可在void中使用 只有 return 没有返回值 后面的代码不执行 所在的方法会从栈内存中清除 亦叫 弹栈
方法重载 同一个类中 方法名相同 参数不同的方法 叫 方法重载
public static void teo5(int[] arr){} // 数组作为参数 传递给方法
int[] arr = {11,22,33,44,55};
teo5(arr);
public static int[] teo6(int[] arr){ // 数组作为参数 返回值 依然是 数组
int[] arr1 ={max,min};
return arr1; // 返回 arr1 数组
}
int[] arr = new int[]{1, 54, 89, 65}; // 用于传递的arr数组
int[] arr1 = teo6(arr); // 用于接收arr1数组 方法之间的数组内存不相同 方法之间传参的数组内存相同
cmd calc 计算器
mstsc 远程连接
msconfig 服务
regedit 注册表
五. 进制
二进制 数值前面以 0b开头 b大小写都可以
八进制 数值前面以 0开头
十六进制 数值前面以 0x开头 x大小写都可以
❶. 任意进制 转换成 十进制
公式: 系数 * 基数的权次幂 相加
系数: 数字
基数: 二进制为2 8进制为8 16进制为16
权: 从右边开始 以0为编号 逐个加1
0b100
0*2^0 = 0
0*2^1 = 0
1*2^2 = 4
0x100
0*16^0 = 0
0*16^1 = 0
1*16^2 = 256
0100
0*8^0 = 0
0*8^1 = 0
1*8^2 = 64
❷. 十进制 转换成 任意进制
公式: 除基取余 使用源数据不断的除以基数 得到余数 直到 商为0 在将余数倒着加起来
11 转换成 二进制 1011
2 11
5 ... 1
2 ... 1
1 ... 0
0 ... 1
60 转换成 十六进制 3c
16 60
3 ... 12
0 ... 3
❸. 二进制 转 十进制
0b1011 转换成 十进制
8421码
128 64 32 16 8 4 2 1 8421码表
1 0 1 1 二进制
8 + 2 + 1 = 11 十进制 把二进制 1对应的相加
❹. 二进制 转 八进制
分成多组 从右边开始 每三个一组
0b111100 转换成 八进制
128 64 32 16 8 4 2 1 8421码表
1 0 0 第一组
1 1 1 第二组
4 第一组相加结果
4 + 2 + 1 = 7 第二组相加结果
74 转换成 八进制
❺. 二进制 转 十六进制
分成多组 从右边开始 每四个一组
0b111100 转换成 十六进制
128 64 32 16 8 4 2 1 8421码表
1 1 0 0 第一组
1 1 第二组
8 + 4 = 12 第一组相加结果
2 + 1 = 3 第二组相加结果
3c 转换成 十六进制
❻. 位运算
先吧数字转换成 二进制 在运算 在二进制运算中 1表示 true 0表示false
& 位与 遇 false 则 false
| 位或 遇 true 则 true
^ 位异或 相同为false 不同为true 一个数被另外一个数 异或两次 该数本身不变
~ 取反 全部取反 0变1 1变0 包括符号位
6 位运算 2
00000000 00000000 00000000 00000110 二进制 6
00000000 00000000 00000000 00000010 二进制 2
010 6 & 2 的结果 返回为 2
110 6 | 2 的结果 返回为 6
100 6 ^ 2 的结果 返回为 4
~6的计算
00000000 00000000 00000000 00000110 二进制 6
11111111 11111111 11111111 11111001 二进制 6取反
-1 求出来反码
11111111 11111111 11111111 11111000 反码
10000000 00000000 00000000 00000111 反码推源码 第一个1 为符号位 1表示负数
-7 转换成十进制为 -7
~6 的结果 返回为 -7
System.out.println(6 & 2); // 可打印查看相关结果
System.out.println(6 | 2);
System.out.println(6 ^ 2);
System.out.println(~6);
❼. 位移运算符
<< 有符号左移运算符 二进制位向左移动 左边符号位丢弃
向左移动几位 就是 乘以 2的几次幂
5 << 1 就是 5乘以2
5 << 2 就是 5乘以4
>> 有符号右移运算符 二进制位向右移动 使用符号位进行补位
向右移动几位 就是 除以 2的几次幂
5 << 1 就是 5除以2
5 << 2 就是 5除以4
>>> 无符号右移运算符 无论符号位是0还是1 都补充0 (用处相当少)
12 << 2
00000000 00000000 00000000 00001100 12的二进制
00000000 00000000 00000000 00110000 12 << 2 转换成十进制结果为 48
亦可使用 12 * 2^2 = 48
12 >> 2 12 / 2^2 = 3
-6 >>> 1
10000000 00000000 00000000 00000110 -6的二进制
01000000 00000000 00000000 00000011 -6 >>> 1 转换成十进制结果为 2147483645 (用处相当少)
System.out.println(12 << 2 ); // 可打印查看相关结果
System.out.println(12 >> 2 );
System.out.println(-6 >>> 1);
❽. 数据交换
a 与 b的值 交换 方法一
int temp = a;
a = b;
b = tmp;
a 与 b的值 交换 方法二 异或的应用
a = a ^ b;
b = a ^ b;
a = a ^ b;
数组中的数据交换
int[] arr = {1,2,3,4,5,6,7,8,9,10,11,12,13};
teo7(arr);
for(int i =0; i < arr.length;i++) {
System.out.println(arr[i]);
}
public static void teo7(int[] arr){
for(int start = 0,end =arr.length -1; start < end; start++,end--){
int temp = arr[start];
arr[start] = arr[end];
arr[end] = temp;
}
}
六. 二维数组
❶. 动态初始化
int[][] arr; // 常用 二维数组是记录一维数组的 内存地址
in arr[][];
int[] arr[];
int[][] arr = new int[2][3]; // 定义一个二维数组 可以存放2个一维数组 每个一维数组可以存放 3个int类型的元素
arr[0]; // 第一个 一维数组 内存
arr[0][0]; // 第一个 一维数组 中的 第一个元素
arr[0][0] = 11; // 赋值
arr[0] = arr1; // 把 一维数组arr1 整体添加到二维数组arr中的 arr[0]数组中
❷. 静态初始化
int[][] arr = new int[][]{{11, 22, 33}, {44, 55, 66}};
int[][] arr = {{11, 22, 33}, {44, 55, 66}};
int[] arr1 = {11, 22, 33};
int[] arr2 = {44, 55, 66};
int[][] arr = {arr1, arr2};
❸. 二维数组的遍历
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
System.out.println(arr[i][j]);
}
}
七. 面向对象
public class phone {
String brand;
int price;
public void call(){
System.out.println("打电话" );
}
public void sendMessage(){
System.out.println("发短信");
}
}
phone p = new phone();
p.call();
p.sendMessage();
私有的成员变量 只能在本类中使用
private int i; \\ 定义一个私有的 成员变量
public void setI(int a){
i =a;
}
public int getI(){
return i;
}
成员变量
局部变量
面向对象三大特征
封装 将类的某些信息隐藏的类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现
对隐藏信息的操作和访问成为变量private，提供对于的 get set 方法
继承
多态
构成方法 与 类名相同 没有返回值
............................................................................................................
八. 杂项
CS架构 客户端 + 服务器
BS架构 浏览器 + 服务器
JavaEE 服务器
weblogic 实现了JavaEE规范, 重量级服务器 又称JavaEE容器.
websphereAS 实现了JavaEE规范,重量级服务器.
JBOSSAS 实现了JavaEE规范,重量级服务器,免费的.
Tomcat 实现了jsp/servlet规范,是一个轻量服务器,开源免费
HelloWorld
# vim HelloWorld.java
public class HelloWorld {
public static void main(String[] args){
System.out.println("Hello World !");
}
}
# javac HelloWorld.java
# java HelloWorld
public 类名 与 文件名相同
关键字
关键字 字母 全部小写 有颜色
Win + e 资源管理器
java se 基础 桌面应用的开发
java me 手机java程序开发 已被安卓 ios取代
java ee web方向 网站开发
JRE: 编写代码的过程中, 需要使用JRE中java已经写好的代码 java运行环境 包含JVM虚拟机及java核心类库
类: 就是java文件 里面存放java代码 A.java
类库: 存放多个java文件的仓库
核心类库: java 已经写好的 代码仓库
JDK 翻译 A.java代码的工具 翻译完成后可被JVM虚拟机所执行
JVM JVM虚拟机 启动翻译java代码的作用... ... 运行代码的过程中, 需要使用JDK中的运行工具
关系
JDK 包含 JRE和开发工具
JRE包含JVM和核心类库
java8.0 最常用的java版本
静态资源发布:
修改 javaEE (Legacy) 主页文件
# vim /WEB-INF/web.xml // 修改 静态项目 主页文件
<welcome-file-list>
<welcome-file>/index/index.html</welcome-file>
</welcome-file-list>
</web-app> // 在</web-app>标签上面 添加 三行代码
