1、函数定义：
函数就是定义在类中的具有特定功能的一段独立的小程序。
2、函数的特点：
- 可以将功能进行封装
- 对该功能进行复用，
- 函数只有被调用才会被执行
- 函数的出现提高的代码的复用性
- 对于函数没有具体返回值的情况，返回值类型用关键字void表示。那么该函数中的return语句如果在最后一行可以省略不写。
注意两点：
函数中只能调用函数，不可以在函数内部定义函数
定义函数时候，函数的结果应该返回给调用者，交由调用者处理。
函数的格式：
修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2，...)
{
执行语句；
return 返回值；
}
返回值的数据类型是由函数运行后的结果决定的
形参：是一个变量，用于存储函数调用时传递给函数的实际参数
实际参数：传递给形式参数的具体数值
return：用于结束函数
返回值 ： 该函数运算后的结果，该结果会返回给调用者。
对于函数没有具体返回值的情况，返回值类型使用关键字void表示， 如果该函数中的return语句如果在最后一行可以省略不写。
注意：
函数中只能调用函数，不可以再函数内部定义函数。
定义函数时，函数的结果应该返回给调用者，交给调用者处理。
函数在应用时需要明确
定义的函数最后的结果是什么
明确定义该功能的过程中，是否需要未知内容参与运算
定义一个函数实现两个整数相加
class FunctionTest {
public static void main(String [] args){
System.out.println(Sum(2,3));
}
public static int Sum(int a , int b){
return a+b;
}
}
此函数可以实现对Sum的调用
函数的重载
在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可
特点：
与返回值无关，只看参数列表
class FunctionTest {
public static void main(String [] args){
System.out.println(Sum(2,3));
System.out.println(Sum(2,3,4));
}
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;
}
}
数组定义：同一种类型数据的集合，其实数组就是一个容器。
数组的好处：可以自动给数组中的元素从0开始编号，方便操作这些元素。
格式：
格式1
元素类型[] 数组名 = new 元素类型 [元素个数或者数组长度]
例：
int [] arr =new int [6] //表示的是 该元素为 int型， 元素的长度为6 （结果为有7个元素，因为从0开始）
格式2
元素类型[] 数组名 = new [] { 元素，元素……};
例：
int [] arr =new int []{1，2，3}；
int [] arr= {3,5,7,9};
class ArrayDemo {
public static void main(String[] args) {
int[] arr=new int [6];
int[] arr2=new int[]{1,2,3};
int [] arr3= {3,5,7,9};
System.out.println(arr.length); // 打印数组长度 arr.length是默认的属性
System.out.println(arr2.length);
System.out.println(arr3.length);
}
}
数组在内存中的形式
数组在内存中是连续的
下表从0开始 //访问数组的某个数字时 可以使用arr(下标) 来实现 如[1,2,3,4] arr[0] 即表示该数组的第一个数1.
//数组的长度为 arr[length] 数组中的最大值为arr[length-1]
数组中无arr[length]这个数字，如果访问的话会报错 //ArraIndexOutOfBoundException :数组越界异常
内存结构：
java程序在运行时，需要在内存中分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈内存：
用于存储局部变量，当数据使用完后，所占空间会自动释放。
多线程：是指有若干段代码段同时并发运行，每个代码段都有自己的局部变量。
所谓的栈就是方法栈，方法栈对应的是线程，所以任何一个java程序都有对应的一个线程。就是主线程，就是main函数对应的线程。栈的数量就取决于并发执行线程的数量。每个线程就是一个栈。变量都存在方法中，方法调用的顺序。
压栈：
弹栈：
方法针：merthod frame
堆内存：（所有的对象都放在堆里面，相当于是堆是共享的）
java中一切都是对象，所有的对象都在堆当中，如果堆设置过小，对象会放不下去。
指针：java中没有指针，但是指的是没有显示的指针操作。(引用就是指针)
*d=&
NullPointerException是运行时异常(RuntimeException)
列示一句代码分解：
int[] arr = new int[5] ;
1、定义一个变量为int[] arr
2、new 是开辟空间，分配一段连续的内存。
3、把它们关联起来
总结：因此arr不叫对象，叫做引用或者指针。
如果arr=null //null 可以当成对象。就是在堆区里，‘=’是赋值的意思，就相当于赋值到空对象里
（因此对象被当成垃圾回收的前提条件是，当没有指针直接或者间接的到达它的话，它就被当成垃圾对象被回收。）
数组在内存中的形式
数组在内存中是连续的
下标从0开始 //访问数组的某个数字时 可以使用arr(下标) 来实现 如[1,2,3,4] arr[0] 即表示该数组的下标识，意思访问的是第0个元素，下标的最大值是arr[length-1]。new arr[0]表示的是各数。
//数组的长度为 arr[length] 数组中的最大值为arr[length-1]
数组中无arr[length]这个数字，如果访问的话会报错 //ArraIndexOutOfBoundException :数组越界异常
课堂练习：
（1）取数组中的最大值，然后在main函数中传递数组。得出它的最大值。
1、先封装一个方法
2、找最大值，返回值应该是int
class ArrMax{
public static void main(String[] x){
System.out.println(getMax(new int[0]));
}
pubilce static int getMax(int [] arr){
int temp = arr [0];
for(int i=0; i<arr.length; i ++){
if(temp < arr[i]){
temp = arr;
}
}
return temp;
}
}
（2）定义一个函数，从数组中查询指定的元素首次出现的位置。
（3）定义函数，完成冒泡排序，完成冒泡下沉。
数组常见操作：
1、或许最大值（最大值、最小值）
2、排序（选择排序、冒泡排序）
3、折半查找（二分查找） 折半查找 数据要有序
堆：heap
---------------
object heap
//数组处在堆区
// new建立的实例都处在堆内存中
//因为所有的对象都处在堆区中，所以如果堆设置的过小会放不下对象出现堆栈溢出（一般是栈溢出）
heap overflow 堆溢出
stack overflow 栈溢出
栈 stack
----------------
方法栈
方法栈至少对应一个线程（主线程main函数所在的线程）
栈中每一个方法叫做 一个方法帧 method frame
push stack : 压栈
pop stack :弹栈
java没有指针是指没有现实的指针操作。引用就是指针（变量的名称）
NullPointerException 是空指针异常（RuntimeException）//arr []=null; 属于运行时异常
内存结构：
java程序在运行时，需要在内存中分配空间，为了提高运算效率，有对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈内存：
用于存储局部变量，当数据使用完后，所占空间会自动释放。
多线程：是指有若干段代码段同时并发运行，每个代码段都有自己的局部变量。
所谓的栈就是方法栈，方法栈对应的是线程，所以任何一个java程序都有对应的一个线程。就是主线程，就是main函数对应的线程。栈的数量就取决于并发执行线程的数量。每个线程就是一个栈。变量都存在方法中，方法调用的顺序。
练习；取数组中的最大值，并封装
class ArrayMax{ //类的名称一定要和文件编译后的名称一样，否则运行会报错。
public static void main(String[] args) {
System.out.println(getMax(new int []{2,5,21,5,7}));
}
public static int getMax (int [] arr){
//从健壮性考虑，应该考虑到arr==null和arr.length 长度为0。
if (arr == null|| arr.length==0){ //短路与先判断大的再判断小的
System.out.println("数组不存在");
return -1; //当为这两种情况时，提示错误，并返回一个-1的结果。
}
int temp =Integer.MIN_VALUE; //Integer.MIN_VALUE是整数型数字的最小值
for (int i=0; i < arr.length ; i++ ){
if (temp < arr[i]){
temp = arr[i] ;
}
}
return temp;
}
}
Integer.MIN_VALUE 是int类型的包装类，integer 对应了整型值的最大值和最小值。
如果求数组中的最小值，之需要将Temp =Integer.MIN_MALUE换成---> Temp =Integer.MAX.MALUE, temp<arr(i)-->temp>arr(i)即可
对数组进行排序 （从小到大） 思想 迭代数组元素--查找最小值和最小值对应的角标--置换位置--返回数组--封装--调用
class ArraySelectSort{
public static void main(String[] args)
{
outArr(sort(new int []{2,1,6,4,9})); //调用数组
}
public static int[] sort(int[] arr){
if (arr == null|| arr.length == 0){ //排除为null和长度为0的情况
System.out.println("数组不存在");
}
//判断该数字往后的数字中的最小值
for (int i =0;i < arr.length ;i++ ){ //遍历数组中的所有数字
int aa=Integer.MAX_VALUE;
int index = 0 ; //定义角标的初始变量为0
for (int j= i + 1;j < arr.length;j++ ) {//遍历arr[i]数字后面的所有数字，求其中的最小值
if ( aa > arr [j]){
aa = arr [j]; //将较小的值赋值给Temp
index = j ; //获取较小值的角标
// System.out.println(aa) ;
}
}
//选出后面数字中的较小值时，如果比自身小，则调换位置
if (arr[i]>aa){
arr[index] = arr[i]; // 将arr[i]这个较大值赋值为arr[index],这里arr[index]充当一个中间量，此时arr[]为空
arr[i] =aa ; //然后将aa 赋值给已经是空值的arr[i] 实现两个数字的互换位置。
}
}
return arr; //返回arr 数组
}
public static void outArr (int [] arr){ //封装outArr 方法
for (int i = 0; i < arr.length ;i++ ){
System.out.print(arr[i]+" "); //打印 arr[i]这个数组
}
}
}
使用大数下沉的方式 进行冒泡排序
class BubbleSort{
public static void main(String[] args) {
outArr(bubble(new int[]{ 3,6,8,2,1,5,9}));
}
public static int[] bubble (int [] arr) { //定义函数数组
//大数下沉的方式
for (int i = 0;i < arr.length - 1 ;i++ ){ //外层循环次数 为arr.length-1
for (int j = 0;j < arr.length - 1 - i ;j++ ){ //n内层循环次数为 arr.length-1-i
int temp= 0; //定义一个临时变量 用来接收数据
//数据的对调（因为是大数下沉的方式）
if(arr[j]>arr[j+1]){
temp = arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
return arr; //返回数组
}
public static void outArr(int [] arr){ //封装方法
for (int i=0 ;i<arr.length ;i++ ){
System.out.print(arr[i]+" ");
}
}
}
打印倒置的二维数组
class MultiArray {
public static void main(String[] args) {
int [][] arr= new int[4][3]; //定义二维数组arr[4][3]
int a= 12; //定义一个数字从12开始
for (int i = 0;i<arr.length ;i++ ){ //定义外层函数 （有几个二维数组）
for (int j = 0;j<3 ;j++ ){ //定义内层函数（每个数组中有多少个元素）
arr [i][j] = a; //对第i行第j个元素赋值
a--; //自减1
}
}
outArr(arr); //调用
}
public static void outArr(int [][] arr){ //定义outArr 函数
for (int i = 0;i <arr.length ;i++ ){
for (int j=0 ;j< 3 ;j++ ){
System.out.print(arr[i][j]+"\t"); //打印arr[i][j]的数值
}
System.out.println();
}
}
}
打印一个三阶魔方
class MultiArray{
public static void main(String[] args) {
int[][][] arr = new int[3][3][3]; //定义一个三维数组
int aa= 0;
// 对三维数组中的每一个元素赋值。
for (int i = 0;i < arr.length ;i++ ){ //定义魔方的层数
for (int j = 0;j < arr[i].length ;j++ ){ //定义魔方的行数 ,J的取值最大是arr[i].length,因为arr[i]在三维数组中也是一个数组所以有值
for(int q = 0;q < arr[i][j].length;q++){//定义[i][j]即第几层第一行的魔方列数
arr[i][j][q]= aa ; //将aa变量赋值给[i][j][q]这个元素.
aa++; //变量自增1
}
}
}
outArray(arr); //输出数组
}
定义输出数组元素
public static void outArray(int[][][] arr){
for (int i = 0; i < arr.length ;i++ ){
for (int j = 0;j < arr[i].length ;j++ ){
for(int q =0;q < arr[i][j].length;q++){
System.out.print(arr[i][j][q]+"\t"); // 打印arr[i][j][q]元素的值，并增加一个空格 不换行
}
System.out.println(); //当输出完一行自动换行
}
System.out.println("********************");//当输出完一列后 打印分割线
}
}
}
面向对象：oop
最典型的面向过程编程是C语言。面向过程编程就是面向方法编程，把所有的机制封装成方法，c语言是方法调用方法。
面向对象编程
class 类，类是对象的抽象。对现实世界的事物的软件抽象。
object 对象 ， 对象的类的实例 ， new+类名
instance 实例，实例就是对象。
面向对象的特征：
1、封装
2、继承
3、多态
类的属性也叫成员变量
类的方法也叫成员函数
成员变量有默认的初始值。
局部变量没有默认的初始值。
构造函数特点：
1、没有返回值
2、函数名和类名相同
3、默认的构造函数是classname()
对象调方法，以.分隔。
show是方法。
static静态成员跟对象无关。访问静态成员只要通过类就可以。
属性都是私有的：private 提供相应的方法
this ： 关键字，对象内部指向自身的一个指针。
面向对象的特征：
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
类的属性也叫成员变量，
类的方法也叫成员函数。
成员变量：
定义在类中，整个类都可以访问
随着对象的建立而建立，存在于对象所在的 堆内存中
成员变量有初始化默认值
局部变量：
只存在于定义的局部范围内，如 函数，语句等
局部变量存在于栈内存中，
所用范围结束后，会立刻释放内存
无默认初始化值
构造函数 没有返回值 并且必须与类同名
函数的转置
class ArrayTrans{
public static void main(String[] args) {
int [][] arr={{1,2,3,},{4,5,6},{7,8,9,}}; //定义函数
out(arr); // 输出数组
System.out.println("*********************");// 为了对比效果 打印*来隔开
arr=trans(arr); //将trans 取arr数组的值
out(arr); //输出arr
}
//定义转置
public static int [][] trans(int [][] arr){
int temp = 0 ;
for (int i = 0; i<arr.length-1 ;i ++ ){ //定义数组的取值范围
for (int j = i+1; j < arr[i].length ;j++ ){ //定义数组列数
// 利用中间量的方法完成置换
temp = arr[i][j];
arr[i][j]= arr[j][i];
arr[j][i]= temp;
}
}
return arr;
}
//打印出arr[i][j]的值
public static void out(int[][] arr){ //定义out
for (int i = 0; i<arr.length ;i ++ ){
for (int j = 0; j < arr[i].length ;j++ ){
System.out.print(arr[i][j]+"\t"); //打印出arr[i][j]的值
}
System.out.println(); //换行
}
}
}