java day05

最新推荐文章于 2024-06-10 21:57:08 发布

大番茄丶

最新推荐文章于 2024-06-10 21:57:08 发布

阅读量67

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_46502924/article/details/105264271

版权

方法

package day05;
/*
定义一个方法的格式：

public static void 方法名称(){
    方法体
}

1.方法定义的先后顺序无所谓
2.方法的定义不能产生嵌套包含关系
3.方法定义好了之后，不会执行的。如果想执行，一定要进行方法的【调用】

如何调用方法，格式：
方法名称();
 */
public class MethonText {


    public static void main(String[] args){

        farmer();


    }


    public static void farmer(){
        //农民伯伯
        System.out.println("播种");
        System.out.println("浇水");
        System.out.println("施肥");
        System.out.println("除虫");
        System.out.println("收割");
        System.out.println("卖给小贩");

    }
    public static void seller(){
        //小商贩
        System.out.println("运输到农贸市场");
        System.out.println("抬高价格");
        System.out.println("卖给厨子");

    }
    public static void cook(){
        //厨师
        System.out.println("洗菜");
        System.out.println("切菜");
        System.out.println("炒菜");
        System.out.println("装盘");

    }
    public static void me(){

        //我
        System.out.println("吃");
    }
}

package day05;

/*
方法其实就是若干语句的功能集合

定义方法的完整格式:
修饰符 返回值类型 方法名称(参数类型 参数名称, ...){
        方法体
        return 返回值；
}

修饰符：现阶段的固定写法，Public static
返回值类型：也就是方法最终产生的数据结果是什么类型
方法名称：方法的名字，规则跟变量一样，小驼峰
参数类型：进入方法的数据类型
参数名称：进入方法的数据对应的变量名称
ps：参数有多个，用逗号隔开
方法体：方法需要做的事情，若干行代码
return：两个作用，一、停止当前方法，二、后面的返回值还给调用处
返回值:也就是方法窒息感后最终产生的数据结果
注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应。
        void 无返回值


 */
public class MethodText03 {

    public static void main(String[] args) {
        //单独调用
        sum(3, 4);

        //打印调用
        System.out.println(sum(4, 5));

        //赋值调用
        int number = sum(5, 6);
        System.out.println(number);

    }

    public static int sum(int a, int b) {
        int result = a + b;
        return result;
    }
}

方法有返回值和无返回值

package day05;
/*

对于有返回值的方法，可以使用单独调用，打印调用或赋值调用
对于无返回值的方法，只能使用单独调用，不能使用打印调用和赋值调用
 */
public class MethodText04 {
    public static void main(String[] args) {

        int num1 = sum1(10,20); //需要输入变量值
        System.out.println(num1);



        sum2(200,10); // 无返回值，自己进行输出打印
    }

    public static int sum1(int a , int b){  // 有返回值

        int result = a +b;
        return result;

    }


    public static void sum2(int a , int b){  // 无返回值

        int result2 = a +b;
        System.out.println(result2); //自己打印输出

    }
}

判断两数是否相等

package day05;

/*
定义一个方法，用来判断两个数字是否相同

 */
import java.util.Scanner;
public class MethodText05 {
    public static void main(String[] args) {


        System.out.println(isSame());

    }

    public static boolean isSame(){
        Scanner scan = new Scanner(System.in);
        System.out.print("请输入第一个数字：");
        int a = scan.nextInt();
        System.out.print("请输入第二个数字：");
        int b = scan.nextInt();
        /*boolean same;
        if (a ==b){
            same  = true;

        }else{

            same =  false;
        }*/



        return a==b;
    }
}

定义一个方法，用来求出1-100的所有数字的和值

package day05;
/*
定义一个方法，用来求出1-100的所有数字的和值
 */
public class MethodText06 {

    public static void main(String[] args) {

        System.out.println(getSum());

    }
    public static int getSum(){
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
                    sum +=i;
        }

        return sum;

    }
}

方法总结

方法应该定义在类当中，但是不能在方法当中在嘀咕一方法。不能嵌套
方法定义的前后顺序无所谓
方法定义之后不会执行，如果希望之星，一定要调用：单独调用、打印调用、赋值调用
如果方法有返回值，那么必须协商“return 返回值;”，不能没有
return 后面的返回值数据，必须何方方法的返回值类型对应起来。
对于一个 void 没有返回值的方法，不能写return后面的返回值，只能写return自己
对于void方法当中最后一行的return可以省略不写
一个方法当中更可以有多个return语句，但是必须保证同时只有一个会被执行到，两个return不能连写

方法的重载

package day05;
/*
对于功能类似的方法来说，因为参数列表不一样，却需要记住那么多不同的方法名称，太麻烦。

方法的重载(Overload):多个方法的名称一样，但是参数列表不一样。
方法的重载与下列因素相关：
1.参数个数不同
2.参数类型不同
3.参数的多类型顺序不同

方法重载与下列重载因素无关：
1.与参数的名称无关
2.与方法的返回值类型无关
 */
public class MethodOverloadText01 {
    public static void main(String[] args) {

        System.out.println(sum(20,10));//两个参数的方法
        System.out.println(sum(10,10,15));//三个参数的方法
        System.out.println(sum(10,12,41,23));//四个参数的方法
    }
    public static int sum(int a ,int b){
        return a+b;
    }

    public static int sum(int a ,int b,int c){
        return a+b+c;
    }

    public static int sum(int a ,int b,int c,int d){
        return a+b+c+d;
    }
}

数组

数组的基本格式：

