###学习心得
今天讲述了泛型是什么，有什么作用，什么是泛型，发现它是一个可以用大写字母表示的，比如<T>这样写，还有一些关于计算机的相关知识，也可以看看一些关于算法的书，建议看英文版
###心情😅😅
对于计算机的了解还是不够，多读书多看报少吃零食多睡觉
------------------------------------------------------------------------------------------------------------------------------------------------------------
* javaSE高级部分 * 1.泛型 * 2.枚举 * 3.多线程 * 4.集合（数据结构 二叉树 红黑树 B+树 B.树） * 5.IO流 * 6.网络通信Socket（tomcat） * 泛型： （Generice） 什么是泛型 泛型广泛性 普通的类型 泛型的修饰： 1.泛型类 2.泛型方法 3.泛型接口
public class Ch03 { public <T> T show(T t) { // 拿着这个t在方法中做好多事情，再把t返回回去 // 调用另一个方法 System.out.println(t); return t; } public static void main(String[] args) { new Ch03().show("哈哈"); } }
泛型类：把泛型定义在类上，用户在使用类的时候才能把类型确定 具体的使用方法是使用<>加上一个未知数，通常用T K A 等大写字母表示 实际上用啥都行，只要是个单词就可以。 * 泛型方法： * 我们如果只关心某个方法，可以不定义泛型类。 * 只定义泛型方法。 * * 泛型方法是不是一定要在泛型类里？不是 * 泛型类里是不是一定要有泛型方法？不是 * * 在定义泛型方法时，要首先定义泛型类型。 * 定义在方法中间，泛型的使用处之前
继承关系： * 泛型类在继承时： * 1.父类是一个泛型类，子类要不要是泛型类？ * 2.永远记住，泛型的声明只能在当前类名后或者方法中间，而且声明的泛型是自己的。 * 3.在子类继承父类时，子类泛型和父类泛型都写出来的情况下，父跟子 * 4.如果在继承时，没有写出任何泛型，当前子类就不是泛型类。
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(); } }
public class Employee {
}
* 如果在一个泛型类中，尽量就不要再使用泛型方法。
* 泛型方法多数都是出现在非泛型类。
*
* 静态泛型方法：
* 1.静态方法如果是泛型方法，泛型的声明必须写。
* 2.因为静态结构是属于类的，不属于某个对象。
interface Inter<T> { T show(T t); static <T> T info(T t){ return t; } } class Demo01<T> implements Inter<T> { // @Override // public Object show(Object o) { // return null; // } @Override public T show(T t) { return t; } } public class Ch05 { public static void main(String[] args) { Inter.info(1); } }
* ?通配符
* 可以接受任何类型。
*
* 如果使用Object类型，别写泛型。
* 泛型约束类的数据类型。
*
* JDK1.5之后泛型。JDK5
class Animal { } class Dog extends Animal { } class Teddy extends Dog { /** * @param superArray */ public static void show(SuperArray<? super Teddy> superArray) { } } public class Ch06 { public static void main(String[] args) { SuperArray<Animal> superArray = new SuperArray<>(); // superArray.add(new Animal()); // superArray.add(new Dog()); // superArray.add(new Teddy()); Teddy.show(superArray); } }
* 类型参数化 * 类型擦除： * 为了兼容性，使用原始类型（没有泛型）是可以的 * 泛型刚刚出现的时候，还有很多不适用的泛型代码 * 为了保持兼容性，Java泛型中，其实有一种类型伪泛型，Java编译期间所有的泛型会被擦除 * * Java的泛型语法是在编译期这个维度上实现的 * 生成字节码文件时，不包含泛型的类型信息 * * JVM中看到的是SuperArray，由泛型附加的类型信息对JVM * * 可以理解为：泛型的本质就是让程序员在编写代码时遵守的一个规则 * * 比如SuperArray：在确定了泛型之后，这个超级数组就统一只放同一类型的数据 * 如果放入其他类型，编译不通过 -----------------------------------------------------------------------------------------------------------------------------------------------------
1.泛型不能是基本数据类型。 <>里面放的就应该是类名，，数组是在编译后才会生成一个类（$xxxx） 2.方法重载：a.同一个类型 b.方法名相同 c.参数不同 原理：类型擦除。 3.多态上。
* 泛型的应用场景： * 1.父类（接口），起到的是一个规范的作用，对里面的数据没有明确要求 * 2.容器类，（超级数组，链表，队列，栈） * * 当类型无法确定时，使用泛型 * * 开发中，我们更多的是会使用到一些泛型类或泛型接口 * * 练习： * 数组，链表，队列，栈 * 他们四个有一个共同的泛型接口，这四个结构都实现这个泛型接口，重写里面的抽象方法
public class SuperArray<T> { // 声明了一个T类型的变量t private T t; // 维护一个数组，要考虑的是怎么存 private Object [] array; // 超级数组的长度 private int size; // 数组当前的容量 private int capacity; public SuperArray(){ // array = new Integer[10]; this(10); // capacity = 10; } public SuperArray(int capacity){ array = new Object[capacity]; this.capacity = capacity; } // 添加数据，默认添加，在数组的尾部添加 public void add(T data) { // 添加时要确保容量足够，如果不够，就需要扩容 ensureCapacity(size + 1); // 真正的添加数据 array[size++] = data; } // 添加数据，传入两个参数 // 在指定位置添加 public void add(int index,T data){ if(rangeCheck(index)){ ensureCapacity(size + 1); System.arraycopy(array,index,array,index + 1,size - index); // 真正的添加数据 array[index] = data; size++; } } // 删除最后一个数据 public Object remove(){ if(size > 0){ return array[--size]; } return null; } // 删除指定下标位置的元素 public Object remove(int index){ if(rangeCheck(index)){ Object res = array[index]; System.arraycopy(array,index + 1,array,index,(--size - index)); return res; } return null; } // 修改 public boolean set(int index,T data) { if(rangeCheck(index)){ array[index] = data; return true; } return false; } // 获取超级数组的长度 public int size(){ return size; } // 获取指定下标的元素 public Object get(int index) { // 判断一下index和合法性 if(rangeCheck(index)){ return array[index]; } return null; } private boolean rangeCheck(int index) { // index >= 0 // index <= size - 1 return (index >=0 && index <= size - 1); } // 这个方法只在当前类使用，所以声明成private private void ensureCapacity(int needCapacity) { // System.out.println(needCapacity + "-----" + capacity); if(needCapacity > capacity){ // 1.5倍 capacity = capacity + (capacity >> 1); // 创建一个新的扩容好的数组 Object [] newArray = new Object[capacity]; // 把原数组的数据拷贝过来 /* src：原数组 srcPos：拷贝原始数组的起始位置 dest：目标数组 destPos：目标数组的起始位置 length：拷贝数据的长度 */ System.arraycopy(array,0,newArray,0,array.length); array = newArray; } } }
简单来说这个枚举是什么意思
- 枚举类型
- 应用场景：
- 在某些情况下，一个类的对象的个数是有限的，
- 如季节，春夏秋冬，比如24节气，星期。。。
- 规定这个类的对象的个数。
枚举：在switch中使用，JDK1.5之后
枚举类的命名规则：所有的枚举类都要以Enum结尾
枚举的静态导入
* 号代表导入枚举类的所有对象
单例模式：
1.使用枚举类实现单例模式
2.高效Java
3.单元素的枚举类型已经成为实现单例模式的最佳方案
----------------------------------------------------------------------------------------------------------------------
- 进程更强调的是【内存资源分配】，线程更强调的是【计算的资源的分配】
- 因为有了线程的概念，一个进程的线程不能修改另一个线程的数据，线程之间是相互隔离的，安全性更好。
* 理论上，一个核在一个时间点只能跑一个线程，但是cpu同一个时间能跑16线程
* 1.物理cpu内核，每颗物理CPU可以有1个或多个物理内核，
* 通常情况下物理CPU内核数都是固定，单核CPU就只有1个物理内核
* 2.逻辑CPU内核，操作系统可以使用逻辑CPU来模拟真实CPU。
* 在没有多核心CPU情况下，单核CPU只有一个核，可以把一个CPU当做多个
* CPU使用，逻辑CPU的个数就是作用的CPU物理内核数。
----------------------------------------------------------------------------------------------------------------------
枚举的优势：
1.int类型不具备安全性，假如某个程序员在定义int时少写了一final，会存在被他人修改的风险，枚举类，他是天然就是一个常量类
2.使用int类型，语义不够明确，如果说在控制台打印输出1。
枚举里面都是常量，静态
用 == 比较
多线程入门
我们要学习多线程，需要学习一些计算机组成的一些知识
为了完成特定的任务，事实上的指令加载到cpu内存的指令寄存器中执行
执行过程中产生的数据要加载到数据寄存器中，ALU负责进行算术逻辑运算
系统总线（System Bus）：连接计算机系统的主要组件，用来降低成本和促进可以通过软件来控制硬件
--------------------------------------------------------------------------------------------------------------------------------------------------------------------
进程：
一个正在执行中的程序就是一个进程，系统就会为这个进程发配独立的【运行】
进程是程序的一次执行过程，它有自己的生命周期
他会在启动程序时产生
运行程序时存在
关闭程序时消亡
早期计算机，单进程，同一时间只能执行一个进程
计算器。同一时间只能执行一段代码
随着计算机的发展，CPU的计算能力大幅提升
按照时间线交替执行不同的继承方式
每个执行一点点时间，感官上觉得这么多的进程时同时在运行
你点我就回上面去了ヾ(≧O≦)〃嗷~