java笔记

_Pomelo

于 2022-12-04 17:32:59 发布

阅读量178

点赞数 2

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_55266011/article/details/128174862

版权

java基础学习笔记（基础语法篇）

一、java环境搭建

获取jdk

Oracle官网下载jdk

jdk-bin路径下：

java.exe-执行程序 javac.exe-编译工具

常用命令:

cls   清屏
dir   目录
cd    进入
exit  退出

java开发的三个步骤

编写代码
编译代码
运行代码

java程序的执行原理

机器语言-汇编语言-高级语言

jdk的组成

jdk：java开发工具包

    开发工具：java javac ···

    jre：java的运行环境,真正运行java程序地方

          jvm  java虚拟机

          核心类库  java自己写好的程序，调用

jdk安装后Path和环境变量

Path环境变量用于记住程序路径，方便在命令行窗口的任意目录启动程序

二、java语言

idea项目结构简介

project（项目、工程）

module（模块）

package（包）

class（类）

idea常用快捷键

Ctrl + Alt + T 快速添加方法

基础语法：

注释：

单行注释      //              Ctal + /
多行注释      /*      */   Ctal+Shift+/
文档注释      /**     */

字面量：

字面量就是数据在程序中的书写格式

常用数据	生活中的写法	程序中的写法	说明
整数	666，-88	666，-88	写法一致
小数	13.14，-5,12	13.14，-5,12	写法一致
字符	A，O，我	‘A’,‘O’,‘我’	单引号，且只有一个字符
字符串	helloworld	“helloworld”	双引号，内容可有可无
布尔值	真，假	ture，false	ture：真 false;假
空值		值是;null	一个特殊的值，空值

\n 换行 \t 一个tab

变量：

变量是用来存储一个数据的内存区域（可以理解成盒子），且里面存储的数据可以变化。

变量定义的格式：

数据类型    变量名称  =  初始值；

public class Demo{
    public static void main(String[] args){
        //目标：学会使用变量
        //数据类型 变量名称 = 初始值；
        double money = 6.0;
        System.out.println(money);
        
        //收红包(从有往左看)
        money = money + 4.0;
        System.out.println(money);
        
        System.out.println("--------------");
        int age = 21;
        System.out.println(age);  //21
        
        age = 25;
        System.out.println(age);  //25
    }
}

变量注意事项：

public slass Demo{
    public static void main(String[] args){
        //1.变量要先声明再使用
        int a = 23;
        System.out.println(a);
        //2.变量声明后，不能存储其他类型数据
        //a=1.5;
        
        //3.变量的有效范围是从定义到“}”截止，且在同一个范围内部不能定义2个同名变量
        {
            int b = 25;
            System.out.println(b);
        }
        // System.out.println(b); 
        
        //变量定义的时候可以没有初始值，但是使用时必须给初始值
        int c;
        Sysout.out.println(c);
    }
}

变量在计算机中的底层原理：

二进制：

只有0 1，按照逢二进一的方式表示数据
计算机中的数据的最小单位

8个二进制位为一组来保存数据，1字节=8bit 1B=8b byte字节 bit位

ASCLL编码表：

a 97

A 65

进制转换：

十进制转二进制：

除二取余法

二进制转十进制：

0011

12^0 +12

二进制转八进制:

97 01100001 141 01 100 001

二进制转16进制：

97： 01100001 0110,0001 61

250:11111010 1111、1010 FA

二进制：0b 八进制：0 十进制：0x或0X

数据类型：

基本数据类型：

整数：

byte 1、short 2、int（默认） 4、long 8

浮点数：

float 4、double（默认） 8

字符：

char 2

布尔：

boolean 1

引用数据类型： string等

关键字、标识符

标识符：数字、字母、下划线等组成不能以数字开头，不能用关键字

变量首字母小写类名首字母大写

类型转换：

自动类型转换

表达式的自动类型转换

强制类型转换：

数据类型 变量2 = （数据类型）变量1、数据

运算符

算术运算符

+、-、*、/、%

"+"做连接符：与字符串运算的时候作连接符，结构依然是一个字符串

能算则算，不能算则在一起

