文章目录
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;
}
}
输出结果: