From 72fc678cecde7dd0023430482fdc7a551d1ee080 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=AC=A3?= <3188923799@qq.com>
Date: Wed, 14 Dec 2022 21:28:17 +0800
Subject: [PATCH 1/2] =?UTF-8?q?=E6=88=91=E7=9A=84=E4=BD=9C=E4=B8=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...346\261\202\345\222\214\357\274\211.md.md" |   0
 ...04\351\200\240\346\226\271\346\263\225.md" | 302 ++++++++++++++++++
 2 files changed, 302 insertions(+)
 rename "29 \347\216\213\351\233\257\351\235\231/2022121020221208 \346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md" => "29 \347\216\213\351\233\257\351\235\231/20221210 \346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md" (100%)
 create mode 100644 "29 \347\216\213\351\233\257\351\235\231/20221213 \351\224\256\347\233\230\345\275\225\345\205\245\345\255\227\347\254\246\344\270\262 String\347\261\273\347\232\204\346\236\204\351\200\240\346\226\271\346\263\225.md"

diff --git "a/29 \347\216\213\351\233\257\351\235\231/2022121020221208 \346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md" "b/29 \347\216\213\351\233\257\351\235\231/20221210 \346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md"
similarity index 100%
rename from "29 \347\216\213\351\233\257\351\235\231/2022121020221208 \346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md"
rename to "29 \347\216\213\351\233\257\351\235\231/20221210 \346\225\260\347\273\204\357\274\210\351\235\231\346\200\201\345\212\250\346\200\201\345\210\235\345\247\213\345\214\226 \351\201\215\345\216\206 \350\216\267\345\217\226\346\234\200\345\244\247\345\200\274 \346\261\202\345\222\214\357\274\211.md.md"
diff --git "a/29 \347\216\213\351\233\257\351\235\231/20221213 \351\224\256\347\233\230\345\275\225\345\205\245\345\255\227\347\254\246\344\270\262 String\347\261\273\347\232\204\346\236\204\351\200\240\346\226\271\346\263\225.md" "b/29 \347\216\213\351\233\257\351\235\231/20221213 \351\224\256\347\233\230\345\275\225\345\205\245\345\255\227\347\254\246\344\270\262 String\347\261\273\347\232\204\346\236\204\351\200\240\346\226\271\346\263\225.md"
new file mode 100644
index 0000000..84ef714
--- /dev/null
+++ "b/29 \347\216\213\351\233\257\351\235\231/20221213 \351\224\256\347\233\230\345\275\225\345\205\245\345\255\227\347\254\246\344\270\262 String\347\261\273\347\232\204\346\236\204\351\200\240\346\226\271\346\263\225.md"	
@@ -0,0 +1,302 @@
+# 1.API
+
+### 1.1 API概述-帮助文档的使用
+
+#### 什么是API
+
+API (Application Programming Interface) ：应用程序编程接口
+
+java中的API
+
+指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这
+
+些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何
+
+使用。
+
+#### 如何使用API帮助文档 :
+
+打开帮助文档
+
+找到索引选项卡中的输入框
+
+在输入框中输入Random
+
+看类在哪个包下
+
+看类的描述
+
+看构造方法
+
+看成员方法
+
+### 1.2 键盘录入字符串
+
+#### Scanner类 :
+
+next() : 遇到了空格, 就不再录入数据了 , 结束标记: 空格, tab键
+
+nextLine() : 可以将数据完整的接收过来 , 结束标记: 回车换行符
+
+```java
+package com.itheima.api; 
+import java.util.Scanner;
+ public class Demo1Scanner { 
+/* next() : 遇到了空格, 就不再录入数据了
+ 结束标记: 空格, tab键 
+nextLine() : 可以将数据完整的接收过来 
+结束标记: 回车换行符 */ 
+public static void main(String[] args) {
+ // 1. 创建Scanner对象 
+Scanner sc = new Scanner(System.in);
+ System.out.println("请输入:"); 
+// 2. 调用nextLine方法接收字符串 
+// ctrl + alt + v : 快速生成方法的返回值
+String s = sc.nextLine(); 
+System.out.println(s); 
+} 
+}
+
+
+
+
+ package com.itheima.api; 
+import java.util.Scanner;
+ public class Demo2Scanner { 
+/* nextInt和nextLine方法配合使用的时候, nextLine方法就没有键盘录入的机会了 建议: 今后键盘录入数据的时候, 如果是字符串和整数一起接受, 建议使用next方法接受字 符串. */ public static void main(String[] args) { 
+Scanner sc = new Scanner(System.in);
+ System.out.println("请输入整数:"); 
+int num = sc.nextInt(); // 10 + 回车换行 
+System.out.println("请输入字符串:");
+ String s = sc.nextLine(); 
+System.out.println(num); 
+System.out.println(s); 
+} 
+}
+```
+
+#### String类
+
+*2.1 String概述*
+
+*1 String 类在 java.lang 包下，所以使用的时候不需要导包*
+
+*2 String 类代表字符串，Java 程序中的所有字符串文字（例如“abc”）都被实现为此类的实例也就是*
+
+*说，Java 程序中所有的双引号字符串，都是 String 类的对象*
+
+*3 字符串不可变，它们的值在创建后不能被更改*
+
+*2.2 String类的构造方法*
+
+*常用的构造方法*
+
+*方法名:                                                     说明:*
+
+*public String                                                   创建一个空白字符串对象，不含有任何内容                  *
+
+*public String(char[] chs)                               根据字符数组的内容，来创建字符串对象*
+
+*public String(String original)                        根据传入的字符串内容，来创建字符串对象*
+
+*String s = "abc";                                             直接赋值的方式创建字符串对象，内容是abc*
+
+```java
+package com.itheima.string;
+ public class Demo2StringConstructor { 
+/* 
+String类常见构造方法: 
+public String() : 创建一个空白字符串对象，不含有任何内容 
+public String(char[] chs) : 根据字符数组的内容，来创建字符串对象 public String(String original) : 根据传入的字符串内容，来创建字符串对象 String s = “abc”; 直接赋值的方式创建字符串对象，内容就是abc 
+注意: String这个类比较特殊, 打印其对象名的时候, 不会出现内存地址 而是该对象所记录的真实内容. 面向对象-继承, Object类 
+*/ 
+public static void main(String[] args) { 
+// public String() : 创建一个空白字符串对象，不含有任何内容 
+String s1 = new String(); 
+System.out.println(s1);
+ // public String(char[] chs) : 根据字符数组的内容，来创建字符串对象
+ char[] chs = {'a','b','c'}; 
+String s2 = new String(chs); 
+System.out.println(s2);
+ // public String(String original) : 根据传入的字符串内容，来创建字符串对象 
+String s3 = new String("123");
+ System.out.println(s3);
+ } 
+}
+```
+
+*2.4 创建字符串对象的区别对比*
+
+*通过构造方法创建*
+
+*通过 new 创建的字符串对象，每一次 new 都会申请一个新的内存空间，虽然内容相同，但是地*
+
+*址值不同 所以直接== 是不成立的*
+
+*直接赋值方式创建*
+
+*以“”方式给出的字符串，只要字符序列相同(顺序和大小写)，无论在程序代码中出现几次，JVM虚*
+
+*拟机 都只会建立一个 String 对象，并在字符串池中维护*
+
+*2.5 字符串的比较*
+
+*2.5.1 字符串的比较*
+
+*== 比较基本数据类型：比较的是具体的值*
+
+*== 比较引用数据类型：比较的是对象(内存)地址值*
+
+*String类 : public boolean equals(String s) 比较两个字符串内容是否相同、区分大小写*
+
+```java
+package com.itheima.stringmethod;
+ public class Demo1Equals {
+ public static void main(String[] args) { 
+String s1 = "abc"; 
+String s2 = "ABC";
+ String s3 = "abc";
+ // equals : 比较字符串内容, 区分大小写 
+System.out.println(s1.equals(s2)); 
+System.out.println(s1.equals(s3));
+ // equalsIgnoreCase : 比较字符串内容, 忽略大小写 
+System.out.println(s1.equalsIgnoreCase(s2));
+} 
+}
+```
+
+*2.6 用户登录案例【应用】*
+
+*案例需求 :*
+
+*已知用户名和密码，请用程序实现模拟用户登录。总共给三次机会，登录之后，给出相应的提示*
+
+*实现步骤 :*
+
+1. *已知用户名和密码，定义两个字符串表示即可*
+
+2. *键盘录入要登录的用户名和密码，用 Scanner 实现*
+
+3. *拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。*
+
+4. *字符串的内容比较，用equals() 方法实现*
+
+5. *用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用break结束*
+
+*循*
+
+```java
+package com.itheima.test;
+ import java.util.Scanner;
+ public class Test1 { 
+/* 
+需求：已知用户名和密码，请用程序实现模拟用户登录。
+ 总共给三次机会，登录之后，给出相应的提示 
+思路： 
+1. 已知用户名和密码，定义两个字符串表示即可
+2. 键盘录入要登录的用户名和密码，用 Scanner 实现 
+3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。 字符串的内容比较，用equals() 方法实现 
+4. 用循环实现多次机会，这里的次数明确，采用for循环实现，并在登录成功的时候，使用 break结束循环 
+*/ public static void main(String[] args) { 
+// 1. 已知用户名和密码，定义两个字符串表示即可
+ String username = "admin";
+ String password = "123456";
+ // 2. 键盘录入要登录的用户名和密码，用 Scanner 实现 
+Scanner sc = new Scanner(System.in); 
+// 4. 用循环实现多次机会，这里的次数明确，采用for循环实现
+ for(int i = 1; i <= 3; i++){
+ System.out.println("请输入用户名:"); 
+String scUsername = sc.nextLine(); 
+System.out.println("请输入密码:"); 
+String scPassword = sc.nextLine(); 
+// 3. 拿键盘录入的用户名、密码和已知的用户名、密码进行比较，给出相应的提示。 
+if(username.equals(scUsername) && password.equals(scPassword)){ System.out.println("登录成功"); 
+break;
+ }else{
+if(i == 3){
+ System.out.println("您的登录次数已达到今日上限, 请明天再来"); }else{System.out.println("登录失败,您还剩余" + (3-i) +"次机会");
+ }
+ }
+ }
+ }
+}
+}
+```
+
+*2.7 遍历字符串案例【应用】*
+
+*案例需求 :*
+
+*键盘录入一个字符串，使用程序实现在控制台遍历该字符串*
+
+*实现步骤 :*
+
+1. *键盘录入一个字符串，用 Scanner 实现*
+
+2. *遍历字符串，首先要能够获取到字符串中的每一个字符, public char charAt(int index)：返回指定*
+
+*索引处的char值，字符串的索引也是从0开始的*
+
+3. *遍历字符串，其次要能够获取到字符串的长度, public int length()：返回此字符串的长度*
+
+4. *遍历打印*
+   
+   ```java
+   package com.itheima.test;
+    import java.util.Scanner; 
+   public class Test2 {
+    /* 
+   需求：键盘录入一个字符串，使用程序实现在控制台遍历该字符串
+   思路：
+    1. 键盘录入一个字符串，用 Scanner 实现 
+   2. 遍历字符串，首先要能够获取到字符串中的每一个字符 public char charAt(int index)：返回指定索引处的char值，字符串的索引也是 从0开始的 
+   3. 遍历字符串，其次要能够获取到字符串的长度 public int length()：返回此字符串的长度 
+   4. 遍历打印 9 
+   */
+    public static void main(String[] args) { 
+   // 1. 键盘录入一个字符串，用 Scanner 实现 
+   Scanner sc = new Scanner(System.in);
+    System.out.println("请输入:"); 
+   String s = sc.nextLine(); 
+   // 2. 遍历字符串，首先要能够获取到字符串中的每一个字符
+    for(int i = 0; i < s.length(); i++){ 
+   // i : 字符串的每一个索引 
+   char c = s.charAt(i);
+    System.out.println(c); 
+   }
+    } 
+   }
+   ```
+
+## 作业：
+
+1,倒序输出乘法口诀,9到1
+
+```java
+public class D1 {
+    public static void main(String[] args) {
+        for (int i = 9;i>=1;i--){
+            for (int j = 9; j>=i;j--){
+                System.out.print(j+"*"+i+"="+j*i+"\t");
+            }
+            System.out.println();
+
+}
+}
+}
+```
+
+
+
+
+
+
+
+
+2.计算燃气那个
+
+```java
+
+```
+
+
-- 
Gitee