public static void main(String[] args){
	int a = 5;
	System.out.println("abc"+'a');//abca
	System.out.println("abc"+a);//abc5
	System.out.println(5+a);//10
	System.out.println("abc"+5+'a');abc5a
	System.out.println(15+"abc"+15);//15abc15
	System.out.println(a+'a');//102
	System.out.println(a+""+'a');//5a
	System.out.println(a+'a'+"itheima");
	//102 itheima
	System.out.println("itheima"+a+'a');//ithiema5a
	System.out.println("itheima"+(a+'a'));
	//itheima102
}

自增自减运算符：

++和–既可以放在变量后也可以放在变量前
++、–只能操作变量、不能操作字面量

++i --i:

放在变量前，先对变量进行+1-1，再拿变量的值进行运算
i++ i–

放在变量后，先拿变量的值进行运算，再对变量的值进行+1、-1

public static void main(String[] args){
    int i = 10;
    int j = ++i;
    System.out.println(i);//11
    System.out.println(j);//11
    
    int m = 10;
    int n = m++;
    System.out.pirntln(m);//11
    System.out.println(n);//10
}

int c = 10;
int d = 5;
//c    10  11  12  11
//d    5  4  3  4
//rs3    10 + 12  - 4 +4  -  12 +  4 =14+2=16
int rs3 = c++ + ++c - --d + d-- - c-- + ++d + 2

赋值运算符：

int i = 10；先看“=”右边，把数据10赋值给变量i
+= -= *= /= %=

a+=b;  //  a = (int)(a+b)

关系运算符

是对数据进行条件判断的符号，最终返回一个比较的布尔结果

符号	说明
==	a==b,判断a和b是否相等，是为ture，不是为false
!=	a!=b,判断a和b是否不相等，是为ture，不是为false
>	a>b,判断a是否大于b，是为ture，不是为false
>=	a>=b,判断a是否大于等于b，是为ture，不是为false
<	a<b,判断a是否小于b，是为ture，不是为false
<=	a<=b,判断a是否小于等于b，是为ture，不是为false

逻辑运算符

符号	介绍	说明
&	逻辑与	必须都是ture，结果才是ture，只要有一个false，结果一定是false
\|	逻辑或	只要有一个ture，结果就是ture
！	逻辑非	你真我假，你假我真
^	逻辑异或	如果两个条件都是false或者都是ture则结果是false。两个条件不同结果是ture。
&&	短路与	判断结果与“&”一样。左边为false，右边则不执行
\|\|	短路或	判断结果与“\|”一样。左边为ture，右边则不执行

三元运算符：

格式：条件表达式？值1：值2；

值为ture，返回值1，如果为false，返回值2.

public static void main(String[] args){
    double score = 98;
    String rs = score >= 60 ? "考试通过" : "挂科" ;
    System.out.println(rs);
    
    //需要从两个整数中找出最大值
    int a = 10;
    int b = 2000;
    int max = a > b ? a : b;
    System.out.println(max);
}

案例:

//求三个整数的最大值：
public static void main(String[] args){
    int i =10;
    int j =30;
    int k = 50;
    int temp = i > j ? i : j ;
    int rsMax = temp > k ? temp : k;
    System.out.println(rsMax);
    
    
    int rsMax1 = i > j ? (i > k ?i : k) : (j > k ? j :k);
    System.out.println(rsMax1);
    
}

运算符优先级：

案例知识:键盘录入

导包：告诉程序去jdk的哪个包中找到扫描器技术

impirt java.util.Scanner;
写一行代码代表得到键盘扫描器对象

Scanner sc = new Scanner(System.in);
等待接受用户输入数据

sc.next();

import java.util,Scanner;


public class Demo{

	public static void mian(String[] args){
        
        Scanner sc = new Scanner(System.in);
        //这个代码等待用户输入，直到用户输入玩并按了回车键就会吧数据得到
        System.out.println("请输入您的年龄：");
        int age = sc.nextInt()
        System.out.println("您的年龄是："+age);
    }  
}

程序流程控制

顺序结构：（程序默认流程）

开始语句1 语句2 … 结束

分支结构：（if 、swich）

if

三种格式:

格式1：
if(条件表达式){
	语句体；
}

格式2：
if(条件表达式){
	语句体1；
	}else{
	语句体2；
	}

格式3：
if(条件表达式1){
	语句体1；
	}else if(条件表达式2){
	语句体2；
    }else if(条件表达式3){
    语句体3；
    }
    ...
     else{
       语句体N+1；
     }

//   案例：

