System.exit(0);//清空内存

练习2::定义功能,判断两个整数是否相同
练习3:定义功能,完成99乘法表


一 方法(函数)
1.1 函数概念Function
函数就是定义在类中的具有特定功能的一段独立小程序
方法是完成特定功能的代码块
函数也称为方法。

1.2 函数的作用
用于将代码进行封装(对功能进行封装),提高了代码的复用性
函数就是程序中一个独立的代码,实现了一个具体的功能

1.3 什么时候用函数
要定义功能时,就用函数(提高复用性)

1.4 函数的格式
[修饰符 n]  方法的返回值类型 方法名([参数列表 n]){         //方法体,带{}代表可以没有,写n代表有多个
        return ;如果有返回值类型必须有return                 //return 返回一个功能的结果给调用者，同时return的作用用来结束函数                               
}

public static 修饰符                对我们定义的内容进行修饰,增加其功能 相当于附属功能
void 返回值类型                        函数运行后的结果的数据类型。
main方法名                                自定义
(String[] args)                         方法的参数,可以没有,参数声明时可以有几个,都可以是什么类型?

                                                参数个数无限制,参数的类型可以是java的任意类型
                                                如果有多个参数,那么他们之间使用,逗号分开,并且每一个参数都要定义类型

参数类型        是形式参数的数据类型。
形式参数        是一个变量，用于存储调用函数时传递给函数的实际参数。
实际参数        传递给形式参数的具体数值。
return：用于结束函数。
返回值：该函数运算后的结果，该结果会返回给调用者。

举例:
为了提高加法运算的复用性,将运算单独封装成一个独立的功能,方便于日后的使用
        public static void main(String[] args)
        {       
                int x1 = add(4,6);
                int x2 = add(5,111111);
                System.out.println("x2="+x2);
        }
        public static int add(int a,int b)
        {
                int sum = a+b;
                return sum;
        }

举例:
老师是个功能:卖盒饭
想买盒饭要调用老师(有需求调用已有的功能)(盒饭定价不同 价格不确定 所以参数钱类型)
结果返回调用者(吃与不吃跟老师没关系)


        使用方法的注意事项:
                1.方法如果想要被执行,必须调用它//add();调用方法
                2.在类中我们可以有多个方法,方法是没顺序的,所有的执行都是从主方法开始的
                3.方法是不可以嵌套,其他方法与main是并列的,在java中方法要存在类体内出现(第一个大括号内),
                4.方法执行后回到方法的被调用处
                5.如果一个方法在声明时有参数,那么我们在调用时必须传参,而且类型要匹配
       
重点掌握:
                        1.方法的返回值类型
                        2.参数列表

1.5 参数列表
                参数列表
它是用来接收外部数据以完成方法的功能.
                参数声明时可以有几个，都可以是什么类型?

                        参数的个数无限制，参数的类型可以是java的任意数据类型。
                        如果有多个参数，那么它们之间使用 逗号(,)分开，并且每一个参数都要定义类型。
                        在调用方法时，如果方法有参数，必须传参，并且顺序要一致，类型要匹配.

        传参的过程
                先给值再调用5,6分别赋值给a,b 再调用
        实参(如5,6)
                在调用方法时传递的参数
        形参(如a,b)
                在声明方法时定义的参数        //调用方法的过程中是,将实参赋值给形参

                我们在声明方法时，什么时候需要参数?
                        当我们的方法完成功能时，是否需要外部数据参与。
                        如果需要外部数据就需要定义参数，如果不需要，那么就可以没有参数.
                        因为变量是有作用范围的，如果想在某个方法内使用其它范围的数据
1.6 void返回值类型
返回值类型
                如果一个方法没有返回值，那么必须声明成 void
                如果有返回值，可以声明成相应的类型，可以是java的任意类型
                如果有返回值，在方法体内必须有return关键字将值返回

void就代表没有返回值类型的情况
函数是一个功能，运算完就会有一个结果，用return关键字将结果返回给调用者。那么返回值类型就是结果的数据类型。
可是也有可能，功能运算完没有结果，这时该如何来体现返回值类型呢？
对于没有结果的情况，可以使用一个特殊的关键字来表示返回值类型，就是  void.

需求：对两个数进行求和，并将和打印。
那就意味着这个功能运算完是没有结果的。所以返回值类型时void。
特殊情况如果函数的返回值类型是void那么函数中的return语句 可以省略不写
如果返回值 是具体类型 必须写return 语句并跟上具体的返回值

