JAVA raf 方法 java 方法 t

一、java方法

1、什么是方法

示例

System.out.ptintln();

System是一个类，out是一个输出对象，println是方法。调用System类中的标准输出对象out中的println方法

java方法是语句的集合，在一起执行一个功能

回顾：

方法的命名规则：首字母小写驼峰原则

static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问

2、方法的定义及调用

Java的方法类似于其他语言的函数，是一段用来完成特定功能的代码的片段。

方法包含一个方法头和一个方法体。

示例：

int sum = add(4,5);//实际参数:实际调用传给它的参数
        System.out.println(sum);
        test();
    }
    //加法
    public static int add(int a, int b){///修饰符   返回值类型 方法名 a,b为形式参数

        return a + b;
    }
    public static void test(){//加上static方便调用
        int i = 1;
        while(i<=1000){
            if(i%5==0){
                System.out.print(i+"\t");
            }
            if(i%15==0){
                System.out.println();
            }
            i++;
        }

    }

方法语法

1. 修饰符：可选，告诉编译器如何调用该方法，定义该方法的访问类型
2. 返回值类型：无返回值用void
3. 方法名：方法实际名称
4. 参数类型：可选，方法被调用时，传递值给参数。值被称为实参或形参。参数列表是指方法的参数类型，顺序和参数的个数
5. 方法体：具体语句，定义该方法的功能

形参与实参

1. 形参：方法被调用时用于接收外界输入的数据

  2. 实参：使用方法时实际传给方法的数据

return：

1. 存在返回值使用return返回
2. return****除了返回结果还能终止方法

方法调用：

1、调用方法：对象名.方法名（实参列表）

两种方式：

1、方法有返回值时，方法调用通常被当做一个值。如：

int larger = max(30,40);

2、方法返回值是void，方法调用一定是一条语句

System.*out*.println("Hello world!");

拓展：值传递和引用传递

java是值传递

3、方法重载（参数类型）

重载就是在一个类中，有相同的函数名称，但形参不同的函数

方法的重载规则：

1. 方法名称必须相同
2. 参数列表必须不同
3. 方法的返回类型可以相同或不同
4. 只有返回值类型不同不能成为方法的重载

实现理论：

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等逐个去匹配，选择对应方法，匹配失败则报错.

参数个数不同或者参数个数相同，类型不同

示例：

double k = max(45.0,43.0);
        int m = max(45,43);
        System.out.println(k);
        System.out.println(m);
    }
    //比大小
    public static int max(int num1, int num2) {
        int result;
        if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }
        return result
    }
        public static double max(double num1, double num2){
            double result;
            if (num1 > num2) {
                result = num1;
            } else {
                result = num2;
            }
            return result;
        }

数组长度：a.length

4、命令行传参

F:\idea\javaSE\基础语法\src>java com.wangchaohong.method.Demo03 this is wangchaohong

args[0]:this

args[1]:is

args[2]:wangchaohong

5、可变参数

不定项参数

在方法声明中，在指定参数类型后加一个省略号（…）

一个方法中只能制定一个可变参数，必须是方法的最后一个参数。

示例

Demo04 demo04 = new Demo04();
        demo04.method(1,2,3,4,5);
    }
    public void method(int... i){//i为数组名
        System.out.println(i[0]);
    }

6、递归

A方法自己调用自己，和A方法调用B方法没有什么区别

递归结构包括两个部分：

1、递归头：什么时候不调用自身方法，如果没有头将陷入死循环

2、递归体：什么时候需要调用自身方法

java都是栈机制

递归占用大量空间，java中能不用就不用

递归示例1

public static void main(String[] args) {
        int k = 20;
        int sum = test(k);
        System.out.println(sum);
    }
    public static int test(int i){
        int sum;
        if(i == 0){
            sum = -200;
        }else{
            sum = test(i-1) + i;
        }
        return sum;
    }

递归示例2

public static void main(String[] args) {
        Demo07 demo07 = new Demo07();
        double sum = demo07.test(10);
        System.out.println(sum);
    }
    public double test(double i){
        double sum;
        if(i==0){
            sum = 1;
        }else{
            sum = test(i-1) * i;
        }
        return sum;
    }

作业：写一个计算器，加减乘除，循环接收新的数据，通过用户交互实现 加减乘除

思路：

1、写四个方法（构建四个方法）

2、利用循环switch进行用户交互（利用Scanner进行用户交互）

3、传递需要操作的两个数（传参）

4、输出结果
初写:

public class TestDemo02 {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        TestDemo02 testDemo02 = new TestDemo02();
        int a = s.nextInt();
        if(s.hasNext()){
            String str = s.next();
            switch(str){
                case"+":{
                    int sum = testDemo02.add(a,s.nextInt());
                    System.out.println(sum);
                    break;
                }
                case"-":{
                    int sum = testDemo02.subtract(a,s.nextInt());
                    System.out.println(sum);
                    break;
                }
                case"*":{
                    int sum = testDemo02.mul(a,s.nextInt());
                    System.out.println(sum);
                    break;
                }
                case"/":{
                    int sum = testDemo02.div(a,s.nextInt());
                    System.out.println(sum);
                    break;
                }
            }
        }
    }
    public  int add(int a, int...b){//加
        int sum = a;
        for (int i = 0; i < b.length; i++) {
            sum = sum + b[i];
        }
        return sum;
    }
    public int subtract(int a, int...b){//减
        int sum = a;
        for (int i = 0; i < b.length; i++) {
            sum = sum - b[i];
        }
        return sum;
    }
    public  int mul(int a, int...b){//乘
        int sum = a;
        for (int i = 0; i < b.length; i++) {
            sum = sum * b[i];
        }
        return sum;
    }
    public  int div(int a, int...b){//除
        int sum = a;
        for (int i = 0; i < b.length; i++) {
            sum = sum / b[i];
        }
        return sum;
    }
}

注意：每次输入之间应有空格

二、java数组

1、数组概述

1. 数组是相同数据类型的有序集合
2. 数组描述的是相同类型的若干个数据，按照一定的先后顺序排列组合而成
3. 每一个数据称为数组元素，每个元素可以通过一个下表来访问

2、数组声明创建

必须先声明数组变量，才能使用

语法：

dataType[] arrayRefVar;首选——String[] args

dataType arrayRefVar[];非首选

java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize]

数组元素通过索引访问，索引从0开始

数组长度：array.length

内存分析：Java内存分析

示例：

public static void main(String[] args) {
        //变量的类型 变量名字 变量值；
        //数组类型
        int[] nums;//定义1,建议用
        int nums1[];//定义2 C,C++语言中
        int sum = 0;
        nums = new int[10];//可存放10个int类型数据，创建数组，分配空间
        for (int i = 0; i < nums.length; i++) {
            nums[i] = i+1;
        }
        for (int i = 0; i < nums.length; i++) {
            System.out.println("nums["+i+"]"+"="+nums[i]);
        }
        System.out.println("nums["+11+"]"+"="+nums[11]);//运行至此处报错
        for (int i = 0; i < nums.length; i++) {
            sum = sum + nums[i];
        }
        System.out.println("所有元素的和为:"+sum);
    }

ArrayIndexOutOfBoundsException:数组下标越界异常

Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException: 11 at com.wangchaohong.array.ArrayDemo01.main(ArrayDemo01.java:17)

三种初始化：

1. 静态初始化

int[] a = {1,2,3};

Man[] mans = new {new Man(1,1),new Man(2,3)}

2. 动态初始化int[] a = new int[2]

a[0]=1;

a[1]=2;

3. 数组的默认初始化

数组是一种引用类型，除了基本数据类型都是引用类型，它的元素相当于类的实例变量，因此数组一经分配空间，其中的每个元素也被按照实例变量同样的方式被隐式初始化

数组的四个基本特点：

1. 长度确定。一旦被创建，大小不可改变
2. 元素必须是相同类型
3. 数组中的元素可以是任何类型，包括基本类型与引用类型
4. 数组变量属引用类型，数组也可看成对象，数组中的每个元素相当于该对象的成员变量

数组本身就是对象，Java中对象是在堆中的。数组对象本身是在堆中的

数组边界问题：【0，length-1】

ArrayIndexOutOfBoundsException:数组下标越界异常

小结：数组是相同数组类型的有序集合

数组也是对象，数组的元素相当于对象的成员变量

数组长度确定，不可改

3、数组使用

1、For-Each循环(增强型)

2、数组作方法入参

3、数组作返回值

4、普通for循环

for循环示例

public class ArrayDemo03 {
    public static void main(String[] args) {
        int[] arrays = {1,2,3,4,5};
        //打印全部数组元素
        for (int i = 0; i < arrays.length; i++) {
            System.out.print(arrays[i] );
        }
        System.out.println();
        System.out.println("==============================");
        //计算 所有元素的和
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {
            sum = sum + arrays[i];
        }
        System.out.println(sum);
        System.out.println("================================");
        //查找最大元素
        int max = 0;
        for (int i = 0; i < arrays.length-1; i++) {
            if (arrays[i]>=arrays[i+1])
                max = arrays[i];
            else
                max = arrays[i+1];
        }
        System.out.println(max);
    }

增强型

public class ArrayDemo04 {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5};
        for (int i : a) {//a是数组，i是数组中的每个元素，JDK1.5
            System.out.println(i);
        }
        printArray(a);
        reverse(a);
        for (int i = 0; i < a.length; i++) {
            System.out.println(a[i]);
        }
    }
    //打印数组元素
    public static void printArray(int[] a){
        for (int i : a) {
            System.out.print(i+" ");
        }
        System.out.println();
    }
    //反转数组
    public static int[] reverse(int[] a){
        for (int i = 0; i < a.length / 2; i++) {
            int t;
            t = a[a.length-i-1];
            a[a.length-i-1] = a[i];
            a[i] = t;
        }
        return a;
    }