//心跳数据在40到100 之间是正常的     
		int hertBeat = 30;
        if(hertBeat<40 || hertBeat>100){
            System.out.println("您的心跳数据是"+hertBeat+"可能需要进一步检查");
        }
        System.out.println("检查结束");



//发送红包
        double money = 5999;
        if(money>=1314){
            System.out.println("发送成功");
        }else{
            System.out.println("没钱了");
        }


//绩效系统：0~60  C 60~80  B 80~90  A  90~100  A+
        int score = 111;
        if (score>=0 && score<60){
            System.out.println("您本月的绩效是：C");
        }else if(score>=60 && score<80){
            System.out.println("您本月的绩效是：B");
        }else if (score>=80 && score<90){
            System.out.println("您本月的绩效是：A");
        }else if (score>=90 && score<=100){
            System.out.println("您本月的绩效是：A+");
        }else {
            System.out.println("您输入的分数不对！");
        }

swich

适合做值匹配的分支选择，结构清晰，格式良好

swich(表达式){
    case  值1:
        执行代码...;
    	break;
    case  值2:
        执行代码...;
    	break;
    
    ...
    case  值1:
        执行代码...;
    	break;
    case  值n-1:
        执行代码...;
    	break;
    default:
    	执行代码n；  
}

//     案例：

String weekday = "周一";
        switch (weekday){
            case "周一":
                System.out.println("埋头苦干，解决bug");
                break;
            case "周二":
                System.out.println("请求大牛程序员帮忙");
                break;
            case "周三":
                System.out.println("今晚烧烤");
                break;
            case "周四":
                System.out.println("主动帮忙女程序员解决bug");
                break;
            case "周五":
                System.out.println("今晚吃鸡");
                break;
            case "周六":
                System.out.println("写作业");
                break;
            case "周日":
                System.out.println("郁郁寡欢，准备上课");
                break;
            default:
                System.out.println("数据有误");
        }

swich的穿透性

//需求：用户输入月份可以展示该月份的天数
//1、3、5、7、8、10、12月份是31天
//2月份是闰年为29天、非闰年为28天
//4、6、9、11月份是30天

public static void main(String[] args){
    int month = 7;
        switch (month){
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                System.out.println(month+"是31天");
                break;
            case 2:
                System.out.println(month+"月份是闰年为29天、非闰年为28天");
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                System.out.println(month+"月份是30天");
                break;
            default:
                System.out.println("数据有误！");
    
        }
    
}

循环结构：（for 、 while、do…while)

for循环

//格式
for(初始化语句;循环条件;迭代语句){
    循环语句体（重复执行的代码）;
}

//示例
for(int i = 0; i < 3; i++){
    System.out.println("Hello World");
}

for循环案例

//案例1：求1~5之间的数据和，并把求和结果在控制台输出
int sum;
for(int i = 0; i <= 5; i++){
    sum+=i;
}
System.out.println(sum);

//案例2：求1~10之间的奇数和，并把结果在控制台输出

//方法1：
int sum = 0;
for(i = 1; i <= 10; i++){
    if(i % 2 == 1){
        sum += i;
    }
}
System.out.println(sum)
    
//方法2：
for(i = 1; i<= 10; i+=2){
        sum+=i;
    }
System.out.println(sum)

//案例3：在控制台输出所有的“水仙花数”，水仙花数满足两个要求：1. 水仙花数是一个三位数   2.水仙花数的个位、十位、百位的数字立方和等于原数。
public class TestDemo {
    public static void main(String[] args) {
        int count = 0;//记录水仙花数
        for (int i = 100;i<1000;i++){
            int ge = i % 10;
            int shi = i /10 %10;
            int bai =   i /100;
            if (ge*ge*ge + shi*shi*shi + bai*bai*bai == i) {
                System.out.print(i+"\t");
                count++;
            }
        }
        System.out.println();//换行
        System.out.println("水仙花的个数为："+count);
    }
}

while循环


// 格式
初始化语句；
whlie(循环条件){
	循环体语句（被重复执行的代码）；
	迭代语句；
}

//示例
int i = 0;
whlie(i<3){
    System.out.println("Hello World");
    i++;
}

whlie循环案例

