JAVA复习Day5

最新推荐文章于 2024-07-27 17:56:15 发布

m0_46511996

最新推荐文章于 2024-07-27 17:56:15 发布

阅读量38

点赞数

文章标签： java

本文链接：https://blog.csdn.net/m0_46511996/article/details/128784234

版权

JAVA复习Day5

7.2成员方法

class Person{
    String name;
    int age;
    //public 表示方法是公开
    //void 表示方法没有返回值
    //speak()speak是方法名,()是形参列表
    //{}方法体，可以写我们要执行的代码
    public void speak(){
        System.out.println("我是一个好人");
    }
    public void add(int n){
        //计算从0到1000的和
        int adds=0;
        for (int i=0;i<=n;i++){
            adds+=i;
        }
        System.out.println("计算结果为："+adds);
    }
    //int：表示方法执行后，返回一个int数据
    public int getsum(int num1,int num2){
        int adds = num1 + num2;
        return adds;
        //计算两个数的和
    }
}//定义一个人类
public class method{
    public static void main(String[] args) {
          Person p1 = new Person();
          p1.speak();//调用方法
          p1.add(5) ;//调用方法
          int adds;
          adds = p1.getsum(34,4);
          System.out.print("两个数的和为"+ adds);
    }
 }

7.2.1方法调用机制

在这里插入图片描述

7.2.2使用方法分好处

提高代码的复用性
可以将实现的细节封装起来，然后提供其他用户来调用即可

7.2.3成员方法的定义

public 返回数据类型方法名（形参列表）{
语句；
return 返回值；//return 语句不是必须的
}

7.2.4方法的细节和注意事项

一：返回类型
1、一个方法最多一个返回值，但是类型可以是数组，这样就可以得到多个结果
2、返回类型可以为任意类型
3、如果返回方法要求有返回数据类型，则方法体中最后执行语句必须为return 值；而且要求返回值类型必须和return值类型一致或者兼容（可以理解为类型自动转换，可以将int给double,但是不能将double给int）
4、类型为void，可以不写return，或者只写return；
二：形参列表
1、参数可以0个或多个
2、参数类型可以为任意类型
3、调用带参数的方法时，一定对应着参数列表传入相同类型或者兼容类型（可以理解为类型自动转换，可以将int给double,但是不能将double给int）的对象
三：方法体
方法不能嵌套定义
四：方法调用细节
1、同一个类中的方法调用，直接调用即可

class A{//在这里就是定义A类
    public void print (int n){
        System.out.println("print()方法被调用n="+n);
    }
    public void sayok(){
        print(10);
        System.out.println("继续执行sayok()");
    }
}

! 运行结果图

2、跨类中的方法A类调用B类方法，需要通过对象名调用

class A{
    public void print (int n){
        System.out.println("print()方法被调用n="+n);
    }
    public void sayok(){
        print(10);
        System.out.println("继续执行sayok()");
    }
    public void m1(){
        System.out.println("m1()方法被调用");
        B b = new B();//在这里创建一个B的对象
        b.hi();//调用b的方法
        System.out.println("m1()方法继续执行");
    }
}
class B{
    public void hi(){
        System.out.println("B类中的hi()被执行");
    }
}

3、跨类的方法调用和方法的访问修饰符有关，有私有的，有公有的，有保护的

7.2.5成员方法传参机制

基本数据类型，传递的是值，形参的任何改变不影响实参
引用类型的传参机制
地址拷贝，而非值拷贝，所指向的是一个位置，可以通过形参影响实参
基本数据值传递，引用类型传递是地址

7.2.6方法递归调用

在这里插入图片描述
方法递归调用的规则
1、执行一个方法时，就会创建一个新的受保护的独立空间**(栈空间)**
2、方法的局部变量是独立的，不会相互影响
3、如果方法中使用的是引用型变量，就会共享该引用类型的数据
4、递归必须向退出递归的条件逼近，否则就会无限递归
5、方法执行完毕，或者遇到return，就会返回，谁调用就将结果返回给谁，当方法执行完毕或者返回时，该方法就执行完毕

7.2.6方法递归调用的练习

斐波那契数列

class F{
    public int Fbnq(int n){
        if (n>=1){
            if(n==1||n==2){
                return 1;
                //当n为1或者n为2的时候都为1
            }
            else{
                return Fbnq(n-1)+Fbnq(n-2);
                //当第三的数的时候就是前两个相加，如果当n更大的时候
                //继续递归
            }
        }
        else{
            System.out.println("要求输入的n>=1的整数");
            return -1;
        }
    }
}

public class Main {

    public static void main(String[] args) {
             F fbnq =new F();
             System.out.println("当n=10对应的斐波那契数="+fbnq.Fbnq(10) );
    }
}

! 程序结果图
猴子吃桃
有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个，以后每天猴子都吃其中的一半，然后在多吃一个，当到第10天的时候，想再吃，发现只有一个桃子，问最初有多少个桃子？

class F{
    public int peach(int n,int t){//这里的t时当第十天的时候，n还没吃桃子的数目
        //每次都吃其中的一半，然后再吃一个桃子
        //到第十天的时候只剩一个
        //每次都是将剩下的桃子加一然后乘以2
        int adds=(n+1)*2;//每次都需要做的事情
        if(t>2){
            System.out.println("第"+(t-1)+"天的桃子有"+adds);
            int max=peach(adds,t-1);//使用递归，用max
            return max;
        }
        else{
            return adds;//当t=1时则不用在继续递归了，则返回adds的总数，
        }
    }
}
public class Main {

    public static void main(String[] args) {
             F p =new F();
             System.out.println("最初的桃子有"+p.peach(1,10) );
    }
}

! 程序结果图
汉诺塔

class H{
    public void hnt(int num,char a,char b,char c){
        //num表示移动的个数
        //a,b,c表示A塔，B塔，C塔
        if (num == 1) {
            System.out.println(a+"->"+c);
        }
        else{
            //如果有多个盘，可以看成两个盘，最下面的和上面的所有盘
            //如果先移动上面所有盘到b,借助c
            hnt(num-1,a,c,b);
            //把最下面的这个盘移动到C
            System.out.println(a+"->"+c);
            //再把b塔的所有盘，移动到c，借助a
            hnt(num-1,b,a,c);
        }
    }
}
public class Main {
    public static void main(String[] args) {
            H tower = new H();
            tower.hnt(5,'A','B','C');
    }
}