十五.泛型和权限修饰符

19.泛型

广泛的数据类型

数组的缺点：需要预先定义容量，java提供的方法较少，增删数据太 麻烦。

优点：数组中的数据的数据类型是一致的

集合：也是用来存储数据的，当成一个容器即可

​ 可以传入各种类型数据，不好，java对数据类型要求较高

​ 所以可以用泛型进行约束

package com.qfedu.b_fanxing;

import java.util.ArrayList;

public class Demo1 {
    public static void main(String[] args) {
        //声明一个int类型数组
        int[] arr = {1, 2, 3, 4};
        char[] chs = {'a', 'b', 'c'};
        //在数组的容量中  数据类型的都是一致的，很好！！！
        //数组中的存储的数据确实一致的，但是开发不用！！！为啥？
        //咱们 使用的时候，容量先定好的，而且数组添加数据删除数据，太麻烦了
        //实际开发中咱们需要后面即将学的集合
        //集合就是用来存储的数据的！！！
        ArrayList  list = new ArrayList();//就把他当成一个容器即可
        list.add("狗蛋");
        list.add(250);
        list.add('a');
        list.add(false);
        //啥类型的数据都可以存进来的
        System.out.println(list);
        //以上存储的数据好不好？  不好！！！
        //对数据类型一致性要求是比较高的！！！
        //取值,每次都需要强转  太不好了
        String str = (String)list.get(0);
        System.out.println(str);

        //可以使用泛型 进行约束
        ArrayList<String> list1 = new ArrayList<>();
        //告知编译器  这个集合只能存String类型的数据
        list1.add("狗蛋");
        list1.add("老邢");
        list1.add("骚磊");
        System.out.println(list1);
        //取值
        String s = list1.get(0);
        System.out.println(s);
    //  ArrayList人家底层是封装了好了泛型，人家已经做好的
        //学习自己如何自己写带有泛型的类  泛型的方法 等

    }
}

1.带有泛型的方法

格式：

public <无意义的占位符> 返回值类型 方法名（参数列表）{
	方法体;
}

相比于一般方法：在返回值类型前加无意义占位符T或E

注意：有参数的方法使用泛型才有意义

有参无返回值的方法

public void test( T t ) {

​ 方法体;

}

相当于重载的升级版，省略了多个重载方法不同数据类型的形参

特性： 1.广泛性和普适性 2.约束性

package com.qfedu.b_fanxing;

public class Demo2 {
    public static void main(String[] args) {
        test(34);
        test("狗");
        test('蛋');
        test1();
        test3("老邢");
        test3(89.7);
    }
//    public static void test (int a) {
//        System.out.println(a);
//    }
//    public static void test (String a) {
//        System.out.println(a);
//    }
//    public static void test (char a) {
//        System.out.println(a);
//    }
    //使用泛型的写法
    //这个T只是一个占位而已，如果你传了字符串 那么这个T就是String
    //如果你传了一个整数 那么T  就是Integer
    //具有广泛性和普适性
    //其实方法的重载的升级版本
    //无返回值有参数的
    public static <T> void test (T t) {
        System.out.println(t);
    }
    //无返回值 无参的方法，没有必要使用泛型  没有意义
    public static <T> void test1 () {
        T t = null;
        //你这个结果和泛型有有啥关联？没有任何意义
        System.out.println("嘻嘻哒");
    }
    //无参 有返回值的方法，有咩有必要使用泛型? 没有
    public static <T> T test2() {

        return null;
    }
    //有参 有返回值的方法,这个使用泛型有没有意义? 有！！！
    public static <T> T test3 (T t) {
        return t;
    }
//    public static <T> T test4 (T t, T t1) {
//        return t + ":" + t1;
//    }
    //总结：
    /**
     * 泛型的方法一定是带有参数的才有意义！！！
     * 无参的都是无意义的，而且一定要注意带有返回值的
     * 这个返回值是和参数的T 数据类型要保持一致的
     */


}

2.带有泛型的类

格式：

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

**注在泛型类中写泛型方法时，不需要在泛型方法声明处加，直接在形参列表处（ T , t ）

