Day011

恶心人双体，一堆事情没做

源码

equals

  • instanceof 判断是否为统一类型

import com.zhangjunlong.www.*;
public class MyTime {
    public static void main(String[] args) {
        mytime m=new mytime(2000,2,5);
        mytime n = new mytime(1999,1,9);
        mytime b = new mytime(1999,1,9);
​
​
        System.out.println(b.equals(n));
​
    }
​
}
​

image-20210422091819580

再改 精简

image-20210422092007168

package com.zhangjunlong.www;
​
import java.util.Objects;
​
​
public class mytime
{
    private int year;
    private int mouth;
    private  int day;
​
    public mytime(int year, int mouth, int day) {
        this.year = year;
        this.mouth = mouth;
        this.day = day;
    }
​
​
​
    public void setYear(int year) {
        this.year = year;
    }
​
    public void setMouth(int mouth) {
        this.mouth = mouth;
    }
​
    public void setDay(int day) {
        this.day = day;
    }
​
    @Override
    public String toString() {
        return "mytime{" +
                "year=" + year +
                ", mouth=" + mouth +
                ", day=" + day +
                '}';
    }
​
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        mytime mytime = (mytime) o;
        return year == mytime.year && mouth == mytime.mouth && day == mytime.day;
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(year, mouth, day);
    }
}
​

String

中有重写ToString 和equals

  • 比较两个字符串不能使用双等号

  • 必须调用equals方法

    String类已重写ToString和equals方法

    大结论

    java中数据类型比较使用“==”

    java中所有引用数据类型统一使用equals方法来判断是否相等

     

练习

equals方法的编写模式是固定的，架子差不多

String 属于引用数据类型

s1.equals(s2)
  

111111111

  • ToString（）方法需要重写

System.out.pintln(引用)自动调用“引用”的tostring（）方法

string这个类是sun公司写的，tostring方法已重写

  • equals（）方法

比较所有类的equals方法也需要重写，因为Object中的equals方法比较的是两个对象的内存地址

我们应该比较内容，所以需要重写

基本数据类型比较使用：==

对象和对象比较：调用equals方法

String类是sun编写的，所有String类的equals方法重写了

以后判断两个字符串是否相等，最好不要使用==。要调用字符串对象的equals方法

equals方法重写要彻底、 多个

public boolean equals（Object obj）{
    if((obj==null)||!(obj instanceof User))return false;
    if(this==obj) return true;
    User u=(User)obj;
    if(this.name.equals(u.name))&&this.addr.equals(u.addr){
        return true;
        
    }
    return false;
}

多态：父类型的引用指向子类型的对象

Object o1 = new String（"hello world "）;

注意equals方法要重写彻底

finalize方法（非重点 了解）

源代码

protected void finalize () throw Throwable{}

  • GC：负责调用finalize方法

  • finalize()方法只有一个方法体，里面没有代码，而且这个方法是protected修饰的

  • 这个方法不需要程序员手动调用

jvm的垃圾回收器负责调用这个方法

  • finalize（）方法的执行时机：当一个java对象即将被垃圾回收器回收时，垃圾回收器负责调用finalize（）方法

  • finalize（）方法实际上是sun公司为java程序员准备的一个时机，垃圾销毁时机

    如果希望在对象销毁时机执行一段代码的话，这段代码要写到finalize（）方法中

  • 静态代码块的作用：

static{

……

}

静态代码块在类加载时刻执行 ，并且只执行一次。这是一个sun准备的类加载时机

finalize（）方法同样也是sun为程序员准备的一个时机，这个时机是垃圾回收时机

项目开发中有这样的需求：所有对象在JVM中释放的时候，请记录一下释放时间！

这个负责记录的代码写在finalize（）方法中

提示：java中的垃圾回收器不是轻易启动的，

垃圾太少，或者时间没到，种种条件下，有可能启动也有可能不启动

有一段代码是可以建议垃圾回收器

System.gc();

(只是建议，可能不启动，也可能启动，启动的概率变高了，只是建议)

hashCode

public native int hashCode（）；

这个方法不是抽象方法，带有native关键字，底层调用C++程序

  • hashCode（）方法返回值是哈希码

实际上就是一个java对象的内存地址，经过哈希算法，得出的一个值

所以hashCode（）方法的执行结果可以等同看做一个java对象的内存地址

 

clone

protected native Object clone（） throwCloneNotSupportedException；

深克隆 浅克隆

匿名内部类

  • 内部类：在类的内部有定义一个新的类，被称为内部类

