类和对象以及数组工具类的常用方法

一、类和对象

1、对象没人引用时，会被自动回收
2、对象一定在堆上，引用变量不一定在栈上
3、this表示当前对象的引用，谁调用eat方法(eat方法里有this)，谁就是this。this.data访问当前对象的属性，this.func()访问当前对象的方法
4、初始化对象成员变量和给对象成员变量赋值的区别，运用构造方法(该方法没有返回值类型，方法名和类名相同)初始化对象成员变量。用this()调用当前类当中的其它构造方法，()中可有参数，看()中的参数匹配到哪个构造方法则调用哪个构造方法，只能在当前的构造方法内部使用，只能放在第一行。可用idea生成构造方法，鼠标右击找到Generate，再点击Constructor
5、类中没有package语句，则该类被放到一个默认的包中，这个默认的包是src。default(默认包访问权限)，如成员变量前没有加访问修饰限定符，同一个包下的不同类之间可以相互访问这个成员变量(这个是default的最大访问权限)
6、静态成员变量和静态成员方法(static修饰，也叫类变量和类方法，static不能修饰局部变量)，通过类调用(类.×××)，不依赖于对象。静态方法内部不能直接调用非静态成员方法(调用则要new一个对象，再通过对象的引用调用)或者直接调用非静态成员变量，static修饰的方法里面不能使用this，因为静态成员变量和静态成员方法不依赖于对象，而this是当前对象的引用。非静态方法内部能直接调用静态成员方法。非静态方法之间可以直接调用。
7、成员变量(属性、字段)，成员方法(行为)。
8、静态成员变量一般不放在构造方法中来初始化，构造方法中初始化的是与对象相关的实例属性。用静态代码块(static加花括号)对静态成员变量进行初始化，静态代码块在类里面，方法外面。先执行静态代码块，再执行构造代码块(实例代码块)，再执行构造方法，静态代码块只执行一次。静态代码块只要类被加载就会被执行，构造代码块(实例代码块)实例化对象的时候才会被执行。

class Student{
    
    
    private String name;
    private String gender;
    private static String classRoom;
    //实例代码块
    {
    
    
        this.name = "ZhangSan";
        this.gender = "man";
        System.out.println("instance");
    }
    //静态代码块
    static {
    
    
        classRoom = "4";
        System.out.println("static");
    }
    public Student(){
    
    
        System.out.println("Student init");
    }
    public static void main(String[] args) {
    
    
        Student s1 = new Student();
        Student s2 = new Student();
    }
}

9、package语句用于说明本文件处于哪个包当中
10、实例化对象时。父类静态代码块先于子类静态代码块执行，静态代码块先执行且只执行一次；然后执行父类构造代码块(实例代码块)和父类构造方法；最后执行子类构造代码块(实例代码块)和子类构造方法。先执行父类和子类静态的，再执行父类的实例和父类的构造，最后执行子类的实例和子类的构造
11、final修饰变量后，变量变成常量，常量不能被修改，如final修饰数组名，则数组名这个引用变量中存储的值(地址)不能被修改；final修饰的类叫密封类，密封类不能被继承
12、protected修饰，访问不同包之间的子类(这个是protected的最大访问权限)
13、组合：如在一个类当中用其它类作为类型定义变量(在类中用别的类型的对象作为成员)。能用组合尽量用组合
14、实例化对象(new Base())时相当于调用了一个构造方法
15、new Rect()是匿名对象，匿名对象的缺点是每次使用都要重新实例化

Rect rect = new Rect();
rect.draw();
rect.draw();
new Rect().draw();
new Rect().draw();//每次使用都要重新实例化

16、一个类生成一个字节码文件，每个内部类都有自己的字节码文件

class OuterClass{
    
    
        class InnerClass{
    
    //实例内部类
        }
        static class InnerClass2{
    
    //静态内部类
        }
    }
    interface A{
    
    
        void testA();
    }
    public class Test{
    
    
        public static void main(String[] args){
    
    
            A a＝new A(){
    
    
                @Override
                public void testA(){
    
    
                    System.out.println("hello");
                }
            };//匿名内部类，即没有名字的内部类，实现了A接口并重写了A接口中的testA方法
            a.testA();
        }
    }