From 35879f357f207669d49de0907c971da641e5f87b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=AC=A3?= <3188923799@qq.com>
Date: Thu, 15 Dec 2022 23:59:21 +0800
Subject: [PATCH 2/2] =?UTF-8?q?=E6=88=91=E7=9A=84=E4=BD=9C=E4=B8=9A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...50\346\204\217\344\272\213\351\241\271.md" | 396 ++++++++++++++++++
 1 file changed, 396 insertions(+)
 create mode 100644 "29 \347\216\213\351\233\257\351\235\231/20221215 \346\227\240\345\217\202\346\226\271\346\263\225  \345\270\246\345\217\202\346\225\260\346\226\271\346\263\225\347\232\204\345\256\232\344\271\211\345\222\214\350\260\203\347\224\250  \345\275\242\345\217\202\345\222\214\345\256\236\345\217\202 \346\226\271\346\263\225\347\232\204\346\263\250\346\204\217\344\272\213\351\241\271.md"

diff --git "a/29 \347\216\213\351\233\257\351\235\231/20221215 \346\227\240\345\217\202\346\226\271\346\263\225  \345\270\246\345\217\202\346\225\260\346\226\271\346\263\225\347\232\204\345\256\232\344\271\211\345\222\214\350\260\203\347\224\250  \345\275\242\345\217\202\345\222\214\345\256\236\345\217\202 \346\226\271\346\263\225\347\232\204\346\263\250\346\204\217\344\272\213\351\241\271.md" "b/29 \347\216\213\351\233\257\351\235\231/20221215 \346\227\240\345\217\202\346\226\271\346\263\225  \345\270\246\345\217\202\346\225\260\346\226\271\346\263\225\347\232\204\345\256\232\344\271\211\345\222\214\350\260\203\347\224\250  \345\275\242\345\217\202\345\222\214\345\256\236\345\217\202 \346\226\271\346\263\225\347\232\204\346\263\250\346\204\217\344\272\213\351\241\271.md"
new file mode 100644
index 0000000..7a96113
--- /dev/null
+++ "b/29 \347\216\213\351\233\257\351\235\231/20221215 \346\227\240\345\217\202\346\226\271\346\263\225  \345\270\246\345\217\202\346\225\260\346\226\271\346\263\225\347\232\204\345\256\232\344\271\211\345\222\214\350\260\203\347\224\250  \345\275\242\345\217\202\345\222\214\345\256\236\345\217\202 \346\226\271\346\263\225\347\232\204\346\263\250\346\204\217\344\272\213\351\241\271.md"	
@@ -0,0 +1,396 @@
+# 方法的概念
+
+方法（method）：将具有独立功能的代码块组织成为一个整体，使其具有特殊功能的代码集
+
+注意：
+
+- 方法必须创建才能使用，该过程成为方法定义。
+
+- 方法创建后并不是直接可以运行的，需要手动使用后，才执行，该过程成为方法调用
+
+# 方法的定义和调用
+
+无参数方法定义和调用
+
+```java
+定义格式：
+public static void 方法名 ( ) {
+ // 方法体; 
+}
+
+```
+
+案例
+
+```java
+public static void 方法名 ( ) { 
+      // 方法体; 
+}
+```
+
+```java
+调用格式：
+
+    方名法（）
+```
+
+案例
+
+```java
+method();
+```
+
+注意：
+
+###### 方法必须先定义，后调用，否则程序将报错
+
+总结：
+
+每个方法在被调用执行的时候，都会进入栈内存，并且拥有自己独立的内存空间，方法内部代码调用完毕之后，会从栈内存中弹栈消失
+
+练习：需求：判断一个数是奇数还是偶数
+
+```java
+public class Demo1Method {
+
+/*
+ 带参数方法的定义格式: 
+public static void 方法名 ( 参数 ) { … … }
+ public static void 方法名 ( 数据类型 变量名 ) { … … } 
+带参数方法的调用格式:
+ 方法名 ( 参数 ) ; 
+方法名 ( 变量名/常量值 ) ; 
+tips: 参数可以是一个, 也可以是多个.
+ 需求: 判断一个数是奇数还是偶数
+ */ 
+public static void main(String[] args) {
+ isEvenNumber(10); 
+}
+public static void isEvenNumber(int num){
+ if(num % 2 == 0){ System.out.println("偶数"); 
+}else{System.out.println("奇数"); 
+} 
+} 
+}
+```
+
+# 带参数方法的定义和调用
+
+定义格式：
+
+参数：由数据类型和变量名组成 - 数据类型 变量名
+
+参数范例：int a
+
+```java
+代码展示：
+
+public static void 方法名 (参数1) {
+ 方法体; 
+}
+public static void 方法名 (参数1, 参数2, 参数3...) { 
+方法体; 
+} 
+```
+
+案例
+
+```java
+public static void isEvenNumber(int number){ 
+... 
+}
+public static void getMax(int num1, int num2){ 
+...
+ }
+```
+
+注意：
+
+方法定义时，参数中的数据类型与变量名都不能缺少，缺少任意一个程序将报错
+
+方法定义时，多个参数之间使用逗号( ，)分隔
+
+调用格式：
+
+```java
+方法名(参数)；
+
+ 方法名(参数1,参数2);
+```
+
+案例
+
+```java
+isEvenNumber(10);
+
+ getMax(10,20);
+```
+
+注意：
+
+方法调用时，参数的数量与类型必须与方法定义中的设置相匹配，否则程序将报错
+
+# 形参和实参
+
+1. 形参：方法定义中的参数
+
+等同于变量定义格式，例如：int number
+
+2. 实参：方法调用中的参数
+
+等同于使用变量或常量，例如：10  number
+
+###### 带参数方法的练习-打印n-m之间所有的奇数
+
+需求：设计一个方法（print） 用于打印 n 到 m 之间所有的奇数
+
+思路：
+
+1：定义方法，名称为print
+
+2：为方法添加两个int类型的形参，准备接受调用者传递过来的实参
+
+3：方法中设计for循环，循环从n开始，到m结束
+
+4：循环中加入if判断，是奇数，则打印
+
+5：main方法中调用print方法，传入两个实际参数
+
+```java
+package com.itheima.method2;
+ public class Demo2Method {
+ public static void main(String[] args) { 
+// 5：main方法中调用print方法，传入两个实际参数
+ print(20,10); 
+}
+//1：定义方法，名称为print
+ // 2：为方法添加两个int类型的形参，准备接受调用者传递过来的实参
+ public static void print(int n, int m){ 
+System.out.println(n + "到" + m + "之间的奇数为:"); 
+// 3：方法中设计for循环，循环从n开始，到m结束 
+for(int i = 20; i <= 10; i++){ 
+// 4：循环中加入if判断，是奇数，则打印
+if(i % 2 == 1){ 
+System.out.println(i); 
+} 
+} 
+} 
+}
+```
+
+# 带返回值方法的定义和调用
+
+```java
+定义格式：
+public static 数据类型 方法名 ( 参数 ) { return 数据 ; }
+```
+
+案例
+
+```java
+public static boolean isEvenNumber( int number ) {
+ return true ;
+ }
+public static int getMax( int a, int b ) { 
+return 100 ;
+ }
+
+```
+
+注意：
+
+方法定义时return后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
+
+```java
+调用格式：
+方法名 ( 参数 ) ; 
+
+数据类型 变量名 = 方法名 ( 参数 ) ;
+```
+
+案例
+
+```java
+isEvenNumber ( 5 ) ;
+
+ boolean flag = isEvenNumber ( 5 );
+```
+
+注意：方法的返回值通常会使用变量接收，否则该返回值将无意义
+
+###### 带返回值方法的练习-求两个数的最大值
+
+需求：设计一个方法可以获取两个数的较大值，数据来自于参数
+
+思路：
+
+1. 定义一个方法，声明两个形参接收计算的数值，求出结果并返回
+
+2. 使用 if 语句 得出 a 和 b 之间的最大值，根据情况return具体结果
+
+3. 在main()方法中调用定义好的方法并使用 【变量保存 】
+
+4. ```java
+   /*
+    需求：设计一个方法可以获取两个数的较大值，数据来自于参数
+    1. 定义一个方法，声明两个形参接收计算的数值，求出结果并返回 
+   2. 使用 if 语句 得出 a 和 b 之间的最大值，根据情况return具体结果
+    3. 在main()方法中调用定义好的方法并使用 【 变量保存 】
+   */
+   public static void main(String[] args) { 
+   // 3. 在main()方法中调用定义好的方法并使用 【 变量保存 】 System.out.println(getMax(10,20)); // 输出调用 
+   int result = getMax(10,20);
+    System.out.println(result);
+    for(int i = 1; i <= result; i++){
+    System.out.println("HelloWorld");
+    }
+    }
+   // 方法可以获取两个数的较大值 
+   public static int getMax(int a, int b){
+    if(a > b){
+    return a; 
+   }else{return b; 
+   }
+    }
+   }
+   ```
+
+# 方法的注意事项
+
+格式：
+
+```java
+public static 返回值类型 方法名(参数) {
+ 方法体;
+ return 数据 ;
+ } 
+```
+
+解释：
+
+- public static 修饰符，目前先记住这个格式
+
+返回值类型 方法操作完毕之后返回的数据的数据类型
+
+如果方法操作完毕，没有数据返回，这里写void，而且方法体中一般不写return
+
+方法名 调用方法时候使用的标识
+
+参数 由数据类型和变量名组成，多个参数之间用逗号隔开
+
+方法体 完成功能的代码块
+
+return 如果方法操作完毕，有数据返回，用于把数据返回给调用者
+
+- 定义方法时，要做到两个明确
+
+明确返回值类型：主要是明确方法操作完毕之后是否有数据返回，如果没有，写void；如果有，写对应的数据类型
+
+明确参数：主要是明确参数的类型和数量
+
+- 调用方法时的注意：
+
+void类型的方法，直接调用即可
+
+非void类型的方法，推荐用变量接收调用
+
+方法不能嵌套定义
+
+例如：
+
+```java
+public class MethodDemo {
+ public static void main(String[] args) {
+ }
+public static void methodOne() { 
+public static void methodTwo() { 
+// 这里会引发编译错误!!!
+ }
+ }
+ }
+```
+
+void表示无返回值，可以省略return，也可以单独的书写return，后面不加数据
+
+例如：
+
+```java
+public class MethodDemo {
+ public static void main(String[] args) {
+ }
+public static void methodTwo() { 
+//return 100; 编译错误，因为没有具体返回值类型
+ return; 
+//System.out.println(100); return语句后面不能跟数据或代码 
+}
+ }
+```
+
+作业：定义一函数，用于求2个数中的较大数，并将其返回，这2个数字在主函数中由用户输入
+
+```java
+import java.util.Scanner;
+
+public class D1 {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.println("请输入a的值");
+        int a = scanner.nextInt();
+        System.out.println("请输入b的值");
+        int b = scanner.nextInt();
+   int s = getNum(a,b);
+        System.out.println("最大值为："+s);
+    }
+
+    private static int getNum(int a,int b) {
+        int max = a>b?a:b;
+        return max;
+    }
+
+}
+```
+
+在主函数中从键盘接收X, Y , Z3个数，编写函数计算这3个数的立方和并返回计算结果：S=X3+Y3+Z3
+
+```java
+    import java.util.Scanner;
+    
+    public class D2 {
+        private static int X = 0;
+        private static int Z = 0;
+        private static int S = 0;
+        private static int Y = 0;
+    
+        public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+            System.out.println("请输入X的值");
+             X = scanner.nextInt();
+            System.out.println("请输入Y的值");
+           Y = scanner.nextInt();
+            System.out.println("请输入Z的值");
+           Z = scanner.nextInt();
+           S = X*X*X+Y*Y*Y+Z*Z*Z;
+            System.out.println("这三个数的立方和为："+S);
+        }
+    
+    
+    }
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-- 
Gitee