`

Java基础 -- 泛型

    博客分类:
  • Java
 
阅读更多

 

 Java基础 -- 泛型

 

概述:

泛型术语的意思就是“适用于许多许多的类型”,是某种不具体的类型即类型参数化,由于某些业务场景下继承类或者实现接口,同样会对程序的约束太强,而我们希望达到的目的是更通用的代码,

所有Java SE5以后增加了泛型。

 

用途:

创建集合类及结合java反射的通用方法

 

泛型类型分类:

1.泛型类

  -- 泛型类的定义如下代码,粉色部分指明泛型,本例中使用 T 和 K,可以使用任意字母指定

  -- 泛型类的使用,在实例化对象时指定泛型类型即new后面的类名后的部分number1,所以number3部分要和number2部分保持一致,number2部分即为确定后的类型,就和其他普通类型一样可以任意使用

  

                   //1.泛型类声明
public class Holder<T, K>{
	private T a;
	private K b;
	public Holder(T a, K b){
		this.a = a;
		this.b = b;
	}
	public T getA() {
		return a;
	}
	public void setA(T a) {
		this.a = a;
	}
	public K getB() {
		return b;
	}
	public void setB(K b) {
		this.b = b;
	}
	
	public static void main(String[] args){
		//3.确定一具体的类型,就和普通类型一样使用       //2.指明泛型类型,传入上面的声明
		Holder<String, Integer> h1 = new Holder<String, Integer>("test", 123);
		System.out.println(h1.getA());
		System.out.println(h1.getB());
	}
}

 

 

 

 

 

2. 泛型接口

  -- 泛型接口定义和泛型类定义类似,在实现类implements 接口时指定泛型类型 :public class A implements InterfaceB<String, Integer>

  -- 实现类实现接口的方法

  -- 具体例子参考Thinking in Java-泛型接口,书中列举了一个生成器 generator Iteratable Iterator的例子

 

3. 泛型方法

  --泛型方法可以独立创建和所在的类是不是泛型类无关系,也就是说是否拥有泛型方法,与其所在的类是否是泛型类无关

  --基本原则 如果使用泛型方法可以取代讲整个类泛型化,那么久应该只使用泛型方法,因为他可以使事情更加清楚明白--代码易读

  --对于一个static方法无法访问泛型类的参数,所以,如果static方法需要使用泛型能力,就必须使其成为泛型方法

  --对于一个非static成员方法,如果所在的类时泛型类,则没有必要再将该方法定义为泛型方法,因为,它已经有了泛型的功能

  --泛型方法的定义及使用如以下代码,静态泛型方法定义及使用与以下相同

  

import java.util.HashMap;
import java.util.Map;

public class Holder2 {
	
	//1.定义泛型方法只需要在方法的返回类型前加上泛型类型<K, T>
	public <T,K> Map<T, K> addMapElement(T a, K b){
		//实例化一个泛型类,只不过这个类的泛型类型是由泛型方法的泛型传入的
		Map<T, K> map = new HashMap<T, K>();
		map.put(a, b);
		return map;
	}
	
	public <T, K> Map<T, K> getMap(){
		Map<T, K> map = new HashMap<T, K>();
		return map;
	}
	
	public static void main(String[] args) {
		Holder2 a = new Holder2();
		//2.隐式泛型类型调用 - jvm泛型类型自动推断
		//  -- 隐式的类型推断只能使用于最终方法返回结果用于赋值的情况(或者不处理返回结果),如果泛型方法的返回结果作为另一个方法的实参,则它被赋值给一个object类型,并不能推断为正确的类型
		//2.1 隐式一
		//  -- 调用泛型方法时,没有指定泛型类型,jvm会根据实际传入的值得类型推断出类型
		//  -- 基本数据类型是无法作为泛型类型的,这里jvm隐式地做了Integer的类型包装
		Map<String, Integer> map01 = a.addMapElement("test", 123);
		System.out.println("result: " + map01.get("test"));
		
		//2.2 隐式二
		//  -- 根据接收方法返回值的本地变量的类型自动推断
		Map<String, Integer> map02 = a.getMap();
		map02.put("test", 456);
		System.out.println("result: " + map02.get("test"));
		
		//3.显示泛型类型调用
		//  -- 在调用的泛型方法的名前面指明泛型类型
		Map<String, Integer> map03 = a.<String, Integer>addMapElement("test", 789);
		System.out.println("result: " + map03.get("test"));
		
	}

}

6.结合java反射实例:

  

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Holder3 {
	private String name;
	private String age;
	
	Holder3(String name, String age){
		this.name = name;
		this.age = age;
	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getAge() {
		return age;
	}

	public void setAge(String age) {
		this.age = age;
	}

	public static <K> String toString(K a) throws Exception{
		String str = "";
		Field[] fields = a.getClass().getDeclaredFields();
		for(Field field : fields){
			String fieldName = field.getName();
			str += fieldName + " : ";
			fieldName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
			Method m =a.getClass().getMethod("get" + fieldName);
			str += m.invoke(a) + "\n";
		}
		return str;
	}

	public static void main(String[] args) throws Exception{
		Holder3 h = new Holder3("lv", "30");
		
		//以下两种调用方式都可以
		//System.out.println("result:" + Holder3.<Holder3>toString(h));
		System.out.println("result:" + Holder3.toString(h));
	}

}

 

 

7.边界

  -- <T extends ParentClass & InterfaceA> 定义泛型类或者泛型接口,在之前的定义中,是无法调用泛型T对象的任何方法的,但是在设置边界后,可以调用父类对象或者接口里的方法

8. 通配符

  -- ? : 表示可以是任意一种具体的泛型类型,使用形式为List<? ** **> 或者 MyClass<? ** **>,不可以出现在泛型类及泛型方法的直接定义中,就和其他普通类型一样使用

  -- ?extends  ClassA 成员方法,泛型方法

  -- ?  super ClassA 成员方法,泛型方法

  -- ?  extends T --用于泛型方法中 

  -- ?  super T -- 用于泛型方法中

 

9.Class<?>,Class<T> 使用 MyClass.class, class传递给class变量,MyClass作为具体泛型类型

 

======以下为引用其他博客=====

 

通配符

在了解通配符之前,我们首先必须要澄清一个概念,还是借用我们上面定义的Box类,假设我们添加一个这样的方法:

1
public void boxTest(Box<Number> n) { /* ... */ }

那么现在Box<Number> n允许接受什么类型的参数?我们是否能够传入Box<Integer>或者Box<Double>呢?答案是否定的,虽然Integer和Double是Number的子类,但是在泛型中Box<Integer>或者Box<Double>Box<Number>之间并没有任何的关系。这一点非常重要,接下来我们通过一个完整的例子来加深一下理解。

首先我们先定义几个简单的类,下面我们将用到它:

1
2
3
class Fruit {}
class Apple extends Fruit {}
class Orange extends Fruit {}

下面这个例子中,我们创建了一个泛型类Reader,然后在f1()中当我们尝试Fruit f = fruitReader.readExact(apples);编译器会报错,因为List<Fruit>List<Apple>之间并没有任何的关系。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class GenericReading {
    static List<Apple> apples = Arrays.asList(new Apple());
    static List<Fruit> fruit = Arrays.asList(new Fruit());
    static class Reader<T> {
        T readExact(List<T> list) {
            return list.get(0);
        }
    }
    static void f1() {
        Reader<Fruit> fruitReader = new Reader<Fruit>();
        // Errors: List<Fruit> cannot be applied to List<Apple>.
        // Fruit f = fruitReader.readExact(apples);
    }
    public static void main(String[] args) {
        f1();
    }
}

但是按照我们通常的思维习惯,Apple和Fruit之间肯定是存在联系,然而编译器却无法识别,那怎么在泛型代码中解决这个问题呢?我们可以通过使用通配符来解决这个问题:

1
2
3
4
5
6
7
8
9
10
11
12
13
static class CovariantReader<T> {
    T readCovariant(List<? extends T> list) {
        return list.get(0);
    }
}
static void f2() {
    CovariantReader<Fruit> fruitReader = new CovariantReader<Fruit>();
    Fruit f = fruitReader.readCovariant(fruit);
    Fruit a = fruitReader.readCovariant(apples);
}
public static void main(String[] args) {
    f2();
}

这样就相当与告诉编译器, fruitReader的readCovariant方法接受的参数只要是满足Fruit的子类就行(包括Fruit自身),这样子类和父类之间的关系也就关联上了。

PECS原则

上面我们看到了类似<? extends T>的用法,利用它我们可以从list里面get元素,那么我们可不可以往list里面add元素呢?我们来尝试一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class GenericsAndCovariance {
    public static void main(String[] args) {
        // Wildcards allow covariance:
        List<? extends Fruit> flist = new ArrayList<Apple>();
        // Compile Error: can't add any type of object:
        // flist.add(new Apple())
        // flist.add(new Orange())
        // flist.add(new Fruit())
        // flist.add(new Object())
        flist.add(null); // Legal but uninteresting
        // We Know that it returns at least Fruit:
        Fruit f = flist.get(0);
    }
}

答案是否定,Java编译器不允许我们这样做,为什么呢?对于这个问题我们不妨从编译器的角度去考虑。因为List<? extends Fruit> flist它自身可以有多种含义:

1
2
3
List<? extends Fruit> flist = new ArrayList<Fruit>();
List<? extends Fruit> flist = new ArrayList<Apple>();
List<? extends Fruit> flist = new ArrayList<Orange>();
  • 当我们尝试add一个Apple的时候,flist可能指向new ArrayList<Orange>();
  • 当我们尝试add一个Orange的时候,flist可能指向new ArrayList<Apple>();
  • 当我们尝试add一个Fruit的时候,这个Fruit可以是任何类型的Fruit,而flist可能只想某种特定类型的Fruit,编译器无法识别所以会报错。

所以对于实现了<? extends T>的集合类只能将它视为Producer向外提供(get)元素,而不能作为Consumer来对外获取(add)元素。

如果我们要add元素应该怎么做呢?可以使用<? super T>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class GenericWriting {
    static List<Apple> apples = new ArrayList<Apple>();
    static List<Fruit> fruit = new ArrayList<Fruit>();
    static <T> void writeExact(List<T> list, T item) {
        list.add(item);
    }
    static void f1() {
        writeExact(apples, new Apple());
        writeExact(fruit, new Apple());
    }
    static <T> void writeWithWildcard(List<? super T> list, T item) {
        list.add(item)
    }
    static void f2() {
        writeWithWildcard(apples, new Apple());
        writeWithWildcard(fruit, new Apple());
    }
    public static void main(String[] args) {
        f1(); f2();
    }
}

这样我们可以往容器里面添加元素了,但是使用super的坏处是以后不能get容器里面的元素了,原因很简单,我们继续从编译器的角度考虑这个问题,对于List<? super Apple> list,它可以有下面几种含义:

1
2
3
List<? super Apple> list = new ArrayList<Apple>();
List<? super Apple> list = new ArrayList<Fruit>();
List<? super Apple> list = new ArrayList<Object>();

当我们尝试通过list来get一个Apple的时候,可能会get得到一个Fruit,这个Fruit可以是Orange等其他类型的Fruit。

根据上面的例子,我们可以总结出一条规律,”Producer Extends, Consumer Super”:

  • “Producer Extends” – 如果你需要一个只读List,用它来produce T,那么使用? extends T
  • “Consumer Super” – 如果你需要一个只写List,用它来consume T,那么使用? super T
  • 如果需要同时读取以及写入,那么我们就不能使用通配符了。

如何阅读过一些Java集合类的源码,可以发现通常我们会将两者结合起来一起用,比如像下面这样:

1
2
3
4
5
6
public class Collections {
    public static <T> void copy(List<? super T> dest, List<? extends T> src) {
        for (int i=0; i<src.size(); i++)
            dest.set(i, src.get(i));
    }
}

类型擦除

Java泛型中最令人苦恼的地方或许就是类型擦除了,特别是对于有C++经验的程序员。类型擦除就是说Java泛型只能用于在编译期间的静态类型检查,然后编译器生成的代码会擦除相应的类型信息,这样到了运行期间实际上JVM根本就知道泛型所代表的具体类型。这样做的目的是因为Java泛型是1.5之后才被引入的,为了保持向下的兼容性,所以只能做类型擦除来兼容以前的非泛型代码。对于这一点,如果阅读Java集合框架的源码,可以发现有些类其实并不支持泛型。

说了这么多,那么泛型擦除到底是什么意思呢?我们先来看一下下面这个简单的例子:

1
2
3
4
5
6
7
8
9
10
public class Node<T> {
    private T data;
    private Node<T> next;
    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }
    public T getData() { return data; }
    // ...
}

编译器做完相应的类型检查之后,实际上到了运行期间上面这段代码实际上将转换成:

1
2
3
4
5
6
7
8
9
10
public class Node {
    private Object data;
    private Node next;
    public Node(Object data, Node next) {
        this.data = data;
        this.next = next;
    }
    public Object getData() { return data; }
    // ...
}

这意味着不管我们声明Node<String>还是Node<Integer>,到了运行期间,JVM统统视为Node<Object>。有没有什么办法可以解决这个问题呢?这就需要我们自己重新设置bounds了,将上面的代码修改成下面这样:

1
2
3
4
5
6
7
8
9
10
public class Node<T extends Comparable<T>> {
    private T data;
    private Node<T> next;
    public Node(T data, Node<T> next) {
        this.data = data;
        this.next = next;
    }
    public T getData() { return data; }
    // ...
}

这样编译器就会将T出现的地方替换成Comparable而不再是默认的Object了:

1
2
3
4
5
6
7
8
9
10
public class Node {
    private Comparable data;
    private Node next;
    public Node(Comparable data, Node next) {
        this.data = data;
        this.next = next;
    }
    public Comparable getData() { return data; }
    // ...
}

上面的概念或许还是比较好理解,但其实泛型擦除带来的问题远远不止这些,接下来我们系统地来看一下类型擦除所带来的一些问题,有些问题在C++的泛型中可能不会遇见,但是在Java中却需要格外小心。

问题一

在Java中不允许创建泛型数组,类似下面这样的做法编译器会报错:

1
List<Integer>[] arrayOfLists = new List<Integer>[2];  // compile-time error

为什么编译器不支持上面这样的做法呢?继续使用逆向思维,我们站在编译器的角度来考虑这个问题。

我们先来看一下下面这个例子:

1
2
3
Object[] strings = new String[2];
strings[0] = "hi";   // OK
strings[1] = 100;    // An ArrayStoreException is thrown.

对于上面这段代码还是很好理解,字符串数组不能存放整型元素,而且这样的错误往往要等到代码运行的时候才能发现,编译器是无法识别的。接下来我们再来看一下假设Java支持泛型数组的创建会出现什么后果:

1
2
3
4
Object[] stringLists = new List<String>[];  // compiler error, but pretend it's allowed
stringLists[0] = new ArrayList<String>();   // OK
// An ArrayStoreException should be thrown, but the runtime can't detect it.
stringLists[1] = new ArrayList<Integer>();

假设我们支持泛型数组的创建,由于运行时期类型信息已经被擦除,JVM实际上根本就不知道new ArrayList<String>()new ArrayList<Integer>()的区别。类似这样的错误假如出现才实际的应用场景中,将非常难以察觉。

如果你对上面这一点还抱有怀疑的话,可以尝试运行下面这段代码:

1
2
3
4
5
6
7
public class ErasedTypeEquivalence {
    public static void main(String[] args) {
        Class c1 = new ArrayList<String>().getClass();
        Class c2 = new ArrayList<Integer>().getClass();
        System.out.println(c1 == c2); // true
    }
}

问题二

继续复用我们上面的Node的类,对于泛型代码,Java编译器实际上还会偷偷帮我们实现一个Bridge method。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Node<T> {
    public T data;
    public Node(T data) { this.data = data; }
    public void setData(T data) {
        System.out.println("Node.setData");
        this.data = data;
    }
}
public class MyNode extends Node<Integer> {
    public MyNode(Integer data) { super(data); }
    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
}

看完上面的分析之后,你可能会认为在类型擦除后,编译器会将Node和MyNode变成下面这样:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Node {
    public Object data;
    public Node(Object data) { this.data = data; }
    public void setData(Object data) {
        System.out.println("Node.setData");
        this.data = data;
    }
}
public class MyNode extends Node {
    public MyNode(Integer data) { super(data); }
    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
}

实际上不是这样的,我们先来看一下下面这段代码,这段代码运行的时候会抛出ClassCastException异常,提示String无法转换成Integer:

1
2
3
4
MyNode mn = new MyNode(5);
Node n = mn; // A raw type - compiler throws an unchecked warning
n.setData("Hello"); // Causes a ClassCastException to be thrown.
// Integer x = mn.data;

如果按照我们上面生成的代码,运行到第3行的时候不应该报错(注意我注释掉了第4行),因为MyNode中不存在setData(String data)方法,所以只能调用父类Node的setData(Object data)方法,既然这样上面的第3行代码不应该报错,因为String当然可以转换成Object了,那ClassCastException到底是怎么抛出的?

实际上Java编译器对上面代码自动还做了一个处理:

1
2
3
4
5
6
7
8
9
10
11
class MyNode extends Node {
    // Bridge method generated by the compiler
    public void setData(Object data) {
        setData((Integer) data);
    }
    public void setData(Integer data) {
        System.out.println("MyNode.setData");
        super.setData(data);
    }
    // ...
}

这也就是为什么上面会报错的原因了,setData((Integer) data);的时候String无法转换成Integer。所以上面第2行编译器提示unchecked warning的时候,我们不能选择忽略,不然要等到运行期间才能发现异常。如果我们一开始加上Node<Integer> n = mn就好了,这样编译器就可以提前帮我们发现错误。

问题三

正如我们上面提到的,Java泛型很大程度上只能提供静态类型检查,然后类型的信息就会被擦除,所以像下面这样利用类型参数创建实例的做法编译器不会通过:

1
2
3
4
public static <E> void append(List<E> list) {
    E elem = new E();  // compile-time error
    list.add(elem);
}

但是如果某些场景我们想要需要利用类型参数创建实例,我们应该怎么做呢?可以利用反射解决这个问题:

1
2
3
4
public static <E> void append(List<E> list, Class<E> cls) throws Exception {
    E elem = cls.newInstance();   // OK
    list.add(elem);
}

我们可以像下面这样调用:

1
2
List<String> ls = new ArrayList<>();
append(ls, String.class);

实际上对于上面这个问题,还可以采用Factory和Template两种设计模式解决,感兴趣的朋友不妨去看一下Thinking in Java中第15章中关于Creating instance of types(英文版第664页)的讲解,这里我们就不深入了。

问题四

我们无法对泛型代码直接使用instanceof关键字,因为Java编译器在生成代码的时候会擦除所有相关泛型的类型信息,正如我们上面验证过的JVM在运行时期无法识别出ArrayList<Integer>ArrayList<String>的之间的区别:

1
2
3
4
5
6
public static <E> void rtti(List<E> list) {
    if (list instanceof ArrayList<Integer>) {  // compile-time error
        // ...
    }
}
=> { ArrayList<Integer>, ArrayList<String>, LinkedList<Character>, ... }

和上面一样,我们可以使用通配符重新设置bounds来解决这个问题:

1
2
3
4
5
public static void rtti(List<?> list) {
    if (list instanceof ArrayList<?>) {  // OK; instanceof requires a reifiable type
        // ...
    }

 

参考自 Thinking In Java

分享到:
评论

相关推荐

    java基础-泛型通配符

    java基础-泛型通配符

    大学课程讲义-Java基础-泛型.docx

    Java泛型是Java编程语言中的一种特性,它允许在数据结构(如集合)中存储特定类型的元素,从而提供了编译时的类型安全性和更清晰的代码。泛型引入的主要目标是...理解并熟练使用泛型是每个Java开发者的基础技能之一。

    关于java基础的泛型的练习

    Java泛型是Java SE 5.0引入的一个重要特性,它极大地增强了代码的类型安全...在进行"关于Java基础的泛型的练习"时,可以尝试编写不同的泛型类、泛型方法,体验泛型带来的便利,并理解其背后的类型系统和类型擦除机制。

    java基础-泛型学习总结

    思维导图

    【Java基础】泛型方法 - 右撇子 - 博客频道 - CSDN.NET

    【Java基础】泛型方法 - 右撇子 - 博客频道 - CSDN.NET

    java基础-中级-高级-深入·

    ### Java基础 #### 1. Java概述 - **定义**:Java是一种面向对象的编程语言,由Sun Microsystems公司于1995年推出。 - **特点**: - 面向对象:支持封装、继承、多态等特性。 - 平台无关性:Java程序可以在任何...

    黑马程序员----泛型与反射的小运用

    在Java编程语言中,泛型和反射是两个非常重要的特性,它们在软件开发中有着广泛的应用。本篇文章将深入探讨这两个概念以及它们在实际开发中的小运用。 首先,我们来看泛型(Generics)。泛型是在Java SE 5.0引入的...

    Java 基础(4-8) - 泛型机制详解.pdf

    Java泛型是自JDK 1.5版本引入的一个重要特性,目的是为了提高代码的类型安全性和重用性。在Java中,泛型允许开发者在类、接口和方法中使用类型参数,使得代码能处理多种数据类型而无需重复编写相似的代码。然而,...

    日常笔记-JAVA泛型

    日常笔记-JAVA泛型

    实例190 - 泛型化的折半查找法

    1. **泛型基础**: - 泛型引入了类型参数的概念,例如 `&lt;T&gt;`,其中 `T` 是一个占位符,代表任意类型。 - 使用泛型可以确保在编译时进行类型检查,避免运行时错误。 - 泛型方法允许我们在方法定义中使用类型参数,...

    java泛型学习ppt

    泛型基础: * 在定义泛型类或声明泛型类的变量时,使用尖括号来指定形式类型参数。 * 当声明或者实例化一个泛型的对象时,必须指定类型参数的值。 自定义简单泛型: * public class Gclass&lt;T&gt;{ private T a; ...

    java基础教程----精华版

    这个"java基础教程----精华版"显然是一份精心整理的资料,旨在帮助初学者快速掌握Java编程的基础知识。下面将详细介绍Java语言的核心概念和关键知识点。 1. **Java语法基础**: - **变量**:在Java中,变量是存储...

    JAVA学习笔试(数据基础+泛型编程)-适合小白

    本笔记主要涵盖了数据基础和泛型编程两大主题,同时也涉及到类和对象、数据类型、类的初始化和加载以及单例模式等多个知识点。 1. **数据基础** - **形参实参的使用**:在函数调用时,形参是方法定义中的参数,而...

    关于C#、java泛型的看法

    在Java中,泛型同样使用尖括号表示,但它的类型擦除特性使得编译后的字节码并不包含类型参数信息,而是使用Object或其他基础类型作为替代。这意味着Java的泛型不支持协变和逆变,但可以通过通配符(如?)来放宽类型...

    JAVA基础-集合类

    ### JAVA基础-集合类 #### 一、集合的概述与分类 ##### 1. 集合概述 集合是Java编程语言中一种重要的数据结构,它用于存储一系列的对象。与数组相比,集合提供了更加灵活的方式来处理数据。集合的一个显著特点是它...

    java泛型的内部原理及更深应用

    这意味着在编译完成后,所有的泛型信息都会被擦除,替换为Object或者其他基础类型。因此,泛型在运行时并不存在,所有关于泛型的操作都在编译期间完成。 2. **边界通配符**:在处理泛型时,我们经常遇到边界通配符...

    java泛型集合 java集合 集合 java Collection

    总的来说,Java泛型集合和集合框架提供了强大的数据存储和处理能力,而`Collection`接口作为基础,连接了各种集合类型。了解并熟练掌握这些概念和用法,对于提高Java编程效率和代码质量至关重要。

    Java基础篇:泛型.pdf

    泛型是Java编程语言中用于减少类型转换错误和增强代码安全性的机制,它允许在定义类、接口和方法时使用类型参数。通过这种方式,可以在编译时期捕获那些只有在运行时期才会暴露的类型错误,提高了代码的健壮性。 ...

Global site tag (gtag.js) - Google Analytics