六大区别 (重载与重写、顺序表和链表、Comparable和Comparator、抽象类和接口、super和this、ArrayList和LinkedList)

云惠网小编 2021年10月14日15:18:00
评论
4767字阅读15分53秒
摘要

区别文章目录区别一、重载与重写1.1方法的重载1.2重载的规则1.3方法的重写 (覆盖,覆写)1.4 重写的规则:1.5 小结二、顺序表和链表三、Comparable和Comparator3.1 comparable3.2Comparator3.3小结四、抽象类和接口4.1 抽象类4.2 接口五、super和this六、ArrayList和LinkedList6.1ArrayList:6.2LinkedList:6.3 小结一、重载与重写重载(overload):在一个类里面我们需要用一个函数同时兼容

广告也精彩
public interface Comparator<T> {
int compare(T o1, T o2);
}

详细的语法规则可以看 这个链接 !!!!

4.2 接口

源码:

2、抽象类可以包含字段,成员方法,和普通方法规则一样

@Override
public int compareTo(Student o) {
return (int)(this.score-o.score);
//return this.name.compareTo(o.name);
//return o.age-this.age;
/*if(this.age > o.age) {
return 1;
}else if(this.age == o.age) {
return 0;
}else {
return -1;
}*/
}

顺序表:底层是数组,数组的优点就是顺序表的优点,所以顺序表比较适合查找和修改,只要给定下标就可以找到这个数据并且可以修改;

六、ArrayList和LinkedList

也可以理解为当前对象大于,等于,小于返回1,0,-1:

 @Override
public int compareTo(Student o) {
if(this.age > o.age) {
return 1;
}else if(this.age == o.age) {
return 0;
}else {
return -1;
}
}
方法 解释
ArrayList() 无参构造
ArrayList(Collection<? extends E> c) 利用其他 Collection 构建 ArrayList
ArrayList(int initialCapacity) 指定顺序表初始容量

compare用法:

1.2重载的规则

3、接口当中的成员变量,可以用publlic static final修饰;

2、boolean add(E e)方法时间复杂度是O(1),因为是链表直接放最后就好了

Comparator也称之为比较器,可以通过compare指定里面的比较规则;

重写:

1、方法名相同

2、方法的返回值相同

3、方法的参数列表相同

一、重载与重写

Comparator称外在比较器,对类的侵入性弱,不需要修改类本身,只需要修改比较器的比较规则,如要进行其他比较规则直接重写比较器即可;这也算是对Comparable不足的增强,扬长补短;

链表:每个数据是由节点组织,链表适合插入和删除,他只需要通过节点修改执行就好。 关于链表的习题讲解可以点 这个链接 !!!

o:是指定的对象比较

 @Override
public int compareTo(Students o) {
return this.age-o.age;
}

2、接口里面不能有普通方法,只能有抽象方法;

源码:

3.1 comparable

方法 解释
LinkedList() 无参构造
LinkedList(Collection<? extends E> c) 利用其他 Collection 构建 LinkedList

6.2LinkedList:

1、get (int index) 方法时间复杂度是O(1),找到下标即可

 List<Integer> list = new ArrayList<>();
ArrayList<Integer> list2 = new ArrayList<>(14);
ArrayList<Integer> list3 = new ArrayList<>(list);//new ArrayList<>()
public interface Comparable<T> {
public int compareTo(T o);
}

image-20211012154425307

2、boolean add(E e)方法,默认是放到这个数组最后的位置,还要考虑扩不扩容,不扩容时间复杂度就是O(1),默认数组大小变为10,需要扩容的话,需要扩容的话,扩容方式就是1.5倍扩容,add的源码最后还有个Arrays.copyOf(),最后还要把原数组复制到新数组中,就会耗时了;

3.2Comparator

ArrayList 和 LinkedList 是 List 接口的两种不同实现。

6.1ArrayList:

​ Comparator重写的是compare;

区别

image-20211011145122386

1.5 小结

LinkedList<Integer> list = new LinkedList<>();
LinkedList<Integer> list2 = new LinkedList<>(new ArrayList<>());

1、用abstract修饰

image-20211011151212748

四、抽象类和接口

所以就引出了他两的区别:

6、接口和接口之间的关系时extends来维护;

//ArrayList 的add方法的源码
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
区别 重载(overload) 重写(override)
概念 方法名称相同,参数的类型及个数不同 方法名称、返回值类型、参数的类型及个数完全相同
范围 一个类 继承关系
限制 没有权限要求 被覆写的方法不能拥有比父类更严格的访问控制权限

想了解更详细重写 请转到 这个链接!!!!!

需要注意的是ArrayList和LinkedList在内存的使用上是不同的,LinkedList是双向链表,所以会存储前序和后续元素地址,所以LinkedList开销会比较大,但是ArrayList就没有这样的开销。另外ArrayList占用的内存用add方法的时候就已经默认是10了,而LinkedList不需要指定大小。

