Java入门指南:从零开始的基础语法

简介: Java是一种高级编程语言,最初由Sun Microsystems(现在是Oracle Corporation的一部分)在1995年推出。Java以其简单、可移植和安全的特性而闻名,并广泛用于各种应用程序开发,从桌面应用程序到移动应用程序和企业级应用程序。

java语言概述

Java是一种高级编程语言,最初由Sun Microsystems(现在是Oracle Corporation的一部分)在1995年推出。Java以其简单、可移植和安全的特性而闻名,并广泛用于各种应用程序开发,从桌面应用程序到移动应用程序和企业级应用程序。


2009 年 04 月 20 日,美国甲骨文公司 74 亿美元收购 Sun,取得 java 的版权。


Java 不只是一种编程语言,它是一个完整的平台,拥有庞大的库,将诸如图形绘制、Socket连接、数据库存取等复杂操作进行了最大程度的简化。


Java的特点之一是其跨平台性。Java程序可以在不同的操作系统上运行,包括Windows、Mac和Linux等。这得益于Java虚拟机(JVM),它充当了一个中间层,将Java代码转换为特定平台上的可执行文件。这种可移植性使得Java成为开发跨平台应用程序的理想选择。


在世界编程语言排行榜中,Java占据着第三名的位置,仅次于C语言。

 

Java是典型的面向对象的语言,晚于C++发布,部分语法和思想也参考了C++:

尽管人们发现C++的语法太复杂,有很多冗余,但是 Java 在设计的时候还是尽可能的接近C++,降低人们的学习成本。Java 语法是 C++ 语法的一个“纯净”版,没有头文件、指针运算(也没有指针语法)、结构、联合、运算符重载、虚基类等。有C++基础的读者,可以轻易地切换到Java。

此外,Java也被广泛用于Android应用程序的开发。Android平台使用Java作为其主要编程语言,开发者可以利用Java的语法和库来构建功能丰富的移动应用程序。

总的来说,Java是一种多功能、可移植和易于学习的编程语言,适用于各种应用程序开发,并在企业级和移动应用开发领域广泛应用。它的跨平台性、面向对象的设计和强大的库支持使得Java成为众多开发人员的首选语言之一。

一、第一个java程序

程序员的第一站:HELLO WORD

1. public class Hello{                  //定义一个名为Hello的类(
2. public static void main(String[] args){      //main入口
3.         System.out.println("Hello World");      //打印输出Hello World
4.     }
5. }

执行可以看到输出结果

 

二、数据类型

Java 是一种强类型的语言,声明变量时必须指明数据类型。变量(variable)的值占据一定的内存空间。不同类型的变量占据不同的大小。

  • 常量:在程序的执行过程中,其值不会发生改变的量(数据)。
  • 变量:就是内存中的存储空间,空间中存储着经常发生改变的值。
  • 基本数据类型
  • 引用数据类型:除了上述8种基本数据类型,其余的都是引用数据类型(引用类型存放在堆里,基本类型存放在栈里)

Java中共有8种基本数据类型,包括4 种整型、2 种浮点型、1 种字符型、1 种布尔型

数据类型 说明 所占内存 举例 备注
byte 字节型 1 byte 3, 127
short 短整型 2 bytes 3, 32767
int 整型 4 bytes 3, 21474836
long 长整型 8 bytes 3L, 92233720368L long最后要有一个L字母(大小写无所谓)。
float 单精度浮点型 4 bytes 1.2F, 223.56F float最后要有一个F字母(大小写无所谓)。
double 双精度浮点型 8 bytes 1.2, 1.2D, 223.56, 223.56D double最后最好有一个D字母(大小写无所谓)。
char 字符型 2 bytes 'a', ‘A’ 字符型数据只能是一个字符,由单引号包围。
boolean 布尔型 1 bit true, false

三、数据类型的转换

在Java中,数据类型的转换是将一个数据类型的值转换为另一个数据类型的过程。Java提供了两种类型的数据类型转换:隐式转换(自动转换)和显式转换(强制转换)。

  1. 隐式转换(自动转换): 隐式转换是指将一个小范围的数据类型自动转换为一个大范围的数据类型。在这种情况下,Java会自动执行类型转换,不需要显式地编写代码来执行转换。例如,将一个整数赋值给一个浮点数变量:
1. int num1 = 10;
2. double num2 = num1; // 隐式转换,将int类型转换为double类型
3. System.out.println(num2); // 输出结果为 10.0

在上述示例中,整数类型的变量num1被隐式转换为浮点数类型的变量num2

  1. 显式转换(强制转换): 显式转换是指将一个大范围的数据类型手动转换为一个小范围的数据类型。在这种情况下,需要使用强制转换操作符(())来显式地将一个数据类型转换为另一个数据类型。例如,将一个浮点数赋值给一个整数变量:
1. double num1 = 10.5;
2. int num2 = (int) num1; // 显式转换,将double类型转换为int类型
3. System.out.println(num2); // 输出结果为 10

