Java进阶使用记录

1. instanceof

该运算符用于操作对象实例，检查该对象是否是一个特定类型（类类型或接口类型）

(Object reference variable) instanceof  (class/interface type);
Object name = "James";
Object age = 17;
boolean resultName = name instanceof String; // 由于 name 是 String 类型，所以返回 true
boolean resultAge = age instanceof String; // 由于 age 是 Integer 类型，所以返回 false

其中左边 obj 为一个对象，右边 Class 表示一个类或者一个接口，当 obj 为 Class 的对象，或者是其直接或间接子类，或者是其接口的实现类，结果 result 都返回 true，否则返回false。

注：编译器会检查 obj 是否能转换成右边的 Class 类型，如果不能转换则直接报错，如果不能确定类型，则通过编译，具体看运行时定。

2. Asset 断言

用于对值进行判断，为真则运行，否则报错，多用于调试

Assert.isNull(null, "是否为空"); // 为空则运行
Assert.notNull("", "是否不为空"); // 不为空则运行
Assert.notEmpty(new ArrayList<>(), "数组是否不为空"); // 不为空则运行

可以使用 assert 进行更多判断操作，使用原则：

使用断言捕捉不应该发生的非法情况。不要混淆非法情况与错误情况之间的区别，后者是必然存在的并且是一定要作出处理的。使用断言对函数的参数进行确认。在编写函数时，要进行反复的考查，并且自问：“我打算做哪些假定？”一旦确定了的假定，就要使用断言对假定进行检查。一般教科书都鼓励程序员们进行防错性的程序设计，但要这种编程风格会隐瞒错误。当进行防错性编程时，如果"不可能发生"的事情的确发生了，则要使用断言进行报警。

2.1 IDEA 开启 assert

新版 IDEA 默认把 VM Options 去掉了，需要手动加进来

在 VM Options 里输入 -ea 开启断言

2.2 assert 使用

public static void main(String[] args) {
	int num = 10;
	// 判断 num 是否大于 12，不大于则为假，报错；大于则为真，继续运行
	assert num > 12;
	System.out.println("运行");
}

也可以在后面定义错误信息

public static void main(String[] args) {
	int i = 10;
	// 假如 i < 10，则 i++，否则则报错
	assert (i++ < 10) : "num 大于等于 10";
	System.out.println(i);
}

3. 泛型

？ 表示不确定的 Java类型T （type）表示 Java类型K 代表 Java 键值中的 KeyV 代表 Java 键值中的ValueE 代表 Element 3.1 定义和使用泛型类

[修饰符] class 类名<代表泛型的变量> { }

// 定义泛型类
class User{
    private Fan type;

    public User(Fan type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return "User{" +
                "type=" + type +
                '}';
    }

    public Fan getType() {
        return type;
    }

    public void setType(Fan type) {
        this.type = type;
    }
}
// 使用
public static void main(String[] args) {
	User stringUser = new User<>("String");  // 可以限制泛型为 String
	System.out.println(stringUser); // 输出 String
	
	User user = new User<>(1); // 不进行限制
	System.out.println(user); // 输出 1
	user.setType("类型"); 
	System.out.println(user); // 输出 类型
}

3.2 定义和使用泛型方法

修饰符 <代表泛型的变量> 返回值类型 方法名(参数) { }

// 定义泛型方法
class Person{
    public  void show(Fan fan){
        System.out.println(fan);
    }
    public  Fan showFan(Fan fan){
        return fan;
    }
}
// 使用
public static void main(String[] args) {
	Person person = new Person();
	person.show("String"); // 无返回，直接输出
	
	// 传入一个 List 的 User泛型对象，User 的泛型又为 List
	ArrayList>> users = person.showFan(new ArrayList>>(){
		{
			this.add(new User<>(new ArrayList(){
				{
					this.add("array11");
					this.add("array12");
				}
			}));
			this.add(new User<>(new ArrayList(){
				{
					this.add("array21");
					this.add("array22");
				}
			}));
		}
	});
	System.out.println(users); // 输出返回值
}

3.3 定义和使用泛型接口

修饰符 interface 接口名<代表泛型的变量> { }

interface MyInterface{
    void add(Fan fan);

    Fan get(Fan fan);
}

3.3.1 定义实现类时确定泛型的类型

class MyInterfaceImpl implements MyInterface{
    @Override
    public void add(String s) {
    	System.out.println(s + "，fan");
    }

    @Override
    public String get(String s) {
        return s;
    }
}

3.3.2 始终不确定泛型的类型，直到创建对象时，确定泛型的类型

// 实现类
class MyInterfaceImpl implements MyInterface{

    @Override
    public void add(Fan fan) {
        System.out.println(fan + "，fan");
    }

    @Override
    public Fan get(Fan fan) {
        return fan;
    }
}
// 主启动类
public static void main(String[] args){
	MyInterface myInterface = new MyInterfaceImpl(); // 不限制泛型
	myInterface.add(1);
	MyInterface myInterface1 = new MyInterfaceImpl<>(); // 限制泛型为 String
	System.out.println(myInterface1.get("String"));
}

3.4 泛型通配符 ？

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符 表示。但是一旦使用泛型的通配符后，只能使用 Object 类中的共性方法，集合中元素自身方法无法使用。

3.4.1 通配符基础使用

泛型的通配符：不知道使用什么类型来接收的时候，此时可以使用 ?,? 表示未知通配符。
此时只能接受数据,不能往该集合中存储数据。

public static void main(String[] args) {
	get(new ArrayList(){
		{
			this.add(1);
			this.add(2);
		}
	});
	get(new linkedList(){
		{
			this.add("String1");
			this.add("String1");
		}
	});
}
public static void get(Collection collection){ // 可以传入任意的 Collection 下的类型
	collection.stream().forEach(o -> {
		System.out.println(o);
	});
}

3.4.2 通配符高级使用----受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。
泛型的上限：

格式： 类型名称 对象名称意义： 只能接收该类型及其子类

泛型的下限：

格式： 类型名称 对象名称意义： 只能接收该类型及其父类型

// 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
// Collection 可以换为 ArrayList 等其他类型
public static void getElement1(Collection collection){
	
}
// 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement2(Collection collection){
	
}
// 现已知 Object 类，String 类，Number 类，Integer 类，其中 Number 是 Integer 的父类
public static void main(String[] args) {
    Collection integer = new ArrayList();
    Collection string = new ArrayList();
    Collection number = new ArrayList();
    Collection