1、get (int index) 方法时间复杂度是O(n),因为要遍历整个链表。

[email protected]== 注解注释,使用该注释编辑器会在编译时就检查该方法是否符合重写的条件,避免以为是重写却因出现导致该方法只是重载的尴尬情况发生。

三、Comparable和Comparator

5、一个类用implements实现n个接口;

2.Comparable重写的是compareTo;

同重载不同,重写(Override)是发生在两个类中的,且两个类是继承关系或者实现关系,同时方法签名完全相同!也就是说,方法名称和传入蚕食要完全一致。重写是java实现运行时多态的方式,这种通过对象类型而非定义类型去匹配实现方法的方式极大地提升了程序的开发效率和扩展性,同事也让程序更加易于维护。

ComparaTo比较当前对象与指定对象的顺序

image-20211011150457061大多数书上this写的是代表当前对象,其实是错误的,应该是代表当前对象的引用,想看原因可以 点击这个链接 !!!

1.1方法的重载

class OverwriteDemo {
void print(int i) {
System.out.println("打印整型值:"+i);
}
void print(String i) {
System.out.println("打印字符串类型值:" +i);
}
void  print(String s1,String s2) {
System.out.println("打印字符串类型值:"+s1+";字符串类型值2:"+s2);
}
}
public class Test {
public static void main(String[] args) {
OverwriteDemo overwriteDemo=new OverwriteDemo();
overwriteDemo.print(12);
overwriteDemo.print("123");
overwriteDemo.print("字符串1","字符串2");
}
}

ComparaTo的源码:

4、不能被实例化;

3.3小结

class Studens {.........}
class AgeComparator implements Comparator<Students> {
@Override
public int compare(Students o1, Students o2) {
return o1.getAge()-o2.getAge();
}
}
public class Test {
public static void main(String[] args) {
Students[] students=new Students[3];
students[0]=new Students("yuenye",12,20);
students[1]=new Students("xiaoming",22,18);
students[2]=new Students("weichi",50,32);
AgeComparator ageComparator=new AgeComparator();
Arrays.sort(students,ageComparator);
System.out.println(Arrays.toString(students));
}

6.3 小结

二、顺序表和链表

 if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; i<high; i++)
for (int j=i; j>low &&
((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
swap(dest, j, j-1);
return;
}

1、用interface修饰;

super关键字一般用于继承中,在构造函数和需要用到父类属性和方注的时候使用

4、不能被实例化;

5、extends维护

this是当前对象;

重载(overload):在一个类里面我们需要用一个函数同时兼容多种参数的情况, 我们就可以使用到方法重载 。在同一个方法内,方法名称相同,但是传入参数不同,这个就可以根据传入的参数来判断调用的到底是哪一个方法。重载大大增强了方法的功能性。[继承的时候,不一定就在同一个类里面了]

ArrayList底层是数组,LinkedList底层是一个双向链表,区别主要是他们不同方法使用和不同的时间复杂度。

3、不能被final和private修饰;

4.1 抽象类

文章目录

  • 区别
    • 一、重载与重写
      • 1.1方法的重载
      • 1.2重载的规则
      • 1.3方法的重写 (覆盖,覆写)
      • 1.4 重写的规则:
      • 1.5 小结
    • 二、顺序表和链表
    • 三、Comparable和Comparator
      • 3.1 comparable
      • 3.2Comparator
      • 3.3小结
    • 四、抽象类和接口
      • 4.1 抽象类
      • 4.2 接口
    • 五、super和this
    • 六、ArrayList和LinkedList
      • 6.1ArrayList:
      • 6.2LinkedList:
      • 6.3 小结

1、Comparable也称内比较器,对类的侵入性强,Comparable里面的类都是自己跟自己比较,在自定义中的数组排序,如要排序就可以用到Comparable,但是要在这个数组进行另一种设定排序的时候就会改变原有类里面的代码,不够灵活.

针对同一个类:

1、方法名相同

2、方法参数不同(参数个数或者参数类型)

3、方法的返回值类型不影响重载

1.3方法的重写 (覆盖,覆写)

image-20211010121106643

1.4 重写的规则:

6、普通类继承抽象类,那么普通类里面所有的抽象方法都要被重写;

五、super和this

本文转自 https://blog.csdn.net/qq_54219272/article/details/120728204

腾讯云618
云惠网小编
[java篇]一口气搞定异常处理 java

[java篇]一口气搞定异常处理

前言:博主在以前的博客中曾经也提起了异常,比如[java篇]多态,接口中在实现clone接口时,就用到了抛出异常,今天就给大家详细的介绍一下关于异常的一些知识。前期文章:1.[ja...
腾讯云618

发表评论