//案例：珠穆朗玛峰（8848.86=8848860毫米），假如我有一张纸，他的厚度是0.1毫米，请问，折叠多少次，可以折成珠穆朗玛峰的高度。
public static void main(String[] args) {
        double peakHeight = 8848860;    //山峰高度
        double paperThickness = 0.1;    //纸张厚度
        int count = 0;
        while (paperThickness < peakHeight){
            paperThickness*=2;
            count++;
        }
        System.out.println("纸张折叠了"+count+"次");
    }

do-whlie循环

//格式
初始化语句；
do{
	循环体语句；
	迭代语句；
}while(循环条件)
    
    
//示例    先执行一次在循环
int i =0;
do{
    System.out.println("Hello World!");
    i++l;
}while(i<3)

三种循环的区别

for循环和while循环（先判断后执行）
do…whlie（第一次先执行后判断）

for和whlie的区别

执行流程是一模一样的
已知循环次数用for循环，不清楚循环次数用whlie循环
for循环中，控制循环的变量只在循环中可以使用，whlie循环控制循环的变量在循环后还可以使用

死循环

一直执行下去，如果没有干预不会停止下来

//写法：
for(;;){
    System.out.println("Hello World")
}

//经典写法
whlie(true){
    System.out.println("Hello World")
}
do {
    System.out.println("Hello World")
}whlie(true)

//案例：   系统密码是520，请用户不断输入密码验证，验证不对输出密码错误，验证成功输出欢迎进入系统，并停止程序。

public static void main(String[] args) {
        int okPassword = 520;
        Scanner sc = new Scanner(System.in);
        while (true){
            System.out.println("请你输入密码：");
            int password = sc.nextInt();
            if (password == okPassword){
                System.out.println("密码正确");
                break;
            }else{
                System.out.println("密码错误");
            }
        }

循环嵌套

public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 3; j++) {
                System.out.println("我爱你！");
            }
            System.out.println("-------------");
        }
    
    
public static void main(String[] args) {
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 5; j++) {
                System.out.print("*");
            }
            System.out.println();
        }
    }

跳转关键字 break,continue

break:跳出并结束当前所在的循环

continue：用于跳出当前循环的当次执行，进入下一次循环

案例技术：随机数Random类

Random生成随机数的特点

nextInt（10） 0~9之间的随机数

int number = r.nextInt(10)+1; 1~10之间

int number = r.nextInt(15)+3; 3~17之间

65~91 => (0~26)+65;
int number = r.nextInt(27)+26;

// Random的使用
import java.util.Random

public static void main(String[] args){
    Random r = new Random();
    
    int number = r.nextInt(10);
    System.out.println("随机数产生了："+number)
}

//猜数字游戏：
随机生成一个1-100之间的数据,提示用户猜测,猜大提示过大,猜小提示过小,直到猜中结束游戏。分析:①随机生成一个1-100之间的数据②使用死循环让用户不断提示用户猜测,猜大提示过大,猜小提示过小,猜中结束游戏。

package com.wuxb.test;
import java.util.Random;
import java.util.Scanner;

public class TestDemo {
    public static void main(String[] args) {
        Scanner sc =new Scanner(System.in);
        Random r = new Random();
        int number = r.nextInt(100)+1;
        while (true){
            System.out.println("请输入猜测的数据（1~100）：");
            int date = sc.nextInt();
            if (date > number){
                System.out.println("猜大了!");
            }else if(date<number){
                System.out.println("猜小了！");
            }else{
                System.out.println("猜对了！正确答案就是："+number);
                break;
            }
        }
    }
}

数组

数组就是用来存储一批同种类型数据的内存区域（可理解为容器）

数组的定义

静态初始化数组

//完整格式
数据类型[]  数组名 = new 数据类型 [] { 元素1，元素2,...   }
int[] ages = new int[] {12,24,56};


数据类型[]  数组名 =  { 元素1，元素2,...   }
int[] ages = {12,24,56};

数组的访问：

 
数组名称[索引]

//数组长度
数组名.length

“ 数据类型[] 数组名 ” 和 “ 数据类型数组名[] “ 一样
什么类型数组放什么类型的数据
数组一旦定义下来数组的类型和长度就固定了

动态初始化

数据类型[] 数组名 = new 数据类型[长度]；
int[] arr = new int[3]

元素默认值

数据类型	明细	默认值
基本类型	byte、short、char、int、long	0
基本类型	float、double	0.0
基本类型	boolean	false
引用类型	类、接口、数组、String	null

