多态与泛型

谁借莪１个温暖的怀抱￠ 2022-07-25 15:38 238阅读 0赞

***多态与泛型***

**1.多态的理解和使用：**

多态自我理解就是同种调用的不同结果表现

1) 方法的多态性：包括重载和重写(其实重写就是为了下面类之间继承的多态)

2)类之间继承的多态

重载和重写已经在之前的文章中学习过了，下面是类的多态：

class animal{
    	public void eat(){
    		System.out.println("animal.eat()");
    	}
    }
    class cat extends animal{
    	public void eat(){
    		System.out.println("cat.eat()");
    	}
    }
    class dog extends animal{
    	public void eat(){
    		System.out.println("dog.eat()");
    	}
    }
    public class abs{
    	/*方法1*/
    //	public static void toEat(cat cat){
    //		cat.eat();
    //	}
    //	public static void toEat(dog dog){
    //		dog.eat();
    //	}
    	/*方法2*/
    	public static void toEat(animal animal){
    		animal.eat();
    	}
    	public static void main(String[] args) {
    		toEat(new cat());
    		toEat(new dog());
    	}
    }

想调用cat和dog子类的eat方法，如果使用方法1的话，要用到两个静态方法，如果有很多子类的话这是不可行的；如果使用方法2的话，参数是父类，只需要用一个方法即可

**2.向上转型和向下转型**

上述的类多态性使用实际上用到了向上转型；下面是向上转型和向下转型的使用：

class animal{
    	public void eat(){
    		System.out.println("animal.eat()");
    	}
    	public void sleep(){
    		System.out.println("animal.sleep()");
    	}
    }
    class cat extends animal{
    	public void eat(){
    		System.out.println("cat.eat()");
    	}
    	public void breath(){
    		System.out.println("cat.breath()");
    	}
    }
    public class abs{
    	public static void main(String[] args) {
    		/*向上转型*/
    		animal animal = new animal();
    		cat cat = new cat();
    		animal = cat;
    		animal.eat();
    		animal.sleep();
    		System.out.println();
    		
    		/*向下转型，这种是错误的*/
    //		animal animal2 = new animal();
    //		cat cat2 = new cat();
    //		cat2 = (cat)animal2;
    //		System.out.println();
    		
    		/*向下转型*/
    		animal animal3 = new cat();
    		cat cat3 = new cat();
    		cat3 = (cat)animal3;
    		cat3.eat();
    		cat3.sleep();
    		cat3.breath();
    	}
    }

实际上向下转型，是子类先向上转型，然后再向下转型；下面是运行结果：

![Center][]  
如果中间的注释去掉的话，就会出现运行时异常，animal2是不能强转为cat类型的，下面是运行结果：

![Center 1][]

关于转型的自我理解：每个父类或者子类，都是一个指向引用的引用(暂定引用1)，其中的方法是引用(暂定子引用2)。 当向上转型的时候，实际上就是子类的引用1和引用2

把父类的引用1和引用2都覆盖了，而且不存在丢失引用2的情况；当直接向下转型的时候，同样是覆盖，但是子类中可能会丢失引用2，所以java语法上不允许。 如果是先向上转型(不丢失引用2，同时多余的引用2仍然是存在的)，再向下转型是可以的。

**3.Java中instanceof使用**

class animal{
    	public void eat(){
    		System.out.println("animal.eat()");
    	}
    	public void sleep(){
    		System.out.println("animal.sleep()");
    	}
    }
    class cat extends animal{
    	public void eat(){
    		System.out.println("cat.eat()");
    	}
    	public void breath(){
    		System.out.println("cat.breath()");
    	}
    }
    public class abs{
    	public static void main(String[] args) {
    		animal Tanimal = new animal();
    		cat Tcat = new cat();
    		animal Fanimal = new cat();
    //		((cat)Fanimal).breath();
    		System.out.println(Tanimal instanceof cat);
    		System.out.println(Tcat instanceof animal);
    		System.out.println(Fanimal instanceof cat);
    		System.out.println(Fanimal instanceof animal);
    	}
    }

注：即使实例通过了instanceof验证，表明是相关类的实例，也并不一定可以直接调用实例中的方法，如上段注释的代码，是需要强转的。下面是运行结果：

![Center 2][]

**4.泛型**

1)为什么要使用泛型

A：类型安全

Map map = new HashMap();
    		map.put("int", 10);
    		String string = (String)map.get("int");

上面的代码，程序员可能会忘记map中”int“键存放的是int类型，在取出的时候会当作String类型，这在运行的时候会出现java.lang.ClassCastException异常。

Map<String,Integer> map2 = new HashMap<>();
    		map2.put("int",10);
    		/*下面注释的写法就是错的*/
    //		String string2 = (String)map2.get("int");
    		int num = map2.get("int");

上面的代码利用泛型避免了出现异常的问题

B：不需要再使用强制类型转换，同时潜在的提高了效率。

