我的世界java版键位表
//1. 无参数无返回值方法
//打印10个-的冗余代码特别多，如何优化？
//引入方法：
//概述：代码的封装，将多处重复编写的代码抽取出去，放到方法定义(实现)处；通过方法调用来执行
//作用： 使代码结构清晰，方便复用
//方法的组成： 1. 方法实现(定义) 2.方法调用
//建议大家创建类，后缀写上Test，代表测试类--里面包含了main方法
//学习面向对象后，就会有非测试类，里面没有main方法
//案例：打印静夜思；每打印一句，都要打印出10个'-'
public class FunTest {
public static void main(String[] args) {
System.out.println("床前明月光");
//使用方法调用，来调方法实现
print();
System.out.println("疑是地上霜");
print();
System.out.println("举头望明月");
print();
System.out.println("低头思故乡");
print();
}
//方法定义(实现)： print为方法名
public static void print() {
//方法体
for(int i=1;i<=10;i++) {
System.out.print("-");
}
System.out.println(); //换行
}
//注意：方法与方法间是同级的不能嵌套使用，main方法也是一个方法，不能把我们定义的方法放到main方法里面
}
//2. 有参数无返回值方法
//案例2：打印静夜思；每打印一句，第一次打印出10个'-';后面每一次都比前一次多5个'-'
public class FunTest2 {
public static void main(String[] args) {
System.out.println("床前明月光");
print(10); //实参：在方法调用传，实际传入的参数
System.out.println("疑是地上霜");
print(15);
System.out.println("举头望明月");
print(20);
System.out.println("低头思故乡");
print(25);
}
//形参： 在方法实现处，形式上的参数
public static void print(int c) { //int c = 10; c = 15
//方法体
for(int i=1;i<=c;i++) {
System.out.print("-");
}
System.out.println(); //换行
}
}
//3. 有参数有返回值方法（常用）
//案例: 从控制台输入两个整数，并求和
//升级： 加入第一个参数小于0，则求和为0
public class FunTest3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个变量");
int a = sc.nextInt();
System.out.println("请输入第二个变量");
int b = sc.nextInt();
int sum = add(a,b); //使用方法，方便复用及扩展
System.out.println("和为:"+sum);
}
//有参数，有返回值方法
public static int add(int a,int b) {
if(a>=0) {
return a+b;
}else {
return 0; //return的值要匹配上返回类型
}
}
//注意：
//1.有返回值，方法实现处不能写void，而是指定要返回的类型--int
//2.方法体最后，一定要写上return，及对应类型的值---int值
//3.有多少个出口，就有多少个return； 且不能重复使用return
}
//4. return的使用
//=======================return使用1=======================
//问题：return只能用在有返回值的方法中吗，其他地方能使用吗？
//1.return使用在无返回值方法中
//案例：循环打印1~10，遇到3的倍数则退出，使用方法来做
public class ReturnTest1 {
public static void main(String[] args) {
for(int i=1;i<=10;i++) {
if(i%3==0) {
return; //跳出函数体，如果方法没有返回值，则return不能带值
//break; //跳出循环体
}
System.out.println(i);
}
System.out.println("最后的执行...");
//return; //在方法最后也可以加return，也可以不加
}
}
//=======================return使用2=======================
//2.return使用在switch中
//打印周一到周五吃饭的问题
public class ReturnTest2 {
public static void main(String[] args) {
System.out.print("请输入一周吃饭问题:");
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
switch (week) {
case 1:
System.out.println("鲍鱼龙虾");
break;
case 2:
case 3:
case 4:
System.out.println("肯德基");
break;
case 5:
System.out.println("泡面");
return; //跳出函数体
default:
System.out.println("输入有误~");
break;
}
System.out.println("结束语句....");
}
}
//5. debug调试
//======================有参有返回值调试======================
//问题：给出一个案例，让你用方法来操作，如何确定是否需要参数和返回值呢？
//加入方法参数，目的是加强复用性和扩展性--变化的数值传入
//加入返回值，目的是在main方法中根据结果做后续处理
//所以后续，往往最常用的就是--有参数有返回值的方法
//案例： 输入两个整数，求出最大值，请使用方法完成
//debug调试：
//1.加断点---从哪个位置开始调试
//f5： 跳到方法的实现处
//f6: 下一步（最常用）
//f8: 跳到下一个断点，如果没有，结束了
public class DebugTest {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一个整数");
int num1 = sc.nextInt();
System.out.println("请输入第二个整数");
int num2 = sc.nextInt();
int max = maxFun(num1,num2);
System.out.println("最大值为:"+max);
}
public static int maxFun(int num1, int num2) {
return (num1>num2)?num1:num2;
}
}
//=======================循环嵌套调试=======================
//案例：打印直角三角形，个数及图形从控制台录入;使用方法封装
public class QianTao {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("请录入个数:");
int count = sc.nextInt();
System.out.print("请录入图形:");
String tu = sc.next();
printTu(count,tu);
}
private static void printTu(int count, String tu) {
for(int i=1;i<=count;i++) {
for(int j=1;j<=i;j++) {
System.out.print(tu);
}
System.out.println(); //回车
}
}
}
//6. 方法的多级调用
//多级方法调用：方法实现中，又调方法
public class ManyFun {
public static void main(String[] args) {
System.out.println("main----start"); //1
m1();
System.out.println("main----end"); //5
}
private static void m1() {
System.out.println("m1....start"); //2
m2();
System.out.println("m1....end"); //4
}
private static void m2() {
System.out.println("执行m2..."); //3
}
}
// 递归方法（扩展）
//递归(扩展)： 自己调用自己；且必须要有出口，没有出口就是死递归
//递归的用法，类似于循环，如果能用循环，可以考虑用递归
//注意：如果能用其他方式解决，尽量不用递归，递归有两个弊端：1.效率低 2.容易出现死递归
//使用递归的条件:
//1.定义一个方法，找出有规律的数列
//2.要有退出的出口
//=======================死递归=======================
public class Test1 {
public static void main(String[] args) {
m1();
}
private static void m1() {
System.out.println("执行m1...");
m1(); //死递归---类似于死循环
}
}
//=======================求阶乘案例=======================
//案例：求一个数的阶乘； 例如4的阶乘： 1*2*3*4
//4的阶乘: 4*3的阶乘 ===>4*3*2*1
//3的阶乘： 3*2的阶乘
//2的阶乘： 2*1的阶乘
//1的阶乘： 1
public class Test2 {
public static void main(String[] args) {
int n = 4;
int val = f(n); //4*3*2*1
System.out.println(n+"的阶乘为:"+val);
}
private static int f(int n) { //4 3
if(n==1) {
return 1;
}
return n*f(n-1); //2*f(1)
}
}
//=======================斐波拉契数列=======================
//案例2：使用递归完成斐波拉契数列：
//0 1 1 2 3 5 8 13 21 ...
//规律：第1项为0 第二项为1 第3项=第1项+第2项
public class Test3 {
public static void main(String[] args) {
System.out.println("请输入斐波拉契数列的项数:");
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i=0;i<=n;i++) {
System.out.print(f(i)+"\t"); //0 1 1 2 3
}
}
public static int f(int n) { //4
if(n==0||n==1) {
return n;
}
return f(n-1)+f(n-2); //2+1
}
}