数组的遍历

int[] ages = {20,30,40,50}

for(i = 0;i < ages.length; i++){
    System.out.println(ages[i])
}

数组的案例

数组元素求和

//某个部门5名员工的销售额分别是：16,26,36,6,100，请计算出他们部门的总销售额
package com.wuxb.create;

public class ArrayDemo {
    public static void main(String[] args) {
        //静态初始化的方式定义数组
        int[] arr = new  int[]{16,26,36,6,100};
        int sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum += arr[i];
        }
        System.out.println("总销售额为："+sum);
    }
}

求数组最大值

// 求出下列最大值  15,,9000,10000,20000,9500,-5;
package com.wuxb.create;

public class ArrayDemo {
    public static void main(String[] args) {
        //静态初始化的方式定义数组
        int[] arr = new  int[]{15,9000,10000,20000,9500,-5};
        int Max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (Max < arr[i]){
                Max = arr[i];
            }
        }
        System.out.println("最大值是："+Max);
    }
}

猜数字游戏

//开发一个幸运小游戏,游戏规则如下:
游戏后台随机生成1-20之间的5个数(无所谓是否重复),然后让大家来猜数字:未猜中提示:“未命中”,并继续猜测猜中提示:“运气不错,猜中了”,并输出该数据第一次出现的位置,且输出全部5个数据,最终结束本游戏。

package com.wuxb.create;

import java.util.Random;
import java.util.Scanner;

public class ArrayDemo {
    public static void main(String[] args) {
        //随机生成1~20之间的5个随机数

        //1.定义一个动态初始化的数组存储5个随机的1~20之间的数据
        int[] data =  new int[5];


        //2.动态的生成5个1~20之间的随机数并存入到数组中去
        Random r = new Random();
        for (int i = 0; i < data.length; i++) {
            data[i] = r.nextInt(20)+1;
        }

        //3.使用一个死循环让用户进行猜测
        Scanner sc = new Scanner(System.in);
        OUT:
        while (true){
            System.out.println("请您输入一个1~20之间的整数进行猜测：");
            int guessData = sc.nextInt();

         //4.遍历数组中的每个数据，看是否数据与猜测的数据相同，相同代表猜中，给出提示
            for (int i = 0; i < data.length; i++) {
                if (data[i] == guessData){
                    System.out.println("恭喜您猜对了，运气不错！您猜的数据的索引是："+ i);
                    break OUT;//结束了整个死循环，代表游戏结束
                }
            }
            System.out.println("当前猜的的数据不在数组中，请重新猜测！");
        }
        //5.输出数组的全部元素，让用户看到自己确实猜中了某个数据
        for (int i = 0; i < data.length; i++) {
            System.out.print(data[i]+"\t");
        }
    }
}

随机排名

//需求某公司开发部5名开发人员,要进行项目进展汇报演讲,现在采取随机排名后进行汇报。请先依次录入5名员工的工号,然后展示出一组随机的排名顺序。
22 33 35 13 88     ->    13 35 88 33 22

package com.wuxb.test;

import java.util.Random;
import java.util.Scanner;

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

        //动态初始化一个数组存储5个员工号
        int[] codes = new int[5];

        //定义一个循环，循环五次，依次输入工号存入对应位置
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < codes.length; i++) {
            System.out.println("请输入员工的工号：");
            int code = sc.nextInt();
            codes[i] = code;
        }

        // 遍历数组中的每个元素，然后随机一个索引出来，让该元素与随机索引位置处的元素交换位置
        Random r = new Random();
        for (int i = 0; i < codes.length; i++) {
            int index = r.nextInt(codes.length);
            int temp = codes[index];
            codes[index] = codes[i];
            codes[i] = temp;
        }

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

    }
}

数组排序

数组排序的技术

冒泡排序

//每次从数组中找出最大值放在数组的后面去

package com.wuxb.test;

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

        int[] arr = {1,8,3,2};

        for (int i = 0; i < arr.length -1; i++) {
            for (int j = 0; j < arr.length - i -1; j++) {
                if (arr[j]>arr[j+1]){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j]  =  temp;
                }
            }
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]+"\t");
        }
    }
}

选择排序
快速排序
插入排序
…

数组搜索相关的技术

二分搜索
分块查找
哈希表查找
…

数组的内存图

java内存分配：

栈：

