泛型--继承泛型

最新推荐文章于 2024-07-02 19:28:08 发布
最新推荐文章于 2024-07-02 19:28:08 发布
阅读量584 收藏
点赞数
文章标签： python
原文链接：https://my.oschina.net/architectliuyuanyuan/blog/3055274
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

42280ff35d80a9fa4ba80a064ba6e694e83.jpg

package com.atguigu.javase.generic;

import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

// 自定义泛型类, A只能是类类型
class Person<A> { // A在这里表示它是某种类型, 类型的形参, 在本类中就可以直接使用A这个类型.
	// A类型在创建对象时指定.
	// 如果A类型在创建对象时,并未确定的指定, 它就是Object类型, 类型不安全了
	// 泛型类型隶属于对象的, 不同的对象在创建时指定的泛型类型可以不一样
	
	private String name;
	private A info;
	
	public Person() {
	}

	public Person(String name, A info) {
		super();
		this.name = name;
		this.info = info;
	}
	
	public void setInfo(A info) {
		this.info = info;
	}
	
	public A getInfo() {
		return info;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public String getName() {
		return name;
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", info=" + info + "]";
	}
	
	/* 静态成员不可以使用泛型类型
	public static void test(A a) {
		
	}*/
	
	/**
	 * 泛型方法, 方法中的泛型类型在方法的返回值之前声明<泛型的类型参数>
	 * 泛型方法必须在形参中指定好特定的类型, 否则泛型方法中的泛型类型永远是Object
	 * 泛型方法中的泛型类型究竟是什么, 由实参来决定.所以是在方法的每一次调用时才能确定的.
	 * 如果实参是null, 则无法确定泛型类型, 只能是Object类型了.
	 * @return
	 */
	public <B> B testB(B b) {
		return null;
	}
}

class A<X> {
	X x;
	
	public X getX() {
		return x;
	}
}
class B extends A {} // 子类在继承时并未指定X的具体类型, 所以永远是Object
class C extends A<String> {} // 子类在继承时直接写死父类的泛型类型, 在子类中X类型永远是一致,不变的
class C2 extends A<Double> {}
class D<X> extends A<X> {} // 子类在继承父类时仍然保持泛型类型的不确定性.

public class GenericTest {
	
	@Test
	public void test6() {
		B b = new B();
		Object x = b.getX();
		
		C c = new C();
		String x2 = c.getX();
		
		D d = new D();
		Object x3 = d.getX();
		D<Integer> d2 = new D<Integer>();
		Integer x4 = d2.getX();
		String x5 = new D<String>().getX();
	}
	
	@Test
	public void test5() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add((int)(Math.random() * 20));
		}
		System.out.println(list);
		
		Object[] array = list.toArray();
		for (Object object : array) {
			System.out.println(object);
		}
		
		System.out.println("**********************");
		
		Integer[] array2 = list.toArray(new Integer[] {});
		for (Integer integer : array2) {
			System.out.println(integer);
		}
	}
	
	@Test
	public void test4() {
		Person<String> person = new Person<String>("张三", "北京");
		Integer testB = person.testB(30);
		String testB2 = person.testB("男");
		Boolean testB3 = person.testB(false);
		Object testB4 = person.testB(null); // 当实参的类型无法确定时, 泛型方法中的类型就是Object
	}
	
	@Test
	public void test3() {
		List<Integer> list1 = new ArrayList<Integer>();
		List<Double> list2 = new ArrayList<Double>();
	}
	
	@Test
	public void test2() {
		// 在这个对象中的A类型就固定是String类型
		Person<String> person = new Person<String>("张三", "北京"); // String在创建对象时,会作为类中的A类型的具体类型
		String info = person.getInfo();
		System.out.println(info);
		
		//person.setInfo(30);
		
		//new Person<Integer>("李四", "上海");
		Person<Integer> person2 = new Person<Integer>("李四", 40);
		Integer info2 = person2.getInfo();
		System.out.println(info2);
	}
	
	@Test
	public void test1() {
		Person person = new Person("张三", 30); // 理论上A类型就是Integer了, 但是没有指定
		Object info = person.getInfo();
		System.out.println(info);
		person.setInfo("男"); // 在这里体现了类型不安全, 因为理论上类型是Integer,但是实际给定的是String
		
		Person person2 = new Person("李四", "女");
		Object info2 = person2.getInfo();
		System.out.println(info2);
	}
}

