java多态及集合详解

目录

一、多态

1、定义

2、优点

3、多态存在的必要条件

4、接口实现多继承

5、default方法

static方法

二、object类

三、异常

四、集合

1、详细的集合框架图

2、手写ArrayList>>>add方法

3、泛型

4、集合的遍历

5、Set

HashSet

LinkedHashSet

TreeSet

6、Map

1、HashMap

LinkedHashMap

2、ConcurrentHashMap

3、Hashtable

---

一、多态

1、定义

多态是同一个行为具有多个不同表现形式或形态的能力，多态就是同一个接口，使用不同的实例而执行不同操作

2、优点

1>消除类型之间的耦合关系

2>可替换性

3>可扩展性

4>接口性

5>灵活性

6>简化性

3、多态存在的必要条件

1>继承

2>重写

3>父类的引用指向子类的实例化对象

4、接口实现多继承

1>首先我们定义三个接口，让其中的一个接口去继承其他两个接口

2>在写一个实现类去实现接口里的方法

// Fa01接口
public interface Fa01 {
    //fa01方法
    void fa01();
}

// Fa02接口
public interface Fa02 {
      //fa02方法
    void fa02();
}

// Fa03接口继承Fa01,Fa02接口
public interface Fa03 extends Fa01,Fa02{   
      //fa03方法
    void fa03();
    }

//  FaFaImpl实现类去实现Fa03接口
public class FaFaImpl implements Fa03{
    
    // 以下是重写接口里的方法
    @Override
    public void fa01() {
        System.out.println("fa01");
    }
    @Override
    public void fa02() {
        System.out.println("fa02");
    }

    @Override
    public void fa03() {
        System.out.println("fa03");
    }
}

3>在进行测试

import org.junit.jupiter.api.Test;
// 测试类
public class FaTest {
@Test
    public void test01(){
		//父类的引用指向子类的实例化对象
    	Fa01 f = new FaFaImpl();
		// 调用fa01方法
    	f.fa01();
    }

@Test
    public void test02(){
        //父类的引用指向子类的实例化对象
        Fa02 f1= new FaFaImpl();
        // 调用fa01方法
        f1.fa02();
    }

@Test
    public void test03(){
        //由于Fa03继承了Fa01,Fa02接口,所以可以调用fa01，fa02方法
        Fa03 fa03 = new FaFaImpl();
        fa03.fa03();
        fa03.fa01();
        fa03.fa02();
    }
}

4>测试结果依次是

fa01
fa02
fa03
fa01
fa02

5、default方法

在jdk8后面的版本中，接口中可以有方法体，但是只能用static和default来修饰

public interface Fun01 {
   default void eat01(){
        // 使用default修饰的方法可以有方法体
        // 在接口中，使用default修饰的方法可以被重写
        // 使用实现类的实例化对象去调用，调用的是被重写的方法
        // 在接口中，使用default修饰的方法可以被子接口继承
        // 继承过来的方法可以在实现类中进行重写
        System.out.println("使用default修饰的eat01方法");
    }
}

static方法

public interface Fun02 { 
public static void eat02(){
        // 在接口中使用static修饰的方法可以有方法体
        // 在接口中使用static修饰的方法不能被实现类重写
        // 使用接口名点方法名去调用
        // 在接口中static修饰的方法不能被继承
        System.out.println("使用static修饰的eat02方法");
    }
}

二、object类

1> 在java中，object类是所有的类的父类，也就是说所有的类都继承了object类，子类可以使用object类所有方法

public class Person {
    /**
     * 年龄
     */
    private Integer age;

    /**
     * 性别 1为男性 2为女性
     */
    private Integer sex;

    /**
     * 名字
     */
    private String name;

    public Person() {
    }

    public Person(Integer age, Integer sex, String name) {
        this.age = age;
        this.sex = sex;
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

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

测试

public class PersonTest01 {
@Test
    public void test01(){
    Person person = new Person();//默认调用了object类的方法
    System.out.println(person);
    }

输出结果

com.lihaozhe.bean.Person@3c0a50da //生成一个16进制数

2>重写toString方法

将属性拼接起来

    @Override
    public String toString() {
        return "Person{" + "age=" + age + ", sex=" + sex + ", name='" + name + "'" + "}";
    }
}

3>重写equals方法

  @Override
        // 重写equals方法
    public boolean equals(Object obj) {
        // 将equals方法中的参数：object类的obj转换成Person类型，需要向下转型
        // 向下转型进行强制类型转换 person01是传进来被比较的值
        Person01 person01 = (Person01) obj;
        // 将它本身的值和传进来的值做对比
        // 年龄做比较，如果不相等
        if (this.age != person01.getAge()) {
            // 返回false
            return false;
            // 性别做比较，如果不相等
        } else if (this.sex != person01.getSex()) {
            // 返回false
            return false;
            // Util包下有objects类 里面有equals方法 将名字做比较
        } else if (!Objects.equals(this.name, person01.getName())) {
            // 返回false
            return false;
        } else {
            // 最终结果返回true
            return true;
        }
    }

测试equals方法

@Test
public void test05(){
    Person01 person01= new Person01(20,0,"胡亥");
    Person01 person02 = new Person01(18,1,"嬴政");
    // 用等号比较是里面的内存地址
    System.out.println(person01 == person02);// 输出结果：false
    // 用equals比较的是参数里的内容
    System.out.println(person01.equals(person02));//输出结果: false
}
@Test
public void test06(){
    Person01 person01 = new Person01(18,1,"嬴政");
    Person01 person02 = new Person01(18,1,"嬴政");
    // 用等号比较是里面的内存地址
    System.out.println(person01 == person02);//输出结果：false
    // 用equals比较的是参数里的内容
    System.out.println(person01.equals(person02));//输出结果：true
}

3、重写HashCode方法

@Override
public int hashCode() {
    //做一个参考值
    int reference = 30;
    return this.age * (this.sex + reference) + this.name.hashCode();
}

测试HashCode方法

@Test
public void test07() {
    Person02 person01 = new Person02(18, 1, "嬴政");
    Person02 person02 = new Person02(20, 0, "嬴政");
    Person02 person03 = new Person02(18, 1, "嬴政");
    // 用hashCode方法判断 只要传进来的参数一样最终hashCode的值就是一样的
    System.out.println(person0