局部内部类只能定义在方法内部，不能被public static等访问限定符修饰，只能在方法内部使用，局部内部类几乎不会被使用
17、实例内部类
(1)在不是外部类的其它类中获取实例内部类对象时，要依赖外部类对象，以下是获取实例内部类对象的两种方法

Outclass outClass = new Outclass();
Outclass.InnerClass innerClass1 = outClass.new InnerClass();//方法1
Outclass.InnerClass innerClass2 = new Outclass().new InnerClass();//方法2

(2)在实例内部类中，要定义静态的成员变量，则必须加上final，因为static修饰的变量不依赖于对象，而在不是外部类的其它类中获取实例内部类对象时，要依赖外部类对象，造成矛盾，(内部类相当于外部类的普通成员变量，类加载的时候不会加载普通的成员变量，实例内部类中又存在static，而static是在类加载的时候创建的，造成矛盾)加上final后final修饰的是常量，而这个常量不需要类加载，编译时就能知道data的值是6

public static final int data = 6;

(3)实例内部类和外部类的成员变量同名时，在实例内部类的成员方法中访问自己的成员变量和访问外部类的成员变量(实例内部类里面是包含外部类的this的)

class Outclass {
    
    
    public int data1 = 1;
    class InnerClass {
    
    
        public int data1 = 11;
        public void test() {
    
    
            System.out.println(this.data1);
            System.out.println(Outclass.this.data1);
        }
    }
}
class Test1 {
    
    
    public static void main(String[] args) {
    
    
        Outclass.InnerClass innerClass2 = new Outclass().new InnerClass();
        innerClass2.test();
    }
}

打印结果是：

(4)外部类的成员可以在实例内部类方法中直接访问(外部类成员和实例内部类成员不同名时)
(5)外部类中，不能直接访问实例内部类中的成员，如果要访问必须要获取实例内部类的对象(注意与(1)获取实例内部类对象的区别)
以下是外部类的某个成员方法：

public void test(){
    
    
    InnerClass innerClass = new InnerClass();
    System.out.println(innerClass.data);
}

18、静态内部类
(1)在不是外部类的其它类中获取静态内部类对象时，不用依赖外部类对象

OuterClass.InnerClass innerClass = new OuterClass.InnerClass();

(2)在静态内部类的成员方法中访问外部类的非静态成员变量，要new一个外部类对象，通过这个外部类对象访问外部类的非静态成员变量(即拿外部类对象访问外部类的非静态成员变量)。在静态内部类的成员方法中可以直接访问外部类的静态成员变量
在静态内部类的成员方法中访问外部类的非静态成员变量：

public void test(){
    
    
    OuterClass outerClass = new OuterClass();
    System.out.println(outerClass.data);
}

19、匿名内部类
匿名内部类中能访问的是没有被修改的数据(变量的捕获)，默认在匿名内部类中能访问的被final修饰的常量

int val = 10;
    //val = 100;加上这句之后匿名内部类使用val会报错
    A a = new A(){
    
    //在匿名内部类中重写A类中的test方法
        @Override
        public void test(){
    
    
            System.out.println(val);
        }
    };
    //val = 100;加上这句之后匿名内部类使用val也会报错，因为是全局编译，这句放在这后面也不行

二、数组工具类的常用方法

Arrays.sort(arrays);//数组排序，arrays是数组名，即数组的引用

System.out.println(Arrays.toString(arrays));//将数组转换为字符串输出

int[] copy = Arrays.copyOf(array，array.length*2);//拷贝array数组，拷贝的长度为array.length*2，如果拷贝的长度太长则扩容
int[] copy = Arrays.copyOfRange(array，1，3);//拷贝array数组中1到3下标的内容，但因为Java[1，3)，所以拷贝到的只是1下标和2下标的内容，如果拷贝的长度太长则扩容

System.out.println(Arrays.binarySearch(array，15));//Arrays工具类实现的二分查找，在数组中找15
Arrays.binarySearch(int[] a, int fromIndex, int toIndex, int key)//在数组指定范围内进行二分查找

boolean flg = Arrays.equals(array1，array2);//比较两个数组对应下标的数据是否一样

int[] arr = new int[]{
    
    1, 2, 3};
Arrays.fill(arr, -1);//帮数组填充数据，这里将数组内容全部填充(这里是修改)为-1
fill(int[] a, int fromIndex, int toIndex, int val)//在数组指定范围内进行填充，指定的范围是[)