java Note 2021.7.21

java Note 2021.7.21

1、方法

1.1、 没有返回值也没有形参的方法
1.2、 没有返回值有形参的方法
修饰符 返回值类型 方法名(形参列表){
	方法体;
}

形参:执行方法的那一方需要调用方提供的数据
    举例:  XX去给我炒一个青椒肉丝   --->  相当于我 调用 XX 烹饪的功能
    那么XX需要我提供青椒还有肉丝,那么这个青椒和肉丝就是XX的烹饪功能的形参
    
    那么在定义方法的时候,必须声明自己需要的数据:   形参
    在调用方法的时候,必须将对应的数据给这个方法:   实参
  
    对应到java中,形参其实就是声明变量
                实参就是具体的值
    			它们的关系就是:将实参赋值给形参
1.3、调用有形参的方法:
类名.方法名(实参列表)
public class Demo1 {
    public static void main(String[] args) {        
    //调用add方法        
    Demo1.add(3,2);
       }   
        /*    
        定义add方法时,指定了两个形参a 与 b    
        它们至少空的变量,是没有值的    
        但是可以在方法体中使用它们,因为要执行方法体,就必须调用方法    
        而调用有形参的方法的时候,必须给形参赋值    
        结果:执行方法体的时候,形参是一定有值的
             */    
             public static void add(int a, int b){        
             System.out.println(a + b);  
              }
}

提示:这里可以添加系列文章的所有文章的目录,目录需要自己手动添加
例如:第一章 Python 机器学习入门之pandas的使用


练习

1.调用方法打印乘法表,有一个参数,决定乘法表的行数

	/*
	1.调用方法打印乘法表,有一个参数,决定乘法表的行数 
	*/
public class Practise1 {
    public static void main(String[] args) {        
    mt(34);
       }    
    public static void mt(int n){
            for (int i = 1; i <= n; i++) {           
             for (int j = 1; j <= i ; j++) {                
             System.out.print(j + "x" + i + "=" + i*j +" "); 
                       }            
          System.out.println();      
           }  
            }
}

2.调用方法打印星号(矩形),有两个参数,分别决定星号的行数与列数

public class Practise2 {
    public static void main(String[] args) {        
    stars(5,7);
       }    
    public static void stars(int rows, int cols){        
    for (int i = 0; i < rows; i++) {            
    for (int j = 0; j < cols; j++) {                
    System.out.print("* ");  
             }            
     System.out.println();  
          }  
           }
}
1.4、有返回值的方法
修饰符 返回值类型 方法名(形参列表){ 
					方法体; 
					return 值;//就是指定某个值为 返回值
		}
		注意: 返回值类型 一定要与 返回值的类型匹配

调用有返回值的方法:

注意:如果一个方法有返回值,则可以将调用该方法的代码直接当做值来使用

变量 = 类名.方法名(形参列表);
System.out.println(类名.方法名(形参列表));
public class Demo2 {
    public static void main(String[] args) {
        int result = add(3, 2);
        System.out.println("结果值为:" + result);
    }

    /*
    返回值类型不是void  表示这个方法一定要有返回值
    也就是方法体中必须有return 值.

     方法体中return 值。就是这个方法的返回值
     表示如果你调用add方法,则你会得到两个形参的和
     */
    public static int add(int a, int b){
        return a + b;
    }
}
练习

定义方法,形参接收3个数字,返回最大的那一个

/*
定义方法,形参接收3个数字,返回最大的那一个
 */
public class Practise3 {
    public static void main(String[] args) {
        System.out.println(getMax(9, 8, 5));
    }

    public static int getMax(int a, int b, int c){
//        return a>b?(a>c?a:c):(b>c?b:c);
        if(a > b){
            if(a > c){
                return a;
            }else{
                return c;
            }
        }else {
            if(b > c){
                return b;
            }else{
                return c;
            }
        }

    }
}

定义方法,形参接收两个数字,判断是否相等

/*
定义方法,形参接收两个数字,判断是否相等
 */
public class Practise4 {
    public static void main(String[] args) {
        System.out.println(equals(5,5));
    }
    public static boolean equals(int a, int b){
//        return a==b;
        if(a==b){
            return true;
        }
        return false;

    }
}
注意事项

一个有返回值的方法,方法体中的return必须被执行

2、方法的重载

方法的重载:

在同一个类中,多个方法的方法名一致,但是形参列表不一致

形参列表不一致:

1.类型不一致

2.数量不一致

3.顺序不一致

以上三个条件,满足了任意一个,都形成方法的重载

