泛型和权限修饰符的使用

---

前言

本文主要浅谈Java中泛型和权限修饰符的使用

一、为什么使用泛型？

在实际开发中对于数据的一致性要求是比较重要的
例如：
ArrayList list = new ArrayList();//数组容器
如果没有对list这个容器进行约束的话，存放数据可以存放任意类型的数据等咱们取数据的时候，可能牵扯到数据类型的强制转换，强转的话就不安全。
这个时候可以使用泛型进行约束
ArrayList list = new ArrayList<>();
这个时候list就只能存放String类型的数据了

使用泛型的好处

1.保证数据一致化
2.避免强转发生错误
3.避免因为数据不一致导致的问题
4.操作统一化

二、最基本的泛型格式

泛型
<无意义的字符> 无意义的字符一般用：T 、E、?
1.约束性
2.普适性

三、自定义泛型的使用

3.1自定义泛型在方法中如何定义

如何一个方法使用了泛型，会让这个方法具有普适性，更加灵活
语法格式：
public [static] <自定义的无意义的占位符> 返回值类型 方法名字（有参数）{}

public class Demo2 {
    public static void main(String[] args) {
        int test = test(2);
        System.out.println(test);//1
        //int 包装类 Integer  int a = 10  ===>Integer a = new Integer(10);
        //char 包装类 Character char ch= 'a'===>Character ch = new Character('a');
        //String 包装类 String  String str = "sjsj";==>String str = new STring("shsjj");
        //boolean包装类 Boolean
        Integer integer = test1(2);
        String gouda = test1("gouda");
        Character a = test1('a');
        Boolean aBoolean = test1(false);
        Person person = test1(new Person(23, "赵四"));
        System.out.println(person);

        Integer integer1 = printArray(new Integer[]{1, 2, 3, 4});
        System.out.println(integer);
        Person person1 = printArray(new Person[]{new Person(20, "狗蛋1"), new Person(34, "狗蛋2")});

    }
    public  static int test(int num) {
        return num;
    }

    /**
     *
     * @param t
     * @param <T>
     * @return  T  是参数的类型
     */
    public static <T> T test1(T t) {
        return t;
    }
//    public static int printARra(int[] arr) {
//        return
//    }
    public static <T> T printArray(T[] arr) {
        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }
        return arr[0];
    }

}

3.2自定义泛型在类中如何使用【重点】

语法格式：
class 类名 <自定义的无意义的字符>{

}
自定义泛型类的总结：
1.在类名的后面加，声明当前类带有的泛型。
2.在实例化这个类的时候，确定了当前类所带的泛型的数据类型。
3.方法中带有的话，和当前类的泛型的数据类型无关。如果方法中不带泛型和当前类泛型保持一致。
4.静态方法的泛型和类的泛型无关。

class Test1<T> {
    //定义一些成员方法
    //public <T> T getType(T t){}这个时候T和类声明的泛型无关
    public  T getType(T t) {//这个时候的T和类声明的泛型有关系
        return t;
    }
    //没有返回值的成员方法
    public void testArgs(T t) {
        System.out.println(t);
    }

    //声明一个静态的方法
    /*
    * 静态的成员方法不能使用类自定义的泛型？
    * 静态的成员方法的调用早于对象的创建，
    * 而咱们泛型的约束，在创建对象的时候进行约束的
    * */
    public static <E> E testStatic(E e) {
        return e;
    }


}
public class Demo3 {
    public static void main(String[] args) {
        Test1<String> stringTest1 = new Test1<>();
        String type = stringTest1.getType("123");
        System.out.println(type);
        stringTest1.testArgs("goudan");
        Test1<Integer> integerTest1 = new Test1<>();
        Integer type1 = integerTest1.getType(12);
        System.out.println(type1);
        Test1<Person> personTest1 = new Test1<>();
        Person person = personTest1.getType(new Person(23, "呵呵哒"));
        System.out.println(person);
        String s = Test1.testStatic("123");
        System.out.println(s);


    }
}

3.3自定义泛型在接口中的使用

语法格式：
interface 接口名字 {
//成员方法
}

interface A<T>{
    public T getT(T t);
    public void test(T t);

}
//实现类必须和接口中泛型保持一致
class TestA<T> implements A<T>{

    @Override
    public T getT(T t) {
        return t;
    }

    @Override
    public void test(T t) {
        System.out.println(t);
    }
}
public class Demo4 {
    public static void main(String[] args) {
        TestA<String> stringTestA = new TestA<>();
        String heheda = stringTestA.getT("heheda");
        System.out.println(heheda);
    }
}

3.4自定义泛型在抽象类中的使用

abstract class B<E>{
    public abstract  E getB(E e);
    public void get(E e) {
        System.out.println(e);
    }
}
class TestB<E> extends B<E>{

    @Override
    public E getB(E e) {
        return e;
    }
}
public class Demo5 {
    public static void main(String[] args) {
        TestB<Integer> integerTestB = new TestB<>();
        Integer b = integerTestB.getB(12);
        System.out.println(b);
    }
}

4. 权限修饰符

java给咱们咱们4个权限修饰符
public private default protected
权限：
四个修饰符就是对咱们学过的 类，方法，属性等进行修饰的
不同的权限修饰符修饰类，方法，属性等，这些类，方法，属性的他们权限就不一样

2.1private

修饰属性和方法

1.只能在同一类中访问到。

2.但是在同一个包下面的其他的类（子类或者其他类），都是不能访问private修饰的成员属性的。

3.不在一个包下面的类，更不能访问私有的成员属性

2.2default

修饰属性和方法

1.除了在同一类中能访问到，同一包的其他类（子类和其他类）也可以访问

2.在其他包中类（即是你是继承关系也不行）不能访问

2.3protected

修饰属性和方法

1.除了在同一个类中和同一个包中的类（子类和其他的任意的类）能访问。其他包中的子类都可以访问

2.4public

公开的，同一个工程下可以使用