资讯专栏INFORMATION COLUMN

Chapter8 Java方法

snowell / 3061人阅读

摘要:案例不带可变参数列表的方法被调用带可变参数列表的方法被调用和为可变参数列表和数组同时作为方法参数

Lecture1 方法简介

方法:所谓方法,就是用来解决一类问题的代码的有序组合,是一个功能模块

方法在类的内部定义,不能嵌套定义(即不能定义在另一个方法里)

方法的声明:语法格式

访问修饰符  返回类型  方法名(参数列表){
  方法体;
}

方法分类:

无参无返回值

无参带返回值

带参无返回值

带参带返回值

Lecture2 方法类型

无参无返回值方法案例:

/**
 * 使用方法进行星号打印
 */
public class MethodDemo {
    //打印输出星号
    public void printStar() {
        System.out.println("**********************");
    }

    public static void main(String[] args) {
        //创建MethodDemo类的对象methodDemo
        MethodDemo methodDemo = new MethodDemo();
        //使用对象名.方法名()调用方法
        methodDemo.printStar();
        System.out.println("欢迎来到Java的世界");
        methodDemo.printStar();
    }
}

无参带返回值方法案例:

/**
 * 使用方法计算矩形面积
 */
public class RectangleArea {
    //求矩形面积的方法
    public int area() {
        int length = 10;
        int width = 5;
        int calArea = length * width;
        return calArea;//返回语句返回面积
    }

    public static void main(String[] args) {
        RectangleArea rectangleArea = new RectangleArea();
        System.out.println("矩形的面积为:" + rectangleArea.area());
    }
}

带参无返回值方法案例:

/**
 * 使用方法求两个float类型数据的最大值,并在方法中将最大值输出
 */
public class MaxDemo {
    //求最大值的方法
    public void max(float a, float b) {
        float max;
        if (a > b) {
            max = a;
        } else {
            max = b;
        }
        System.out.println("最大值是:" + max);
    }


    public static void main(String[] args) {
        MaxDemo maxDemo = new MaxDemo();
        float m = 2.1f, n = 3.7f;
        maxDemo.max(m, n);
    }
}

带参带返回值方法案例:

/**
 * 定义一个求n!的方法
 * 然后计算1!+2!+3!+4!+5!
 */
public class FacDemo {
    //求n!的阶乘
    public int fac(int n){
        int s = 1;
        for(int i = 1; i <= n; i++){
            s *= i;
        }
        return s;
    }

    public static void main(String[] args) {
        FacDemo facDemo = new FacDemo();
        //求1!+2!+3!+4!+5!
        int sum = 0;
        for(int i = 1; i <= 5; i++){
            sum += facDemo.fac(i);
        }
        System.out.println("阶乘结果为:"+sum);
    }
}
Lecture3 数组作为方法参数

数组作为方法参数案例一:

/**
 * 使用方法打印输出数组的元素
 */
public class ArrayMethod {
    //输出数组元素的方法
    public void printArray(int[] arr) {
        for (int n : arr) {
            System.out.print(n + "  ");
        }
        System.out.println();//格式调整
    }

    public static void main(String[] args) {
        ArrayMethod arrayMethod = new ArrayMethod();
        int[] array = {10, 20, 30, 40, 50};
        arrayMethod.printArray(array);
    }
}

数组作为方法参数案例二:

import java.util.Scanner;

/**
 * 使用方法查找数组元素的值
 */
public class ArraySearch {
    //查找数组元素值的方法
    public boolean search(int n, int[] arr) {
        boolean flag = false;//默认没找到
        for (int m : arr) {
            if (m == n) {
                flag = true;
                break;//使用break语句提高程序的效率
            }
        }
        return flag;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        ArraySearch arraySearch = new ArraySearch();
        int[] array = {1, 2, 3, 4, 5};
        System.out.println("请输入要查询的值:");
        int n = sc.nextInt();
        boolean flag = arraySearch.search(n, array);
        if (flag) {
            System.out.println("找到了");
        } else {
            System.out.println("没找到");
        }
    }
}
Lecture4 方法重载

