public static void main(String[] args) {
Collection c = new ArrayList();
//当我们没有指定集合中元素类型的时候,add()默认传入的类型为Object类型,因为集合默认是引用类型,而Object类型可以代表所有的引用类型。我们传入String类型的元素,则向上转型为Object类型。
c.add("liubei");
c.add("guanyu");
c.add("zhangfei");
Iterator it = c.iterator();
while (it.hasNext()){
Object obj = it.next();
System.out.println(obj);
}
}
而我们存储的是String类型,我们不想把其作为Object类型使用,则我们要将其强转:
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("liubei");
c.add("guanyu");
c.add("zhangfei");
Iterator it = c.iterator();
while (it.hasNext()){
String s = (String) it.next();
System.out.println(s);
}
}
但若是我们把所有的元素都作为String类型使用,而在某一刻传入了一个不是String类型的元素时,就会报错:
public static void main(String[] args) {
Collection c = new ArrayList();
c.add("liubei");
c.add("guanyu");
c.add("zhangfei");
c.add(100);//存储的时候是Integer类型,Integer不能强转为String类型,所以报错。我们使用的时候,我可能会认为我们存储的只有String类型,就强转,然后出现问题。也就是说,如果我们不使用泛型,程序就隐含了类型转换异常出现的可能。
Iterator it = c.iterator();
while (it.hasNext()){
String s = (String) it.next();//ClassCastException
System.out.println(s);
}
}
而使用泛型,程序在添加元素的类型不符合泛型所指定的类型时就直接报错,即把运行时期的问题提前到了编译期间,而且迭代器也可以通过泛型指定元素类型,避免了强制类型转换:
public static void main(String[] args) {
Collection<String> c = new ArrayList<>();
c.add("liubei");
c.add("guanyu");
c.add("zhangfei");
//c.add(100);//报红
Iterator<String> it = c.iterator();
while (it.hasNext()){
String s = (String) it.next();
System.out.println(s);
}
}
综上,泛型的好处:
(1)把运行时期的问题提前到了编译期间;
(2)避免了强制类型转换。
public class Generic<T> {
private T t;
public T getT() {
return t;
}
public void setT(T t) {
this.t = t;
}
}
public class GenericDemo {
public static void main(String[] args) {
Generic<String> g1 = new Generic<>();
g1.setT("liubei");
System.out.println(g1.getT());
Generic<Integer> g2 = new Generic<>();
g2.setT(100);
System.out.println(g2.getT());
}
}
public class Generic<T> {
public void show(String s){
System.out.println(s);
}
public void show(Integer i){
System.out.println(i);
}
public void show(Boolean b){
System.out.println(b);
}
}
public static void main(String[] args) {
Generic g = new Generic();
g.show("liubei");
g.show(30);
g.show(true);
g.show(213.13);
}
public class Generic<T> {
public void show(T t){
System.out.println(t);
}
}
public static void main(String[] args) {
Generic<String> g1 = new Generic<>();
g1.show("liubei");
Generic<Integer> g2 = new Generic<>();
g2.show(30);
Generic<Boolean> g3 = new Generic<>();
g3.show(true);
}
public class Generic {
//调用方法的那一刻,根据传入参数的类型,才真正确定类型
public<T> void show(T t){
System.out.println(t);
}
}
public static void main(String[] args) {
Generic g1 = new Generic();
g1.show("liubei");
g1.show(20);
g1.show(false);
}
public interface Generic<T> {
void show(T t);
}
public class GenericImpl<T> implements Generic<T>{
@Override
public void show(T t) {
System.out.println(t);
}
}
public class GenericDemo {
public static void main(String[] args) {
Generic<String> g1 = new GenericImpl<>();
g1.show("liubei");
Generic<Integer> g2 = new GenericImpl<>();
g2.show(20);
}
}
public static void main(String[] args) {
//首先我们要知道Integer的父类为Number,Number的父类为Object
//类型通配符:
List<?> list1 = new ArrayList<Object>();
List<?> list2 = new ArrayList<Number>();
List<?> list3 = new ArrayList<Integer>();
//类型通配符上限:
//List list4 = new ArrayList
List<? extends Number> list5 = new ArrayList<Number>();
List<? extends Number> list6 = new ArrayList<Integer>();
//类型通配符下限:
List<? super Number> list7 = new ArrayList<Object>();
List<? super Number> list8 = new ArrayList<Number>();
//List list9 = new ArrayList();//报错
}
public class ArgsDemo {
public static void main(String[] args) {
System.out.println(sum(10,20));
System.out.println(sum(10,20,30));
System.out.println(sum(10,20,30,40));
System.out.println(sum(10,20,30,40,50));
System.out.println(sum(10,20,30,40,50,60));
System.out.println(sum(10,20,30,40,50,60,70));
System.out.println(sum(10,20,30,40,50,60,70,80));
System.out.println(sum(10,20,30,40,50,60,70,80,90));
}
public static int sum(int...a){
int sum = 0;
for (int i : a){
sum += i;
}
return sum;
}
}
public static void main(String[] args) {
List<String> list = Arrays.asList("liubei","guanyu","zhangfei");
//list.add("zhugeliang");//UnsupportedOperationException
//list.remove("liubei");//UnsupportedOperationException
list.set(1,"zhugeliang");
System.out.println(list);//[liubei, zhugeliang, zhangfei]
//List list2 = list.of("liubei","guanyu","zhangfei");
//list2.add("zhugeliang");//UnsupportedOperationException
//list2.remove("liubei");//UnsupportedOperationException
//list2.set(1,"zhugeliang");//UnsupportedOperationException
//System.out.println(list2);
//Set set = Set.of("liubei","guanyu","zhangfei");
//set.add("zhugeliang");//UnsupportedOperationException
//set.remove("liubei");//UnsupportedOperationException
//System.out.println(set);
}