零基础java自学流程-认识Java基础语法10

最新推荐文章于 2024-01-18 07:00:00 发布

Limingmingaa

最新推荐文章于 2024-01-18 07:00:00 发布

阅读量82

点赞数 1

分类专栏：视频教程 java 编程文章标签： java

本文链接：https://blog.csdn.net/Limingmingaa/article/details/120550274

版权

Java方法参数传递方法重载代码复用设计原则

关键词由CSDN通过智能技术生成

java 同时被 3 个专栏收录

692 篇文章 2 订阅

订阅专栏

编程

559 篇文章 0 订阅

订阅专栏

视频教程

546 篇文章 0 订阅

订阅专栏

方法的定义与参数

1、方法的概念

将一个功能抽取出来，放在类中的大括号中，形参一个独立的功能，当需要使用它时，直接调用它，这样可以增强代码的复用性（重复利用），并解决代码冗余现象。

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

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

2、设计方法的原则

方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展

3、方法的语法

【访问修饰符】返回值类型 方法名（【参数类型 参数名1，参数类型 参数名2.....】）{

				方法体

详解:

访问修饰符:用于修改对该方法的调用。当前默认为public static

返回值类型:写入void而不返回值或返回方法执行结果的数据类型，该结果在方法执行完成后返回

方法名:按照标识符的规则对方法进行命名

参数类型、参数名称:它们被定义在同一时间,该方法在执行时,不知道价值需要通过调用方法时,参数类型表示的数据类型参数,参数名称参数名、参数名可用于身体的方法

方法体:该方法所包含的函数(代码块)

定义一个方法
public static int add（int num1，int num2）{
		return num1+num2；
}

4、方法的分类

根据方法的参数不同，返回值不同，可以将方法分为四类：

1、无参无返回值方法

语法

public static void 方法名（）{
    方法体
}

2、无参有返回值方法

语法

public static void 返回值类型 方法名（）{
    方法体
}

  /**
     *        定义无参有返回值，需要先指定  这个返回值的数据类型
     *        生成一个100以内的随机整数
     */
    public static int getRandomNum(){
        System.out.println("生成随机数");
        int num = (int)(Math.random()*100);
        return num;  //注意 返回值类型  必须与定义的数据类型一致
    }
    public static void main(String[] args) {
       //调用有返回值类型
        //（返回值可以接受，也可以不接受，一般建议接受）
        int   n=getRandomNum();
        System.out.println(n);
    }
	//	结果在n中

3、有参无返回值方法

语法：

public static void 方法名（参数列表）{
    方法体
}

情况一：当参数中是基本数据类型，将实参的值赋值给形参

public static void add(itn num){
    num++;
    System.out.println("方法中num的值："+num);
}

调用方法：num的改变不会改变n的值，因为是两个独立的内存

int n = 10;
System.out.println(n);
add(n);
System.out.println("方法外面  实参的值："+n)；

结果输出：

方法中num的值：11

方法外面实参的值：10

情况二：当参数的数据类型是引用数据类型

例如：数组

//方法的比对   参数的数组
public static void add(int [] arr){
    arr[0]++;
    System.out.println("方法中aar[0]="+aar[0]);
}

调用：

int [] array = {10,20};
add(array);//会调用 参数是数组的add方法
System.out.println("方法外面的arr【0】"+array[0]);

结果：

方法中arr[0]=11

方法外面的arr[0]=11

public static void addAge(Stdent studen){
    //将学生的年龄 获取 自加
    int age = student.age;
    age++;
    // 在重新赋值
    student.age=age;
}

调用：

Student student = new Student();  //age默认为 18
System.out.println("方法调用之前："+student.age);//18
	addAge(student);// 传送的地址
	System.out.println("方法外面 学生的年龄："+student.age);

结果输出：方法调用之前： 18

方法外面学生的年龄：19

/**
         *   以上方法调用 的结论： 对于参数为引用数据类型，方法外面和方法内部公用同一块内存，
         *       也就是说  参数再传递时，将引用类型的地址赋值给 方法的形参
         *                      对于基本数据类型 ，方法的参数将 值的副本赋值给形参，这样形参的改变
         *                      不会影响实参的值
         *       原因： 引用数据类型在参数传递时 是地址  （JVM对于堆内存的大小不可控）
         *             基本数据类型在参数传递时 是值
         *
         */

情况三：当参数是String类型时，String是引用数据类型，但是在参数传递时，与基本类型一样

public static void main(String[] args){
    //参数是字符串
    String uname = “李四”；
    sayHello（uname）；
    System.out.println("我最后对："+uname+"sayHello");
    }
    public static void sayHello(String name){
        name= "张三"；
        System.out.println("我对"+name+"sayHello")；
    }

结果：我对张三sayHello

我最后对李四sayHello

4、有参有返回值方法

语法：

public static 返回值类型 方法名（参数列表）{
    方法体
}

例如：

public static String sayHello(String name){
        name="张三";
        System.out.println("我对"+name+"sayHello");
        return name ;
    }

调用：

public static void main(String[] args) {		
		// 参数是字符串
        String uname ="李四";
        // 将返回值接收  ，这是 uname 才被改变 ，如果不接受，则不改变
        uname = sayHello(uname);
        System.out.println("我最后对"+uname+"sayHello");
 }

结果：

我对张三sayHello

我最后对张三sayHello

5、方法的调用

如果方法体中需要一些位置的数据作为执行条件，那么这些数据可以作为参数

如果方法需要返回数据，在定义有返回值的方法，且需要明确返回值类型

方法调用两种方式：

在一个方法中可以调用另外一个方法

对象名方法名（参数）

直接写方法名调用，但必须是static修饰的

//获取这个字符串的第一个字符
public void method1(String str){
    //返回字符串的第一个字符
    return str。charAt（0）；
}

//调用方法
对象名.method1()
//调用静态方法  （static修饰的）
    String s = "abc";
	char c = method1(s)  //s将赋值给方法的形参  str 那么方法执行时str有值
    //	c就是方法调用后的返回值0

6、方法参数传递

1、方法的参数是基本数据类型，它传递的是值

//计算一个属的平方
public int pow（int a）{
    a = a + 2；
        return  a * a；
}

main:
	int num = 4;
	int sum = pow(num);//赋值给a
	System.out.println(num);//4
	System.out.println(sum);//36

2、方法的参数是引用数据类型，它传递的是地址（除了String类型除外）

//参数 是数组类型
    public static int pow(int [] arr){
        arr[0]=arr[0]+2; //根据地址 改变数组的第一个元素值 arr[0]=4;
        return arr[0]*arr[0];  // 4*4
    }

调用

// 调用另一个pow
        int [] array = {2,3};
       int sum2 =  pow(array) ; //  array中存放数组的地址  ，将地址赋值给  arr形参
        System.out.println(array[0]);// 4
        System.out.println(sum2 ); // 16

7、方法的重载

在一个类中，存在相同的方法名的两个级以上的方法，且它们的参数列表不同（参数类型不通风，参数个数不同，参数顺序不同），不考虑参数名，不考虑返回值类型

一个类中不能存在完全相同的方法，它们是重复的方法。JVM编译不通过

例如：

public int add(int a,int b){
    return a+b;
}
//重载
public int add(long a,long b){
    return (int)(a+b);
}
//与前两个 不重载
public void add(int c,int d){
    
}
// 能与 方法1 ，2 构成重载
  public void  add(int a){
     
  }
// 能与 方法1 ，2 构成重载
  public void  add(int a ,long b){
      
  }
// 能与 方法1 ，2 构成重载
  public void add(long a ,int b){
      
  }

注意：方法名是否相同，参数列表是否相同（数据类型，参数个数，参数顺序）

方法重载的规则
方法名称必须相同
参数列表不同（类型，个数，顺序等）
方法的返回类型可以相同也可以不相同
仅仅返回类型不同不足以成为方法的重载

实现理论:

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

在一个方法中可以调用另外一个方法

//在一个方法中可以调用另外一个方法，它们的执行顺序是这样的
     public static void main(String[] args) {
        System.out.println("这是main方法 的开始语句块");
         method1();
         System.out.println("这是main方法 的结束语句块");
     }
        public static void method1(){
            System.out.println("这是method1 的开始语句块");
            //在一个方法中可以调用另外一个方法，它们的执行顺序是这样的
            method2();
            System.out.println("这是method1 的结束语句块");
        }
        public static void method2(){
            System.out.println("这是method2 的开始语句块");
            method3();
            System.out.println("这是method2 的结束语句块");
        }
        public static void method3(){
            System.out.println("这是method3 的开始语句块");
            System.out.println("这是method3 的结束语句块");
        }

public static void m3(int i){
        if(i==5){
            return ;
        }
        System.out.println("这是m3方法开始i :"+ i);
        i++;
        m3(i);
        System.out.println("m3方法的结束 i:"+ i );
  }
   public static void main(String[] args) {
    
        m3(0); //
    }

例题：用户输入一个数字使用递归计算出这个数的阶乘

```
//使用递归输入一个数计算它的阶乘
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数");
        int num=sc.nextInt();
        int sum=f(num);
        System.out.println(sum);
    }
    public static int f(int n){
        if (n==1)
            return 1;
        return n*f(n-1);
    }
```
以下是递归的练习题，有兴趣的可以做做

练习1 ：一组序列 1 ，1, 2，3, 8...13,21,34,55,89,144 n，第12个数为多少？

练习2： 1， 3， 5， 7， 9， 11 . 问前10个数的和

练习3 ：前5个阶乘之和例如 5!+4!+3!+...1!

练习4：定义一个函数，函数有一个整型参数n，
如果参数n为偶数时，调用函数求1/2+1/4+...+1/n,
如果参数n为奇数时，调用函数1/1+1/3+...+1/n

练习5、 1/1+1/2+2/3+3/5+5/8.。。。前8个数之和

想要系统学习JAVA推荐JAVA300集

Java300集零基础适合初学者视频教程https://www.bilibili.com/video/BV1oy4y1H7R6?spm_id_from=333.999.0.0

Limingmingaa

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
零基础java自学流程-认识Java基础语法10

方法的定义与参数1、方法的概念将一个功能抽取出来，放在类中的大括号中，形参一个独立的功能，当需要使用它时，直接调用它，这样可以增强代码的复用性（重复利用），并解决代码冗余现象。Java方法是语句的集合，它们在一起执行一个功能方法是解决一类问题的步骤的有序组合方法包含于类或对象中方法在程序中被创建，在其他地方被引用2、设计方法的原则方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成一个功能，这样利于我们后期的扩展
复制链接

扫一扫