特殊情况
如果函数的返回值类型是void，那么函数中的return语句，可以省略不写 不写，系统也会自动加上
如果有具体的返回值类型，那么函数中必须有return语句，并跟上具体的返回值

                void前:public private static final,

        怎样使用返回值类型
                1.在方法声明时定义返回值类型,类型是什么,要根据返回的具体值分析
                2.知道了返回值类型,我们先在方法体内声明一个与其类型匹配的变量来接受功能执行后的结果
                3.将这个变量返回 return 变量名;
                4.方法使用return返回后,我们可以在调用方发出接收方法的返回值 (如 int sum = add(5,6)伸手接收的过程)
简单说就是谁传的实参就返回给谁

                什么时候方法要有返回值
                        1.一般情况下,如果一个方法完成功能后,得到一个结果,这个结果我们需要在外部去使用.这是这个方法就需要有返回值
                        2.方法这需要执行不需要结果,或者结果不使用这个方法就可以没有返回值
                return 注意事项
                        return 下面不能在有语句
                        如果一个方法没有返回值类型，那么在方法内是否可以使用return
                        可以。这种操作一般情况都是让方法结束。

                 在定义方法时两个明确
                        1.明确参数    方法是否需要外部数据
                        2.明确返回值  方法执行后是否有结果，并且这个结果外部是否要使用。

使用函数的好处
        1.定义函数可以将功能代码进行封装
        2.便于对该功能进行服用
        3.函数只被调用时才被执行
        4.函数的出现提高了代码的复用性
        5.对于函数没有具体返回值类型用void表示,那么该函数中的return语句如果在最后一行可以省略不写

函数使用注意
        使用函数尽量简单,实现一个功能就用一个方法
1.7 函数的特点
定义函数可以将功能代码进行封装
便于对该功能进行复用
函数只有被调用才会被执行
函数的出现提高了代码的复用性
对于函数没有具体返回值的情况，返回值类型用关键字void表示，那么该函数中的return语句如果在最后一行可以省略不写。

注意：
函数中只能调用函数，不可以在函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交由调用者处理。
1.8 函数的应用
2个明确
明确1:明确该功能的运算结果
明确2:明确该功能实现过程中是否需要未知功能参与运算
字符串类型定义 String a = “xxx” (这个String是个类)

举例
需求：定义一个功能，可以实现两个整数的加法运算。
分析：
该功能的运算结果是什么？两个数的和，也是一个整数(int)
在实现该功能的过程中是否有未知内容参与运算？加数和被加数是不确定的。(两个参数int，int)
int  getSum(int x,int y)
{
return x+y;
}

二 函数重载
2.1 重载的概念
(简单理解同一个函数被重复载入)
在同一个类中，允许存在一个以上的同名函数，只要它们的参数个数或者参数类型不同即可

方法重载
        在一个类内具有相同的方法名，参数的个数，类型，类型排列顺序不同可以形成方法重载.
        方法的返回值类型不同不可以做为判断重载的条件。

方法重点掌握(Demo2.java)
                1.方法的返回值类型 (如 void)
                2.参数列表 (如 String) //它是用来接收外部数据以完成方法的功能

        方法举例
                public static void main(String[] args)
                        add(5,6);
                        add(1,2);
                public static void add(int a,int b)
                {
                        System.out.println(a+b);       
                }

方法重载
        在一个类内具有相同的方法名,不同的参数的个数,类型,(类型)的排列顺序,就形成方法重载//返回值类型不同不足以形成方法重载
        判断合法重载
                通过参数来判定是否可以合法重载,方法的返回值类型不可以作为判断重载的条件
        为什么要使用重载
                当一个功能需要不同实现时使用重载,方便与阅读,优化了程序设计
        想要形成一个重载条件
                调用时候能不能让程序区分开调用的是哪个方法
                       
Test6
1.定义一个方法,这个方法可以完成指定行数的图形的打印
2.定义一个方法,这个方法可以求两个数的结果,根据你传递的是 + - * / 这4个符号来求这两个数的值
2.2 重载的特点
与返回值类型无关，只看参数列表

2.3 重载的好处
方便于阅读，优化了程序设计。

