目录
1.java程序的基本格式
权限修饰符 class 类名{
程序代码;
}
案例:创建第一个java程序
步骤
1）打开idea,点击new Project
2)填写相关的信息
3)等待创建完毕
4）运行程序
点击第一个
5）运行结果
2.java中的注释
1.单行注释（对某一行代码的解释）
//
2.多行注释(注释的内容)
/*
*/
3.文档注释（对代码进行解释的文档）
/**
*
*/
案例:创建我的自定义程序
步骤
输入main,点击回车
//输入sout，点击回车
//输入内容
输入一下内容就可以运行了
package org.xiji;
public class MyFirstJava {
public static void main(String[] args) {
//输出语句
System.out.println("你好，这是我的第一个java程序");
/*
多行注释
*/
/**
* 文档注释
*/
}
}
结果
3.java中的关键字
-
abstract - 用于声明抽象类或方法。抽象类不能被实例化，抽象方法必须在子类中实现。
-
assert - 用于断言测试条件。如果条件为假，则抛出一个 AssertionError。
-
boolean - 基本数据类型，表示逻辑上的真（true）或假（false）。
-
break - 用于立即退出循环（for, while, do-while）或 switch 语句。
-
byte - 8位有符号整数类型，取值范围是 -128 到 127。
-
case - 用在 switch 语句中，定义分支。
-
catch - 与 try 关键字一起使用，处理 try 块中可能发生的异常。
-
char - 16位无符号 Unicode 字符类型。
-
class - 定义一个类。
-
const - 保留的关键字，目前没有实际用途。
-
continue - 跳过当前循环的剩余部分，并继续下一次循环。
-
default - 用在 switch 语句中作为默认情况，或者接口中的默认方法。
-
do - 与 while 结合使用构成 do-while 循环。
-
double - 双精度浮点数，通常占用 64 位存储空间。
-
else - 与 if 结合使用，定义 if 条件不满足时执行的代码块。
-
enum - 允许创建枚举类型，枚举是一组命名的常量。
-
extends - 使一个类继承另一个类，或者接口扩展另一个接口。
-
final - 可以用来修饰类、变量和方法，表明它们不可改变或覆盖。
-
finally - 与 try 和 catch 配合使用，无论是否发生异常都会执行 finally 块中的代码。
-
float - 单精度浮点数，通常占用 32 位存储空间。
-
for - 用于创建 for 循环，重复执行一段代码指定次数。
-
goto - 保留的关键字，但 Java 中并未使用。
-
if - 用于条件判断，根据条件真假执行相应的代码块。
-
implements - 用于实现一个或多个接口。
-
import - 导入其他包中的类或接口到当前文件中。
-
instanceof - 测试对象是否是指定类的一个实例，或者实现了特定的接口。
-
int - 32位有符号整数类型。
-
interface - 定义接口，接口可以包含抽象方法和默认方法。
-
long - 64位有符号整数类型。
-
native - 指明方法是由非Java语言编写的，比如C/C++。
-
new - 创建新对象的运算符。
-
package - 定义包，有助于组织类并控制访问权限。
-
private - 访问级别限定词，仅在声明它的类内部可见。
-
protected - 访问级别限定词，同一包内的类或不同包的子类可见。
-
public - 访问级别限定词，对所有类可见。
-
return - 从方法返回一个值，或者结束方法的执行。
-
short - 16位有符号整数类型。
-
static - 表示成员属于类而不是类的实例，静态成员可以通过类名直接访问。
-
strictfp - 确保浮点计算遵循IEEE 754标准。
-
super - 引用父类的对象，通常用于调用父类的方法或构造函数。
-
switch - 选择结构，根据表达式的值来决定执行哪段代码。
-
synchronized - 标记方法或代码块，保证多线程环境下的同步访问。
-
this - 引用当前对象，可以在方法或构造函数中使用。
-
throw - 显式地抛出一个异常。
-
throws - 在方法签名中声明该方法可能抛出的异常。
-
transient - 标记字段不会被序列化。
-
try - 尝试执行可能抛出异常的代码块，通常与 catch 和 finally 一起使用。
-
void - 表示方法没有返回值。
-
volatile - 标记变量，确保其修改对所有线程都可见。
-
while - 当条件为真时重复执行代码块。
4.java中的命名规则
1.标识符
- 标识符是程序员定义的名字，用于类、接口、方法、变量等。
- 标识符必须以字母（A-Z 或 a-z）、下划线（_）或美元符号（$）开始。
- 之后可以跟任何数量的字母、数字（0-9）、下划线（_）或美元符号（$）。
- Java是区分大小写的语言，因此
myVariable和myvariable是不同的标识符。
2.包名
- 包名应全部小写。
- 包名通常是公司域名的反向拼写，例如
com.example.myapp。
3.类名和接口名
- 应使用大驼峰命名法（Camel Case），即每个单词首字母大写，其余字母小写，如
MyClass或MyInterface。
4.方法名
- 使用小驼峰命名法（camelCase），即第一个单词首字母小写，后续单词首字母大写，如
calculateTotal。
5.变量名
- 局部变量、参数名通常也使用小驼峰命名法。
- 成员变量（实例变量）有时会在前面加上一个前缀，比如单个下划线
_来与局部变量区分开来，但这不是强制性的。
6.常量
- 常量名应该全部大写，并且单词之间用下划线分隔，如
MAX_VALUE或PI。 - 常量一般通过
static final修饰符声明。
7.构造器
- 构造器名称必须与类名完全相同。
8.注释
- 虽然不是命名规则的一部分，但良好的注释习惯对代码理解同样重要。注释应该清楚地解释代码的目的和逻辑。
9.不能使用java中的关键字去命名
- 如for
注:刚开始了解一下就可了，后续使用的时候慢慢查就可以了
5.java中的常量
1.整型常量
- 0b或0B 开头的数字 二进制
- 0 开头的数字 八进制
- 我们正常使用的数字 十进制
- 0x或0X 开头的数字 十六进制
package org.xiji; public class MyVar { public static void main(String[] args) { //定义二进制 byte b = 010; System.out.println(b); //定义2字节 short s = 2; System.out.println(s); //定义4字节 int i = 4; System.out.println(i); //定义8字节 long l = 8L; System.out.println(l); } }
2.浮点常量
- float 4个字节
- double 8个字节
package org.xiji; public class MyDoubleVar { public static void main(String[] args) { //定义双浮点 double d = 3.1415926456789446f; System.out.println(d); //定义单浮点 float f = 3.1415926456789446f; System.out.println(f); System.out.println("可以明显看到:双浮点的精度大于单浮点"); } }
3.字符常量
'' 这个符号包括起来的
char myFirstChar = 'A' ；
4.字符串常量
使用""包括起来的，表示连续的字符串
string myFirstString = "这是我的第一个字符串";
5.布尔常量
布尔常量有两个值 false 和true
boolean myFirstBoolean = false;
boolean myTwoBoolean = true ;
6.null常量
只有一个null值，表示对象的引用为空
int myFirstInt ;
扩:
为空就是这个变量名没有引用变量值地址
7.算数运算符
1.加法运算符 (+):
- 用于两个数值相加。
- 也可以用于字符串连接。
int sum = 5 + 3; // 结果是8
String greeting = "Hello, " + "world!"; // 结果是"Hello, world!"
2.减法运算符 (-):
- 用于从一个数中减去另一个数。
int difference = 10 - 4; // 结果是6
3.乘法运算符 (*):
- 用于两个数相乘。
int product = 7 * 6; // 结果是42
4.除法运算符 (/):
- 用于将一个数除以另一个数。
- 对于整数类型，结果会向下取整。
int quotient = 20 / 4; // 结果是5 double quotientDouble = 20.0 / 4; // 结果是5.0
5.取模（余数）运算符 (%):
- 用于获取两数相除后的余数。
int remainder = 20 % 3; // 结果是2
6.自增运算符 (++):
- 将变量的值增加1。
- 可以放在变量之前或之后。
- 前置自增 (
++i)：先自增，后使用新值。 - 后置自增 (
i++)：先使用旧值，后自增。
- 前置自增 (
int i = 5; int j = ++i; // i 现在是6, j 也是6 int k = i++; // k 是6, i 现在是7
7.自减运算符 (--):
- 将变量的值减少1。
- 与自增运算符类似，可以前置或后置。
- 前置自减 (
--i)：先自减，后使用新值。 - 后置自减 (
i--)：先使用旧值，后自减。
- 前置自减 (
int m = 10; int n = --m; // m 现在是9, n 也是9 int o = m--; // o 是9, m 现在是8
8.赋值运算符
1)基本赋值运算符
= (等于)：
将右侧表达式的值赋给左侧变量。
int a = 5; // 将整数5赋值给变量a String name = "John"; // 将字符串"John"赋值给变量name
2)符合运算符
1.+= (加并赋值)：
将右侧的值加到左侧变量上，并将结果赋给左侧变量。
int a = 10; a += 5; // 等同于 a = a + 5; 结果a为15
2.-= (减并赋值)：
从左侧变量中减去右侧的值，并将结果赋给左侧变量。
int b = 20; b -= 3; // 等同于 b = b - 3; 结果b为17
3.*= (乘并赋值)：
将左侧变量与右侧的值相乘，并将结果赋给左侧变量。
int c = 4; c *= 6; // 等同于 c = c * 6; 结果c为24
4./= (除并赋值)：
将左侧变量除以右侧的值，并将结果赋给左侧变量。
double d = 8.0; d /= 2; // 等同于 d = d / 2; 结果d为4.0
5.%= (取模并赋值)：
将左侧变量对右侧的值取模，并将结果赋给左侧变量。
int e = 10; e %= 3; // 等同于 e = e % 3; 结果e为1
6.&= (按位与并赋值)：
执行按位与操作，并将结果赋给左侧变量。
int f = 12; // 二进制 1100 f &= 8; // 二进制 1000, 结果f为8 (二进制 1000)
7.|= (按位或并赋值)：
执行按位或操作，并将结果赋给左侧变量。
int g = 12; // 二进制 1100 g |= 3; // 二进制 0011, 结果g为15 (二进制 1111)
8.^= (按位异或并赋值)：
执行按位异或操作，并将结果赋给左侧变量。
int h = 12; // 二进制 1100 h ^= 3; // 二进制 0011, 结果h为15 (二进制 1111)
9.<<= (左移并赋值)：
将左侧变量的值向左移动指定的位数，并将结果赋给左侧变量。
int i = 4; // 二进制 0100 i <<= 2; // 向左移两位, 结果i为16 (二进制 10000)
10. >>= (右移并赋值)：
将左侧变量的值向右移动指定的位数，并将结果赋给左侧变量。
int j = 16; // 二进制 10000 j >>= 2; // 向右移两位, 结果j为4 (二进制 0100)
11.>>>= (无符号右移并赋值)：
将左侧变量的值向右移动指定的位数，并将结果赋给左侧变量。高位补0。
int k = -16; // 某种负数表示 k >>>= 2; // 无符号右移两位, 结果取决于具体的数值表示
9.比较运算符
普通比较
-
1.等于 (
==):- 检查两个操作数是否相等。
int a = 5; int b = 5; boolean isEqual = (a == b); // 结果为 true -
2.不等于 (
!=):- 检查两个操作数是否不相等。
int c = 5; int d = 3; boolean isNotEqual = (c != d); // 结果为 true -
3.大于 (
>):- 检查左边的操作数是否大于右边的操作数。
int e = 10; int f = 5; boolean isGreater = (e > f); // 结果为 true -
4.小于 (
<):- 检查左边的操作数是否小于右边的操作数。
int g = 5; int h = 10; boolean isLess = (g < h); // 结果为 true -
5.大于等于 (
>=):- 检查左边的操作数是否大于或等于右边的操作数。
int i = 10; int j = 10; boolean isGreaterOrEqual = (i >= j); // 结果为 true -
6.小于等于 (
<=):- 检查左边的操作数是否小于或等于右边的操作数。
int k = 5; int l = 5; boolean isLessOrEqual = (k <= l); // 结果为 true
对于对象的比较
对于引用类型的变量，使用 == 和 != 运算符比较的是对象的引用，而不是对象的内容。也就是说，它们检查的是两个变量是否指向内存中的同一个对象。
-
如果你需要比较对象的内容，应该使用
equals()方法。例如：String str1 = new String("hello"); String str2 = new String("hello"); boolean areStringsEqual = str1.equals(str2); // 结果为 true -
注意，
String类重写了Object类的equals()方法来比较字符串的内容，而不仅仅是引用。其他类如果需要基于内容进行比较，通常也需要重写equals()方法。
10.逻辑运算符
1. 逻辑与 (&&)
- 语法:
expression1 && expression2 - 功能: 如果两个操作数都为
true，则结果为true。如果任何一个操作数为false，则结果为false。 - 短路特性: 如果第一个操作数为
false，那么第二个操作数将不会被计算，因为整个表达式已经确定为false。
boolean a = true; boolean b = false; boolean result = a && b; // 结果为 false
2. 逻辑或 (||)
- 语法:
expression1 || expression2 - 功能: 如果两个操作数中有任意一个为
true，则结果为true。只有当两个操作数都为false时，结果才为false。 - 短路特性: 如果第一个操作数为
true，那么第二个操作数将不会被计算，因为整个表达式已经确定为true。
boolean c = true; boolean d = false; boolean result = c || d; // 结果为 true
3. 逻辑非 (!)
- 语法:
!expression - 功能: 对操作数的布尔值进行取反。如果操作数为
true，则结果为false；如果操作数为false，则结果为true。
boolean e = true; boolean result = !e; // 结果为 false
int x = 10; int y = 20; // 使用逻辑与 if (x > 5 && y < 30) { System.out.println("Both conditions are true"); } // 使用逻辑或 if (x > 5 || y < 10) { System.out.println("At least one condition is true"); } // 使用逻辑非 if (!(x == y)) { System.out.println("x is not equal to y"); }
4.短路行为
- 逻辑与 (
&&): 如果左侧的操作数为false，则右侧的操作数不会被评估，因为整体表达式的结果已经是false。 - 逻辑或 (
||): 如果左侧的操作数为true，则右侧的操作数不会被评估，因为整体表达式的结果已经是true。
这种短路行为可以用来提高效率，并且有时也可以避免潜在的错误，例如防止对 null 对象的方法调用。
String s = null; if (s != null && s.length() > 0) { // 这里不会抛出NullPointerException，因为如果s是null，s.length()不会被执行 System.out.println(s); }
11.条件判断
1.if
if(条件){
满足条件执行的代码
}
2.if-else
if(条件){
满足条件执行
}else{
不满足条件执行
}
案例:判断今天是星期几
1.代码
package org.xiji; public class WeekP { public static void main(String[] args) { int weekday = 1; //使用if if(weekday == 1){ System.out.println("星期一"); return; } if(weekday == 2){ System.out.println("星期二"); return; } if(weekday == 3){ System.out.println("星期三"); return; } if(weekday == 4){ System.out.println("星期四"); return; } if(weekday == 5){ System.out.println("星期五"); return; } if(weekday == 6){ System.out.println("星期六"); return; } if(weekday == 7){ System.out.println("星期日"); return; } System.out.println("--------------------------------"); } }
2.效果
注:三元运算符
条件判断 ? 满足条件执行 : 不满足条件执行
12.switch语句
switch(变量){
case 1 :
变量值等于1时执行代码；
break;//跳出循环
case 2 :
变量值等于2时执行代码；
break;//跳出循环
default :
条件都不满足的情况下执行;
break;
}
案例:使用switch判断
1.代码
package org.xiji; public class WeekPBySwitch { public static void main(String[] args) { int weekday = 4; switch (weekday){ case 1: System.out.println("星期一"); break; case 2: System.out.println("星期二"); break; case 3: System.out.println("星期三"); break; case 4: System.out.println("星期四"); break; case 5: System.out.println("星期五"); break; case 6: System.out.println("星期六"); break; case 7: System.out.println("星期日"); break; default: System.out.println("输入不合法"); break; } } }
2.效果
13.while循环
while(条件){
满足条件执行循环
}
案例:使用while输出1-10
1.代码
package org.xiji; public class WhileTest { public static void main(String[] args) { //使用while输出1-10 int i = 1; while(i <= 10) { System.out.println(i); i++; } } }
2.效果
14.do...while循环
do{
满足条件执行(注:这个会先执行一次在进行条件判断)
}
while(条件)
案例:输入1-30的偶数
1.代码
package org.xiji; public class MyDoWhile { public static void main(String[] args) { int i = 1; //输入1-30的偶数 do{ if (i % 2 == 0) { System.out.println(i); } i++; }while(i <= 30); } }
2.效果
15.for循环
for(条件 ; 判断是否满足条件 ; 条件变化 ){
满足条件继续执行
}
不满足条件执行
案例:使用for循环输出1-30的偶数
1.代码
package org.xiji; public class MyForTest { public static void main(String[] args) { //使用for循环输出1-30的奇数 for(int i = 1; i <= 30; i++){ if(i % 2 == 1){ System.out.println(i); } } } }
2.效果
16.嵌套循环
for(条件 ; 判断是否满足条件 ; 条件变化 ){
满足条件继续执行;
for(条件 ; 判断是否满足条件 ; 条件变化 ){
满足条件继续执行;
}
}
案例:打印一个长方形
1.代码
package org.xiji; public class MyTest { public static void main(String[] args) { //打印一个长方形使用嵌套 for (int i = 0; i < 5; i++) { for (int j = 0; j < 10; j++) { System.out.print("*"); } System.out.println(); } } }
2.效果
17.break语句
跳出当前循环层
当你在循环中使用
break时，它会立刻终止循环，不再检查循环条件是否满足，并跳转到循环体外的第一条语句继续执行。
18.continue语句
跳出当次循环，不会跳出当前层循环
在循环中的用法
- 对于
for循环：执行continue后，会立即跳转到下一个迭代。- 对于
while循环：执行continue后，会重新检查循环条件来决定是否继续下一次迭代。
19.java数组
数据类型[] 数组名 = null;
数据类型[] 数组名 = null;
数据类型[] 数组名 =new 数据类型[];
注:通过索引访问数组
int myArrayInt = [1,2,3,4,5]
//通过索引访问数组
myArrayint[0]
//索引是从0开始的
案例:遍历数组
1.代码
package org.xiji; public class MyArray { public static void main(String[] args) { int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; for (int i = 0; i < arr.length; i++) { System.out.println(arr[i]); } } }
2.效果
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
