Java基础知识第二篇-CSDN博客

注：部分代码演示如果因长度问题观看不便利，可粘贴到idea中观看

一、数组进阶

1、数组的默认值

int[] arr1 = new int[3];

System.out.println(Arrays.toString(arr1));

int类型，输出结果为[0,0,0]

boolean[] arr2 = new boolean[3];

System.out.println(Arrays.toString(arr2));

boolean类型，输出结果为[false,false,false]

String[] arr3 = new double[3];

System.out.println(Arrays.toString(arr3));

String类型，输出结果为[null,null,null]

2、数组的长度

数组一旦创建长度将不可改变，如果想要扩容或者删减数组只能创建一个新数组并进行数组赋值的操作。

3、数组当返回值

public static void main(String[] args) {

System.out.println(Arrays.toString(fanZhuan()));

}

public static int[] fanZhuan(){
    int[] arr ={1,2,3,4,5};
    int[] newArr = new int[5];
    for (int i = 0; i < arr.length; i++) {
       newArr[i] = arr[arr.length - i - 1];
    }
    return newArr;
}

数组可以当方法的返回值类型，因为数组本身是一种引用类型

public static void main(String[] args) {

int[] arr = new int[]{22, 33, 44, 55};

printArr(arr)；

}

public static void printArr (int[] arr) {

for (int i = 0; i < arr.length; i++) {

System.out.println(arr[i]);

}

数组可以当方法的参数，把数组的实参传递给方法中的形参

二、排序算法

冒泡排序与选择排序是有必要学习的

1、冒泡排序

int[] arr = {3,5,1,4,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];

arr[j] = arr[j + 1];

arr[j + 1] = temp;

}

System.out.println(Arrays.toString(arr));*/

冒泡排序是两两交换，核心思想是将大的元素不断的向前挪最终变成升序排列

/*
* 第一轮
* i=0 0<4 true 》
*   j=0 0<4 true arr[0] > arr[1] false {3,5,1,4,2} j++
*   j=1 1<4 true arr[1] > arr[2] true {3,1,5,4,2} j++
*   j=2 2<4 true arr[2] > arr[3] true {3,1,4,5,2} j++
*   j=3 3<4 true arr[3] > arr[4] true {3,1,4,2,5} j++
*   j=4 4<4 false i++
* 第二轮
* i=1 1<4 true 》
*   j=0 0<3 true arr[0] > arr[1] true {1,3,4,2,5} j++
*   j=1 1<3 true arr[1] > arr[2] false {1,3,4,2,5} j++
*   j=2 2<3 true arr[2] > arr[3] true {1,3,2,4,5} j++
*   j=3 3<3 false i++
*第三轮
* i=2 2<4 true
*   j=0 0<2 true arr[0] > arr[1] false {1,3,2,4,5} j++
*   j=1 1<2 true arr[1] > arr[2] true {1,2,3,4,5} j++
*   j=2 2<2 false i++
* 第四轮
* i=3 3<4 true
*   j=0 0<1 true arr[0] > arr[1] false {1,2,3,4,5} j++
* j=1 1<1 false i++
* 第五轮
* i=4 4<4 false 》循环结束
* */

冒泡排序的流程分析

2、选择排序

int[] arr = {7,4,3,5,1,2,6};

