Java入门 ：泛型

1泛型

泛型: 广泛的类型

在开发中对数据一致性的要求是比较看重的！！！

方便于数据储存的一致性

1.1带有泛型的方法

语法格式：

public <无意义的占位符> 返回值类型 方法名 (参数列表){
​
}

这个 <无意义的占位符> 里的字符可以任意英文字母，只是在开发中常用的就是 'T' 'E' '?' 这三个

几种方法类型声明：

1.1.1无参数无返回值的方法

public <T> void 方法名(){
​
}

1.1.2有参无返回值的方法

public <T> void 方法名(T t){//这个T也可以时其他的英文字母，只是在开发中常用的就是 'T' 'E' '?' 这三个
    
}

1.1.3无参有返回值的方法

public <T> T 方法名(){
    
}

1.1.4有参有返回值的方法

public <T> T 方法名字(T t){
    
}
​

演示

public class Demo{
    public static void main (String [] args){
        test("张三");//这个里面填什么类型的数据这个T就是什么类型的数据
        test(18);
        test('男');
        test(78.5);
    }
    public static <T> void test(T t){
        System.out.println(t);
    }
}

注意：泛型方法一定是带有参数才有意义，否则完全没有必要声明一个泛型方法

1.2带有泛型类型的类

语法格式：

class 类名 <无意义的占位符> {
​
}

​

演示

public class Demo1 {
    public static void main(String[] args) {
        Test<String> test = new Test<>();
        //当你创建对象时给这个泛型类赋了值，
        // 那么在这个对象里这个T就是String类型的了
        //所以当在调用这个eat方法时只能传入String类型的数据
        test.eat("张三吃黄焖鸡");
        // test.eat(18);//就会报错
        Test<Integer> test2 = new Test<>();
        //在创建对象的时候就会给这个泛型赋值，并且这个对象无法改变
        test2.eat(88);//只能传入int类型的数据
        //当在泛型类中写泛型方法时候，这个泛型方法的数据类型不受对象不影响
        test.sellp("张三要睡觉");
        test.sellp(99);
        test.sellp('男');
        //所以要注意，如果要保证属于类型一致的话，在泛型类中就不要写泛型方法
    }
}
class  Test <T>{
​
    public void eat(T t){
        System.out.println(t);
    }
    public <T> void sellp(T t){//这个T和泛型类的T不是同一个
        System.out.println(t);
    }
}

1.3带有泛型的抽象类

语法格式：

abstract class 类名 <无意义的占位符>{
​
}

演示

public class Demo1 {
    public static void main(String[] args) {
        /**
         * int 的包装类 Integer
         * byte 的包装类 Byte
         * short 的包装类 Short
         * long 的包装类 Long
         * float 的包装类 Float
         * double 的包装类  Double
         * char  的包装类 Character
         * boolean 的包装类 Boolean
         *
         */
        //是int的包装类  就是代表的是int类型的数据
        TestA<Integer> testA = new TestA<>();
        testA.testA(66);
    }
}
abstract class A <T> {
    abstract void testA (T t);
}
//抽象类，暂时没有办法直接实例化，只能再写一个普通类去继承抽象类
//总结：继承了带有泛型的抽象类，那么继承类也需要有泛型！！！
class TestA<T> extends A<T> {
​
    @Override
    void testA(T t) {
        System.out.println(t);
    }
}

1.4带有泛型的接口

语法格式：

interface 接口名 <无意义的占位符>{
​
}

案例

public class Demo1 {
    public static void main(String[] args) {
        Test1<String> test1 = new Test1<>();
        test1.eat("晚上吃什么？");
​
    }
}
interface TestA <T> {
    void eat(T t);
}
class Test1 <T> implements TestA <T>{
    
    @Override
    public void eat(T t) {
        System.out.println(t);
    }
}

​