泛型，枚举

什么是泛型？

泛型是广泛普通的类型

泛型能够帮助我们把[类型明确]的工作推迟到创建对象或调用方法的时候

泛型的修饰：

1.泛型类

2.泛型方法

3.泛型接口

泛型类：

把泛型定义在类上，用户在使用类时才能把类型确定。具体使用方法使用<>加上一个未知数通常用大写字母表示。

如果一个泛型类，创建对象时，没有指定泛型方法，默认object,使用这个类时去确定泛型类型

写法

1.SuperArray<String> superArray = new SuperArray()

2.SuperArray<Employee> superArray1 = new SuperArray<>();

JDK7以前两边都有<>

JDK7以后可以如2代码等号右边没有<>

以上面2代码为规范

泛型方法：

我们如果只关心某个方法。可以不定义泛型类，只定义泛型方法

泛型方法是不是一定要在泛型类里？不是

泛型类是不是一定有泛型方法？不是

定义泛型方法时要首先定义泛型类型

定义在方法中间，泛型使用处之前

Public<t>T show(T t){
System.out.println(t);
return t;
}//泛型方法

定义泛型

T 泛型

T t 传泛型类型参数t

使用泛型方法最后结合返回值和object一样

如果出现继承关系：

泛型类在继承时

1.父类是泛型类。子类要不要是泛型类？--不

2，泛型的声明只在当前类名后或方法中间而且声明的类型是自己的

class Father<T> {
    T t;
}
// 在确定子类泛型的时刻，父类的泛型和子类一样
class Son<T> extends Father<T> { }
class Son2 extends Father { }
public class Ch04 {
    public static void main(String[] args) {
        Son<Employee> son = new Son<>();
        son.t = new Employee();
        Son2 son2 = new Son2();
        son2.t.notify();
    }
}

在确定子类泛型某一时刻，父类泛型和子类一样。

3.子类继承父类时，子类泛型和父类泛型都写出来情况下，父跟子。

4.继承时，没有写出任何泛型。当前子类就不是泛型

5.如果在一个泛型中，尽量不使用泛型方法。泛型方法多出现在非泛型类

6，静态方法：（泛型）

1. 静态方法如果是泛型方法，泛型声明必须写

2. 因为静态结构属于类，不属于某个对象

？通配符：可以接收任何类型

如使用object类型。别写泛型。泛型约束类的数据类型

类型参数化。

类型擦除：

为了兼容性，使用原始类型（没有泛型）是可以的。

泛型刚刚出现的时候，还存在大量的不适用泛型的代码。

保证代码的兼容性，将参数化类型的实例传递给设计用于原始类型的方法必须是合法的。

为了保持兼容性，Java泛型中，其实有一种类似伪泛型，因为Java在编译期间，所有的泛型都会被擦掉。

Java的泛型语法是在编译期这个维度上实现的。

正常来说在生成的字节码文件中，不包含泛型的类型信息的。

在JVM中看到的只是SuperArray，由泛型附加的类型信息对JVM是看不到的。

可以理解为，泛型的本质就是让程序员在编写代码时遵守的一个规则。

比如SuperArray：在确定了泛型之后，这个超级数组中就统一只放同一类型的数据。

如果放入其他类型，编译不通过。

经验：开发中，能够在业务上解决的问题，尽量不要在技术上解决。

1.泛型不能是基本数据类型。（原则上来说，数组可以作为泛型，语法角度，不可以）<>里面放的就应该是类名。数组是在编译后才会生成一个类（$xxxx）

2.方法重载：a.同一个类里 b.方法名相同 c.参数不同

原理：类型擦除。

3.多态上

泛型的应用场景：

• 父类（接口），起到的是一个规范的作用，对里面的数据类型没有明确要求。
• 容器类。（超级数组，链表，队列，栈）
• 当类型无法确定时，使用泛型。
• 开发中，我们更多的是会使用到一些泛型类或泛型接口。

枚举

枚举类型

应用场景：
在某些情况下，一个类的对象的个数是有限的，如季节，春夏秋冬，比如24节气，星期...规定这个类的对象的个数。

枚举在switch中使用

JDK1.5之后

枚举类的命名规则：所有的枚举类要以Enum结尾。

public class Ch03 {
    public static void main(String[] args) {
        SeasonEnum season = SeasonEnum.SPRING;
        switch (season) {
            case SPRING:
            case SUMMER:
            case AUTUMN:
            case WINNER:
        }
    }
}

枚举的静态导入