函数名
函数名如果有多个单词组成 第一个单词首字母小写,从第二个单词看是每个首字母都大写
一看名称的写法就能看出函数和类

举例
int add(int x,int y){return x+y;}                                //返回两个整数的和
int add(int x,int y,int z){return x+y+z;}                //返回三个整数的和
double add(double x,double y){return x+y;}        //返回两个小数的和

学习一下，感谢分享！

3.4 数组的常见操作_最值
1获取最大值(最大值,最小值)
2排序(选择排序,冒泡排序)
3折半查找(二分查找)

数组中的数组
格式1：int[][] arr = new int[3][2];
定义了名称为arr的二维数组
二维数组中有3个一维数组
每一个一维数组中有2个元素
一维数组的名称分别为arr[0], arr[1], arr[2]
给第一个一维数组1脚标位赋值为78写法是：arr[0][1] = 78;

格式2：int[][] arr = new int[3][];
二维数组中有3个一维数组
每个一维数组都是默认初始化值null
可以对这个三个一维数组分别进行初始化
arr[0] = new int[3];
arr[1] = new int[1];
arr[2] = new int[2];

格式3：int[][] arr = {{3,8,2},{2,7},{9,0,1,6}};
定义一个名称为arr的二维数组
二维数组中的有三个一维数组
每一个一维数组中具体元素也都已初始化
第一个一维数组 arr[0] = {3,8,2};
第二个一维数组 arr[1] = {2,7};
第三个一维数组 arr[2] = {9,0,1,6};
第三个一维数组的长度表示方式：arr[2].length;

3.5 数组操作常见问题
数组操作常见问题 Demo7
        1.下标越界("补充下标越界提示")
                下标的范围 0~数组长度-1        //下标从0开始
                得到数组长度
                        数组名.length //得到一个int类型值,代表数组长度

        2.数组本身是引用类型(null是引用类型的默认值)
        堆内空间没有引用指向时变成垃圾
        arr=null;//让堆内存空间变成垃圾
        "空指针":引用没有指向任意堆内存的身体,补报错提示

        3.举例
                int arr=new int[100];
                arr[0];                        //取值
                arr[0]=982                //赋值
                arr[0到100-1];  //得到数组长度 .length
                arr=null;                //让堆内存空间变成垃圾

数组使用详细分析Demo8
//创建数组
        int[] arr = int [10];//开辟可以装入10个int数据的容器
//使用数组,通过下标操作
//取得某个元素的值
        int a = arr[3];
        System.out.println(a);
//对某个元素赋值
        arr[3]=100;
        System.out.println(a);


//要对数组中的元素进行简单赋值,将数组中的元素赋值成1,2,3

分析:知道数组的开始,结束(长度) 用循环

        for(int i=0 :i<arr.length:i++)
                arr[i]=1;

        "一提到数组,马上想到,for+下标"

数组练习 Test7
1.对数组中的元素进行随机赋值(1-100)
int[] arr=new int[];

//怎样得到随机数
1.import java.util.*;
2.得到随机数的方法 Random ran =new random();

数组练习 Test8
定义一个数组,数组中的元素随机赋值 1-100以内
统计数组中大于50的数的个数

分析:功能有几个
        1.赋值功能
        2.判断数组中元素值是否>50
数组操作练习 Test9
//定义一个数组,
        int[] arr={34,2,57,5,23,76,12};
        1.找出数组中的最大值
        2.找出数组中的最小值

        //最大值:
        方式1:
        使用max与min记录数组中元素的最大值与最小值
        定义一个变量max让他与数组中的所有元素进行比较
        如果小于,A就将数组中元素值赋给max
        将所有元素都遍历一次后max就记录的是数组中的最大值
        (MAX初始值不能为0)

        方式2:记录最大值最小值的下标(方式2 效率高些)
扩展知识:基本数据类型与引用数据类型内存分配Demo9
示例
class Demo9
{
        public static void main(String[] args)
        {
                int a=10;
                int[] arr=new int[]{10};

                change(a);
                change(arr);

                System.out.println(a);
                System.out.println(arr[0]);
        }

        public static void change(int a){               
                a=100;
        }

        public static void change(int[] arr){               
                arr[0]=100;
        }
}
附
面试题
函数面试题
如果一个方法没有返回值类型,那么在方法是否可以使用return//可以,这种情况一般都是让方法结束. 注意break是让循环结束,return是让方法结束

