浅谈JAVA数组与对象

数组的定义： int [ ] array=new int[ ];
JAVA中数组在堆上。
如果数组不进行初始化，默认所有元素为0。
System.out.pritln(Arrays.toString(array)) ; //以字符串的形式打印数组。
二维数组 int [ ] [ ] array = new int [行数] [列数]，二维数组每个元素用{ }括起来，如：{(1,2),(3,4),(5,6)}

Arrays.deepToString(array);//打印二维数组
Arrays.sort(array);//给数组进行排序
Arrays.binarySearch(byte[] a, int fromIndex, int toIndex,  byte key)// 此处数组必须为有序数组

数组的拷贝，拷贝方式有：for , clone, System.arraycopy() , Arrays.copyof()
以上四种方式对于基本类型都为深拷贝，对引用类型为浅拷贝。
用for循环拷贝数组：

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] array1=new int[]{1,2,3,4,5,6};
        int[] array2=new int[array1.length];
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
        for(int i=0;i<array1.length;i++){
            array2[i]=array1[i];
        }
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}

用clone拷贝数组：

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] array1=new int[]{1,2,3,4,5,6};
        int[] array2=new int[array1.length];
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
        array2=array1.clone();
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}

用System.arraycopy()
无返回值
该方法速度最快

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] array1=new int[]{1,2,3,4,5,6};
        int[] array2=new int[array1.length];
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
        System.arraycopy(array1,0,array2,0,array1.length);
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}

用Arrays.copyof()拷贝
有返回值

import java.util.Arrays;

public class TestDemo {
    public static void main(String[] args) {
        int[] array1=new int[]{1,2,3,4,5,6};
        int[] array2=new int[array1.length];
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
        array2=Arrays.copyOf(array1,array1.length);
        System.out.println(Arrays.toString(array1));
        System.out.println(Arrays.toString(array2));
    }
}

面向对象的三大特征：封装性，多态性，继承性。
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程
类的组成：属性和方法。
对象属性初始化的方式： 1.提供一系列set. get方法。
2.通过构造函数。（构造函数也会发生重载）
3.静态代码块，实例代码块。

对象的产生需要：①.为对象开辟内存。
②.调用合适的构造函数。

封装性体现在private.

继承性。 用extends
class 子类 extends 父类
如：

class Person{
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
class Student extends Person{

}//实现了继承
public class TestDemo {
    public static void main(String[] args) {
        Student student=new Student();
        student.setName("小马哥");
        student.setAge(22);
        System.out.println("姓名："+student.getName()+'\n'+"年龄："+student.getAge());
    }
}

对子类进行扩充
需在上个代码定义子类处加入需要扩充的属性，且进行初始化。如下图：

向上转型：

class Father {
    public void printle(){
        System.out.println("爸爸");
    }
}
class Son extends Father{
    public void printle(){
        System.out.println("儿子");
    }
}
public class TestDemo{
    public static void main(String[] args) {
        Father f =new Son();
        f.printle();
    }
}//输出结果为“儿子”，发生了覆写

覆写（override）：函数名相同，参数列表相同，返回值相同
final：变量加上final后不能被修改，是用final定义的类不能有子类。