方法

ｆｕｎｃｔｉｏｎ方法

１．１什么是方法

将共性内容抽取出来,使用{}包裹起来,为{}起名字---方法 (一个独立的代码块{})

１．２如何定义一个方法

１．２．１　有具体返回值(数据类型)的方法

                                                              形式参数列表
         权限修饰符 + 静态修饰符 + 具体的返回值类型 + 方法名(数据类型1 变量名1 ,数据类型2 变量名2 ,....){
         //完成的业务逻辑
                return 结果;
         }  
         权限修饰符 :public
      静态修饰符:static(带上)
      具体的返回值类型:数据类型 (目前学习过的基本类型:没有告诉什么类型,都是默认int)
      方法名: 符号 标识符的规则: 小驼峰命名法:
                  一个单词:字母全部小写
                  多个单词:第一个单词小写,从第二个单词开始:每个单词首字母大写
      形式参数列表:
              数据类型1(目前学习过的基本类型:没有告诉什么类型,都是默认int) + 参数名1(变量名) ,  数据类型2 参数名2..
       return :结束方法: 必须返回具体结果;

１．２．２定义方法两个明确

​ 　　　　1)明确返回值类型 : int类型
​ 　　　　 2)明确参数类型以及参数个数:

１．２．３定义方法的注意事项:

　　　1)方法与方法是平级关系 ,不能再一个方法中定义另一个方法 (不能再方法中定义)
　　　
   2)Java是强类型语言 (语法结构非常严谨)               弱类型语言:前端:javascript   (定义方法:不需要携带数据类型)
           定义形式参数:必须携带数据类型

   3)调用方法的时候
           数据类型 变量名 = 方法名(实际参数列表) ;实际参数如果定义了,传递参数,不需要携带类型
 
   4)目前我们定义的方法都是有方法体的 (有左大括号"{ 的地方不能有分号;  有分号;的地方不能有左大括号"{" )
           权限修饰符 + 静态修饰符 +返回值类型 +方法名(形式参数列表){
           }

１．２．２固定格式

 public static 返回值类型 方法名(形式参数列表){
　　　　　　　 业务....
              return 结果;
          }

１．２．３调用方法

　　　　1)单独调用:(没有输出)没有意义
       2)输出调用:输出:写死了,不利于值的进一步操作
       3)赋值调用(推荐)

１．２．４ｃｏｄｅ比较大小的方法定义格式

public class FunctionDemo3 {
    public static void main(String[] args){
        //两个实际参数
        int a = 20 ;
        int b = 30 ;
       //调用
        int max = getMax(a,b) ; //不需要携带数据类型
    }
    public static int getMax( int a,int  b){ //形式参数a,b没有数据类型
        int max = (a>b)? a: b ;
        return max ;
    }
}

１．２．５没有返回值类型

两个明确：

　　　　1)明确返回值类型: void 来代替
    　 2)明确参数类型以及参数个数
    　 Java语法规定:当一个方法没有具体返回值类型的时候,使用void 代替

调用：单独调用

需要在控制台输出４行5列的*

public class FunctionDemo4 {
    public static void main(String[] args){
 　　　　　　　printStar(4,5);单独调用
}
public static void  printStar(int m,int n){
        for(int x = 0 ; x < m ; x ++){
            for(int y = 0 ; y < n ; y++){
                System.out.print("*") ;
            }
            System.out.println() ;
        }
    }
}

１．２．６没有返回值类型的方法

1)键盘录入一个数据n(1-9),输出nn乘法表

import  java.util.Scanner;
public class FunctionTest4 {
    public static void main(String[] args){

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请您输入一个数据n(1-9):") ;
        int n = sc.nextInt() ;

        //调用方法
        printNN(n);
    }
    public static void printNN(int m){
        for(int i = 1 ; i <= m ; i ++){
            for(int j = 1 ; j <= i ; j ++){
                System.out.print(j+"*"+i+"="+(j*i)+"\t") ;
            }
            System.out.println() ;
        }
    }
}

１．３方法重载