2.1、没有使用方法的重载
public class Demo3 {
    public static void main(String[] args) {
        //计算两个数字的和
        
        /*
        这种情况下,定义方法与调用方法实质上是没有问题的
        但是对于调用方法,压力很大。因为调用方法需要记住方法名与形参的对应的关系
        如果方法的数量很多,则记起来就很麻烦
        
        解决方案:能不能所有功能类似的方法使用同一个名称
        向这种如果  方法名相同,但是形参列表不一样的情况,就是方法的重载
         */
        add2(3, 2);
        add3(3, 4, 5);
        add4(4,7,1,3);
    }
    public static int add2(int a, int b){
        return a + b;
    }
    public static int add3(int a, int b, int c){
        return a + b + c;
    }
    public static int add4(int a, int b, int c, int d){
        return a + b + c + d;
    }
}
2.2、使用方法的重载
public class Demo3 {
    public static void main(String[] args) {
        add(3, 2);
        add(3, 4, 5);
        add(4,7,1,3);
    }
    /*
    以下三个方法形成了方法的重载
    因为三个方法都叫做add  但是形参列表都不一致
     */
    public static int add(int a, int b){
        return a + b;
    }
    public static int add(int a, int b, int c){
        return a + b + c;
    }
    public static int add(int a, int b, int c, int d){
        return a + b + c + d;
    }
}
练习

定义plus方法形成重载,可以接收两个int参数或者两个string参数,如果是两个int参数打印两个数的和,

如果是两个String参数,打印拼接起来的结果

定义方法打印矩形的星号形成重载,如果只有一个参数,则该参数决定了矩形的行和列

如果有两个参数,则第一个参数决定行,第二个参数决定列

/*
定义方法打印矩形的星号形成重载,如果只有一个参数,则该参数决定了矩形的行和列
如果有两个参数,则第一个参数决定行,第二个参数决定列
 */
public class Practise6 {
    public static void main(String[] args) {
        stars(5);
        stars(2,6);
    }

    public static void stars(int n){
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }

    public static void stars(int m, int n){
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                System.out.print("* ");
            }
            System.out.println();
        }
    }
}

3、数组

数组就相当于一个容器,可以同时存放多个数据

优点:对自己存放的多个数据可以统一管理

在这里插入图片描述

4、初始化数组

4.1、动态初始化

只声明数组的长度,而不给数组的元素赋值

数据类型[] 变量名 = new 数据类型[长度];
4.2、静态初始化

声明数组的长度的同时也指定每一个元素的值

数据类型[] 变量名 = new 数据类型[]{数据1,数据2....};

也可以简写为:
数据类型[] 变量名 = {数据1,数据2....};

注意:这个简写只对初始化有效

5、获取数组的信息

5.1、获取长度
数组名.length;
5.2、获取数组指定元素的值
数组名[索引];
5.2、遍历数组

取出数组的每一个元素

public class Demo1 {
    public static void main(String[] args) {
        //动态初始化数组
        int[] ary1 = new int[5];//表示创建一个元素类型为int,长度为5的数组
        int[] ary2 = new int[]{1,3,5,7};//表示创建一个指定元素的数组
        int[] ary3 = {2,4,6,8};
        //ary3 = {1,2};会报错  因为这不是对ary3初始化  所以不能使用简写

        //获取数组的长度
        System.out.println(ary2.length);//4
        //获取数组指定索引的元素
        System.out.println(ary3[2]);//6

        //遍历ary2数组
        for (int i=0;i<ary2.length;i++){
            int cell = ary2[i];
            System.out.print(cell + ",");
        }
    }
}
练习

创建一个类,声明一个方法,参数是int[],方法返回包含了该数组每一个元素的字符串

/*
创建一个类,声明一个方法,参数是int[],方法返回包含了该数组每一个元素的字符串
 */
public class ArrayUtil {

    /**
     * 将指定的数组转换为字符串
     * @param ary 指定的数组
     * @return 数组的元素组成的字符串
     */
    public static String toString(int[] ary){
        String str = "";

        //1.遍历数组取出每一个元素
        for (int i = 0; i < ary.length; i++) {
            int cell = ary[i];
            //2.将取出的每一个元素都拼接到字符串上
            str += cell;
            //3.如果不是最后一个元素,则向字符串拼接一个逗号
            if(i!=ary.length-1){//任何一个数组的最后一个元素的索引,一定是这个数组的长度-1
                str += ",";
            }
        }
        return str;
    }
}
public class Demo2 {
    public static void main(String[] args) {
        int[] ary2 = new int[]{1,3,5,7};
        int[] ary3 = {2,4,6,8};

        //注意:调用方法与声明方法不在同一个类,所以不能省略类名了
        String str1 = ArrayUtil.toString(ary2);//调用方法 遍历ary2数组
        System.out.println(str1);

        System.out.println(ArrayUtil.toString(ary3));//调用方法遍历ary3数组
    }
}

6、不同类型的数组的默认值问题