如上A中所示，在利用泛型之后，不需要再使用强制类型转换，类型的判断有编译器来决定。  既然不需要强制类型转换，在编译的时候也就不需要类型转换占用的那些多余的字节码，这样会带来JVM的优化。

2)类中使用泛型

/*类中使用泛型*/
    class animal<T,K,L>{
    	/*属性中使用泛型*/
    	private T name;
    	private K age;
    	private L print;
    	/*构造方法中使用泛型*/
    	public animal(L l){
    		this.print = l;
    		System.out.println("animal.animal()："+this.print);
    	}
    	public T getName() {
    		return name;
    	}
    	public void setName(T name) {
    		this.name = name;
    	}
    	public K getAge() {
    		return age;
    	}
    	public void setAge(K age) {
    		this.age = age;
    	}
    }
    /*下面的注释，说明子类也必须是同样的类型*/
    //class cat<T,K,L> extends animal<T,K,L>{
    //	public cat(L l) {
    //		super(l);
    //	}
    //}
    public class abs{
    	public static void main(String[] args) {
    		animal<String,Integer,String> animal = new animal<String, Integer, String>("这是参数L初始化的值");
    		animal.setName("tiger");
    		animal.setAge(10);
    		System.out.println("name:"+animal.getName());
    		System.out.println("age:"+animal.getAge());
    	}
    }

3)泛型类作为方法参数时的，需要使用通配符的问题

/*类中使用泛型*/
    class animal<T,K>{
    	/*属性中使用泛型*/
    	private T name;
    	private K age;
    	public T getName() {
    		return name;
    	}
    	public void setName(T name) {
    		this.name = name;
    	}
    	public K getAge() {
    		return age;
    	}
    	public void setAge(K age) {
    		this.age = age;
    	}
    	@Override
    	public String toString() {
    		return "animal [getName()=" + getName() + ", getAge()=" + getAge() + "]";
    	}
    	
    }
    /*下面的注释，说明子类也必须是同样的类型*/
    //class cat<T,K,L> extends animal<T,K,L>{
    //	public cat(L l) {
    //		super(l);
    //	}
    //}
    public class abs{
    	public static void main(String[] args) {
    		animal<String,Integer> animal = new animal<String,Integer>();
    		animal.setAge(10);
    		animal.setName("tiger");
    		test(animal);
    	}
    	/*方法1*/
    	public static void test(animal<?,?> animal){
    		System.out.println("abs.test():"+animal.toString());
    	}
    	/*方法2*/
    /*对于一个static的方法而言，无法访问泛型类的类型参数，所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。*/
    //	public static<T, K> void test(animal<T,K> animal){
    //		System.out.println("abs.test():"+animal.toString());
    //	}
    }

注：除了在方法中使用通配符之外，还可以使用上段代码中方法2.

4)接口中使用泛型，数组中使用泛型

interface plants<T,K,L>{
    	/*泛型方法*/
    	public T eat(T t,K k,L l[]); 
    }
    class tree<T,K,L> implements plants<T,K,L>{
    	public T eat(T t,K k,L l[]) {
    		System.out.println("tree.eat():"+t.toString());
    		System.out.println("tree.eat():"+k.toString());
    		for (int i = 0; i < l.length; i++) {
    			System.out.println("tree.eat():"+l[i].toString());
    		}
    		return t;
    	}
    }
    public class abs{
    	public static void main(String[] args) {
    		Integer integer[] = {1,2,3};
    		tree<String,String,Integer> tree = new tree<String,String,Integer>();
    		tree.eat("t值","k值",integer);
    	}
    }

5)对上面的代码做一点改动，在接口中去掉T泛型， 那么在使用其中的eat方法的时候就必须指定为泛型方法，即在返回值浅加上泛型。这样一个好处是不用在实例化的时候指定类型，只需要在调用方法的时候指定类型即可。

interface plants<K,L>{
    	/*泛型方法*/
    	public <T>T eat(T t,K k,L l[]); 
    }
    class tree<K,L> implements plants<K,L>{
    	public <T>T eat(T t,K k,L l[]) {
    		System.out.println("tree.eat():"+t.toString());
    		System.out.println("tree.eat():"+k.toString());
    		for (int i = 0; i < l.length; i++) {
    			System.out.println("tree.eat():"+l[i].toString());
    		}
    		return t;
    	}
    }
    public class abs{
    	public static void main(String[] args) {
    		Integer integer[] = {1,2,3};
    		tree<String,Integer> tree = new tree<String,Integer>();
    		tree.eat("t值","k值",integer);
    	}
    }

[Center]: /images/20220724/4303feb9f48847b895b9557d6bbf4b79.png
[Center 1]: /images/20220724/8d4ab2f6db994faca93bf75f3dfcfa80.png
[Center 2]: /images/20220724/94a28620f4df4811a7e7bd4c698513aa.png