在上述示例中,浮点数类型的变量num1被显式转换为整数类型的变量num2

需要注意的是,当执行显式转换时,可能会发生数据丢失或溢出。例如,将一个大范围的整数转换为一个小范围的整数时,可能会导致溢出。因此,在进行显式转换之前,应该确保转换是安全的。

四、java运算符

Java中的运算符和C/C++相差无几,是对常量或者变量进行操作的符号。

数学运算符

数学运算,结果为一个数值。见下表:

运算符 说明 举例
+ 加法 1 + 2
- 减法 4 - 3.4
* 乘法 7 * 1.5
/ 除法 3.5 / 7
% 取余 7 % 2
++ 自增 3++
-- 自减 3--

 

1. public static void main(String[] args) {
2. // 算术运算符示例
3. int num1 = 10;
4. int num2 = 5;
5. int sum = num1 + num2;
6. int difference = num1 - num2;
7. int product = num1 * num2;
8. int quotient = num1 / num2;
9. int remainder = num1 % num2;
10.         System.out.println("Sum: " + sum);
11.         System.out.println("Difference: " + difference);
12.         System.out.println("Product: " + product);
13.         System.out.println("Quotient: " + quotient);
14.         System.out.println("Remainder: " + remainder);
15. }

关系运算符

关系运算符,结果为一个布尔值。见下表:

运算符 说明 举例
> 大于 a > 4.2
>= 大于等于 3.4 >= b
< 小于 1.5 < 9
<= 小于等于 6 <= 1
== 等于 2 == 2
!= 不等于 2 != 2
&& true && false
|| (3 > 1) || (2 == 1)
! !true
1. // 比较运算符示例
2. int a = 5;
3. int b = 10;
4. boolean isEqual = (a == b);
5. boolean isNotEqual = (a != b);
6. boolean isGreater = (a > b);
7. boolean isLess = (a < b);
8. boolean isGreaterOrEqual = (a >= b);
9. boolean isLessOrEqual = (a <= b);
10.         System.out.println("isEqual: " + isEqual);
11.         System.out.println("isNotEqual: " + isNotEqual);
12.         System.out.println("isGreater: " + isGreater);
13.         System.out.println("isLess: " + isLess);
14.         System.out.println("isGreaterOrEqual: " + isGreaterOrEqual);
15.         System.out.println("isLessOrEqual: " + isLessOrEqual);

位运算符

位运算符对整数的二进制形式逐位进行逻辑运算,得到一个整数。见下表:

运算符 说明 举例
& 1 & 4
| 2 | 5
^ 异或 2 ^ 3
~ ~5
<< 左移 5 << 3
>> 右移 6 >> 1
1. // 逻辑运算符示例
2. boolean p = true;
3. boolean q = false;
4. boolean logicalAnd = p && q;
5. boolean logicalOr = p || q;
6. boolean logicalNot = !p;
7.         System.out.println("logicalAnd: " + logicalAnd);
8.         System.out.println("logicalOr: " + logicalOr);
9.         System.out.println("logicalNot: " + logicalNot);
10.     }

四、流程控制

通过一些语句,来控制程序的执行流程,Java流程控制的语法与 C/C++ 类似,也有 if...else、while、do...while、for、switch...case等

顺序结构语句:程序中最简单最基本的流程控制,没有特定的语法结构,按照代码的先后顺序依次执行,程序中大多数代码都是这样的

1、if语句

1. if(关系表达式){
2.     语句体1;
3. }else{
4.     语句体2;
5. }

执行流程

  1. 首先计算关系表达式的值
  2. 如果关系表达式的值为true则执行语句体1
  3. 如果关系表达式为false就执行语句体2
  4. 继续执行后续代码
1. import java.util.Scanner;
2. public class a{
3. public static void main(String[] args){
4. Scanner sc = new Scanner(System.in);
5.     System.out.println("请输入您的年龄:");
6. int age = sc.nextInt();
7. if(age >= 18){
8.       System.out.println("您已成年");
9.     }else{
10.       System.out.println("您未成年");
11.     }
12.   }
13. }

如果if语句中的语句体只有一条,那么大括号{}可以省略不写,但是不建议,容易混淆 if语句小括号后面不要写分号;

多条件判断:

基本语法:

1. if(判断条件){
2.     语句体1;
3. }else if(判断条件2){
4.     语句体2;
5. }
6. ...
7. else{
8.     语句体n+1;
9. }

代码示例:

1. public class a{
2. public static void main(String[] args){
3. Scanner sc = new Scanner(System.in);
4.     System.out.println("请输入您的成绩:");
5. int score = sc.nextInt();
6. if(score >= 90 && score <= 100){
7.       System.out.println("优秀");
8.     }else if(score >= 80 && score < 90){
9.       System.out.println("良好");
10.     }else if(score >=60 && score < 80){
11.       System.out.println("及格");
12.     }else if(score <60 && score >= 0){
13.       System.out.println("不及格");
14.     }else{
15.       System.out.println("请输入正确的成绩!");
16.     }
17.   }
18. }