public class Demo3 {
    public static void main(String[] args) {
        /*
        所有的整型数组的元素的默认值都是0
         */
        int[] ary1 = new int[5];
        System.out.println(ArrayUtil.toString(ary1));
        byte[] ary2 = new byte[3];
        for (int i = 0; i < ary2.length; i++) {
            System.out.print(ary2[i] + " ");
        }
        System.out.println();

        /*
            所有浮点型数组的元素的默认值都是0.0
         */
        double[] ary3 = new double[4];
        for (int i = 0; i < ary3.length; i++) {
            System.out.print(ary3[i] + " ");
        }
        System.out.println();
        /*
        字符型数组的元素的默认值是数字0对应的那个字符
         */
        char[] ary4 = new char[4];
        for (int i = 0; i < ary4.length; i++) {
            System.out.print(ary4[i] + " ");
            System.out.print((int)ary4[i]);
        }
        System.out.println();

        /*
        布尔类型数组的元素的默认值是false
         */
        boolean[] ary5 = new boolean[4];
        for (int i = 0; i < ary5.length; i++) {
            System.out.print(ary5[i] + " ");
        }
        System.out.println();

        /*
        所有的引用类型数组的元素的默认值是null
         */
        String[] ary6 = new String[4];
        for (int i = 0; i < ary6.length; i++) {
            System.out.print(ary6[i] + " ");
        }
        System.out.println();
    }
}

7、数组索引的范围问题

public class Demo4 {
    public static void main(String[] args) {
        //创建一个长度为5的数组  索引的范围是:0~4
        int[] ary = new int[5];

        /*
        取出数组中索引为5的元素
        因为该数组没有值为5的索引  所以这里使用的索引越界了
        会出现ArrayIndexOutOfBoundsException
        当程序出现异常,则程序会在出现异常的那一行代码被中断
         */
        System.out.println(ary[5]);

        System.out.println("------------------");
    }
}

8、数组元素的操作

8.1、查找元素

查找指定元素: 数组名[索引]

查找所有元素:遍历数组

8.2、修改元素的值

数组名[索引] = 值;

练习

创建int数组,添加100个元素,值为1~100范围的随机数

然后将每一个元素的值都+1

import java.util.Random;
public class Demo5 {
    public static void main(String[] args) {
        Random random = new Random();

        int[] ary = new int[100];
        //设置数组的元素为1~100范围内的随机整数
        for (int i = 0; i < ary.length; i++) {
            ary[i] = random.nextInt(100) + 1;
        }
        System.out.println(ArrayUtil.toString(ary));

        //将每一个元素的值加1
        for (int i = 0; i < ary.length; i++) {
            ary[i] += 1;
        }
        System.out.println(ArrayUtil.toString(ary));
    }
}
public class Practise {
    public static void main(String[] args) {
        String[] ary = {"周杰伦","昆凌","侯佩岑"};
        //将ary数组的每一个元素值后面加上"同志"两个字
    }
}
public class Practise {
    public static void main(String[] args) {
        String[] ary = {"周杰伦","昆凌","侯佩岑"};
        //将ary数组的每一个元素值后面加上"同志"两个字
        for (int i = 0; i < ary.length; i++) {
            ary[i] += "同志";
        }
        for (int i = 0; i < ary.length; i++) {
            System.out.println(ary[i]);
        }
    }
}
8.3、向数组中添加元素

数组的长度是不可更改的

所以如何才能向一个数组中添加元素呢?

答案:创建一个长度更大的新数组,将原数组的元素复制到新数组中,再向新数组中添加元素

public class Demo6 {
    public static void main(String[] args) {
        int[] ary = {1,3,5,7};
        int value = 9;
        /*
        将调用append方法得到的新数组赋值给ary变量
        ary变量之前存放的是原数组  现在存放的变成了新数组
        这么做的好处:对于使用ary变量的用户来说,给它的感觉是ary数组变大了
         */
        ary = append(ary, value);

        for (int i = 0; i < ary.length; i++) {
            System.out.print(ary[i] + " ");
        }

    }

    /**
     * 将指定值添加到指定的数组的末尾
     * @param ary 指定的数组
     * @param value 指定的值
     * @return 添加了元素的新数组
     */
    public static int[] append(int[] ary, int value){
        //1.创建容量为ary.length+1的新数组
        int[] newAry = new int[ary.length + 1];
        //2.将原数组中的所有元素复制一份到新数组中
        for (int i = 0; i < ary.length; i++) {
            //将原数组的元素复制给新数组的元素
            newAry[i] = ary[i];
        }
        //3.将指定值添加到新数组的末尾
        newAry[newAry.length - 1] = value;
        return newAry;
    }
}

9、数组作为方法的参数

10、 创建数组变量的内容图

public static void methodName(){
    int i = 5;
    int[] ary = {1,3,5,7};
}

在这里插入图片描述

可以发现创建的数组变量,实际上存放的数组的地址值