三 数组
3.1 数组的概念
数组:容器,用来装数据的使用数组我们将有关联的数据进行统一管理,这样就可以使用数组
同一种类型数据的集合。其实数组就是一个容器,它是用来数据。
使用数组我们是将有关联的数据进行统一管理，这样就可以使用数组。

数组的好处
可以自动给数组中的元素从0开始编号，方便操作这些元素
数组是引用数据类型,放在堆内存当中
3.2 数组的定义
怎样创建数组
        1.动态创建(Demo6重点掌握,开发中应用多)
                元素类型 数组名 = new 元素类型 [长度];//长度只能是int类型,可以是0
                        int[] arr = new int[5];//声明了一个可以装入5个int类型数据的数组

                        int-->数组中元素的类型
                        []-->一个数组
                        arr-->数组名

                        new-->开辟内存中空间,(在堆内存中开辟空间)
                        int-->元素的类型
                        [5]-->代表数组的长度为5,数组最多可以装入5个类型数据
                        "动态创建数组的内存图必会"
                        //当数组被创建后,其在堆内存中开辟空间,
                                1.空间是有首地址
                                2.堆内的元素有默认值,取元素类型默认"整形默认0 浮点0.0 char 空白 布尔型默认flase"

        2.静态(2种格式)
                        格式1(Demo5.java)
                        元素类型[] 数组名 = {元素1,元素2,....};
                        int[] arr = {3,5,1,7,8....};//我们将这些数据都放入到数组中,就可以对这些数据进行统一操作

                        格式2
                        元素类型[] 数组名 = new 元素类型[]{元素1,元素2,...}
                        int[] arr2 = new int []{1,2,3,4,5};

怎样操作数组(操作数组中的元素)
        通过下标来操作数组中的元素

        怎么使用下标
                数组名[下标]; //的到数组中指定位置上的元素
                       
        注意事项:
                使用下标操作数组元素,可以取值,赋值
                初学者错误:再对元素进行操作时不要再加类型了 如 int arr=[3] 就错啦
                以后一提到数组，马上想到  for+下标.

数组格式
格式1
元素类型[] 数组名 = new 元素类型[元素个数或数组长度];
示例：int[] arr = new int[5];

格式2
元素类型[] 数组名 = new 元素类型[]{元素，元素，……};
int[] arr = {3,5,1,7};                                //只能在给变量初始化的时候使用,不能作为参数传入方法
int[] arr = new int[]{3,5,1,7};                //任何地方都可以用,上面为简便方式,下面是完整写法

数组的内存分配及特点
Java程序在运行时，需要在内存中的分配空间。为了提高运算效率，有对空间进行了不同区域的划分
因为每一片区域都有特定的处理数据方式和内存管理方式。

数组的好处
        便于操作数据,对一些相关联的类型相同的数据进行统一管理与操作时就可以使用数组,沙盘军演

数组的特点:
        1.单一的,数组中的元素类型一致
        2.固定的,数组的长度固定
        3.顺序的,数组中的元素是有顺序的
3.3 数组的内存分配 栈&堆

                栈内存        用于存储局部变量,效率高//当数据使用完，所占空间会自动释放(沙盘演习)
                堆内存        数组和对象,这些实体在没有引用指向后会变成垃圾,当垃圾回收执行才被回收//通过new建立的实例都存放在堆内存中
                                每一个实体都有内存地址值
                                实体中的变量都有默认初始化值
                                实体不在被使用，会在不确定的时间内被垃圾回收器回收
                方法区        本地方法区，寄存器
                               
                栈和堆的区别
                                1.栈内存效率较高
                                2.栈内我们一般存储局部变量,当不在使用这些变量时,马上自动清理掉
                                3.堆内存储的是数组,对象,当这些数组对象不在使用时,不一定马上清理掉,变成垃圾,只有执行垃圾回收时这些才被清理掉
栈内存                        用于存储局部变量，当数据使用完，所占空间会自动释放。
堆内存                        数组和对象，通过new建立的实例都存放在堆内存中。
                                每一个实体都有内存地址值
                                实体中的变量都有默认初始化值
                                实体不在被使用，会在不确定的时间内被垃圾回收器回收
方法区                        本地方法区，寄存器

数组操作常见问题
数组脚标越界异常        空指针异常

数组定义方式
动态初始化方式
静态初始化方式