2、switch语句

当需要根据不同的条件执行不同的代码块时,可以使用Java中的switch语句。switch语句根据给定的表达式的值,选择匹配的case语句执行相应的代码块

语法:

1. switch(表达式){
2. case 值1:
3.         语句体1;
4. break;
5. case 值2;
6.         语句体2;
7. break;
8.     ....
9. default:
10.         语句体n+1;
11. break;
12. }

格式说明

  • 表达式(将要被匹配的值)取值为byte、short、int、char、枚举(jdk5)、String(jdk7)
  • case:后面跟的是要和表达式比较的值(被匹配的值)
  • break:表示中断,结束的意思,用来结束switch语句
  • default:表示所有的情况都不匹配的时候,就执行该处的内容,和if语句的else相似

案例:

1. public class SwitchExample {
2. public static void main(String[] args) {
3. int dayOfWeek = 4; // 假设今天是星期四
4. 
5. switch (dayOfWeek) {
6. case 1:
7.                 System.out.println("今天是星期一");
8. break;
9. case 2:
10.                 System.out.println("今天是星期二");
11. break;
12. case 3:
13.                 System.out.println("今天是星期三");
14. break;
15. case 4:
16.                 System.out.println("今天是星期四");
17. break;
18. case 5:
19.                 System.out.println("今天是星期五");
20. break;
21. case 6:
22.                 System.out.println("今天是星期六");
23. break;
24. case 7:
25.                 System.out.println("今天是星期日");
26. break;
27. default:
28.                 System.out.println("无效的星期几");
29. break;
30.         }
31.     }
32. }

3、for循环

推荐在明确循环次数时使用

当需要重复执行一段代码块固定次数或基于条件时,可以使用Java中的for循环结构。for循环由三个部分组成:初始化语句、循环条件和循环迭代语句

语法:

1. for(初始化语句;条件判断语句;条件控制语句){
2.     循环体语句;
3. }
1. public class ForLoopExample {
2. public static void main(String[] args) {
3. // 循环执行5次
4. for (int i = 1; i <= 5; i++) {
5.             System.out.println("循环次数:" + i);
6.         }
7. 
8.         System.out.println();
9. 
10. // 根据数组长度循环遍历数组元素
11. int[] numbers = {1, 2, 3, 4, 5};
12. for (int i = 0; i < numbers.length; i++) {
13.             System.out.println("数组元素:" + numbers[i]);
14.         }
15. 
16.         System.out.println();
17. 
18. // 根据条件循环执行代码块
19. int counter = 0;
20. for (; counter < 3; ) {
21.             System.out.println("计数器值:" + counter);
22.             counter++;
23.         }
24.     }
25. }

在上述示例中,展示了几种使用for循环的情况。第一个for循环示例是一个固定次数的循环,重复执行5次,输出循环次数。第二个for循环示例是基于数组的循环,通过迭代变量i访问数组元素并输出。第三个for循环示例是根据条件循环执行代码块,计数器初始值为0,每次循环递增1,直到计数器的值小于3为止。

你可以根据需要修改和扩展示例代码。for循环是Java中最常用的循环结构之一,用于重复执行一段代码块,具有很高的灵活性和适应性。

4、while循环

不明确循环次数时推荐while

当需要根据条件重复执行一段代码块时,可以使用Java中的while循环结构。while循环在每次循环迭代之前检查循环条件是否为真,如果条件为真,则执行循环体内的代码块

语法:

1. while(条件判断语句){
2.     循环体语句;
3.     条件控制语句;
4. }

案例:

1. public class WhileLoopExample {
2. public static void main(String[] args) {
3. // 循环执行5次
4. int counter = 1;
5. while (counter <= 5) {
6.             System.out.println("循环次数:" + counter);
7.             counter++;
8.         }
9. 
10.         System.out.println();
11. 
12. // 根据条件循环执行代码块
13. int number = 0;
14. while (number < 10) {
15.             System.out.println("当前数字:" + number);
16.             number += 2;
17.         }
18.     }
19. }

在上述示例中,展示了两种使用while循环的情况。第一个while循环示例是一个固定次数的循环,重复执行5次,输出循环次数。循环之前初始化计数器为1,每次循环迭代后计数器递增。第二个while循环示例是根据条件循环执行代码块,初始数字为0,每次循环迭代后数字递增2,直到数字达到10为止。

你可以根据需要修改和扩展示例代码。while循环是一种常用的循环结构,用于根据条件重复执行代码块,灵活性较高。

5、do...while循环

使用较少  

语法:

1. do{
2.     循环体语句;
3.     条件控制语句;
4. }while(条件判断语句);

    三种循环的区别:

  1. for循环:
  • for循环是一种在已知循环次数的情况下使用的循环结构。它由初始化语句、循环条件和循环迭代语句组成。
  • 初始化语句用于初始化循环变量,循环条件用于判断是否继续循环,循环迭代语句用于更新循环变量的值。
  • for循环适用于需要固定次数重复执行的情况,循环次数在循环开始前就已知。
  1. while循环:
  • while循环是一种在未知循环次数的情况下使用的循环结构。它在每次循环迭代之前检查循环条件是否为真,只要条件为真,就会继续执行循环体内的代码块。
  • while循环适用于需要根据条件重复执行代码块的情况,循环次数在循环开始前不一定已知。
  1. do-while循环:
  • do-while循环是一种与while循环类似的循环结构,不同之处在于它会先执行循环体内的代码块,然后再检查循环条件是否为真。
  • do-while循环至少会执行一次循环体内的代码块,然后在每次循环迭代之前检查循环条件是否为真。
  • do-while循环适用于需要至少执行一次循环体的情况,循环次数在循环开始前不一定已知。

总结:

  • for循环适用于已知循环次数的情况。
  • while循环适用于根据条件循环执行代码块的情况。
  • do-while循环适用于至少执行一次循环体的情况。

在实际使用中,根据不同的需求和场景,选择合适的循环结构可以提高代码的可读性和执行效率。

6、continue与break关键字

  • continue:跳过某次循环内容,继续开始下一层循环,只能在循环中使用
  • break:跳出整个循环,终止循环体内容的执行,只能在循环和switch中使用
  • 标号:可以给语句块加标号赋予它们名称,标号位于语句之前。标号只能被continue和break引用。
1. public class Test{
2. public static void main(String[] args){
3. int n = 1;
4.         lo:        //标号
5. while(true){
6. switch(n){
7. case 1:
8.                     System.out.println("1");
9. break lo;      //通过标号,这里的break将结束外层while循环
10.             }
11.         }
12.     }
13. }

语句前只允许加一个标号,标号后面不能跟大括号。通过用break后加标号对处于标号中的语句进行控制。往往标号后是for、while、do-while等循环

五、Java数组的定义和使用

数组(array):是一种容器,用来存储同种数据类型(或者比它所占字节小的)的多个值

语法:

1. //1.数据类型[] 变量名  【最常用】
2. int[] array;
3. 
4. //2.数据类型 变量名[]    
5. int array[];

与C、C++不同,Java在定义数组时并不为数组元素分配内存,因此[ ]中无需指定数组元素的个数,即数组长度。而且对于如上定义的一个数组是不能访问它的任何元素的,我们必须要为它分配内存空间,这时要用到运算符new

在Java中,数组必须先初始化,才能使用

所谓初始化,就是在内存中,为数组容器开辟空间,并将数据存入容器的过程

动态初始化:初始化时只指定数组长度,由系统为数组分配初始值

  • 只明确元素个数,不明确具体数值时推荐使用
  • 格式:数据类型[] 变量名 = new 数据类型[数组长度];
  • 范例:int[] arr = new int[3];
  • 注意:打印数组变量名,输出的是数组在内存中的地址值

静态初始化:初始化时就可以指定数组要存储的元素,系统还会自动计算出该数组的长度

  • 需求中明确了具体数据,直接静态初始化即可
  • 格式:数据类型[] 变量名 = new 数据类型[]{数据1,数据2,数据3,....};
  • 范例:int[] arr = new int[]{1,2,3};
  • 简化格式:int[] arr = {1,2,3};

内存分配

Java程序在运行时,需要在内存中分配空间,为了提高效率,就对空间进行了不同区域的划分

每一片区域都有特定的处理数据的方式和内存管理方式

  • 栈内存:方法运行时,进入的内存,局部变量都存放于这块内存当中
  • 堆内存:new出来的内容(引用类型)就会进入堆内存,并且会存在地址值
  • 方法区:字节码文件加载时进入的内存
  • 本地方法栈:调用操作系统相关资源
  • 寄存器:交给CPU去使用

你可以在声明数组的同时进行初始化(静态初始化),也可以在声明以后进行初始化(动态初始化)。例如:

1. // 静态初始化
2. // 静态初始化的同时就为数组元素分配空间并赋值
3. int intArray[] = {1,2,3,4};
4. String stringArray[] = {"微学苑", "http://www.weixueyuan.net", "一切编程语言都是纸老虎"};
5. // 动态初始化
6. float floatArray[] = new float[3];
7. floatArray[0] = 1.0f;
8. floatArray[1] = 132.63f;
9. floatArray[2] = 100F;

数组引用

可以通过下标来引用数组:

   arrayName[index];

与C、C++不同,Java对数组元素要进行越界检查以保证安全性。


每个数组都有一个length属性来指明它的长度,例如 intArray.length 指明数组 intArray 的长度。


【示例】写一段代码,要求输入任意5个整数,输出它们的和。

1. import java.util.*;
2. public class Demo {
3. public static void main(String[] args){
4. int intArray[] = new int[5];
5. long total = 0;
6. int len = intArray.length;
7. 
8. // 给数组元素赋值
9.         System.out.print("请输入" + len + "个整数,以空格为分隔:");
10. Scanner sc = new Scanner(System.in);
11. for(int i=0; i<len; i++){
12.             intArray[i] = sc.nextInt();
13.         }
14. 
15. // 计算数组元素的和
16. for(int i=0; i<len; i++){
17.             total += intArray[i];
18.         }
19. 
20.         System.out.println("所有数组元素的和为:" + total);
21.     }
22. }

