2021年8月10日

今天的內容

1.泛型

2.權限修飾符

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] <自定義的無意義的占位符> 返回值類型 方法名字（有參數）{}

package com.qfedu.a_fanxing;
​
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. 靜態方法和類中泛型無關

package com.qfedu.a_fanxing;
​
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>{

//成員方法

}

package com.qfedu.a_fanxing;
​
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自定義泛型在抽象類中的使用

package com.qfedu.a_fanxing;
​
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	可以	不可以	不可以	不可以