07-14

一 数组

1.1 数组概述

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bX2NhmdO-1626267663174)(C:\Users\77647\AppData\Roaming\Typora\typora-user-images\image-20210714092048430.png)]

注意:数组是相同类型的数的集合

array : 数组

1.2 数组的声明和创建

1.2.1 数组声明

dataType[] arrayRefVar;//首选的方法
datatype arrayRefVar[];//效果相同,但不是首选的方法

1.2.2 数组创建

dataType[] arrayRefVar=new dataType[arraySize];
int[] x = new int[10]//这里面可以存放10个int类型的数字,每个数字的默认值为0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q249guft-1626267663178)(C:\Users\77647\AppData\Roaming\Typora\typora-user-images\image-20210714094109600.png)]

1.3 三种初始化及内存分析

1.3.1 内存分析

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zCV2ii0p-1626267663182)(C:\Users\77647\AppData\Roaming\Typora\typora-user-images\image-20210714095155358.png)]

bound : 界限,范围 ; 弹跳 , 跳

exception : 例外

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-APuTSatg-1626267663184)(C:\Users\77647\AppData\Roaming\Typora\typora-user-images\image-20210714100144645.png)]

使用new创建的对象都是在堆中的

1.3.2 三种初始化

• 静态初始化

int[] a={10,300,50};//创建+赋值
Man[] men={new Man(),new man()};//Man为事先创建好的一个类

• 动态初始化:包含默认初始化

int[] b=new int[];

1.4 小结

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ubUSQNkj-1626267663185)(C:\Users\77647\AppData\Roaming\Typora\typora-user-images\image-20210714103241863.png)]

二 数组使用

package com.baidu;
//输出用户输入的数组的倒转
public class Array01 {
    public static void main(String[] args) {
        int[] array={10,20,30,50};
        for(int x:(reverse(array))){
        System.out.print(x+" ");
        }
        }
    public static int[] reverse(int[] array1){//数组array1作为形式参数
        int[] result=new int[array1.length];
        for (int i = 0; i < array1.length; i++) {
            result[i]=array1[(array1.length-1)-i];

        }
        return result;//数组作为返回值
    }
}

50 30 20 10

上面的代码可替换为

package com.baidu;

public class Array01 {
    public static void main(String[] args) {
        int[] array={10,20,30,50};
        for(int x:(reverse(array))){
        System.out.print(x+" ");
        }
        }
    public static int[] reverse(int[] array1){
        int[] result=new int[array1.length];
        for (int i = 0,j= array1.length-1; i < array1.length; i++,j--) {/*这个方法在此处更加精简*/
            result[i]=array1[j];

        }
        return result;
    }
}

三 多维数组

数组嵌套

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0BsAiXNj-1626267663187)(C:\Users\77647\AppData\Roaming\Typora\typora-user-images\image-20210714132156290.png)]

int[][] a={{1,2},{2,3},{3.4}}
a.length 表示的是最外层数组的长度

四 Arrays 类讲解

package com.baidu;

import java.util.Arrays;

public class Array02 {
    public static void main(String[] args) {
        int[][] a=new int[2][3];
        System.out.println(a);
    }
}


[[I@1b6d3586  //打印输出引用对象,输出的是这个引用对象的哈希编码

System.out.println(Array.toString(数组a))//使用系统类Arrays中的静态方法toString打印输出数组

在jdk帮助文档中,在索引框内输入我们想要搜索的类

五 冒泡排序

1. 比较数组中,两个相邻的元素,如果第一个比第二个数大,我们就交换他们的位置;
2. 每一次比较,都会产生出一个最大,或者最小;
3. 下一轮排序则可以少一次排序!
4. 依次循环,直到结束!

package com.newpackage;

import com.baidu.Array;

import java.util.Arrays;

public class SortArray {
    public static void main(String[] args) {
        int[] x1={60,8, 900,110,150};
        System.out.println(Arrays.toString(sort(x1)));
    }
    public static int[] sort(int[] array){
        boolean flag = true;
        int x =0;
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-i-1; j++) {
                if(array[j]>array[j+1]){
                    x=array[j];
                    array[j]=array[j+1];
                    array[j+1]=x;
                    flag=false;
                }
            }
            if (flag){
                break;//忘记使用break,退出循环;return用来结束函数.
            }
        }return array;
    }
}

六 稀疏数组

package com.newpackage;
//打印数组的两种方法
public class PrintArray {
    public static void main(String[] args) {
        int[][] x=new int[11][11];
        x[1][2]=1;
        x[2][3]=2;
        for (int i = 0; i < x.length; i++) {
            for (int j = 0; j < x[i].length; j++) {
                System.out.print(x[i][j]+"\t");
            }
            System.out.println();
        }
        System.out.println("===================");
        for(int[] arry1:x){
            for(int y: arry1){
                System.out.print(y+"\t");
            }
            System.out.println();
        }
    }
}

七 面向对象编程

7.1 初识面向对象

• 面向对象编程 : Object-Oriented Programming

• 本质:以类的方式组织代码,以对象的组织(封装)数据.

• 三大特性 : 封装 : 将代码数据装入一个盒子中,隐藏起来

  ​ 继承 :

  ​ 多态 : 对象调用同一个方法产生不同的结果

• 从认识论角度来说,先有对象,后有类;对象,是具体的类;类,是抽象的,是对对象的抽象.如婴儿先认识苹果,才知道水果.

• 从代码运行角度来说,先有类,后有对象

7.2 回顾方法的调用

• 两个同为静态或非静态(实列方法)的方法可以相互调用,而静态方法则无法调用非静态的方法.因为静态方法是属于类的,先有静态方法,后有非静态方法(实列方法).

• 要分清楚值传递还是引用传递