*号代表导入枚举类的所有对象

import static com.jsoft.afternoon.SeasonEnum.*;
public class Ch04 {
    public static void main(String[] args) {
        System.out.println(SPRING.getName());
    }
}

单例模式

使用枚举类实现单例模式

单元素的枚举类型已经成为实现单例模式的最佳方案。

class Singleton {

   // 私有化构造器
     private Singleton() {}

  // 提供公有的获取实例的静态方法
      public static Singleton getInstance(){
        return SingletonHolder.INSTANT.instant;
    }

    // 声明一个枚举类（内部类）
      private enum SingletonHolder{

        INSTANT;

        private final Singleton instant;

        SingletonHolder() {
           instant = new Singleton();
        }
    }
}

public class Ch05 {

    public static void main(String[] args) {
        System.out.println(Singleton.getInstance() == Singleton.getInstance());
    }
}

枚举的优势

• int类型不具备安全性。假如某个程序员在定义int时少写了个final，会存在被他人修改的风险。枚举类，它天然就是一个常量类

• 2使用int类型，语义不够明确。如果说在控制台打印输入1。

  枚举里面都是常量，静态 推荐枚举的比较使用 ==

多线程前置

• 我们要学习多线程，需要学习一些计算机组成的一些知识。

• 为了完成特定的任务，用某种编程语言写一个软件（程序）。

• 程序要想运行就必须加载到内存中执行。

• 在执行程序的时候，实时的指令加载到cpu内存的指令寄存器中执行。

• 执行过程中产生的数据要加载到数据寄存器中。ALU负责进行算术逻辑运算的操作。

• 系统总线（System Bus）：连接计算机系统的主要组件，用来降低成本和促进模块化。

• 可以通过软件来控制硬件。

  进程：

• 一个正在执行中的程序就是一个进程，系统就会为这个进程发配独立的【运行资源】

• 进程是程序的一次执行过程，它有自己的生命周期

• 它会在启动程序时产生，运行程序时存在，关闭程序时消亡比如：QQ，idea，腾讯会议，PDF

• 早期的计算机，单进程，同一时间只能执行一个进程。

• 计算器。同一时间只能执行一段代码。

• 随着计算机的发展，CPU的计算能力大幅提升，

• 按照时间线交替执行不同继承的方式。

• 每个执行一点点时间，感官上觉得这么多的进程是同时在运行。

• 如果一个进程有多个任务打开浏览器，下载游戏（好几个小时，实况足球2022），另一个标签在看视频，另一个标签在写博客，另一个标签在听音乐。。。

• 如果为每一个任务分配单独的进程去执行，进程间通信。CPU在调度。

• 病毒，熊猫烧香。操作你的运行中的进程，修改了你的数据。*

• 引入了线程。

• 线程是由进程创建，是进程的一个实体，是具体干活的人

• 一个进程有多个线程。线程不独立分配内存，而是共享进程的内存资源，

• 线程可以共享cpu资源。

• 进程更强调的是【内存资源分配】，线程更强调的是【计算的资源的分配】

• 因为有了线程的概念，一个进程的线程不能修改另一个线程的数据，线程之间是相互隔离的，

• 安全性更好。

• 我使用浏览器打开两个腾讯视频，他们同时播放视频，我一个浏览器也可以同时下载多个文件，同时播放两个视频，在多线程的作用下。下载，网络资源，IO问题。

• 我的电脑有2个核心，又有4个逻辑处理器。2核心4线程。

• 8核心16线程啥意思？

• 理论上，一个核在一个时间点只能跑一个线程，但是cpu同一个时间能跑16线程

• 1.物理cpu内核，每颗物理CPU可以有1个或多个物理内核，

• 通常情况下物理CPU内核数都是固定，单核CPU就只有1个物理内核

• 2.逻辑CPU内核，操作系统可以使用逻辑CPU来模拟真实CPU。

• 在没有多核心CPU情况下，单核CPU只有一个核，可以把一个CPU当做多个CPU使用，逻辑CPU的个数就是作用的CPU物理内核数。英特尔研发的一种技术

• 超线程，2002发布。和硬件有关，了解。

• 几个问题：

• 1.我们的进程直接创建、调度线程。不能。

• 2.QQ执行了一会，不执行，等其他线程执行完毕之后。在上一次执行间歇期，会记录位置。

• 不同进程间的线程切换，耗费极大资源空间。

今日总结：枚举和泛型应用场景是理解的，但是具体应用时可能不太会用。线程初步了解了一下