方法重载:方法名相同,参数列表不同

方法重载案例:

/**
 * 定义三个方法,实现int、double和数组类型和的问题
 */
public class MathDemo {
    //求两个int类型数的和
    public int plus(int a, int b) {
        return a + b;
    }

    //求两个double类型的数的和
    public double plus(double a, double b) {
        return a + b;
    }

    //求数组元素的累加和
    public int plus(int[] arr) {
        int sum = 0;
        for (int n : arr) {
            sum += n;
        }
        return sum;
    }

    public static void main(String[] args) {
        int m = 5, n = 10;
        int[] array = {1, 2, 3, 4, 5, 6};
        MathDemo mathDemo = new MathDemo();
        System.out.println("int类型的和:" + mathDemo.plus(m, n));
        System.out.println("double类型的和:" + mathDemo.plus(m, n));
        System.out.println("数组元素的累加和:" + mathDemo.plus(array));
    }
}
Lecture5 方法传值

基本数据类型的传值:基本数据类型传值,形式参数的改变对实际参数没有影响(传递的是值)

案例一:

public class ExchangeDemo1 {
    //定义交换方法
    public void swap(int a, int b) {
        int temp;
        System.out.println("交换前: a = " + a + ", b = " + b);
        temp = a;
        a = b;
        b = temp;
        System.out.println("交换后: a = " + a + ", b = " + b);
    }

    public static void main(String[] args) {
        int m = 4, n = 5;
        ExchangeDemo1 swapDemo = new ExchangeDemo1();
        System.out.println("交换前: m = " + m + ", n = " + n);
        swapDemo.swap(m, n);
        System.out.println("交换后: m = " + m + ", n = " + n);
    }

案例二:

public class ExchangeDemo2 {
    public void add(int n) {
        n++;
        System.out.println("方法中n的值:" + n);
    }

    public static void main(String[] args) {
        int n = 10;
        System.out.println("方法调用前n的值:" + n);
        ExchangeDemo2 exchangeDemo2 = new ExchangeDemo2();
        exchangeDemo2.add(n);
        System.out.println("方法调用后n的值:" + n);
    }
}

数组的传值:数组类型传值,形式参数的改变对实际参数有影响(传递的是地址 -- 数组第一个元素的地址)

public class ArrayDemo {
    //定义一个用于修改数组某个元素值的方法
    public void update(int[] arr) {
        arr[3] = 15;
        System.out.println("修改后数组arr的元素为:");
        for (int n : arr) {
            System.out.print(n + "  ");
        }
        System.out.println();
    }

    public static void main(String[] args) {
        ArrayDemo arrayDemo = new ArrayDemo();
        int[] array = {1, 2, 3, 4, 5};
        System.out.println("方法调用前数组array的元素为;");
        for (int n : array) {
            System.out.print(n + "  ");
        }
        System.out.println();
        arrayDemo.update(array);
        System.out.println("方法调用后数组array的元素为;");
        for (int n : array) {
            System.out.print(n + "  ");
        }
        System.out.println();
    }
}
Lecture6 可变参数列表

可变参数列表:又称为可变元参数或者可变参数类型

案例一:

public class ArgsDemo1 {
    //求和
    public void sum(int... n) {
        int sum = 0;
        for (int i : n) {
            sum += i;
        }
        System.out.println("sum = " + sum);
    }

    public static void main(String[] args) {
        ArgsDemo1 argsDemo = new ArgsDemo1();
        argsDemo.sum(1);
        argsDemo.sum(1, 2);
        argsDemo.sum(1, 2, 3);
    }
}

案例二:参数列表中如果有两个以上的参数,可变参数一定是在最后;可以将数组传递给可变参数列表,但是数组作为参数时,是不能将多个值传递给数组的

public class ArgsDemo2 {
    //查找
    public void search(int n, int... a) {
        boolean flag = false;
        for (int i : a) {
            if (i == n) {
                flag = true;
                break;
            }
        }
        if (flag) {
            System.out.println("找到了");
        } else {
            System.out.println("没找到");
        }
    }

