敲重点! 本篇讲述了比较重要的基础,是必须要掌握的
1.程序入口
在Java中,main
方法是程序的入口点,是JVM(Java虚拟机)执行Java应用程序的起始点。
main
方法的方法签名必须遵循下面规范:
public static void main(String[] args){...}
public
:main
方法必须是public
,以便JVM能够调用它。static
:main
方法必须是静态的,因为在调用时不会创建类的实例,而是通过类名直接调用。void
:main
方法不返回任何值,其返回类型必须是void
。String[] args
:main
方法的参数是一个字符串数组,用于接收命令行输入的参数。
当Java应用程序运行时,JVM会先加载应用程序的主类(包含main
方法的类)再执行main
方法。
2.输入输出
3.标识符与变量
标识符
所谓标识符就是变量、方法,类,接口等对象的名字,标识符的命名规则必须以下换线(_),$或者英文字母开头,并且不能使用关键字和保留字。
一般变量命名遵守小驼峰命名法或大驼峰命名法。
小驼峰命名法命名变量和方法名时,例如$userName,age,myFunction(),getResult(),除第一个单词其他单词首字母大写。
大驼峰命名法命名变量和方法名时,例如$UserName,Age,MyFunction(),GetResult(),所有单词首字符大写。
变量与常量
基本概念
变量与常量是指内存中的一个存储区域的引用,变量其值可以改变,而常量不可变。
基本数据类型变量名和值都存储在栈中,引用类型的变量名/对象引用 (内存地址)存储在栈中,变量值(实例)存储在堆中
变量
变量初始化(赋值) 有两种方式,分布是静态初始化和动态初始化。
静态初始化
声明并分配内存空间。
int a=1;
动态初始化
先声明变量,后面使用再赋值。
int a;
a=1
常量
常量值一旦赋值不可被修改,已经被确定,变量前加关键字:final 。
final int a=1;
还有final 方法:最终方法,final 类:最终类,不可被继承
4.关键字与保留字
关键字被Java语言赋予了特殊含义,用做专门用途的字符串,不可被使用,如class ,interface ,enum ,byte ,short,void等等
保留字是指现有Java版本尚未使用,但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字,如goto 、const等
5.数据类型
数据类型分类
Java中的数据类型分为 基本数据类型 和 引用数据类型
基本数据类型
- 整型:
short
、int
、long
- 浮点:
float
、double
- 字节:
byte
- 字符:
char
- 布尔:
boolean
注意:
float
精度为8位有效数字,超出部分四舍五入,需带f/F
后缀表示。double
精度为17位有效数字。
引用数据类型
- 类
- 接口
- 数组
- 字符串
数组
一维数组
声明格式:数组类型[] 数组名={…} 或者 数组类型 数组名[]= {…}
数组初始化
动态初始化
通过new关键字分配内存空间,使用时再赋值,若未赋值则默认值为0
int[] list=new int(a) //申请a位空间数(整数)
int[] list=new int(5) //申请了5个元素空间
list[0]=1;
list[1]=8;
system.out.print(list[0],list[1])
>>>1,8
静态初始化
用花括号声明的同时并赋值
int[] list={1,2,3,4,5}
system.out.print(list[0])
>>>1
创建二维数组
声明格式:数组类型[][] 数组名={…} 或者 数组类型 数组名[][]= {…}
规则二维数组
子数组元素个数相同
静态初始化
int[][] list={{1},{2},{3},{4},{5}}
动态初始化
int[][] list=[5][1]
不规则二维数组
子数组元素个数不相同
静态初始化
int[][] list={{1},{2,3},{4,5,6}}
动态初始化
int[][] list=[3][]
list[0]=new int[1] 为第1个子数组分配1个空间
list[1]=new int[2] 为第2个子数组分配2个空间
list[2]=new int[3] 为第3个子数组分配3个空间
字符串
字符串底层为final修饰私有的字符数组,String类在long包中,无需导入
创建字符串对象
无参构造直接赋值即可,如String str=‘abc’;
带参构造
public String(char[] a/byte[] a)
//byte 97,98,99---->a,b,c 字节对应相关字符
//char{'a','b','c'}---->abc 将字符输出为字符串(拼接)
字符数组和字节数组作为参数创建字符串对象,可以指定字节字符区间以及字符集,带参构造字符串通常用于io流数据类型转换
字符串相关操作和方法
字符串拼接
通常用StringBuilder,效率更高
str=str1+str2 产生一个新的字符串(和可变字符串相比会产生新对象,耗时,浪费空间)
字符串的比较
使用“==”做比较时
- 基本类型:比较值是否相等
- 引用类型:比较引用地址是否相同
构造方法创建的字符串对象不同对象不同地址
直接赋值相同内容的字符串对象共用一个地址(存储在常量池,已存在则直接引用)
String s1="A";
String s2="A";
String s3=new String("A");
String s4=new String("A");
System.out.println(s1==s2);//true
System.out.println(s3==s4);//false
System.out.println(s1==s4);//false
引用类型比较值
引用类型判断值是否相等时,使用equals()方法
//方法1
str1.equals(str2)
//方法2
Objects.equals(str1, str2)
注意:
a.equals(b), 当a是null, 会抛出NullPointException空指针异常,因为null对象无equals方法。
使用Objects.equals(a, b)比较时不会抛出空指针异常
返回字符串元素个数
//xxx.length()
System.out.println("abc".length()); //3
修改字符串值
字符串对象不可变,若修改产生新对象,可以覆盖引用或者申请新地址,调用replace替换,字for循环替换等等
//覆盖原引用地址内容,使常量池中b值的引用指向a
String a="1"
String b="0"
a=b;
//a-->0 , b-->0
提取子串(切片)
//按索引截取指定子串
//若省略endIndex则从起始位置取到最后一个
//若startIndex=endIndex,则返回空串
str.substrng(startIndex[,endIndex]) (不计endIndex,开区间)
遍历字符串
//取字符串索引i的元素
str="abc"
for (....){
str.charAt(0)
}
String a="123456";
for (int i=0;i<a.length();i++){
System.out.println(a.charAt(i));
}
Stringbuilder
Stringbuilder是可变字符串,其值修改,地址不变(修改后还是原对象,不会在常量池中创建新对象),相同的还有StringBuffered(线程安全类)
创建可变字符串对象
构造方法创建
//无参
Stringbuilder str=new Stringbuilder()
//带参
Stringbuilder str=new Stringbuilder(string) //String转StringBuilder(还支持其他类型参数)
可变字符串的相关操作和方法
拼接
append方法
//其返回原对象(可使用链式编程)
StringBuilder str=new StringBuilder()
str.append(str1)
逆置(序列反转)
reverse方法
StringBuilder str=new StringBuilder(str1)
str.reverse(str)
//abc-->cba
数据类型转换
自动类型转换
自动类型转换又为隐式转换,Java内部自动完成。
基本类型由低级到高级分别为(byte,short,char)->int->long->float->double
自动类型转换是从低到高的,所以当int+float的结果还是float
int a=1;
float b=1.5f;
float result = a + b;
强制类型转换
强制类型转换是手动进行,将高级类型转换为低级类型,可能丢失精度
double d = 3.14;
int i = (int) d; // 强制转换为整数,丢失小数部分,i的值为3
long l = 1000000000L;
int i = (int) l; // 强制转换为整数,可能会导致数据溢出
char c = 'A';
int i = (int) c; // 强制类型转换为整数,i的值为65,即字符'A'对应的ASCII码值
字符串数组转换整型数组
通过遍历将每个元素转换成int型,long包中的Intege.parseInt(str)方法
字符数组转换整型数组
getNumericValue
方法将字符转换为整型
char[] chars = "abc".toCharArray();
int[] ints = new int[chars.length];
for (int i = 0; i < chars.length; i++) {
int numericValue = Character.getNumericValue(chars[i]);
ints[i] = numericValue;
}
System.out.println(Arrays.toString(ints)); //[10, 11, 12]
string和stringBuilder类型转换
//string->stringBuilder 直接在创建stringBuilder对象时传参
//tringBuilder->string 调用tooString方法
StringBuilder str=new StringBuilder(astr);
String fstr=str.toString(); //此时fstr为string类型
字符串转字符数组
//字符串->字符数组
"abc".toCharArray(); //["a","b","c"]
int转string
//int -> string
Integer.parseInt(str)
//string -> int
string.valueOF(i)
装箱与拆箱
装箱(Boxing)和拆箱(Unboxing)是指基本数据类型和对应的包装类(引用类型)之间的转换。
手动
通过传参进行转换
int a=10;
// 手动装箱 基本类型---->包装类
Integer b=new Integer(a);
// 手动拆箱 包装类---->基本数据类型
int c= b.intValue();
自动
java内部会自动实现拆箱操作,将包装类型转换为基本类型。
// 自动装箱 基本类型---->包装类 直接将值赋给对应的包装/基本类
int a=10;
Integer b=a;
// 自动拆箱 包装类---->基本数据类型
int c= b;
6.运算符
算术运算符
算术运算符用于执行基本的数学运算,包括加法、减法、乘法、除法、取余以及自增自减操作。
- 加法(+):将两个数相加。
- 减法(-):将右操作数从左操作数中减去。
- 乘法(*):将两个数相乘。
- 除法(/):将左操作数除以右操作数。
- 取余(%):返回左操作数除以右操作数的余数。
- 自增(++):将操作数的值增加1。
- 自减(–):将操作数的值减少1。
除法运算符在处理不同数据类型时会产生不同的结果:
System.out.println(4 / 3); // 输出:1
System.out.println(4 / 3.0); // double 输出:1.3333333333333333
System.out.println(4 / 3f); // float 输出:1.3333334
根据向上转型返回不同数据类型。
i++和++i
i++
:先返回i
的值,然后将i
的值加1。++i
:先将i
的值加1,然后返回i
的值。
int i = 5;
System.out.println(i++); // 输出:5,i先返回自增前的值
System.out.println(++i); // 输出:7,i先自增后返回自增后的值
逻辑运算符
逻辑运算符用于执行逻辑操作,常用的有与、或、非。
- 与(&&):当且仅当两个操作数都为true时,结果为true。
- 或(||):当两个操作数中至少有一个为true时,结果为true。
- 非(!):用于反转操作数的逻辑状态。
逻辑运算符可能会出现短路现象
,即在逻辑运算过程中,如果根据左操作数已经可以确定整个表达式的结果,则右操作数将不再计算。例如:
boolean a = false;
boolean b = true;
boolean c = true;
if (a && b || c) {
// 如果a为false,则不会计算b
}
关系运算符
关系运算符用于比较两个值之间的关系,返回一个布尔值。
- 小于(<)
- 大于(>)
- 小于等于(<=)
- 大于等于(>=)
- 等于(==)
- 不等于(!=)
移位运算符
移位运算符用于对二进制位进行移动操作。
- 左移(<<):将操作数的所有位向左移动指定数量的位。
- 右移(>>):将操作数的所有位向右移动指定数量的位,右移时,左边用符号位填充。
- 无符号右移(>>>):将操作数的所有位向右移动指定数量的位,右移时,左边用0填充。
位运算符
位运算符用于对操作数的位进行操作。
- 与(&):对两个操作数的每个位执行逻辑与操作。
- 或(|):对两个操作数的每个位执行逻辑或操作。
- 异或(^):对两个操作数的每个位执行逻辑异或操作(相同为0,不同为1)。
- 非(~):对操作数的每个位执行逻辑非操作(0变为1,1变为0)。
三元运算符
三元运算符也称为条件运算符,用于根据表达式的结果选择执行不同的操作。
语法:表达式1 ? 表达式2 : 表达式3;
int value = (a == 0) ? 1 : (b + c);
如果表达式a等于0,则将1赋值给value,否则将b+c的结果赋值给value。
复合运算符
复合运算符是一种组合了赋值运算符和算术运算符的运算符,用于简化代码。
例如,+=
、-=
、*=
、/=
等等。
7.流程控制
分支结构
分支结构用于根据条件选择不同的执行路径。
单分支:if
if (条件) {
// 如果条件为真,执行这里的代码块
}
双分支:if… else
if (条件) {
// 如果条件为真,执行这里的代码块
} else {
// 如果条件为假,执行这里的代码块
}
多分支 if…else if… else
if (条件1) {
// 如果条件1为真,执行这里的代码块
} else if (条件2) {
// 如果条件2为真,执行这里的代码块
} else if (条件3) {
// 如果条件3为真,执行这里的代码块
} else {
// 如果以上条件都不满足,执行这里的代码块
}
Switch语句
Switch语句用于根据表达式的值选择执行不同的分支。
switch (表达式/值) {
case 值1/入口1:
// 执行语句1
break; // 终止当前分支的执行
case 值2/入口2:
// 执行语句2
break;
case 值3/入口3:
// 执行语句3
break;
default:
// 如果以上入口都不匹配,执行这里的语句
break;
}
如果不使用break
关键字,将会继续执行下一个分支。如果没有匹配的分支,将执行default
分支(可选)。
循环结构
循环结构用于重复执行一段代码。
for循环
for (初始化表达式; 判断表达式; 增减表达式) {
// 循环体,当判断表达式为true时执行
}
增强for循环(foreach)
for (循环变量 : 数组/集合) {
// 对数组/集合中的每个元素执行相同的操作
}
while循环
while (判断表达式) {
// 循环体,当判断表达式为true时执行
}
do…while循环
do {
// 循环体,至少会执行一次
} while (判断表达式);
do...while
循环先执行一次循环体,然后再判断条件是否满足。
8.代码块的分类
在Java中,代码块可以根据其位置和作用进行分类,包括局部代码块、构造代码块和静态代码块。
位置 | 作用 |
---|---|
局部代码块 | 在方法当中使用,作用是控制变量的生命周期。 局部代码块的变量,只能在代码块内部使用,在执行结束后会被Java回收//相当于Python中函数或类中方法 |
构造代码块 | 在类的成员位置使用。 在每次执行构造方法前先执行构造代码块, 可以将多个构造方法中的相同的代码放到构造代码块中,对对象进行初始化.//相当于Python类——init——构造函数,初始化对象 |
静态代码块 | 在类的成员位置,代码块前添加static修饰符。一般用于给类初始化,被静态修饰的代码块仅执行一次.静态代码块是主动执行的代码块,在JVM加载类时就会执行,且最高优先权限执行 static{…} |
局部代码块
局部代码块通常位于方法内部,用于控制变量的生命周期。在局部代码块中定义的变量只能在代码块内部使用,并且在代码块执行结束后会被Java回收。局部代码块的作用类似于Python中函数或类中的方法。
public void exampleMethod() {
{
// 这是一个局部代码块
int x = 10;
System.out.println("在局部代码块中:" + x);
}
// 这里无法访问局部代码块中定义的变量 x
}
构造代码块
构造代码块位于类的成员位置,每次执行构造方法之前都会先执行构造代码块。构造代码块可以将多个构造方法中相同的代码放到一起,对对象进行初始化。构造代码块类似于Python中的类__init__
构造函数。
public class Example {
{
// 这是一个构造代码块
System.out.println("执行构造代码块");
}
public Example() {
// 构造方法
System.out.println("执行构造方法");
}
}
静态代码块
静态代码块也位于类的成员位置,但在代码块前需要添加static
修饰符。静态代码块用于给类初始化,它仅在类加载时执行一次。静态代码块是被动执行的,在JVM加载类时就会执行,并且具有最高优先级。
public class Example {
static {
// 这是一个静态代码块
System.out.println("执行静态代码块");
}
public static void main(String[] args) {
System.out.println("执行main方法");
}
}
在上面的示例中,静态代码块会在main
方法执行之前先执行,并且只会执行一次。
好了,到这里,你已经掌握了java中最基础重要的内容了,动动你们的小手,一键三连,让我们进入下一篇!