JAVA基础知识点06-方法，封装、方法的调用、参数、return关键字、不可达语句、方法的重载

方法:  解决事情的办法
    封装功能的

要求:
        类中方法外,方法不能嵌套
        方法不调用不执行

定义:
    有返回值类型的方法
        修饰符 返回值类型 方法名(参数列表){
            方法体
            return 返回值;
        }

        修饰符: 访问权限修饰符 ->public static 默认
        返回值类型: 数据类型: 基本|引用
            分析: 在方法执行完毕之后,是否要得到一个值|结果,如果需要定义成有返回值,不需要定义成没有返回值类型的方法
            配合方法体中return关键字一起使用,返回一个值给方法的调用处
            返回值类型: return后面数据的类型
        方法名: 标识符,遵循标识符的命名规范|规则
        (参数列表) : 可以定义参数,可以不定义参数,可以定义多个参数
            分析: 定义方法的时候,是否有某些数据是未知的,不确定的,可变的,定义在方法的参数列表上
                参数:相当于局部变量的声明  (数据类型 参数名,数据类型 参数名,数据类型 参数名....)
        方法体: 实现功能的具体代码段;
        注意: 如果是有返回值类型的方法,必须使用 return关键字返回结果

    没有返回值类型的方法
        修饰符 void 方法名(参数列表){
            方法体
        }


   定义方法分析步骤:
    1.需求:返回一个PI的值
    2.返回值:需要  double
    3.参数: 没有
    4.方法名: getPI()


    方法的调用: 执行方法中的代码
        方法名(参数);

        有返回值类型的方法:
            1.输出调用   System.out.printn(方法名(参数));
            2.赋值调用   数据类型 变量名 = 方法名(参数);
            3.普通调用  不推荐,有返回值类型的方法,不接受返回值没意义

 

public class MethodDemo11 {

    public static void main(String[] args) {
        //调用
        //getPI();
        //输出调用
        System.out.println(getPI());

        //赋值调用
        double  d = getPI();
        System.out.println(d);

        System.out.println(getSum(5,7));
        System.out.println(getd(5,9));
        System.out.println(getmax(60,95));

    }

    //需求:返回一个PI的值
    //返回值:需要  double
    //参数: 没有
    //方法名: getPI()
    //没有参数有返回值的方法
    public static double getPI(){
        System.out.println("没有参数有返回值的方法getPI");
        return 3.1415926;
    }

    //需求: 求2个整数的和
    //1.方法名 getSum()
    //2.返回值 int
    //3.参数 int x,int y
    //有返回值,有参数的方法
    public static int getSum(int x,int y){
        System.out.println("有返回值,有参数的方法getSum");
        return x+y;
    }

    //练习:
    //1.比较2个数是否相等
    public static int getd(int x,int y){
        String S = x == y? "相等":"不相等";
        System.out.println(S);
        return x;
    }
    //2.求两个数中最大的值
    public static int getmax(int x,int y){
        if(x > y){
            System.out.println("x最大,为：" + x);
        }else {
            System.out.println("y最大,为：" + y);
        }
        return x;
    }
}

有返回值类型的方法
    修饰符 返回值类型 方法名(参数列表){
        实现功能的语句体;
        return 返回值;
    }

    有返回值类型的方法 :
        必须配合return一起使用,把返回值返回给方法的调用出

没有返回值类型的方法
    修饰符 void 方法名(参数列表){
        实现功能的语句体;
        [return];
    }
    方法体重可以定义return关键字 ,但是return后面不能带出返回值的,作用只有提前结束方法
    void : 标识没有返回值
    调用:
        只能使用普通调用
        不能使用赋值|输出调用,因为没有返回值

    return:
        1) 提前结束方法
        2) 带出返回值

    参数:
        形式参数(形参) : 定义方法时()中的参数  : 局部变量的声明
        实际参数(实参) : 调用方法时()中的数据  : 局部变量的赋值
        形参和实参类型,个数,顺序必须一一对应

   局部变量使用前必须已经声明并且已经赋值
   形参不赋值没有默认值
   返回值不存在默认值

