2021年8月10日
1.泛型
2.权限修饰符
1.泛型【重点难点】
1.1为什么实用泛型
在实际的开发中对于数据的一致性要求是比较重要的
例如：
如果没有对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 类名<自定义的无意义的字符> {
}
自定义泛型类的总结：
在类名的后面加<T> 声明当前类带有的泛型。
在实例化这个类对象的时候，确定了当前所带泛型的数据类型
方法中带有<T>的话，和当前类的泛型数据类型无关。如果方法中不带<T>泛型和当前类泛型保持一致
静态方法和类中泛型无关
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>{
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>{
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 | 可以 | 不可以 | 不可以 | 不可以 |