for(int i = 0; i < arr.length - 1; i++){

int minIndex = i;

for (int j = i + 1; j < arr.length; j++) {

if (arr[minIndex] > arr[j]) {

minIndex = j;

}

int temp = arr[minIndex];

arr[minIndex] = arr[i];

arr[i] = temp;

}

System.out.println(Arrays.toString(arr));

选择排序是找最小的元素的下标，然后和第一个数进行交换，然后再依次找剩余最小的按顺序交换，最终从小到大升序排列

第一轮：

比较第一次： 3 和 4比 3小 index=0

一直找最小值和最小值的下标

比较第二次: 3和 5 比 3小 index=0

比较第三次: 3和2 比 2小 index=3

比较第四次: 2和 1比 1小 index=4

开始交换 arr[0] 和 arr[4]===>[1,4,5,2,3]

第二轮:

比较第一次: 4和5比较 4 小 index=1

比较第二次: 4和 2比较 2小 index=3

比较第三次: 2和3比较 2小 index=3

开始交换 arr[1] 和arr[3]===>[1,2,5,4,3]

第三轮:

比较第一次: 5和4比较 4小 index=3

比较第二次: 4和3比较 3小 index=4

开始交换 arr[2]和arr[4]==>[1,2,3,4,5]

第四轮:

比较第一次: 4和5比较 4小 index=3

开始交换: arr[3] 和 arr[3]

选择排序的流程分析

三、数组拷贝

面向对象入门

int[] arr1 = {1,2,3,4};

int[] arr2 = new int[arr.length];

for(int i = 0; i < arr.length; i++){

arr2[i] = arr1[i];

}

System.out.println(Arrays.toString(arr2))

面向过程的拷贝,需要一步步手写

Arrays.copyof(拷贝的对象,新数组的长度)

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

int[] newArr = Arrays.copyof(arr,4);

System.out.println(Arrays.toString(newArr))

面向对象的拷贝,直接使用Arrays.copyof方法，就可以省去繁琐的过程把功能实现。

System.arraycopy(拷贝的对象,从第几个索引开始拷贝,要拷贝到的目标对象,从目标对象第几个索引开始放入数据,拷贝多少个)

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

int[] newArr = new int[5];

System.arraycopy(arr,3,newArr,0,5);

System.out.println(Arrays.toString(newArr));

更加精确的拷贝方法，System.arraycopy需要先创建一个数组然后进行指定。

四、数组扩容

public static void main(String[] args) {

int[] arr = {44,11,22,33};//容量为3

System.out.println("扩容前arr数组的内存地址：" + arr);

System.out.println("开始扩容");

int[] ints = grow(arr);

System.out.println("扩容后的arr数组的内存地址：" + ints);

System.out.println(Arrays.toString(ints));

}

public static int[] grow (int[] arr) {

int[] newArr = new int[arr.length * 3];

System.arraycopy(arr,0,newArr,0,arr.length);

return newArr;

}

数组的扩容本质上是创建一个新的数组设置长度并将原数组的内容拷贝进去。

五、数组的排序

Arrays.sort();

int[] arr = {5,8,2,7,9,1,4,6,34,7658,342};

Arrays.sort(arr);

System.out.println(Arrays.toString(arr));

使用Arrays.sort方法就可以直接将数组升序排列,不用再麻烦的用各种排序方法几十行代码的写。

六、面向对象编程

1、概念

重点：具有相似属性(变量)和行为(方法)的一系列东西统称为“类”！

类是模板，一个广泛的概念。

2、类的内容

类里面有属性和方法。

类创建出对象，对象由类创建（对象是类的实例）。

对象有属性和方法，且能表现出来。

3、创建类

带有mian方法的叫做主类，一般可以起名叫做demo或者test。

rat这样的类叫做实体类，一般单独成一个文件，文件名可以随意但是要见名知意。

public class rat {
    String name; //属性
    String color;
    String hobby;

    public void eat(){ //行为

        System.out.println("偷吃奶酪");
    }
    public void play(){
        System.out.println("戏耍tom");
    }
}

4、创建对象

语法格式:

类名对象名 = new 类名();

rat cartoonRat = new rat();

创建对象的语法格式,一个类可以创建多个对象

语法格式：

对象名.属性名 = 值

cartoonRat.name = “jerry”;

cartoonRat.color = "灰色";
cartoonRat.hobby = "找汤姆玩";

System.out.println(cartoonRat.name);
System.out.println(cartoonRat.color);
System.out.println(cartoonRat.hobby);

为属性赋值

语法格式:

对象名.方法名();

cartoonRat.eat();

cartoonRat.play();

调用行为

5、类可以创建多个对象

public class Test{

public static void main(String[] args) {

/***

* - 一个类可以创建多个对象

* - 对象和对象之间没有关系

* - 每个对象都拥有属于自己的属性和方法

// 创建第1个对象

Phone p1 = new Phone();

p1.brand = "OPPO";

p1.price = 2999.0;

System.out.println(p1.price );// 2999.0

System.out.println(p1.brand );// OPPO

System.out.println("------------" );

// 创建第2个对象

Phone p2 = new Phone( );

System.out.println(p2.brand );// null

System.out.println(p2.price );// 0.0

// p1和p2对象没有任何关系

// p1和p2对象都有属于自己的属性和方法

}

6、多个引用指向一个对象

public static void main(String[] args) {

Phone p1 = new Phone( );

Phone p2 = p1;

//此时,p1和p2都是引用且都指向一个对象

p1.price = 3999.0;

System.out.println(p2.price );// 3999

}

七、对象内存

一个对象内存

代码是先编写后编译
执行时类加载进内存
方法执行进栈
new出来的对象都会进堆
堆中创建对象时，开辟空间——》分配地址——》属性和方法初始化给默认值（例如int类型默认为0，String引用类型默认为null）
使用对象名调用属性和方法时，其实时通过地址值找到堆中的对象中的属性和方法

多个对象内存

一个类可以创建多个对象
对象和对象之间没有关系
每个对象都有属于自己的属性和方法

八、成员变量和局部变量

1、成员变量是在类当中，在方法外的变量。作用于类中所有方法，存在堆里。

2、局部变量是在方法内的变量。仅作用于方法内出方法就无效，存在栈里。

3、特殊的,局部变量可以和成员变量重名,重名时,默认方法内使用自己的局部变量即**就近原则**但是,当重名时,就指定使用成员变量,可以使用this来指代,因为this是当前类对象