​ 静态方法无法使用类名后的泛型，因为类名后的泛型需要在new对象时才会指定具体数据类型，但是static静态方法声明早于创建对象，所以会报错

package com.qfedu.b_fanxing;

class Person<T> {

//    T name;//所以成员变量最好不用
//    T age;
//    T sex;
    //主要看成员方法
    //带有泛型的方法，最起码得有参数
    //注意： 如果再一个带有泛型的类，成员方法不要加<T> 了
    public <T> void test (T t) {
        System.out.println(t);
    }
    //想要一个方法中的泛型和类保持一致，一定在方法不要加<T>
    public void test1 (T t) {
        System.out.println(t);
    }
    //如果是静态方法呢？
    //对象创建的时候才 确定E数据类型，静态的方法在创建对象之前
    //这个E和上面 类的T无关的  自娱自乐
    public static <E> void test2 (E e) {
        System.out.println(e);
    }

}
public class Demo4 {
    public static void main(String[] args) {
        //在声明对象的时候，指定好了咱们的T是啥数据类型
        //那么 你的成员变量 T  name  T 就是那种数据类型
        Person<String> stringPerson = new Person<>();
       // stringPerson.name = "goudan";
        // stringPerson  泛型 是String 就意味着test(T t)
        //T  也应该是String
        stringPerson.test(89);
        stringPerson.test1("wuw");
        Person<Integer> person1 = new Person<>();
        //person1.name = 98;
        person1.test1(56);
        //调用静态方法
        Person.test2("hjsj");
    }
}

package com.qfedu.b_fanxing;

class Cat<E> {

    //带有泛型的方法
    public void eat (E e) {
        System.out.println(e);
    }
}
public class Demo5 {
    public static void main(String[] args) {
        Cat<String> cat = new Cat<>();
        cat.eat("还是当今世界");
    }
}

3.带有泛型的抽象类

格式：

abstract class 类名<无意义的占位符> {
	抽象方法;
}

注意：

​ 继承了有泛型的抽象类的子类也需要有泛型，且要和抽象类保持一致

package com.qfedu.c_fanxing;

abstract class A<T> {
    abstract void testA (T t);
}
//抽象类，暂时没有办法直接实例化，只能再写一个普通类去继承抽象类
//总结：继承了带有泛型的抽象类，那么继承类也需要有泛型！！！
class TestA<T> extends A<T> {

    @Override
    void testA(T t) {
        System.out.println(t);
    }
}
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(89);
    }
}

4.带有泛型的接口

格式：

interface 接口名<无意义的占位符> {
	抽象方法;
}

注意：

​ 带有反省的接口的实现类也需要是带有泛型的

package com.qfedu.c_fanxing;

//element 元素  Type  类型
interface B<T> {
    //成员方法
    void eat(T t);
}
class TestB<T> implements B<T> {

    @Override
    public void eat(T t) {
        System.out.println(t);
    }
}
public class Demo2 {
    public static void main(String[] args) {
        TestB<Character> testB = new TestB<>();
        testB.eat('g');


    }
}

20.权限修饰符

private default(默认的) protected public

用于修饰类，成员变量，成员方法等

1.private修饰符

用于修饰成员变量和成员方法，指私有的

1. 私有化的属性和方法只能在本类中使用
2. 同一个包下其他类没办法使用该类私有化的属性和方法
3. 其他包下的其他类不能使用该类私有化的属性和方法

总结：private修饰的成员变量和方法只能在本类中使用

2.不写（默认的）

默认的属性和方法只能在当前包下使用

3.protected

其他包下其他类不能使用，其他包下继承该类的子类可以使用该类的protected修饰的属性和方法

4.public

公开的属性和方法，同一项目谁都可以用

权限修饰符的名称	当前类	同一个包下面其他类	不同包下面子类	不同包下面的其他类
public	可以	可以	可以	可以
protected	可以	可以	可以	不可以的
不写（默认）	可以	可以	不可以	不可以
private	可以	不可以	不可以	不可以