每次使用这个变量,其实是根据存放的地址值到堆内存中找到对应的数组进行操作

10.1、 java只有值传递

如果将一个基本数据类型的变量赋值给另一个变量,是将这个变量本身的值复制一份给另一个变量

int i = 5;
int j = i;

如果将一个引用类型的变量赋值给另一个变量,是将这个变量存放的地址值复制一份给另一个变量

int[] ary = {1,2,3};
int[] ary2 = ary;
练习
public class Practise2 {
    public static void main(String[] args) {
        int i = 5;
        int[] ary = {1,2,3};

        test1(i);
        System.out.println(i);//5

        test2(ary);
        System.out.println(ary[0]);//2
    }
    public static void test1(int i){
        i++;
    }

    public static void test2(int[] ary){
        ary[0]++;
    }
}

在这里插入图片描述

11添加元素的内存图

在这里插入图片描述

12、删除数组元素

删除数组中指定索引处的元素删除的思路:
1.将数组中需要被删除的元素后面的所有元素,向前移动一位
2.创建一个容量为原数组的长度-1的新数组
3.将原数组的元素(长度-1个)复制到新数组中

public class Demo7 { 
   public static void main(String[] args) {
           int[] ary = {1,3,5,7,9};        ary = delete(ary,0);
           //调用方法删除ary数组中索引为1的元素        
           for (int i = 0; i < ary.length; i++) {            
           System.out.print(ary[i] + " "); 
                 } 
  }   
  				 /**     
  				 * 删除指定数组中指定索引处的元素    
  				 *  * @param ary 指定的数组     
  				 * * @param index 指定的索引     
  				 * * @return 删除元素之后的效果的新数组
  				 *      */    
  		     public static int[] delete(int[] ary,int index){        
  		     //1.将原数组中需要被删除的元素后面的所有元素向前移动一位       
  		      for (int i = index+1; i < ary.length; i++) {
  		                  ary[i-1] = ary[i]; 
  		                        }        
  		         //2.创建长度为原数组的长度-1的新数组        
  		         int[] newAry = new int[ary.length-1];        
  		         //3 将元素值的元素复制到新数组        
  		         for (int i = 0; i < newAry.length; i++) {
  							newAry[i] = ary[i];
  							       }        
  							       return newAry; 
  							         }
}

在这里插入图片描述

练习

生成100个1~100范围的随机整数,将偶数放入一个数组,将奇数放入一个数组将每一个数组中5的倍数都删除


public class demo1 {
    public static void main(String[] args) {
    int[] arr=new int[100];

        Random random=new Random();
        int o=0,j=0;
        for (int i = 0; i < 100; i++) {
            arr[i]=random.nextInt(100)+1;
            if (arr[i]%2==0)
                o++;
            else
                j++;
        }
        System.out.println("===========================");
        System.out.println("得到的原数组为:");
        System.out.println(toString(arr));
        System.out.println("\n===========");
        int[] ji=getJi(arr,j);
        System.out.println("得到的奇数数组为:");
        System.out.println(toString(ji));
        System.out.println("\n===========");
        int[] ou=getOu(arr,o);
        System.out.println("得到的偶数数组为:");
        System.out.println(toString(ou));
        System.out.println("===========================");
        System.out.println("去掉5的倍数后:");
        System.out.println("\n===========");
       ji=getNewArr(ji);
        System.out.println("得到的奇数数组为:");
        System.out.println(toString(ji));
        System.out.println("\n===========");
         ou=getNewArr(ou);
        System.out.println("得到的偶数数组为:");
        System.out.println(toString(ou));
    }
    //除去5的倍数得到的数组
    public static  int[] getNewArr(int[] arr){
        int k=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%5!=0) {
                k++;//获取不是5的倍数数组的个数作为新数组的长度
            }else
                arr[i] = 0;//将5的倍数置为0
        }
        int[] newArr=new int[k];
        int k1=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]!=0){
            newArr[k1]=arr[i];
            k1++;
            }
        }
        return newArr;
    }
    //获取奇数数组
    public  static int[] getJi(int[] arr,int count){
        int[] newArr=new int[count];
        int k=0;
    for (int i = 0; i < arr.length; i++) {
        if (arr[i]%2!=0){
            newArr[k]=arr[i];
            k++;
        }
    }
    return newArr;
}
	//获取偶数数组
    public  static int[] getOu(int[] arr,int count){
        int[] newArr=new int[count];
        int k=0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i]%2==0){
                newArr[k]=arr[i];
                k++;
            }
        }
        return newArr;
    }
	//将数组变成字符串输出
    public static String toString(int[] arr){
        String str="";
        for (int i = 0; i < arr.length; i++) {
            str+=arr[i]+" ";
            if ((i+1)%10==0){
                str+="\n";
            }
        }
        return str;
    }
}

输出结果:

在这里插入图片描述

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值