java基础知识

目录

1.java程序的基本格式

案例:创建第一个java程序

步骤

2.java中的注释

案例:创建我的自定义程序

步骤

3.java中的关键字

4.java中的命名规则

1.标识符

2.包名

3.类名和接口名

4.方法名

5.变量名

6.常量

7.构造器

8.注释

9.不能使用java中的关键字去命名

5.java中的常量

1.整型常量

2.浮点常量

3.字符常量

4.字符串常量

5.布尔常量

6.null常量

扩:

7.算数运算符

8.赋值运算符

1)基本赋值运算符

= (等于)：

2)符合运算符

1.+= (加并赋值)：

2.-= (减并赋值)：

3.*= (乘并赋值)：

4./= (除并赋值)：

5.%= (取模并赋值)：

6.&= (按位与并赋值)：

7.|= (按位或并赋值)：

8.^= (按位异或并赋值)：

9.<<= (左移并赋值)：

10. >>= (右移并赋值)：

11.>>>= (无符号右移并赋值)：

9.比较运算符

普通比较

1.等于 (==):

2.不等于 (!=):

3.大于 (>):

4.小于 (<):

5.大于等于 (>=):

6.小于等于 (<=):

对于对象的比较

10.逻辑运算符

1. 逻辑与 (&&)

2. 逻辑或 (||)

3. 逻辑非 (!)

4.短路行为

11.条件判断

1.if

2.if-else

案例:判断今天是星期几

1.代码

2.效果

注:三元运算符

12.switch语句

案例:使用switch判断

1.代码

2.效果

13.while循环

案例:使用while输出1-10

1.代码

2.效果

14.do...while循环

案例:输入1-30的偶数

1.代码

2.效果​编辑

15.for循环

案例:使用for循环输出1-30的偶数

1.代码

2.效果

16.嵌套循环

案例:打印一个长方形

1.代码

2.效果

17.break语句

18.continue语句

19.java数组

案例:遍历数组

1.代码

2.效果

---

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中的关键字

1. abstract - 用于声明抽象类或方法。抽象类不能被实例化，抽象方法必须在子类中实现。

2. assert - 用于断言测试条件。如果条件为假，则抛出一个 AssertionError。

3. boolean - 基本数据类型，表示逻辑上的真（true）或假（false）。

4. break - 用于立即退出循环（for, while, do-while）或 switch 语句。

5. byte - 8位有符号整数类型，取值范围是 -128 到 127。

6. case - 用在 switch 语句中，定义分支。

7. catch - 与 try 关键字一起使用，处理 try 块中可能发生的异常。

8. char - 16位无符号 Unicode 字符类型。

9. class - 定义一个类。

10. const - 保留的关键字，目前没有实际用途。

11. continue - 跳过当前循环的剩余部分，并继续下一次循环。

12. default - 用在 switch 语句中作为默认情况，或者接口中的默认方法。

13. do - 与 while 结合使用构成 do-while 循环。

14. double - 双精度浮点数，通常占用 64 位存储空间。

15. else - 与 if 结合使用，定义 if 条件不满足时执行的代码块。

16. enum - 允许创建枚举类型，枚举是一组命名的常量。

17. extends - 使一个类继承另一个类，或者接口扩展另一个接口。

18. final - 可以用来修饰类、变量和方法，表明它们不可改变或覆盖。

19. finally - 与 try 和 catch 配合使用，无论是否发生异常都会执行 finally 块中的代码。

20. float - 单精度浮点数，通常占用 32 位存储空间。

21. for - 用于创建 for 循环，重复执行一段代码指定次数。

22. goto - 保留的关键字，但 Java 中并未使用。

23. if - 用于条件判断，根据条件真假执行相应的代码块。

24. implements - 用于实现一个或多个接口。

25. import - 导入其他包中的类或接口到当前文件中。

26. instanceof - 测试对象是否是指定类的一个实例，或者实现了特定的接口。

27. int - 32位有符号整数类型。

28. interface - 定义接口，接口可以包含抽象方法和默认方法。

29. long - 64位有符号整数类型。

30. native - 指明方法是由非Java语言编写的，比如C/C++。

31. new - 创建新对象的运算符。

32. package - 定义包，有助于组织类并控制访问权限。

33. private - 访问级别限定词，仅在声明它的类内部可见。

34. protected - 访问级别限定词，同一包内的类或不同包的子类可见。

35. public - 访问级别限定词，对所有类可见。

36. return - 从方法返回一个值，或者结束方法的执行。

37. short - 16位有符号整数类型。

38. static - 表示成员属于类而不是类的实例，静态成员可以通过类名直接访问。

39. strictfp - 确保浮点计算遵循IEEE 754标准。

40. super - 引用父类的对象，通常用于调用父类的方法或构造函数。

41. switch - 选择结构，根据表达式的值来决定执行哪段代码。

42. synchronized - 标记方法或代码块，保证多线程环境下的同步访问。

43. this - 引用当前对象，可以在方法或构造函数中使用。

44. throw - 显式地抛出一个异常。

45. throws - 在方法签名中声明该方法可能抛出的异常。

46. transient - 标记字段不会被序列化。

47. try - 尝试执行可能抛出异常的代码块，通常与 catch 和 finally 一起使用。

48. void - 表示方法没有返回值。

49. volatile - 标记变量，确保其修改对所有线程都可见。

50. 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. 1.等于 (==):

   • 检查两个操作数是否相等。

   int a = 5;
   int b = 5;
   boolean isEqual = (a == b); // 结果为 true

2. 2.不等于 (!=):

   • 检查两个操作数是否不相等。

   int c = 5;
   int d = 3;
   boolean isNotEqual = (c != d); // 结果为 true

3. 3.大于 (>):

   • 检查左边的操作数是否大于右边的操作数。

   int e = 10;
   int f = 5;
   boolean isGreater = (e > f); // 结果为 true

4. 4.小于 (<):

   • 检查左边的操作数是否小于右边的操作数。

   int g = 5;
   int h = 10;
   boolean isLess = (g < h); // 结果为 true

5. 5.大于等于 (>=):

   • 检查左边的操作数是否大于或等于右边的操作数。

   int i = 10;
   int j = 10;
   boolean isGreaterOrEqual = (i >= j); // 结果为 true

6. 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;//使用ifif(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-10int 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.效果