方法运行时所进入的内存，变量也是在这里
堆

new出来的东西会在这块内存中开辟空间并产生地址
方法区

字节码文件加载时进入的内存
本地方法栈
寄存器

两个变量指向同一个数组

数组使用常见的问题

不要访问超过数组最大索引—否则出现数组访问越界异常

int[] arr = null

    System.out.println(arr);  //null
	System.out.println(arr.length);  //空指针异常

Debug工具的使用

DEBUG工具基本使用步骤：

①在需要控制的代码行左侧,点击一下,形成断点

②选择使用Debug方式启动程序,启动后程序会在断点暂停

③控制代码一行一行的往下执行

方法

方法是什么：

方法是一种语法结构，他可以把一段代码封装成一个功能，以便重复调用

提高代码的复用性
让程序的逻辑更清晰

方法定义、调用

方法完整格式

修饰符 返回值类型 方法名（形参列表）{
    方法体代码（需要执行的功能代码）
    return 返回值；
}

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

调用：

方法名（…);

方法的其他写法

方法定义时：返回值类型、形参列表、可以按照需求进行填写

修饰符 返回值类型 方法名（形参列表）{
    方法体代码（需要执行的功能代码）
    return 返回值；
}

public static void print(){
	System.out.println(Hello World);
	System.out.println(Hello World);
	System.out.println(Hello World);
}

如果方法不需要返回结果，返回值类型必须声明成void（无返回值），此时方法内部不可以使用return返回数据
方法如果没有参数，或者返回值类型声明为void可以称为五参数、无返回值的方法，以此类推。

方法使用的常见问题

方法的编写顺序无所谓。
方法与方法之间是平级关系,不能嵌套定义。
方法的返回值类型为void (无返回值),方法内则不能使用return返回数据,如果方法的返回值类型写了具体类型,方法内部则必须使用return返回对应类型的数据。
return语句下面,不能编写代码,因为永远执行不到,属于无效的代码。
方法不调用就不执行,调用时必须严格匹配方法的参数情况。
有返回值的方法调用时可以选择定义变量接收结果,或者直接输出调用,甚至直接调用;无返回值方法的调用只能直接调用一下。

方法案例

定义方法的技巧：

修饰符: public static (暂时固定的)
方法名称:自己取名,有意义,英文小写,驼峰模式。(有意义的名字即可)
方法体代码:完成自己需要写的功能代码即可。(具体需求具体实现)
    1.分析方法是否需要申请返回值类型 2.分析方法是否需要接受参数


//使用方法计算1~n的和并返回
package com.wuxibin.Demo01;

public class MethodText {
    public static void main(String[] args) {
        int s = sum(3);
        System.out.println(s);
    }
    public static int sum(int n){
        int sum = 0;
        for (int i = 0 ; i <= n; i++){
            sum += i;
        }
        return sum;
    }
}

//拿一个整数，把整数交给方法，在方法中输出改数是奇数还是偶数

package com.wuxibin.Demo01;

import java.util.Scanner;

public class MethodText {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数：");
        int data = sc.nextInt();
        up(data);
    }

    public static void up(int n){
        if (n%2 == 0){
            System.out.println("该数是偶数");
        }else
            System.out.println("该数是奇数");
    }
}

//	把找出数组的最大值案例，改造成支持返回任意整型数组的最大值数据

package com.wuxibin.Demo01;

import java.util.Scanner;

public class MethodText {
    public static void main(String[] args) {
       int[] ages = {23,55,19,78,34};
       int max = getArray(ages);
        System.out.println("最大的数据是："+max);
    }

    public static int getArray(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (max < arr[i]){
                max = arr[i];
            }
        }
        return max;
    }
}

方法的参数传递机制

基本类型的参数传递:

java的参数传递机制：值传递
在传输实参给方法的形参的时候，并不是传输实参变量本身，而是传输实参变量中存储的值，这就是值传递



package com.wuxibin.Demo01;

public class MethodText {
    public static void main(String[] args) {
        int a = 10;
        change(a);
        System.out.println(a);//10
    }

    public static void change(int a){
        System.out.println(a);//10
        a = 20;
        System.out.println(a);//20
    }
}

引用类型的参数传递:

package com.wuxibin.Demo01;

public class MethodText {
    public static void main(String[] args) {
        int[] arr = new int[]{10,20,30};
        change(arr);
        System.out.println(arr[1]);//222
    }