import java.util.Random;
public class Demo01 {
    public static void main(String[] args) {
        System.out.println(getMax(3,1));;

        //普通调用
        printStar();

        //输出调用
        //System.out.println(printStar());
        //赋值调用

        System.out.println("--------------------");
        printStar2(3,5);
        System.out.println("--------------------");
        printStar3(6);
        System.out.println("--------------------");
        printStar4(5,10);

    }

    //打印5行5列的星星
    //返回值: 不需要
    //参数: 不需要
    //方法名: printStar
    //没有返回值没有参数的方法
    public static void printStar(){
        for(int i=1;i<=5;i++){
            for(int j=1;j<=5;j++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }

    //定义打印某行某列的星星的方法
    //返回值: 不需要
    //参数: int x,int y
    //方法名printStar2()
    public static void printStar2(int x,int y){
        if(x==0 || y==0){
            System.out.println("输入错误!!!");
            return; //提前结束方法
        }
        for(int i=1;i<=x;i++){
            for(int j=1;j<=y;j++){
                System.out.print("* ");
            }
            System.out.println();
        }
    }



    public static int getMax(int x,int y){
        if(x>y){
            return x;  //提前结束方法
        }

        System.out.println("------");
        return y;

    }
    //练习:
    // 输出m行乘法表
    public static void printStar3(int m){
        for(int i = m;i < m+1;i++){
            for(int j = 1;j <=i;j++){
                System.out.print(i + "×" + j + "=" + i*j + "\t");
            }
            System.out.println();
        }
    }

    // 计算某个范围内所有整数的和

    public static void printStar4(int min,int max){
        if(min > max || min == max){
            System.out.println("输入不规范！");
            return;
        }
        int sum = 0;
        for(int i=min;i<=max;i++){
            sum+=i;
        }
        System.out.println(sum);
    }
}

 运行截图：

return 关键字
    1) 提前结束方法  2)带出返回值

不可达语句:
        1.会执行的return后面出现的语句
        2.死循环后面的代码
        3.while(false){不可达;}
        4.会执行的break后的代码
        5.会执行continue后的代码

 方法签名: 标识方法的唯一
          方法名+参数列表

 兼容类型:
    参数类型 :  实参类型<=形参类型
    返回值数据的类型 :  return后数据的类型<=方法的返回值类型<=接受返回值的变量类型

 定义方法时候需要注意:
    1.方法中不能定义方法
    2.方法的形参与实参要一一对应
    3.返回值数据的类型要统一
    4.方法名要见名知意,标识符的规范
    5.形参没有默认值,在调用的时候才有值,由实参决定的
    6.方法的参数 是只属于方法的

方法 的重载:  重写
    重要的特性
    同一个类中的多个方法,方法名相同,参数列表不同|方法签名不同

    同一个类中的多个方法
    方法名相同
    参数列表不同|方法签名不同
        参数个数不同
        参数的类型不同
        不同类型的参数顺序不同

    测试方法的重载跟方法的修饰符? 没有关系
    测试方法的重载跟方法的返回值类型? 没有关系
    测试方法的重载跟方法的参数的名字? 没有关系
    方法的重载只跟方法签名相同

    重载的方法的调用?
        根据实参决定

    一个类中方法的重载是多态的一种体现
    一个类中的方法就是封装的一种体现

 

public class OverrideDemo05 {
    public static void main(String[] args) {
        getSum(1,2.0);
    }

    //求和
    //求2个int整数的和
    public static void getSum(int a,int b){
        System.out.println("求2个int整数的和");
        System.out.println(a+b);
    }

    //求3个int整数的和
    public static void getSum(int a,int b,int c){
        System.out.println("求3个int整数的和");
        System.out.println(a+b+c);
    }
    //求2个double整数的和
    //求3个double整数的和
    //求2个1个double,1个int整数的和
    public static void getSum(double a,int b){
        System.out.println("求2个1个double,1个int整数的和");
        System.out.println(a+b);
    }
    //求2个1个int,1个double整数的和
    public static void getSum(int b,double a){
        System.out.println("求2个1个int,1个double整数的和");
        System.out.println(a+b);
    }
}