java自定义泛型类和接口

一时失言乱红尘 2024-03-22 23:37 95阅读 0赞

#### 文章目录 ####

*  java泛型类
 *  自定义泛型类
 *   *  什么时候使用泛型类？
     *  看代码理解
 *  自定义泛型接口
 *   *  什么时候使用泛型接口
     *  定义泛型接口的格式
     *  泛型接口中的泛型确定时机？
     *  看代码理解
 *  自定义泛型方法
 *   *  定义格式
 *  泛型的指定
 *   *  代码理解
 *  定义存储字符串的ArrayList集合，将字符串的集合转化为字符串数组
 *  泛型通配符 ==？==
 *   *  泛型上限的格式和含义
     *  泛型下限的格式
     *  代码理解

## java泛型类 ##

什么是泛型类呢？

先了解一下java中包含的泛型类：

ArrayList<String> c = new ArrayList<>();

熟悉嘛，ArrayList<>。

熟悉的话，我们继续往下看。

## 自定义泛型类 ##

### 什么时候使用泛型类？ ###

当定义类时，内部方法中其参数类型，返回值不确定时，就可以使用泛型代替。

### 看代码理解 ###

注意使用格式和使用场景。

public class Demo {
        
        public static void main(String[] args) {
        
            Person<String> person = new Person<>();
        }
    }
    
    //自定义泛型类,类型为类型
    class Person<H>{
        
    
        private H hobby;
    
        public Person(){
        
    
        }
    
        public Person(H hobby) {
        
            this.hobby = hobby;
        }
    
        public H getHobby() {
        
            return hobby;
        }
    
        public void setHobby(H hobby) {
        
            this.hobby = hobby;
        }
    
        @Override
        public String toString() {
        
            return "Person{" +
                    "hobby=" + hobby +
                    '}';
        }
    }

## 自定义泛型接口 ##

### 什么时候使用泛型接口 ###

当定义接口时，内部方法中其参数类型，返回值不确定时，就可以使用泛型替代。

### 定义泛型接口的格式 ###

接口名后面加上尖括号，里面定义泛型名。

### 泛型接口中的泛型确定时机？ ###

子类如果可以确定类型，在实现接口的时候，直接确定类型  
  子类如果不确定类型，回到泛型类的使用。

### 看代码理解 ###

着重理解格式

//自定义泛型接口
    
    public interface MyCollection<E> {
        
        public abstract void add(E e);
    }
    
    //如果泛型没有指定，默认Object类型
    class MyCollectionImpl1 implements MyCollection{
        
    
        @Override
        public void add(Object o) {
        
    
        }
    }
    
    class MyCollectionImpl2 implements MyCollection<String>{
        
    
        @Override
        public void add(String s) {
        
    
        }
    }
    
    //着重理解三张格式，特别时第三种
    class MyCollectionImpl3<E> implements MyCollection<E>{
        
    
        @Override
        public void add(E e) {
        
    
        }
    }

## 自定义泛型方法 ##

当定义方法时，方法中的参数类型，返回值类型不确定时，就可以使用泛型替代了。

### 定义格式 ###

修饰符<泛型名> 返回值类型 方法名（参数类别）{
    }

## 泛型的指定 ##

调用含有泛型的方法时，传入的数据其类型就是泛型的类型

### 代码理解 ###

public class Demo {
        
        public static void main(String[] args) {
        
            show("abc");
            //String
            show(2);
            //Integer
            
            
        }
    
        //自定义泛型方法
        public static <E> void show (E e){
        
            //如果e的类型是String
            if(e instanceof String){
        
                System.out.println("String");
            }
            如果e的类型是Integer
            if(e instanceof Integer){
        
                System.out.println("Integer");
            }
        }
    }

## 定义存储字符串的ArrayList集合，将字符串的集合转化为字符串数组 ##

public class Demo2 {
        
        public static void main(String[] args) {
        
            ArrayList<String> list = new ArrayList<>();
    
            list.add("abc");
            list.add("ert");
            list.add("ghg");
    
            //将字符串的集合转化为字符串数组
            String[] strings = new String[list.size()];
            String[] array = list.toArray(strings);
            System.out.println(Arrays.toString(array));
            //[abc, ert, ghg]
        }
    }

## 泛型通配符 ？ ##

### 泛型上限的格式和含义 ###

<? entends 类型> 只能是本类型或者子类型

### 泛型下限的格式 ###

<? super 类型> 只能是本类型或者父类型，到顶只能是Object。

### 代码理解 ###

public class Test1 {
        
        public static void main(String[] args) {
        
            ArrayList<Integer> integers = new ArrayList<>();
            ArrayList<Number> numbers = new ArrayList<>();
            ArrayList<String> strings = new ArrayList<>();
            ArrayList<Object> objects = new ArrayList<>();
    
            //下限
            show1(numbers);
            show1(objects);
    
            //上限
            show2(numbers);
            show2(integers);
    
    
        }
        //泛型的下限
        //show1方法，参数只接收元素类型Number或者其父类型的集合
        //接受的集合，集合中元素的类型可以是Number或者Number的父类型
        public static void show1(ArrayList<? super Number> List){
        
    
        }
    
        //泛型的上限
        //show2方法，参数只接收元素类型Number或者其子类型的集合
        //接受的集合，集合中元素的类型可以是Number或者Number的子类型
        public static void show2(ArrayList<? extends Number> List){
        
    
        }
    }

学的不是技术，更是梦想！！！