2021-01-22Day2

方法

1. 何谓方法

Java方法相当于一些语句的集合，这些语句在一起可以执行一个功能。

它的特点是

1. 是解决一类问题的步骤的有序组合
2. 包含于类或者对象中
3. 在程序中被创建，在其他地方被引用

System.out.println();

就以这句话为例：

1. System是java.lang包中的一个类
2. out是java.io.PrintStream类的对象，println是java.io.PrintStream这个类里的方法
3. 这个方法的作用就是输出加换行，它的源代码如下:

public void println(int x//这个方法就是方法的重载，这里的参数类型可以有很多种但是函数名不变) {
        if (getClass() == PrintStream.class) {
            writeln(String.valueOf(x));
        } else {
            synchronized (this) {
                print(x);
                newLine();
            }
        }
    }

2. 方法的定义和调用

方法的定义有如下规则：

修饰符 返回值类型 方法名(参数类型 参数名){

	中间体；

	return 返回值；//若返回值类型为void，那么就没有return。

}

方法就以英雄联盟中的英雄攻击为例，设计一个attack方法

public void attack(){
    System.out.println(name+"攻击了，但不确定攻击了哪个")；
}

3. 方法的重载

方法的重载就是方法名相同，但是参数类型不同。

方法的重载在开始的时候提到过一下，就是println这一方法使用了重载

方法名相同，参数类型不同，参数类型可以是Boolean，int，float，string等等

举个例子就是英雄联盟中的攻击可以攻击一个英雄也可攻击多个英雄那么这是就可以对attack这一方法进行重载

public void attack(){
    
}
public void attack(Hero hero1){
    
}
public void attack(Hero hero1,Hero hero2){
    
}

这里的attack方法就是重载，而我们在对方法进行调用的时候不必担心方法名的问题，Java本身会进行识别选择合适的方法

4. 可变参数

而方法的重载也可能存在弊端，就比如attack这个方法，如果需要攻击多个单位，数量非常之多，那么就需要重复写出许多方法

这是也是非常的耗费时间，运行程序时占用内存，我们就可以使用一个可变参数对方法的重载进行优化(优化二字仅仅是我的个人理解，若有更好的说法欢迎指正)

这个时候，在方法的声明中，指定参数类型之后就需要加入一个省略号…

例如：

public void attack(Hero... hero){
    System.out.println("攻击了"+hero.length+"个英雄")；//这里的hero可以看作是一个数组名
    for(int i=0;i<hero.length;i++){
        System.out.println(hero[i]);
    }
}

调用此方法的例子如下：

attack(...hero:hero1,hero2,hero3);

这个时候就会输出

​ 攻击了3个英雄

​ hero1

​ hero2

​ hero3

5.递归

对于一些特别复杂的问题，需要重复使用同一种方法，调用起来特别不方便，那么就可以使用递归

递归一个浅显易懂的说法就是，对于一个方法A，A方法调用A方法本身的行为就是递归

递归结构由两部分组成：

1. 递归头 什么时候就可以不用调用自身方法 //若没有头，那么就会进入死循环
2. 递归体 什么时候需要调用自身方法

就以计算一个数的阶乘为例:

public int f(int n){
    if(n==1){
        return 1;//递归头，return还有退出循环的作用
    }else{
        return n*f(n:n-1);//递归体
    }
}

6.练习

写一个计算器，实现加减乘除功能并能循环接受新数据，实现用户交互

点子：

1. 写加减乘除
2. 利用循环和switch进行用户交互
3. 传递出需要操作的两个数
4. 输出结果

那么有了点子就可以进行编译了。

在进行编程序之前也是看了好多人的方法，但是由于页面布局和事件监听等知识点还没有学习完成，只能实现功能

package calculator;

import java.util.Scanner;

public class Calculator {

	public static void main(String[] args) {
		double a,b;
		char x;
		System.out.println("输入的数字和符号之间要留出空格");
		while(true) {
			Scanner s=new Scanner(System.in);
			a=s.nextDouble();
			x=s.next().charAt(0);
			b=s.nextDouble();
			OperationSymbol u=new OperationSymbol();
			u.start(x, a, b);
			//s.close();//scanner使用结束后要记得关闭，但是这个语句加上以后，进行一次运算后就会报错，是由于程序还没有结束就关闭了scanner方法
		}
	}

}


package calculator;

public interface symble {
		public abstract double operation(double a,double b);
	}
public class OperationSymbol{
	
	public void start(char x,double a,double b) {
		switch (x) {
		case '+': {
			add num=new add();
			System.out.println("a + b = "+num.operation(a, b));
			break;
		}
		case '-': {
			subtract num=new subtract();
			System.out.println("a - b = "+num.operation(a, b));
			break;
		}
		case '*': {
			multiply num=new multiply();
			System.out.println("a * b = "+num.operation(a, b));
			break;
		}
		case '/': {
			divided num=new divided();
			System.out.println("a / b = "+num.operation(a, b));
			break;
		}
		default:{
			System.out.println("超出计算范围");
			break;
		}
	}
}
}
public class add implements symble{

	public double operation(double a, double b) {
		return a+b;
	}
}
public class subtract implements symble{
	public double operation(double a, double b) {
		return a-b;
	}	
}
public class multiply implements symble{
	public double operation(double a, double b) {
		return a*b;
	}	
}
public class divided implements symble{
	public double operation(double a, double b) {
		return a/b;
	}	
}