    public static void main(String[] args) {
        ArgsDemo2 argsDemo2 = new ArgsDemo2();
        argsDemo2.search(3, 1, 2, 3, 4, 5);
        int[] a = {4, 5, 6, 7, 8};
        argsDemo2.search(3, a);
    }
}

Tips:若此时定义另一个search方法 -- public void search(int n, int[] array),并不是方法重载而是重复定义

可变参数列表作为方法参数的重载问题:可变参数列表所在的方法是最后被访问的;可变参数列表和数组可以同时作为方法参数。

案例:

public class ArgsDemo3 {
    public int plus(int a, int b) {
        System.out.println("不带可变参数列表的方法被调用");
        return a + b;
    }

    public int plus(int... a) {
        int sum = 0;
        for (int i : a) {
            sum += i;
        }
        System.out.println("带可变参数列表的方法被调用");
        return sum;
    }

    public int plus(int[] arr, int... a) {
        int sum1 = 0, sum2 = 0;
        for (int i : arr) {
            sum1 += i;
        }
        for (int i : a) {
            sum2 += i;
        }
        return sum1 + sum2;
    }

    public static void main(String[] args) {
        ArgsDemo3 argsDemo3 = new ArgsDemo3();
        System.out.println("和为:" + argsDemo3.plus(1, 2));
        int[] arr = {1, 2, 3};
        System.out.println("可变参数列表和数组同时作为方法参数" + argsDemo3.plus(arr, 1, 2, 3, 4));
    }
}

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/68524.html

相关文章

  • 一起来学SpringBoot | 第九篇:整合Lettuce Redis

    摘要:相比它支持存储的类型相对更多字符哈希集合有序集合列表,同时是线程安全的。基于的连接实例,可以在多个线程间并发访问,且线程安全,满足多线程环境下的并发访问,同时它是可伸缩的设计,一个连接实例不够的情况也可以按需增加连接实例。 SpringBoot 是为了简化 Spring 应用的创建、运行、调试、部署等一系列问题而诞生的产物,自动装配的特性让我们可以更好的关注业务本身而不是外部的XML...

    yacheng 评论0 收藏0
  • 一起学并发编程 - sleep与wait的差异

    摘要:一般差异简单来说,是一个用于线程同步的实例方法。暂停当前线程,不释放任何锁。用来线程间通信,使拥有该对象锁的线程等待直到指定时间或。执行对该对象加的同步代码块。 在JAVA的学习中,不少人会把sleep和wait搞混,认为都是做线程的等待,下面主要介绍下这俩者是什么,及了解它们之间的差异和相似之处。 一般差异 简单来说,wait()是一个用于线程同步的实例方法。因为定义在java.l...

    noONE 评论0 收藏0
  • 使用 ember-simple-auth 实现 Ember.js 应用的权限控制

    摘要:很多网站都有登录功能,对于的应用我们怎么实现权限的控制呢本篇将为你演示一个最常用的权限控制例子用户登录。升级后使用的版本是。修改这两个文件后执行命令升级。到目前为止我们还没使用过任何有关插件的内容。目前官方提供了三种常用的验证器。 很多网站都有登录功能,对于Ember的应用我们怎么实现权限的控制呢?本篇将为你演示一个最常用的权限控制例子:用户登录。 要实现登录最常用的方式是通过判断se...

    joyqi 评论0 收藏0
  • 一起学设计模式 - 外观模式

    摘要:适配器是将接口转换为不同接口,而外观模式是提供一个统一的接口来简化接口。 外观模式(Facade Pattern)属于结构型模式的一种,为子系统中的一组接口提供一个统一的入口,它通过引入一个外观角色来简化客户端与子系统之间的交互... 概述 外观模式是一种使用频率非常高的结构型设计模式,当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时...

    zone 评论0 收藏0

发表评论

0条评论

snowell

|高级讲师

TA的文章

阅读更多
最新活动
阅读需要支付1元查看
<