songboyao-java-多态和泛型

多态

面向对象三大特性: 继承, 封装, 多态

定义
多态： 是指同一行为，对于不同的对象具有多个不同表现形式。
程序中多态: 是指同一方法,对于不同的对象具有不同的实现

前提条件【重点】

• 继承或者实现【二选一】
• 父类引用指向子类对象\接口引用指向实现类对象【格式体现】
• 方法的重写【意义体现：不重写，无意义】

多态的体现：父类的引用指向它的子类的对象：

父类类型 变量名 = new 子类对象；
变量名.方法名();

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。
多态的好处和弊端
好处

提高了代码的扩展性
弊端

多态的情况下，只能调用父类的共性内容，不能调用子类的特有内容。
无法访问子类独有的方法或者成员变量,因为多态成员访问的特点是,编译看父类

引用类型转换

向上转型

• 子类类型向父类类型向上转换的过程，这个过程是默认的。

 Aniaml anl = new Cat(); 

向下转型

• 父类类型向子类类型向下转换的过程，这个过程是强制的。

 Aniaml anl = new Cat();  
 Cat c = (Cat)anl;//向下转型

泛型

为什么要使用泛型?
集合不使用泛型的时候，存的时候什么类型都能存(Object)。但是取的时候(Object)就懵逼了。取出来啥也不是。
使用泛型在编译期直接对类型作出了控制，只能存储泛型定义的数据
泛型: 定义的时候表示一种未知的数据类型,在使用的时候确定其具体的数据类型。
泛型的作用是在创建对象时，将未知的类型确定具体的类型。当没有指定泛型时，默认类型为Object类型。

定义和使用含有泛型的类

定义格式：

修饰符 class 类名<代表泛型的变量> {  }
代表泛型的变量: 可以是任意字母  例如: T,E...

泛型在定义的时候不具体类型，使用的时候才具体类型。在使用的时候确定泛型的具体数据类型。

// 泛型类
class ArrayList<E>{ 
	// 参数是泛型
    public boolean add(E e){ }
	// 返回值是泛型
    public E get(int index){ }
   	....
}

确定泛型具体类型

在创建对象的时候确定泛型
例如，ArrayList<String> list = new ArrayList<String>();

此时，变量E的值就是String类型,那么我们的类型就可以理解为

class ArrayList<String>{ 
     public boolean add(String e){ }

     public String get(int index){  }
     ...
}

定义含有泛型的类

public class MyList<E>{
    E e;
    public E func(E e){
        return e;
    }

    public static void main(String[] args) {
        MyList<String> myList = new MyList<>();
        // 属性赋值
        myList.e = "哈哈";
        System.out.println(myList.e );
        System.out.println(myList.func("呵呵"));
        MyList<Integer> myList2 = new MyList<>();
        // 属性赋值
        myList2.e = 666;
        System.out.println(myList2.e );
        System.out.println(myList2.func(888));
    }
}

定义和使用含有泛型的方法

格式

修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

• 调用方法时，确定泛型的类型

public class Test {
    // 修饰符 <代表泛型的变量> 返回值类型 方法名(参数){  }

    public static <T> T func1(T t){
        return t;
    }

    public static void main(String[] args) {
       Integer i =  func1(100);
        System.out.println(i);
        String s =  func1("2222");
        System.out.println(s);

    }
}

定义含有泛型的接口

修饰符 interface接口名<代表泛型的变量> {  }

public interface IA <E>{
    public abstract void m1(E e);
    public default E m2(E e){
        return e;
    }
}
public class ImplA<E> implements IA<E>{

    @Override
    public void m1(E e) {

    }

    @Override
    public E m2(E e) {
        return e;
    }

    public static void main(String[] args) {
        // 使用时确定泛型
        ImplA<String> implA = new ImplA<>();
        implA.m1("哈哈");
        System.out.println(implA.m2("嘻嘻"));
    }
}