数据常见操作

获取最值

  • 定义一个变量,用于保存最大值(或最小值)
  • 取数组中的第一个值作为变量的初始值(假设第一个值就是最大/小值)
  • 与数组中的剩余数据逐个对比
1. int[] arr = {1, 2, 3, 4, 5, 6, 7000, 8, 919};
2. int max = arr[0];
3. for(int i = 0; i < arr.length; i++){
4. if(arr[i] > max) max = arr[i];
5. }
6. System.out.println("最大值为:" + max);

数组元素求和

1. import java.util.Scanner;
2. public class test{
3. public static void main(String[] args){
4. Scanner sc = new Scanner(System.in);
5. int[] arr = new int[];
6. int sum = 0;
7. for(int i = 0; i < arr.length; i++){
8.             System.out.print("请输入第" + (i+1) + "个数值:");
9. int n = sc.nextInt();
10.             sum += n;
11.         }
12.         System.out.println("数组内的元素的和为:" + sum);
13.     }
14. }

数组基本查找

1. int[] arr = {19, 28, 37, 46, 50};
2. Scanner sc = new Scanner(System.in);
3. System.out.print("请输入您要查找的数据:");
4. int n = sc.nextInt();
5. for(int i = 0; i < arr.length; i++){
6. if(arr[i] == n){
7.         System.out.println("您要查找的数据索引为:" + i);
8. break;
9.     }
10. }

二维数组

二维数组的声明、初始化和引用与一维数组相似:

1. int intArray[ ][ ] = { {1,2}, {2,3}, {4,5} };
2. int a[ ][ ] = new int[2][3];
3. a[0][0] = 12;
4. a[0][1] = 34;
5. // ......
6. a[1][2] = 93;

Java语言中,由于把二维数组看作是数组的数组,数组空间不是连续分配的,所以不要求二维数组每一维的大小相同。例如:

1. int intArray[ ][ ] = { {1,2}, {2,3}, {3,4,5} };
2. int a[ ][ ] = new int[2][ ];
3. a[0] = new int[3];
4. a[1] = new int[5];

【示例】通过二维数组计算两个矩阵的乘积。

1. public class Demo {
2. public static void main(String[] args){
3. // 第一个矩阵(动态初始化一个二维数组)
4. int a[][] = new int[2][3];
5. // 第二个矩阵(静态初始化一个二维数组)
6. int b[][] = { {1,5,2,8}, {5,9,10,-3}, {2,7,-5,-18} };
7. // 结果矩阵
8. int c[][] = new int[2][4];
9. 
10. // 初始化第一个矩阵
11. for(int i=0; i<2; i++)
12. for(int j=0; j<3 ;j++)
13.                 a[i][j] = (i+1) * (j+2);
14. 
15. // 计算矩阵乘积
16. for (int i=0; i<2; i++){
17. for (int j=0; j<4; j++){
18.                 c[i][j]=0;
19. for(int k=0; k<3; k++)
20.                     c[i][j] += a[i][k] * b[k][j];
21.             }
22.         }
23. // 输出结算结果
24. for(int i=0; i<2; i++){
25. for (int j=0; j<4; j++)
26.                 System.out.printf("%-5d", c[i][j]);
27.             System.out.println();
28.         }
29.     }
30. }

运行结果:

25   65   14   -65

50   130  28   -130

几点说明:

  • 上面讲的是静态数组。静态数组一旦被声明,它的容量就固定了,不容改变。所以在声明数组时,一定要考虑数组的最大容量,防止容量不够的现象。
  • 如果想在运行程序时改变容量,就需要用到数组列表(ArrayList,也称动态数组)或向量(Vector)。
  • 正是由于静态数组容量固定的缺点,实际开发中使用频率不高,被 ArrayList 或 Vector 代替,因为实际开发中经常需要向数组中添加或删除元素,而它的容量不好预估。

六、方法

方法就是一段具有独立功能 的代码块,不调用就不执行

基本使用

  • 方法必须先创建才可以使用,该过程称为方法的定义
  • 方法创建后并不是直接运行的,需要手动使用后才执行,该过程称为方法调用

语法

1. public void 方法名(){
2. //方法体
3. }

方法调用方法名();

注意

  • 方法必须先定义后调用,否则程序将会报错
  • 方法与方法之间是平级关系,不能嵌套定义
  • 在方法没有被调用的时候,都在方法区中的字节码文件(.class)中存储
  • 方法被调用的时候,需要进入到栈内存中运行

带参方法

形参和实参 形参:全称形式参数,是指方法定义中的参数 实参:全称实际参数,是指方法调用中的参数

语法

1. public void 方法名(参数){
2. //方法体
3. }