c67777ab558099088b6263d0263c0c40e76.jpg

03dd31d728ad3b04fba28e200df46e42ae3.jpg

package com.atguigu.javase.generic;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;

import org.junit.Test;

public class GenericTest2 {
	
	public Comparable max(Collection<? extends Comparable> col) {
		Iterator<? extends Comparable> iterator = col.iterator();
		// 假设第1个数最大
		Comparable max = iterator.next();
		// 遍历所有数据, 如果某数据比最小值还小, 刷新最小值
		while (iterator.hasNext()) {
			Comparable next = iterator.next();
			if (next.compareTo(max) > 0) {
				max = next;
			}
		}
		return max;
	}
	
	public Comparable min4(Collection<? extends Comparable> col) {
		Iterator<? extends Comparable> iterator = col.iterator();
		// 假设第1个数最小
		Comparable min = iterator.next();
		// 遍历所有数据, 如果某数据比最小值还小, 刷新最小值
		while (iterator.hasNext()) {
			Comparable next = iterator.next();
			if (next.compareTo(min) < 0) {
				min = next;
			}
		}
		return min;
	}
	// 找出任意集合中的最大值
	@Test
	public void test8() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add((int)(Math.random() * 20));
		}
		System.out.println(list);
		System.out.println(min4(list));
		
		Set<Integer> set = new HashSet<Integer>();
		for (int i = 0; i < 10; i++) {
			set.add((int)(Math.random() * 20));
		}
		System.out.println(set);
		System.out.println(min4(set));
		
		List<String> list2 = new ArrayList<String>();
		list2.add("xxx");
		list2.add("abc");
		list2.add("YYY");
		list2.add("123");
		list2.add("来点汉字");
		list2.add("你好");
		System.out.println(list2);
		System.out.println(min4(list2));
	}
	
	///
	
	public Number min3(Collection<? extends Number> col) {
		Iterator<? extends Number> iterator = col.iterator();
		// 假设第1个数最小
		Number min = iterator.next();
		// 遍历所有数据, 如果某数据比最小值还小, 刷新最小值
		while (iterator.hasNext()) {
			Number next = iterator.next();
			if (next.doubleValue() < min.doubleValue()) {
				min = next;
			}
		}
		return min;
	}
	
	@Test
	public void test7() {
		List<Integer> list1 = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list1.add((int)(Math.random() * 20));
		}
		System.out.println(list1);
		System.out.println(min3(list1));
		
		List<Float> list2 = new ArrayList<Float>();
		for (int i = 0; i < 10; i++) {
			list2.add((float)(Math.random() * 20));
		}
		System.out.println(list2);
		System.out.println(min3(list2));
		
		Set<Integer> set = new HashSet<Integer>();
		for (int i = 0; i < 10; i++) {
			set.add((int)(Math.random() * 20));
		}
		System.out.println(set);
		System.out.println(min3(set));
	}
	
	///
	
	public Number min2(List<? extends Number> list) {
		// 假设第1个数最小
		Number min = list.get(0);
		// 遍历所有数据, 如果某数据比最小值还小, 刷新最小值
		for (Number number : list) {
			if (number.doubleValue() < min.doubleValue()) {
				min = number;
			}
		}
		return min;
	}
	
	@Test
	public void test6() {
		List<Integer> list1 = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list1.add((int)(Math.random() * 20));
		}
		System.out.println(list1);
		System.out.println(min2(list1));
		
		List<Float> list2 = new ArrayList<Float>();
		for (int i = 0; i < 10; i++) {
			list2.add((float)(Math.random() * 20));
		}
		System.out.println(list2);
		System.out.println(min2(list2));
	}
	
	///
	
	// 写一个方法 double min(List<????> list) 
	public double min(List<? extends Number> list) {
		// 假设第1个数最小
		double min = list.get(0).doubleValue();
		// 遍历所有数据, 如果某数据比最小值还小, 刷新最小值
		for (Number number : list) {
			if (number.doubleValue() < min) {
				min = number.doubleValue();
			}
		}
		return min;
	}
	
	// 在测试方法中创建两个List集合, 一个保存随机整数, 另一个保存Float型随机数据
	@Test
	public void test5() {
		List<Integer> list1 = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list1.add((int)(Math.random() * 20));
		}
		System.out.println(list1);
		System.out.println(min(list1));
		
		List<Float> list2 = new ArrayList<Float>();
		for (int i = 0; i < 10; i++) {
			list2.add((float)(Math.random() * 20));
		}
		System.out.println(list2);
		System.out.println(min(list2));
	}
	
	public double avg(List<? extends Number> list) {
		double sum = 0;
		for (Number num : list) {
			sum += num.doubleValue();
		}
		return sum / list.size();
	}
	
	
	@Test
	public void test4() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add((int)(Math.random() * 20));
		}
		System.out.println(list);
		System.out.println(avg(list));
		
		List<Double> list2 = new ArrayList<Double>();
		for (int i = 0; i < 10; i++) {
			list2.add((Math.random() * 20));
		}
		System.out.println(list2);
		System.out.println(avg(list2));
	}
	
	/*public int avg(List<Integer> list) {
	int sum = 0;
	for (Integer integer : list) {
		sum += integer;
	}
	return sum / list.size();
}*/
	
	@Test
	public void test3() {
		// 集合中保存的是Number类型及其未知父类   类型范围>= Number
		List<? super Number> list = new ArrayList<>();
		list.add(200); // 适合添加, 因为它里面可以保存至少是Number类型的对象
		list.add(2.5);
		
		Object object = list.get(0); // 不适合于获取, 因为是未知父类
		
		// 集合中保存的是Number类型及其未知子类类型, 类型范围 <= Number
		List<? extends Number> list2 = new ArrayList<>();
		//list2.add(200); // 不可以添加元素, 因为具体的子类类型是未知的. 不可以冒然添加元素
		//list2.add(2.8);
		Number number = list2.get(0); // 适合于获取, 因为最多就是Number. 
	}
	
	/**
	 * 此方法对于集合的访问是只读的, 更安全
	 * @param col
	 */
	public void travel(Collection<?> col) {
		for (Object object : col) {
			System.out.println(object);
		}
	}
	
	@Test
	public void test2() {
		List<Integer> list = new ArrayList<Integer>();
		for (int i = 0; i < 10; i++) {
			list.add((int)(Math.random() * 20));
		}
		travel(list);
	}
	
	@Test
	public void test1() {
		List<Integer> list1 = new ArrayList<Integer>();
		//List<Number> list2 = new ArrayList<Integer>(); // 原因是左侧的集合中保存的是范围更大的类型.
		// List<?>list 集合只能获取, 不能添加, 所以适用于只读访问.
		List<?> list2 = new ArrayList<Integer>(); // ?表示未知类型, 范围不确定
		//list2.add(100); // 绝对不可以... 因为集合中的类型未知, 不可以冒然添加
		//list2.add(new Object());
		list2.add(null); // 因为null不表示任何类型
		
		Object object = list2.get(0);
		
		List<Object> list3 = new ArrayList<Object>();
		list3.add(200);
	}
}

 

