Java小白学点东西（11）

1.泛型【重点难点】

1.1为什么实用泛型

在实际的开发中对于数据的一致性要求是比较重要的

例如：

ArrayList list = ArrayList();数组容器

如果没有对list这个容器进行约束的话，存放数据可以方法任意类型的数据

等咱们取数据的时候，可能牵涉到强转。强转的话就不安全。

这个时候可以加泛型

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

这个时候list就只能存放String类型的数据了，泛型的好处：

1.数据一致化

2.避免强转发生错误

3.避免因为数据不一致导致的问题

4.操作统一化

1.2最基本的泛型格式

泛型

<无意义的字符><T> <E><?>

1.约束性

2.普适性

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

如果一个方法使用了泛型，会让该方法具有普适性，更加灵活

语法格式：

public （static）<自定义的无意义的占位符> 返回值类型 方法名字（有参数）{}

class Person{
    private int age;
    private String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}
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];
    }
​
}

 

1.4自定泛型在类中如何使用【重点难点】

语法格式：

class 类名<自定义的无意义的字符> {

}

自定义泛型类的总结：

        1. 在类名的后面加<T>  声明当前类带有的泛型。
        2. 在实例化这个类对象的时候，确定了当前所带泛型的数据类型
        3. 方法中带有<T>的话，和当前类的泛型数据类型无关。如果方法中不带<T>泛型和当前类泛型保持一致
        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);
​
    }
}

 

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

语法格式：

interface 接口名字<T>{

//成员方法

}

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);
    }
}
​

 

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

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);
    }
}

​

 

2.权限修饰符

java有4个权限修饰符

public private default protected

权限：

四个修饰符就是对咱们学过的 类，方法，属性等进行修饰的

不同的权限修饰符修饰类，方法，属性等，这些类，方法，属性的他们权限就不一样

2.1private

修饰属性和方法

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

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

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

2.2default

修饰属性和方法

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

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

2.3protected

修饰属性和方法

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

2.4public

公开的，怎么样都可以 为所欲为

修饰符的名称	当前类	同一个包	其他包的子孙类	其他包的类
public	可以	可以	可以	可以
protected	可以	可以	可以	不可以
default	可以	可以	不可以	不可以
private	可以	不可以	不可以	不可以