    public static void change(int[] arr){
        System.out.println(arr[1]);//20
        arr[1] = 222;
        System.out.println(arr[1]);//222
    }
}

方法的参数传递案例

设计一个方法用于输出任意整型数组的内容，要求输出成如下格式：
“该数组内容：[11,22,33,44,55]”

package com.wuxibin.Demo01;

import java.util.Scanner;

public class MethodText {
    public static void main(String[] args) {
        //打印任意整型的数组
        int[] arrs = new int[]{11,22,33,44,55};
        printArray(arrs);

        System.out.println("-------------");
        int[] number = {1,3,56,76,43};
        printArray(number);

        int[] number1 = null;
        printArray(number1);
    }

    public static void printArray(int[] arr){
        System.out.print("[");
        if (arr != null && arr.length > 0){
            for (int i = 0; i < arr.length; i++) {
            /*if (i == arr.length - 1){
                System.out.print(arr[i]);
            }else {
                System.out.print(arr[i] + ",");
            }*/
                System.out.print(i == arr.length -1 ? arr[i] : arr[i]+ ",");
            }
        }
        System.out.println("]");
    }
}

设计一个方法可以接受整形数组，和要查询的元素值；最终要返回元素在改素组中的索引，如果数组中不存在该元素则返回 -1；

package com.wuxibin.Demo01;

import java.util.Scanner;

public class MethodText {
    public static void main(String[] args) {
        int[] number = {12,34,56,67,98};
        int index = searchIndex(number,98);
        System.out.println("该数据的索引是："+ index);
    }


    public static int searchIndex(int[] arr,int data){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == data){
                return i;
            }
        }
        return -1;
    }
}

如果两个数组的类型，元素顺序和内容是一样的我们就认为这2个数组是一模一样的
例如：如下2个数组是一样的
int[] arrs = {10,20,30}
int[] arrs = {10,20,30}
请使用方法完成：能够判断任意两个整型数组是否一样，并返回true或者false。


package com.wuxibin.Demo01;

import java.util.Scanner;

public class MethodText {
    public static void main(String[] args) {
        //判断两个整型数组是否一样
        int[] arr1 = {10,20,30};
        int[] arr2 = {10,20,30};
        System.out.println(compare(arr1, arr2));
    }

    //定义一个方法，有两个整型数组，返回值类型是布尔类型
    public static boolean compare(int[] arr1,int[] arr2){
        //判断两个数组是否一样
        for (int i = 0; i < arr1.length; i++) {
            if (arr1.length == arr2.length){
                if (arr1[i] != arr2[i]){
                    return false;
                }
            }else {
                return false;
            }
        }
        return true;
    }
}

方法重载

同一个类中，出现多个方法名称相同，但是形参列表不同，这些就是方法重载
形参列表不同指的是：形参的个数、类型、顺序不同，不关心形参的名称。

单独使用return关键字

return 可以立即跳出并结束当前方法的执行；return关键字可单独使用在方法中

d main(String[] args) {
int[] number = {12,34,56,67,98};
int index = searchIndex(number,98);
System.out.println(“该数据的索引是：”+ index);
}

public static int searchIndex(int[] arr,int data){
    for (int i = 0; i < arr.length; i++) {
        if (arr[i] == data){
            return i;
        }
    }
    return -1;
}

}


```java
如果两个数组的类型，元素顺序和内容是一样的我们就认为这2个数组是一模一样的
例如：如下2个数组是一样的
int[] arrs = {10,20,30}
int[] arrs = {10,20,30}
请使用方法完成：能够判断任意两个整型数组是否一样，并返回true或者false。


package com.wuxibin.Demo01;

import java.util.Scanner;

public class MethodText {
    public static void main(String[] args) {
        //判断两个整型数组是否一样
        int[] arr1 = {10,20,30};
        int[] arr2 = {10,20,30};
        System.out.println(compare(arr1, arr2));
    }

    //定义一个方法，有两个整型数组，返回值类型是布尔类型
    public static boolean compare(int[] arr1,int[] arr2){
        //判断两个数组是否一样
        for (int i = 0; i < arr1.length; i++) {
            if (arr1.length == arr2.length){
                if (arr1[i] != arr2[i]){
                    return false;
                }
            }else {
                return false;
            }
        }
        return true;
    }
}