四、数组定义/冒泡排序的理论/什么是方法

数组

结构

形式一：int[] students = new int[300]

形式二：int students[] = new int[300]

• 数组的使用：数组名【下标】–>数组元素

• 四要素：数组名 下表 类型 数组元素

• 数组的类型和数组元素的类型一致（兼容）

什么时候用数组

当多个元素类型相同，考虑用数组

数组长度一旦定义，则不能改变

数组的定义

• int[] students = new int[]{97,98,99} ;//可拆

• int[] students = {97,98,99} ;//此种形式不可以拆开写

数组的长度students.length;

左右两侧的类型必须一致，但是数据值只需要兼容（类型范围本身比其小的类型）即可

冒泡排序流程

冒泡排序
    2  12  4   20  1
冒泡排序流程：
第一趟：当前>下一个，如果是：交换
  a,2  4<->12  20  1
  b,2  4   12  1   [20]
第一轮比较完毕可以得到一个最大值
第二趟：
  a.2  4   1  [12]  [20]
第三趟：
  a.2  1  [4] [12]  [20]
第四趟：
  a.1 [2] [4] [12]  [20]
    总结：几轮？
    元素个数--->轮数
    5->4
    4->3
    3->2
    2->1
    1->0
    n->(n-1)
    每轮内部规则是什么

冒泡排序重要结论

n个元素排序，排n-1轮结束

二维数组

int[] [] cities = {{1,2,3},{1,2,3},{1,2,3}};

对象数组

Student[] students = new Student[]{stu1,stu2,stu3};

一个数组里面数组的元素是对象叫对象数组

方法

方法的定义

在面向对象编程中，将“具体”称为“对象”，将“抽象”称为“类“

多个对象，可以抽象出类

类和对象的组成部分：

​ 静态：属性 身高，体重，年龄

动态（功能）：方法 吃饭，睡觉

类可以细分，但细分的产物并不一定是对象

结构

类 对象 = new 类（）；

Persion zs = new Person() ;

方法是多个对象共享的

属性是各个对象独有的

Person zs = new Person() ;

一般而言，对象 是指堆中的东西new Person()。

栈里面的 称位引用 zs（持有对象的内存地址）

但是根据Everything is an Object来说zs也是对象

new:实例化

对象使用前必须先实例化（new）

static的调用常见情况

同一个类中

static:静态方法

都有static，|或者都没有static |,或没static的掉有static的：直接调用\

有static不能直接调用 没有static的方法！！

不同的类

万能方法：new p 然后p.方法

如果被调用类有static可以直接用类名.方法名调用！

static方法是类级别的

非static方法是对象级别的

返回值

有返回值

pubilc 返回值类型 方法名(){

​ return 类型对应的数据;

}

调用有发牛只的方法时，需要接收返回值

package method;

public class MethodReturn {
    public String a1() {
        String name = "zs";
        System.out.println(name);
        //返回值
        return name;
    }

    public void b() {
        //接收
        String name = a1();
        System.out.println("c" + name);
    }

    public static void main(String[] args) {
        MethodReturn method = new MethodReturn();
        method.b();
    }
}

无返回值（返回值为void）

package method;

public class MethodReturn {
    public void a() {
        System.out.println("张三");
    }
    public void b() {
        a();
    }
    public static void main(String[] args) {
        MethodReturn method = new MethodReturn() ;
        method.b();
    }
}

面向对象编程：类和对象、将功能独立的写的写在方法中

参数

有参

单参

package method;
public class People {
    //形参
    public void sleep( String name){
        System.out.println( name+"睡觉");
    }
    public static void main(String[] args) {
    People zs = new People() ;
    zs.sleep("张三");
    //实参
    People ls = new People() ;
    ls.sleep("李四");
    }
}

参数越多越个性化

package method;
public class People {
    //形参
    public void sleep( String name,String place,String time){
        System.out.println( name+place+"睡觉--"+time);
    }
    public static void main(String[] args) {
    People zs = new People() ;
    zs.sleep("张三","山东","20:23");
    //实参
    People ls = new People() ;
    ls.sleep("李四","黑龙江","19:23");
    }
}

数组简化参数

多个元素的类型相同–>数组

package method;

public class People {
    //形参
    //数组 infos = {name,place,time}
    public void sleep( String [] infos){
        System.out.println(infos[0]+infos[1]+"睡觉--"+infos[2]);
    }
    public static void main(String[] args) {
    People zs = new People() ;
    //创建参数数组
    String[] lsinfos ={"张三","家里","23：23"} ;
    zs.sleep(lsinfos);
    }
}

多个元素类型不同–> 类/对象

1. MyInfo.java

package method;
public class MyInfo {
    String name ;
    String place;
    int time ;
}

2. People.java

package method;
public class People {
    //形参
    //数组 infos = {name,place,time}
    public void sleep( MyInfo myInfo){

        System.out.println(myInfo.name+myInfo.place+"睡觉--"+myInfo.time);
    }
    public static void main(String args[]) {
        MyInfo info = new MyInfo() ;
        info.time = 23 ;
        info.place = "上海" ;
        info.name = "李四" ;
       People ls = new People() ;
        ls.sleep(info);
    }
}

无参

package method;

public class People {
    public void sleep(){
        System.out.println("睡觉");
    }

    public static void main(String[] args) {
        People zx = new People() ;
        zx.sleep();
        People ls = new People() ;
        ls.sleep();
    }
}