单个参数:数据类型 变量名 多个参数:数据类型 变量名1 , 数据类型 变量名2 , .....调用

  • 方法名(变量名/常量值);
  • 方法名(变量名1/常量值1 , 变量名2/常量值2 , ...);

方法调用时,参数的数量与类型必须与方法定义中的设置相匹配,否则程序将会报错

案例:

1. public class ParameterizedMethodExample {
2. public static void main(String[] args) {
3. int number1 = 10;
4. int number2 = 5;
5. 
6. // 调用带参方法,并传入两个整数作为参数
7. int sum = calculateSum(number1, number2);
8. 
9.         System.out.println("Sum: " + sum);
10.     }
11. 
12. // 带参方法,用于计算两个整数的和
13. public static int calculateSum(int a, int b) {
14. int sum = a + b;
15. return sum;
16.     }
17. }

带返回值方法

语法:

1. public 返回值数据类型 方法名(参数){
2. return 数据;
3. }
  • 方法定义时,return后面的返回值与方法定义上的数据类型要匹配,否则就会报错
  • 在执行代码时,return语句后面的语句都不会执行,属于无效代码
  • return;可以用于结束方法,也就是方法从栈内存中弹出去,该过程称为方法的弹栈

当需要在方法内部执行一些操作并返回结果时,可以定义带有返回值的方法。下面是一个简单的示例,展示了Java中带返回值的方法的用法:

1. public class ReturnValueMethodExample {
2. public static void main(String[] args) {
3. int number1 = 10;
4. int number2 = 5;
5. 
6. // 调用带返回值的方法,并将返回结果赋值给变量
7. int maxNumber = findMax(number1, number2);
8. 
9.         System.out.println("Max Number: " + maxNumber);
10.     }
11. 
12. // 带返回值的方法,用于找到两个整数的最大值,并返回结果
13. public static int findMax(int a, int b) {
14. int max = (a > b) ? a : b;
15. return max;
16.     }
17. }

方法重载

方法名相同,参数也完全相同,称为方法的重复定义,是一种冲突性的错误 在调用方法的时候,Java虚拟机会通过参数的不同来区分同名的方法

  • 在同一个类中,定义了多个同名的方法,但每个方法具有不同的参数类型或参数个数,这些同名的方法,就构成了重载关系
  • 好处:不用记忆过多繁琐的方法名字
  • 注意:识别方法之间是否是重载关系,只看方法名和参数,和返回值无关

方法重载(Method Overloading)是指在一个类中可以定义多个方法名称相同但参数列表不同的方法。下面是一个简单的示例,展示了Java中方法重载的用法:

1. public class MethodOverloadingExample {
2. public static void main(String[] args) {
3. int result1 = add(5, 10);
4. double result2 = add(2.5, 3.7);
5. int result3 = add(1, 2, 3);
6. 
7.         System.out.println("Result 1: " + result1);
8.         System.out.println("Result 2: " + result2);
9.         System.out.println("Result 3: " + result3);
10.     }
11. 
12. // 方法重载示例
13. public static int add(int a, int b) {
14. return a + b;
15.     }
16. 
17. public static double add(double a, double b) {
18. return a + b;
19.     }
20. 
21. public static int add(int a, int b, int c) {
22. return a + b + c;
23.     }
24. }

方法的重写

方法重写(Method Overriding)是指在子类中重新定义(覆盖)从父类继承而来的方法,使得子类可以根据自身的需求来改变方法的实现。重写的方法具有相同的名称、参数列表和返回类型。

下面是一个简单的示例,展示了Java中方法重写的用法:

1. class Animal {
2. public void makeSound() {
3.         System.out.println("动物发出声音");
4.     }
5. }
6. 
7. class Cat extends Animal {
8. @Override
9. public void makeSound() {
10.         System.out.println("猫发出喵喵的声音");
11.     }
12. }
13. 
14. public class MethodOverrideExample {
15. public static void main(String[] args) {
16. Animal animal = new Animal();
17.         animal.makeSound(); // 输出: 动物发出声音
18. 
19. Cat cat = new Cat();
20.         cat.makeSound(); // 输出: 猫发出喵喵的声音
21.     }
22. }

在上述示例中,有一个父类Animal和一个子类Cat。父类Animal有一个名为makeSound的方法,子类Cat通过使用@Override注解重写了父类的makeSound方法,并在方法体中改变了实现逻辑。

main方法中,创建了一个父类对象animal和一个子类对象cat,分别调用它们的makeSound方法。由于方法重写的存在,调用子类对象的makeSound方法时会执行子类中重写的方法实现,而不是父类中的方法实现。

方法重写使得子类可以在继承的基础上修改和定制父类的行为,实现了多态性的一种表现。

七、String字符串

在Java中,String是一个类,用于表示字符串。它是Java中最常用的数据类型之一,用于存储和操作文本数据。String类是不可变的,也就是说,一旦创建了一个字符串对象,它的值就不能被修改。