数组：是一种容器，可以同时存放多个数据值。

数组的特点：
1.数组是一种引用数据类型
2.数组当中的多个类型，类型必须统一
3.数组的长度在程序运行期间不可改变

数组的初始化：在内存当中，创建一个数组，并且香向其中赋予一些默认值

两种常见的初始化方式：
1.动态初始化(指定长度)：在创建数组的时候。直接指定数组当中的数据元素个数
2.静态初始化(指定内容)：在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定

动态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[数组长度];

解析含义：
左侧数据类型：也就是数组当中保存的数据，全部是统一的类型
左侧的中括号：代表是一个数组
右侧数组名称：给数组取一个名字
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

静态初始化基本格式：
数据类型[] 数组名称 = new 数据类型[]{元素1，元素2，…};

public class ArrayText01 {
    public static void main(String[] args) {
        //创建一个数组，里面可以存放300个int型数据
        int[] arrayA = new int[300];

        //创建一个数组，里面可以存放300个double型数据
        double[] arrayB = new double[300];

        //创建一个数组，里面可以存放300个String型数据
        String[] arrayC = new String[300];

        //直接创建一个数组，里面装的全部都是int数字，具体为：5，15，25
        int[] arrayD = new int[] {5,15,25};

        //创建一个数组，用来装字符串:"Hello","World","Java"

        String[] arrayE = new String[]{"Hello,World,Java" };


        System.out.println(arrayE);
    }
}

数组的省略格式

package day05;

/*
数组的省略格式：
数据类型[] 数组名称 = {元素1，元素2， ...}


注意：
1.静态初始化没有直接指定长度，但是仍然会自动推算到长度
2.静态初始化标准格式可以拆分成为两个步骤
3.动态初始化也可以拆分成为两个步骤
4.静态初始化一旦使用省略格式，就不能拆分成为两个步骤了

使用建议：
如果不确定数组当中的具体内容，用动态初始化，否则使用静态初始化
 */
public class ArrayText02 {
    public static void main(String[] args) {
        //省略格式的静态初始化
        int[] arrayA = {10,20,30};

        //静态初始化的标准格式，可以拆分成两个步骤
        int[] arrayB;
        arrayB = new int[]{10,20,30};

        //动态初始化也可以拆分成为两个步骤：
        int[] arrayC;
        arrayC = new int[15];
        

    }
}

数组赋值

package day05;

/*
使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下：
如果是整数类型，呢么默认为0；
如果是浮点型，呢么默认值为0.0；
如果是字符类型，呢么默认值为'\U0000'
如果是布尔类型，呢么默认为false；
如果是引用类型，呢么默认为null；

注意事项：
静态初始化也有默认值的过程，只不过系统自动马上将默认值替换成了大括号当中的具体数值。
 */
public class ArrayText04 {
    public static void main(String[] args) {
        //动态初始化一个数组
        int[] array = new int[3];

        System.out.println(array);//哈希值
        System.out.println(array[0]);
        System.out.println(array[1]);
        System.out.println(array[2]);
        System.out.println("====================================");

        //将数据123赋值交给数组array当中的一号元素
        array[1] = 123;

        System.out.println(array);//哈希值
        System.out.println(array[0]);
        System.out.println(array[1]); //123
        System.out.println(array[2]);
    }
}

Java内存

java的内存需要划分成为5个部分：
1.栈(Strack)：存放的都是方法中的局部变量，方法的运行一定要在栈当中运行。
局部变量：方法的参数，或者是方法{}内部的变量
作用域：一旦超出作用域，立刻从栈内存当中消失

2.堆(Heap)：凡是new出来的东西，都在堆当中。

堆内存里面的东西都有一个地址值：16进制
对内存里面的数据，都有默认值。规则:
如果是整数类型，呢么默认为0；
如果是浮点型，呢么默认值为0.0；
如果是字符类型，呢么默认值为’\U0000’
如果是布尔类型，呢么默认为false；
如果是引用类型，呢么默认为null；

3.方法区（Method Area）：储存.class相关信息，包含方法的信息。

4.本地方法栈(Native Method Stack)：与操作系统相关

5.寄存器（pc Register）:与CPU相关。

数组的遍历输出：

package day05;

public class ArrayText07 {
    public static void main(String[] args) {

        int[] array = new int[]{15,25,30,35,40,50,3,32,32,323,32,323,454};

        int len = array.length; // 获取数组长度
        for (int i = 0 ; i< len ; i++){

            System.out.println(array[i]);
        }
    }
}

数组作为方法传递

package day05;

/*
数组可以作为方法的参数。
当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。

 */
public class ArrayText10 {
    public static void main(String[] args) {
        int[] array = {10,11,12,13,14,15};

        printArrat(array);//传递的是地址
        printArrat(array);
        printArrat(array);
    }

    /*
    返回值类型：知识进行打印而已，不需要进行计算，也没有结果，用void
    方法名称：printArray
    参数列表：必须给我数组，我才能打印其中的元素。 iny[] array
     */
    public static void  printArrat(int[] array){
        for (int i = 0 ; i< array.length; i++){
            System.out.println(array[i]);
        }

    }
}

大番茄丶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java day05

方法package day05;/*定义一个方法的格式：public static void 方法名称(){ 方法体}1.方法定义的先后顺序无所谓2.方法的定义不能产生嵌套包含关系3.方法定义好了之后，不会执行的。如果想执行，一定要进行方法的【调用】如何调用方法，格式：方法名称(); */public class MethonText { publ...
复制链接

扫一扫