内部类的分类

  • 静态内部类：类似静态变量

  • 实例内部类：类似于实例变量

  • 局部内部类：类似于局部变量

由于该类在类的内部，所以被称为内部类

image-20210422114935435

  • 使用内部类编写的代码，可读性太差，能不用就尽量不用

  • 匿名内部类是局部内部类的一种

因为这个类没有名字而得名，叫做匿名内部类

image-20210422121309282

图中 new Compute（）{。。。。。。}都是匿名内部类创建的对象

不写接口实现类

这个表面看上去好像是接口可以直接new了，实际上并不是接口可以new，后面的{}代表了对接口的实现

不建议使用匿名内部类，没有办法重复使用，另外代码太乱，可读性太差

代码看着高端

idea 中纠正错误 alt+回车

文本编辑器 完结散花

使用idea工具开发

Alt+ insert 新建

 

数组

  • 数组是一种引用数据类型，不属于基本数据类型，数组的父类是Object

  • 数组实际上是一个容器，可以同时容纳多个元素（数组是一个数据的集合）

  • 数组中可以存储基本数据类型的数据，也可以存储引用数据类型的数据

  • 数组因为是引用数据类型，所以数组对象是堆内存当中的。

  • 数组在内存结构

image-20210422123504632

 

对于数组当中，如果存储的是java对象的话，实际上存储的是对象的引用（内存地址）

数组中不能直接存储java对象

  • 数组一旦创建，在java中规定，长度不可变（数组长度不可变）

  • 数组的分类：一维数组、二维数组、三维数组、多维数组……

  • 所有的数组对象都有length属性（java自带的），用来获取数组中元素的个数

  • java中的数组要求数组中元素的类型统一，

  • 数组在内存存储方面中，数组中元素内存地址是连续的。（存储的每一个元素都是有规律的挨着排列的）这是数组存储元素的特色。数组实际上是简单的数据结构

  • 所有的数组都拿“第一个小方框的内存地址”作为整个数组对象的内存地址（数组中首元素的数组地址作为整个数组对象的地址）

  • 数组中每一个元素都是有下标的，下标从0开始，从0开始，以1递增，最后一个元素是length-1。下标非常重要，因为我们对数组中元素进行存取的时候，都需要通过下标来进行

  • 数组这个数据结构的优缺点

优点：查询、查找、检索某个下标上的元素效率极高。

 

image-20210422125717621

缺点：

image-20210422160819295

  • 对于数组中最后一个元素的增删，是没有效率影响的

声明一个一维数组

语法格式：

int[] array1;

double [] array2;

boolean[]array3;

String[]array4;

Object[]array5;

初始化一个一维数组

静态初始化一维数组

int 【】array = {100，20000，23423}；

动态 初始化 语法格式：

int 【】 array = new int 【5】；//这里的5表示数组的元素个数

初始化一个5个长度int 类型 初始值为0；

 

所有的数组对象都有length属性

System.out.println(“数组中元素的个数”+a.length)；
    

通过下标对数组中的元素进行存取；

image-20210422161818240

一维数组遍历

for (int i =0; i< a.length;i++){
    System.out.println(a[i]);
    
}

每个类型的默认值

image-20210422162745090

  • 当创建数组的时候，确定数组中存储哪些具体元素时，采用静态初始化，

不确定将来数组中存储哪些数据时，采用动态初始化的方式，预先分配内存空间

 

main方法的编写方式，还可以采用c++的语法格式

 public static void main（String args[]）{}
printArray(new int[]{1,2,4});

image-20210422170132269

关于一维数组的扩容

在java开发中，数组一旦确定不可变，数组满了，需要扩容，

java中对数组的扩容：先新建一个大容量的数组，然后将小容量的数组中的数据一个一个拷贝到大数组当中。

结论：数组扩容效率较低，因为涉及到拷贝的问题，所以尽可能少的进行数组的拷贝，可以在创建数组对象的时候预估准确，减少数组扩容效率，提高效率、

拷贝

System.arraycopy(原数组，起始位置，目标数组，目标起始位置，拷贝多长)

CTRL+P 看参数

数组中存储的是引用，也可以使用arraycopy来拷贝

实际上是拷贝对象的地址。

image-20210422185923972

二维数组

二维数组其实是一特殊的一维数组，特殊在这个一维数组当中的每一个元素都是一个一维数组。

int【】【】

遍历二维数组

image-20210422201208071

image-20210422201548164

 

posted @ 2021-04-22 22:08  各人blanknote  阅读(442)  评论(0)    收藏  举报