String类提供了许多其他的方法,用于处理和操作字符串。由于String是不可变的,每次对字符串的修改都会生成一个新的字符串对象。在处理大量字符串或频繁修改字符串内容时,建议使用StringBuilderStringBuffer类,它们提供了可变的字符串操作的功能,可以提高性能。

1. public class StringExample {
2. public static void main(String[] args) {
3. String str1 = "Hello";
4. String str2 = "World";
5. 
6. // 字符串拼接
7. String greeting = str1 + " " + str2;
8.         System.out.println("拼接结果:" + greeting);
9. 
10. // 字符串长度
11. int length = greeting.length();
12.         System.out.println("字符串长度:" + length);
13. 
14. // 字符串比较
15. String str3 = "hello";
16. boolean isEqual = str1.equals(str3);
17.         System.out.println("字符串比较结果:" + isEqual);
18. 
19. // 字符串查找
20. int index = greeting.indexOf("World");
21.         System.out.println("查找结果:" + index);
22. 
23. // 字符串提取
24. String subStr = greeting.substring(6);
25.         System.out.println("提取结果:" + subStr);
26. 
27. // 字符串替换
28. String replacedStr = greeting.replace("Hello", "Hi");
29.         System.out.println("替换结果:" + replacedStr);
30. 
31. // 字符串转换
32. String upperCaseStr = greeting.toUpperCase();
33.         System.out.println("大写转换结果:" + upperCaseStr);
34. 
35. String lowerCaseStr = greeting.toLowerCase();
36.         System.out.println("小写转换结果:" + lowerCaseStr);
37.     }
38. }

在上述示例中,我们定义了两个字符串str1str2,然后进行了一系列的字符串操作:

  • 使用+运算符进行字符串拼接,将str1、空格和str2连接起来。
  • 使用length()方法获取字符串的长度。
  • 使用equals()方法比较两个字符串是否相等。
  • 使用indexOf()方法查找子字符串在原字符串中的位置。
  • 使用substring()方法提取字符串的子串。
  • 使用replace()方法将字符串中的子串替换为新的字符串。
  • 使用toUpperCase()toLowerCase()方法将字符串转换为大写和小写形式。

运行以上代码,将会输出以下结果:

1. 拼接结果:Hello World
2. 字符串长度:11
3. 字符串比较结果:false
4. 查找结果:6
5. 提取结果:World
6. 替换结果:Hi World
7. 大写转换结果:HELLO WORLD
8. 小写转换结果:hello world

这个例子演示了一些常见的String操作,你可以根据需要修改和扩展示例代码。String类提供了许多其他的方法,用于处理和操作字符串,你可以参考Java官方文档以获得更详细的了解。

StringBuffer与StringBuider

在Java中,StringBufferStringBuilder是用于可变字符串操作的类。它们提供了类似于String的功能,但与String不同的是,它们的内容可以修改。

以下是关于StringBufferStringBuilder的特点和区别:

  1. 可变性:
  • StringBufferStringBuilder都是可变的,允许修改字符串内容。
  • String是不可变的,每次对字符串的修改都会创建一个新的字符串对象。
  1. 线程安全性:
  • StringBuffer是线程安全的,适用于多线程环境。
  • StringBuilder是非线程安全的,适用于单线程环境。
  1. 性能:
  • StringBuilder相对于StringBuffer具有更好的性能,因为StringBuilder不需要处理线程同步的开销。
  1. 方法:
  • StringBufferStringBuilder提供了类似于String的方法,例如length()charAt()indexOf()等。
  • 除了这些方法,它们还提供了额外的方法用于字符串的插入、删除、替换和反转等操作。

使用示例:

1. public class StringBufferStringBuilderExample {
2. public static void main(String[] args) {
3. StringBuffer stringBuffer = new StringBuffer();
4.         stringBuffer.append("Hello");
5.         stringBuffer.append(" ");
6.         stringBuffer.append("World");
7. String result1 = stringBuffer.toString();
8.         System.out.println("StringBuffer Result: " + result1);
9. 
10. StringBuilder stringBuilder = new StringBuilder();
11.         stringBuilder.append("Hello");
12.         stringBuilder.append(" ");
13.         stringBuilder.append("World");
14. String result2 = stringBuilder.toString();
15.         System.out.println("StringBuilder Result: " + result2);
16.     }
17. }

在上述示例中,我们创建了一个StringBuffer对象和一个StringBuilder对象,通过append()方法将字符串连接起来。最后,使用toString()方法将StringBufferStringBuilder对象转换为String类型的结果,并输出到控制台。

输出结果:

1. StringBuffer Result: Hello World
2. StringBuilder Result: Hello World

StringBufferStringBuilder是在处理大量字符串操作时的有用工具,特别是当需要频繁修改字符串内容时。如果在单线程环境下操作字符串,建议使用StringBuilder,它具有更好的性能。如果在多线程环境下操作字符串,应使用StringBuffer以确保线程安全。

以上我们学习了java语言的介绍、第一个java程序、数据类型、数组等相关java基础知识,Java是一种广泛使用的面向对象编程语言,具有简单、可靠、安全和跨平台等特点,希望小伙伴们可以早日掌握java,成为一名优秀的java开发工程师