转载于:https://my.oschina.net/architectliuyuanyuan/blog/3055274

weixin_34319999
关注
java 返回值 泛型 继承_Java泛型 - 返回父类的子类
weixin_39997253的博客
02-13 915
一、栗子public class GenericityInher {//error: Type mismatch: cannot convert from ArrayList to ArrayListpublic ArrayList list(){return new ArrayList();}//rightpublic Parent inher(){return new Child();}//E...
java高级--泛型--注解
qq_55682798的博客
07-14 532
例子: 要求定义一个Point点类，该类中属性有x坐标和y坐标。 如果我们为坐标一个赋值整数，一个赋值为字符串，这时会不会报错。 3. 如何使用泛型? 4. 通配符 5. 受限泛型 6. 泛型接口 如何实现泛型接口: 7. 泛型方法 9. java高级--注解 9.1 预定义注解---了解 预定义注解就是JDK自带的一些注解，该注解被JVM而解析。 9.3 元注解 10.自定义注解---高级...
java 继承泛型类示例
06-21
java 继承泛型类示例 java 继承泛型类示例 java 继承泛型类示例
泛型的继承
u011463470的博客
01-08 1005
1.泛型的继承包括：普通泛型的继承，抽象泛型的继承，接口的继承     注：其实他们的继承方式都一样，对于泛型的继承我们只要记住一些规则就可以了     ①：泛型的继承分为保留继承和不保留继承。            a.保留继承又分为部分保留和全部保留====》子类也一定是泛型            b.不保留又分为具体类型继承，和不具体类型继承（相当于类型擦除，类似于Object类型）
【Java】泛型的继承和通配符
最新发布
qq_39921135的博客
07-02 837
需求：定义一个方法，形参是一个集合，但是集合中的数据类型不确定。？？> list) {有同学就想了：既然集合里面的数据类型不确定，那就可以利用我们刚刚学的泛型方法解决，告诉你，完全是可以的。// 泛型需要先定义，再使用：即先在修饰符后面定义 <E>，才能在形参中使用 E此时在测试类中添加都没有问题但是这种写法它会有一个小小的弊端：此时他可以接受任意的数据类型，例如Ye Fu Zi，甚至你定义的类不在继承结构中，例如Student，它也是可以传递过去的。
继承泛型类
Little_Fish_KEKE的博客
09-16 348
这样就通过泛型继承得到了多个类型的集合，赋值后变成了Tom，当然，也可以继续创建另一个，就像是女娲造人一样，女娲用泥土，我们用代码，用一个个信息去拼凑出一个存在于数据上的 ‘人’说白了，继承泛型类就是对继承类的延伸用法，利用了泛型。的特性让子类继承父类，实现类的继承,对继承进行了拓展。再创建一个 ’ 人 ‘再复杂一点，继承多个。
泛型的继承测试
老紫竹的专栏
10-15 3582
我对泛型的理解有限，这个只是极其简单的一个测试，欢迎指正，一起完善。泛型方法的继承默认情况，父类，子类都是泛型方法，没有任何问题class Parent0 {   void say() {    System.out.println("Parent");  }}class Child0 extends Parent0 {   void say() {    System.out.println("
泛型：继承和通配符
yubin1285570923的博客
08-20 1544
泛型的参数类型可以用在类，接口和方法创建中分别称为：泛型类，泛型接口和泛型方法。 ArrayList<E>:整个称为泛型类型，E表示泛型变量或泛型参数 ArralyList<Integer>：整个称为参数化类型，Integer称为类型参数的实例或者实际类型参数 一、泛型类 如果子类继承带泛型的父类时，指明了泛型类型，则new子类的时就不需要带<>指明类型了。 如果子类在继承带泛型的父类时，没有指明泛型类型或者部分指明泛型，那么可以沿用泛型。如下 public c...
java 泛型 父类_java泛型基础、子类泛型不能转换成父类泛型--未完待续
05-12
在Java中，泛型是一种强类型机制，它可以让你在编译时检查类型错误，从而提高代码的安全性和可读性。在使用泛型时，我们经常会遇到父类和子类的泛型转换问题。 首先，我们需要明确一点：子类泛型不能转换成父类泛型...
java抽象类泛型_Java实训笔记（二）——-抽象类-接口-泛型-集合
weixin_36420089的博客
02-12 1512
1.1方法的可变参数从JDK1.5之后，定义方法时参数的个数可以变化语法：最后一个数据类型后增加3个点注意：1.可变参数只能处于参数列表的最后；2.一个方法中最多只能包含一个可变参数；3.可变参数的本质就是一个数组，因此在调用一个包含可变参数的方法时，既可以传人多个参数，也可以传入一个数组。1.2装箱与拆箱基本数据类型与对应的封装类之间能够自动进行转换，其本质是Java的自动装箱与拆箱过程。-装箱...
【Java 16】泛型 - 集合中使用泛型、自定义泛型结构、泛型在继承上的体现、通配符
Wmiao
08-31 344
泛型泛型1 为什么要有泛型2 在集合中使用泛型3 自定义泛型3.1 泛型类、泛型接口3.2 泛型方法4 泛型在继承上的体现5 通配符的使用5.1 使用5.2 使用注意点5.3 有限制的通配符5.3.1 简述5.3.2 练习题6 泛型应用举例7 自定义泛型类的使用 泛型 1 为什么要有泛型 2 在集合中使用泛型 ArrayList<Integer> list = new ArrayList<>();//jdk7新特性， 类型推断 list.add(78); list.add
JAVA泛型-泛型类的继承
justlpf的专栏
02-07 2192
2.2 定义一个继承了父类的泛型子类。2.3 定义一个继承了父类的普通子类。1.1 方式一 ：子类也是泛型类。1.2 方式二 ：子类不是泛型类。2.4 创建子类的对象使用。2.实现一下泛型类的继承。2.1 定义一个泛型父类。1.泛型类的继承语法。
继承与泛型
qq_43217356的博客
11-05 220
/* 其中：Person是Student和Worker的父类 java的泛型中，List中泛型定义为父类的，为什么可以添加继承类（子类的）？ */ public class Test { public static void main(String[] args) { List list = new ArrayList(); list.add(new Student());//为什么此行代码没...
java泛型类中类型继承_Java泛型 泛型类型的继承规则
weixin_28960321的博客
02-27 401
泛型类型的继承规则可能不能凭直觉的来想当然。下面举个例子来看看泛型类型的继承规则。首先有几个辅助类：package generic;public class Person extends Animal {private String name;public Person(String name) {super();this.name = name;}public String getName() ...
java 泛型继承_Java中接口继承泛型接口
weixin_39636333的博客
02-19 247
在使用Mybatis做web开发时，每一个模块的数据持久层的接口都会定义：增删改查四个方法。我想为什么不新建一个Base接口来做所有数据持久层的父接口呢？于是，我试验了一下，建立了一个泛型接口，里面定义了四个操作数据库的基本方法，对应增删改查：public interface BaseMapper {public T selectByPrimaryKey(Integer id);public vo...
Java泛型_继承
widenstage的专栏
05-07 362
泛型类的继承： package com.ws.generic; /** * 泛型父类，子类为富二代 * 1、保留父类泛型 -->子类为泛型 * 2、不保留父类泛型 -->子类按需实现 * * 属性及方法 类型 -->随位置而定 * 1)、子类重写方法的类型 -->随父类而定 * 子类新增方法的类型 -->随子类而定 * 2)、子类中使用父类的属性 -->随父类而定
java中泛型的继承
伯兰的博客
01-02 1011
现在有如下两个类：public class GenericFather<T> { public void (T t) { System.out.println(t); } }public class GenericSon extends Generic<T> { } 如果按照这样的方式继承的话，编译器将报错：T cannot be resolved to a type
C# 泛型---继承
weixin_39328209的博客
05-11 2239
泛型类型可以实现泛型接口，也可以派生自一个类。 泛型类可以派生自泛型基类 泛型类型继承写法： public class Base<T> { } public class Derived<T> : Base<T> { } 指定基类的类型写法： public class Base<T> { } public class Derived<T> : Base<string> { } 写一个从 Query 中派生 ..
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值