需求:
       求数据之和(使用方法改进)  int类型
 
    分析:    这个需求没有明确告诉我们 几个数据进行求和
 
    定义两个数据之和的方法
    定义三个数据之和的方法
    定义四个数据之和的方法
 
 
    按照上面的这种写法:测试 没有问题
    三个方法:都是属于 "求和功能"
    方法名----遵循标识符的规则:"见名知意",都是"求和的功能",方法名可以相同
 
    Java提供一个技术:方法重载 (overLoad)
    含义:
           多个方法的方法名相同,参数列表不同,与返回值无关 ---将这些方法称为"方法重载" 
                       参数列表不同有两种情况
                               1)参数个数不同 (参数类型一致)
                               2)参数类型不一致(参数个数一致）
 
            举例:
                   public static float sum(float a,float b) {}
                   public static float sum(int a,float b){}
                   public static int  sum(int a,int b){}
                   public static double sum(double a,double b,double c)
 
                   public static int add(int a,float b)
                   public static int add(float a ,int b)

只看方法名和形参列表, 与返回值类型无关

在调用时, 虚拟机通过参数列表的不同来区分同命方法

import java.util.Scanner ;
public class FunctionTest5 {

    public static void main(String[] args){

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请输入第一个int类型的数据:") ;
        int a = sc.nextInt() ;
        System.out.println("请输入第二个int类型的数据:") ;
        int b = sc.nextInt() ;

        boolean flag = compare(a,b) ;
        System.out.println("flag:"+flag) ;
        System.out.println("-----------------------------") ;


        System.out.println("请输入第一个double类型的数据:") ;
        double x = sc.nextDouble() ; //Scanner类:提供了录入double类型
        System.out.println("请输入第二个double类型的数据:") ;
        double y = sc.nextDouble() ;

        boolean flag2 = compare(x,y) ;
        System.out.println("flag2:"+flag2) ;

    }


    /**
     *
     * compare方法就属于重载的方法
     */
    //两个都是int类型
    /*
    * 两个明确:
    * 1)明确返回值类型:boolean
    * 2)明确参数类型以及参数个数
    *       int ,2个参数
    * */
    public static boolean compare(int a,int b){
        return a == b;
    }
    //两个double类型比较
    public  static boolean compare(double a,double b){
        return a == b;
    }
}

１．４例　　写一个方法，键盘录入一个数据,判断一个整数是否是质数

概念：质数又称素数。
 		一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数
  	                4   :  1 * 4
  	                       2 * 2 
  	                 3 ,5
       键盘录入数据:9
                       9 % 3 ==0
                 分析:大于1的自然数:
                       定义一个范围:
                               for循环
                                       最大值:为了提高程序计算的效率 Math.sqrt(键盘录入数据): 　　　　　　　　　　　　　　　　　　　　　　　　　　　对这个数据进行开根
                                       Math类中静态的功能:
                                       public static double sqrt(double a) 
  	自然数:
  	        分为质数/合数(能够被其他自然数整除的)
  	        0数据既不是质数也不是合数

import  java.util.Scanner ;
public class Test2 {
    public static void main(String[] args){

        //创建键盘录入对象
        Scanner sc = new Scanner(System.in) ;

        //提示并录入数据
        System.out.println("请您输入一个数据:") ;
        int num =  sc.nextInt() ;

        //调用
        boolean flag = isPrime(num);
        System.out.println("flag:"+flag);
    }

    //判断一个数据是否是质数
    /*
    * 明确返回值类型:
    *   1)明确返回值类型:boolean
    * 2)明确参数类型以及参数个数
    *   int   1个参数
    * */
    public static boolean isPrime(int num){//形参
            if(num ==0){
                return false ; //0就是不是质数
            }

        //定义一个范围, i = 2 开始(大于1的自然数),
        // 为了提高计算效率,对录入的数据进行开正平方根
        for(int i = 2 ; i<= Math.sqrt(num); i++){
            //2....
            //录入num:9
            //i=3
            //如果当前数据能够被其他自然数正常,就不是质数
            if(num % i ==0){
                return false ;//不是质数
            }

        }
        return true ;//就是质数

    }
}