目录
相关文章
|
12天前
|
存储 Java 容器
Java 基础语法
Java是一种面向对象的编程语言,其基础语法包括类和对象、方法、变量、控制流语句、继承和多态以及异常处理。代码需写在类中,`main()`方法是程序入口,变量用于存储数据,控制流语句控制程序执行流程,继承和多态增强代码灵活性,异常处理保证程序稳定性。掌握这些知识可帮助您编写简单的Java程序。
|
16天前
|
安全 前端开发 Java
浅析JVM invokedynamic指令与Java Lambda语法的深度融合
在Java的演进历程中,Lambda表达式无疑是Java 8引入的一项革命性特性,它极大地简化了函数式编程在Java中的应用,使得代码更加简洁、易于阅读和维护。而这一切的背后,JVM的invokedynamic指令功不可没。本文将深入探讨invokedynamic指令的工作原理及其与Java Lambda语法的紧密联系,带您领略这一技术背后的奥秘。
13 1
|
19天前
|
算法 Java 开发者
Java 编程入门:从零到一的旅程
本文将带领读者开启Java编程之旅,从最基础的语法入手,逐步深入到面向对象的核心概念。通过实例代码演示,我们将一起探索如何定义类和对象、实现继承与多态,并解决常见的编程挑战。无论你是编程新手还是希望巩固基础的开发者,这篇文章都将为你提供有价值的指导和灵感。
|
20天前
|
存储 Java 程序员
Java中的集合框架:从入门到精通
【8月更文挑战第30天】在Java的世界里,集合框架是一块基石,它不仅承载着数据的存储和操作,还体现了面向对象编程的精髓。本篇文章将带你遨游Java集合框架的海洋,从基础概念到高级应用,一步步揭示它的奥秘。你将学会如何选择合适的集合类型,掌握集合的遍历技巧,以及理解集合框架背后的设计哲学。让我们一起探索这个强大工具,解锁数据结构的新视角。
|
20天前
|
小程序 Java
【aspose-words】Aspose.Words for Java模板语法详细剖析
本文通过详细分析Aspose.Words for Java模板语法,介绍了使用条件块、变量和动态合并表格单元格三个常用模板标签,并结合实际案例进行演示。通过这三个标签的实操,帮助读者更好地掌握Aspose.Words的使用技巧。此外,还提供了官方文档链接以便进一步学习。
63 0
【aspose-words】Aspose.Words for Java模板语法详细剖析
|
22天前
|
Java 程序员 UED
Java中的异常处理:从入门到精通
【8月更文挑战第28天】在Java编程的世界里,异常处理是一块基石,它确保了程序的健壮性和可靠性。本文将通过深入浅出的方式,带你了解Java异常处理的基本概念、分类、以及如何有效地捕获和处理异常。我们将一起探索try-catch-finally结构的奥秘,并学习如何使用throws关键字声明方法可能会抛出的异常。此外,我们还会讨论自定义异常类的创建和使用,以及最佳实践。无论你是Java新手还是有一定经验的开发者,这篇文章都将为你提供宝贵的知识,帮助你编写出更加稳定和可靠的代码。
|
22天前
|
编解码 网络协议 Oracle
java网络编程入门以及项目实战
这篇文章是Java网络编程的入门教程,涵盖了网络编程的基础知识、IP地址、端口、通讯协议(TCP和UDP)的概念与区别,并提供了基于TCP和UDP的网络编程实例,包括远程聊天和文件传输程序的代码实现。
java网络编程入门以及项目实战
|
7天前
|
Java 程序员
Java中的异常处理:从入门到精通
在Java编程的世界中,异常处理是保持程序稳定性和可靠性的关键。本文将通过一个独特的视角—把异常处理比作一场“捉迷藏”游戏—来探讨如何在Java中有效管理异常。我们将一起学习如何识别、捕捉以及处理可能出现的异常,确保你的程序即使在面对不可预见的错误时也能优雅地运行。准备好了吗?让我们开始这场寻找并解决Java异常的冒险吧!
|
19天前
|
Java 程序员 UED
Java 中的异常处理:从入门到精通
【8月更文挑战第31天】在Java编程的世界中,异常处理是保持应用稳定性的重要机制。本文将引导你理解异常的本质,学会如何使用try-catch语句来捕获和处理异常,并探索自定义异常类的魅力。我们将一起深入异常的世界,让你的代码更加健壮和用户友好。
|
19天前
|
Java 数据库连接 开发者
Java中的异常处理:从入门到精通
【8月更文挑战第31天】 在编程世界中,错误和异常就像是不请自来的客人,总是在不经意间打扰我们的程序运行。Java语言通过其异常处理机制,为开发者提供了一套优雅的“待客之道”。本文将带你走进Java异常处理的世界,从基础语法到高级技巧,再到最佳实践,让你的程序在面对意外时,也能从容不迫,优雅应对。