JavaEE就业班day01-day06学习交流

到今天为止我们学习JavaEE已经有一个月了，在这一个月中我们在各位老师的陪伴下过这比较充实的学习生活。

下面我也对最近的JavaEE的学习做一个认真的总结：

第一天我们进行了前期知识的回顾和总结，学习了新的静态、代码块等。

static：
    * 含义
        * 静态
        * 是一个关键字
    * 作用
        * 修饰成员变量, 成员方法, 使其被该类的所有对象共享
        * 修饰类(后面讲)
    * 如何调用static修饰的变量和方法
        * `类名.静态成员属性`: `System.out`
        * `类名.静态成员方法();`: `Arrays.toString(arr);`
    * 静态的特点
        * 静态成员被所有对象共享
        * 静态成员可以直接使用类名调用
        * 静态成员的加载优先于对象
            * 静态资源在创建类时加载并初始化(在方法区中)
            * 非静态资源在创建对象时才加载并初始化(在堆内存中)
        * 静态成员生命周期
            * 随着类的加载而创建, 直到程序结束
静态的内存图解

生命周期不同
        * 静态成员: 随着类的加载而创建, 随着程序结束而销毁
        * 非静态成员: 随着对象的创建而创建, 随着对象的销毁而销毁
        * 所以, 静态成员的生命周期优先于非静态成员创建, 晚于非静态成员销毁
    * 内存中的定义位置不同
        * 静态成员: 方法区中类字节码区域的静态区中
        * 非静态成员: 堆内存中
    * 初始化时机不同
        * 静态成员: 类加载时初始化
        * 非静态成员: 对象创建时初始化

静态注意事项

注意：在静态的方法中没有this对象，因为静态的方法随着累的加载而加载优先于所有对象。
缺点：在静态的方法中只能用静态的成员
用static的时机：有一个数据所有的对象都要用它，而且用的数据类型和值都是一样的。

局部代码块
    位置：方法中
    执行时机：执行带方法中的局部代码块时
    存在于方法中控制变量的生命周期（作用域）
构造代码块
    位置    类中 方法外
    执行时机：创建一个对象时，在构造方法执行之前执行，无论是有参构造还是无参构造
    提取构造方法中的共性，每次创建方法都会执行，并且在构造方法方法之前提前执行
*静态代码块*
    位置：类中 方法外
    执行时机：加载类是执行，只执行一次
    随着类的加载而加载，只加载一次，加载类时需要做一些初始化比如加载驱动
同步代码块（多线程讲解）

继承：
    多个类有共同的成员，抽取到另外一个类中（父类）再让多个类去继承这个父类，
    我们的多个类就可以获取到父类中的成员了。可以提高程序的工作效率

关键字 extends
    作用：子类继承父类时使用
    位置：在子类类名后
    格式：class 子类名 extends 父类名{}；

Java中继承的特点：
    Java语言只支持单一继承，只能继承一个父类
    Java语言支持多层继承。

变量使用原则：就近原则；有局用局，没局用子，没子用父亲，没父就错。

关键字：super 获取父类的成员变量和成员方法
方法的重写：在子类中子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），
    重写之后子类调用的就是子类中的方法
继承中成员方法的特点：
    子类中没方法调用父类
    子类中重写，调用子类
方法重写的应用场景
    父类的方法不能完全满足子类的使用，就要重写。
    并且可以使用关键字super调用父类的方法。
    这样做既有父类的功能，也有子类特有的功能
方法重写的注意事项
    不能重写父类私有的方法
    权限必须大于等于父类的权限
继承中构造方法的执行顺序
    在有继承关系的类中，创建创建子类的对象调用子类的构造方法，
    如果子类的构造方法的第一行代码没有调用父类的构造方法，则会默认调用父类的无参构造，
    肯定会先执行父类的构造，因为要先给父类的成员变量进行初始化，子类可能会使用到
**我们可以在子类的构造方法中使用super()来调用父类的构造方法
**在子类的构造方法中只要第一行代码中没有this或者super那就默认调用父类无参

this 和 super 的区别
this：  当前对象的引用
    调用子类的成员变量
    调用子类的成员方法
    在在的构造方法第一行调用子类其他构造方法
super： 子类对象的父类引用
    调用父类的成员变量
    调用父类的成员方法
    在子类的构造方法第一行调用父类的构造方法
继承：多个类共有的成员抽取到另外一个类中（父类），再让这个类去继承这个父类我们的多个类就可以获取到父类的-成员
    提高了代码的复用性和课维护性
    缺点：
    累的耦合性增强了
    开发的原则：高内聚低耦合；内聚：就是自己完成某件事情的能力；耦合；类与类的关系
匿名对象：没有名字的对象
应用场景：当方法只调用一次的时候可以使用匿名对象
注意：匿名对象可以调用成员变量并赋值，但赋值并没有意义，

关键字：final
final：修饰符，可以用于修饰类、成员
final所修饰的类，不能被继承，不能有子类
final修饰的方法不能被重写
final修饰的变量不可修改，是常量

常量：
    字面值常量：123....
    自定义常量：被final修饰的成员变量，一旦初始化则不可改变
注意：自定义常量必须初始化，可以选择显示初始化和构造初始化。

关键字    abstract（用于修饰方法和类）
抽象方法：不同类的方法是相似的但是具体的内容又不太一样，所有我们只能抽取他的申明，没有具体的方法体，没有具体方法体的的方法就是抽象方法   
抽象类：有抽象方法的类必须是抽象类

注意：一个类继承了抽象类需要重写他的所有抽象方法，否则这个类就是抽象类
抽象类的特点：
    抽象方法只能在抽象类里面
    抽象类和抽象方法必须被abstract修饰
    抽象类不能创建对象（不能实例化）
    抽象类中可以有非抽象的方法
    抽象类和类的关系也是继承
    一个类继承了抽象类要么重写所有方法要么他自己是抽象类
抽象类成员的特点
    成员变量：
    可以有成员变量
    可有常量
    成员方法:
    可以有抽象方法
    可以有非抽象方法
    构造方法
    可以有构造方法，给成员变量抽象类的成员变量初始化

抽象类的细节：
    抽象类的关键字不能和final、private公存
    抽象类中有构造函数，需要对成员变量初始化，子类的继承需要调用父类的构造方法
    抽象类中也可以没有抽象方法，没有抽象方法的作用是不让别人创建对象，抽象类的抽象方法不能实例化

接口：
接口的作用
    为实现类扩展出接口具有的功能
    弥补Java只能单一继承的局限性，抽象类只能单继承接口实现多实现
implements（实现）
interface（接口）
    接口是一个比抽象类还抽象的类，接口里所有的方法全是抽象方法接口和类的关系是实现
格式：
    interface 接口名{}
接口的特点：
    只能有抽象方法；
    只能有常量；
    默认使用public static final修饰变量（常量）
    默认且只能使用public&abstract修饰方法
   
建议：手动加public和abstract
**注意**
    不能创建对象（不能实例化
    类与接口的关系是实现关系，一个类的实现一个接口必须实现他所有的方法（因为所有的方法都是抽象方都是抽象方法）
     
    类与类：继承关系，单一继承，多层继承
    类与接口：实现关系，多实现
    接口与接口的关系，继承，多继承

接口的优点：
    类与接口的关系，实现关系，而且是多实现一个类可以实现多个接口打破了局限性
    对外提供规则（USB）接口
    降低了程序的耦合性
接口和抽象类的区别：
    共性：不断地抽取，抽取出抽象的概念
    区别：
    1：与类的关系
        类与接口是实现关系，而且是多实现，一个类可以实现多个接口
        类与抽象类的是继承关系，Java中的继承是单一继承，一个类只能有一个父类
    2：成员的区别
        成员变量：
        抽象类可以有成员变量，也可以有常量
        接口只能有常量
        成员方法：
        抽象类可以有抽象方法也可以有非抽象方法
        接口只能有抽象方法
        构造方法：
        抽象类有构造方法
        接口没有构造方法
多态的前提：
    子类的继承关系
    方法的重写
    父类引用指向子类对象

    动态绑定：运行期间调用的方法，是根据其具体的类型

多态的成员特点：
    编译时看的是左边，运行时成员方法看的是右边，其他（成员变量和静态方法）看的都是左边
    变量没有重写的概念，也没有动态绑定的问题
多态的向上转型和向下转型
    引用类型之间的转换
        向上转换
            由小到大
        向下转型
            由大到小
多态的有缺点
    缺点：无法直接问子类的特有成员
    优点，可以提高可维护性，（多态所保证的）提高代码的可扩展性
包的特点：
    可以有多层
    不同的包下文件名可以重复
    包的声明必须在第一行
不同包之间的访问
    使用类的全名
    使用关键字import将类导入

注意
    --*代表的是通配符，代表导入了这个包下的所有的类，并没有导入子包下的类

权限修饰符
    public 当前类，相同包下不同的类，不同包下的类
    default 当前类，相同包下的不同类（默认但是不要自己去写）
    private 当前类
    protected 当前类，相同包下不同类
    default：当前包下使用
    protected：让子类对象使用

常见规则（并不一定）：
        类：
        使用public来修饰，一个Java文件中只有一个如果有多个类，类名和文件名一样的类必须用public修饰

        以后所有的成员变量都使用private修饰
        所有的方法都使用public修饰，不想让别的类访问就用private修饰，想让子类使用就用protected
        以后所有的构造方法public修饰    不想让创建对象就用private

内部类：
    成员内部类：
        位置：在类的成员位置，和成员变量及成员方法的位置是一样的
        使用时机：可以在外部类的成员方法中创建对象
        在内部类中，可以直接访问外部类的成员，包括私有成员

我们可以用权限修饰符来修饰成员内部类，private来修饰的只能在当前类中使用，其他类访问不到
我们可以使用static修饰成员内部类，不用创建外部类的对象了

也可以使用abstracted final修饰成员内部类




collection接口(集合的最顶层，是层次结构的最顶层，定义了一些规范和规则)
| boolean add(Object e)//返回Boolean值，永远为true因为ArrayList允许重复
| void clear（）//清空集合
| boolean cotains(Object o)是否包含指定元素
| boolean isEmpty()是否为空有一个就返回false
| boolean remove(Object o)删除成功就true没有就返回false
| int size（） 返回集合中元素个数
| Object[] toArray() 将集合转换成Object类型的数组（因为不知道什么类型）
|****
迭代器的概述
| Iterator：可以用来遍历集合
| E next() 返回下一个元素
| boolean hasNext()  ：判断是否有元素可以获取
|Exception in thread "main" java.util.ConcurrentModificationException:并发修改异常
    迭代器是依赖于集合的，相当于集合的一个副本，当迭代器在操作的时候，如果发现和集合不一样，则抛出异常
|泛型：是一种广泛的类型，把明确数据类型的工作提前到了编译时期，借鉴了数组的特点
* 泛型好处：
*             避免了类型转换的问题
*             可以减少黄色警告线
*             可以简化我们代码的书写
|- List
|    ListIterator:可以对集合进行增删改查操作
   ArrayList

LinkedList类(底层是链表, 查询慢, 增删快)
    void addFirst(E e): 添加元素到集合的开头
    void addLast(E e): 添加元素到集合的末尾
    E getFirst(): 获取集合开头的元素
    E getLast(): 获取集合末尾的元素
    E removeFirst(): 删除开头的元素, 并返回
    E removeLast(): 删除末尾的元素, 并返回

JavaEE就业班day01-day06学习交流

到今天为止我们学习JavaEE已经有一个月了，在这一个月中我们在各位老师的陪伴下过这比较充实的学习生活。

下面我也对最近的JavaEE的学习做一个认真的总结：

第一天我们进行了前期知识的回顾和总结，学习了新的静态、代码块等。

static：
    * 含义
        * 静态
        * 是一个关键字
    * 作用
        * 修饰成员变量, 成员方法, 使其被该类的所有对象共享
        * 修饰类(后面讲)
    * 如何调用static修饰的变量和方法
        * `类名.静态成员属性`: `System.out`
        * `类名.静态成员方法();`: `Arrays.toString(arr);`
    * 静态的特点
        * 静态成员被所有对象共享
        * 静态成员可以直接使用类名调用
        * 静态成员的加载优先于对象
            * 静态资源在创建类时加载并初始化(在方法区中)
            * 非静态资源在创建对象时才加载并初始化(在堆内存中)
        * 静态成员生命周期
            * 随着类的加载而创建, 直到程序结束
静态的内存图解

生命周期不同
        * 静态成员: 随着类的加载而创建, 随着程序结束而销毁
        * 非静态成员: 随着对象的创建而创建, 随着对象的销毁而销毁
        * 所以, 静态成员的生命周期优先于非静态成员创建, 晚于非静态成员销毁
    * 内存中的定义位置不同
        * 静态成员: 方法区中类字节码区域的静态区中
        * 非静态成员: 堆内存中
    * 初始化时机不同
        * 静态成员: 类加载时初始化
        * 非静态成员: 对象创建时初始化

静态注意事项

注意：在静态的方法中没有this对象，因为静态的方法随着累的加载而加载优先于所有对象。
缺点：在静态的方法中只能用静态的成员
用static的时机：有一个数据所有的对象都要用它，而且用的数据类型和值都是一样的。

局部代码块
    位置：方法中
    执行时机：执行带方法中的局部代码块时
    存在于方法中控制变量的生命周期（作用域）
构造代码块
    位置    类中 方法外
    执行时机：创建一个对象时，在构造方法执行之前执行，无论是有参构造还是无参构造
    提取构造方法中的共性，每次创建方法都会执行，并且在构造方法方法之前提前执行
*静态代码块*
    位置：类中 方法外
    执行时机：加载类是执行，只执行一次
    随着类的加载而加载，只加载一次，加载类时需要做一些初始化比如加载驱动
同步代码块（多线程讲解）

继承：
    多个类有共同的成员，抽取到另外一个类中（父类）再让多个类去继承这个父类，
    我们的多个类就可以获取到父类中的成员了。可以提高程序的工作效率

关键字 extends
    作用：子类继承父类时使用
    位置：在子类类名后
    格式：class 子类名 extends 父类名{}；

Java中继承的特点：
    Java语言只支持单一继承，只能继承一个父类
    Java语言支持多层继承。

变量使用原则：就近原则；有局用局，没局用子，没子用父亲，没父就错。

关键字：super 获取父类的成员变量和成员方法
方法的重写：在子类中子类的方法和父类的完全一样，子类重写了父类的方法（覆盖），
    重写之后子类调用的就是子类中的方法
继承中成员方法的特点：
    子类中没方法调用父类
    子类中重写，调用子类
方法重写的应用场景
    父类的方法不能完全满足子类的使用，就要重写。
    并且可以使用关键字super调用父类的方法。
    这样做既有父类的功能，也有子类特有的功能
方法重写的注意事项
    不能重写父类私有的方法
    权限必须大于等于父类的权限
继承中构造方法的执行顺序
    在有继承关系的类中，创建创建子类的对象调用子类的构造方法，
    如果子类的构造方法的第一行代码没有调用父类的构造方法，则会默认调用父类的无参构造，
    肯定会先执行父类的构造，因为要先给父类的成员变量进行初始化，子类可能会使用到
**我们可以在子类的构造方法中使用super()来调用父类的构造方法
**在子类的构造方法中只要第一行代码中没有this或者super那就默认调用父类无参

this 和 super 的区别
this：  当前对象的引用
    调用子类的成员变量
    调用子类的成员方法
    在在的构造方法第一行调用子类其他构造方法
super： 子类对象的父类引用
    调用父类的成员变量
    调用父类的成员方法
    在子类的构造方法第一行调用父类的构造方法
继承：多个类共有的成员抽取到另外一个类中（父类），再让这个类去继承这个父类我们的多个类就可以获取到父类的-成员
    提高了代码的复用性和课维护性
    缺点：
    累的耦合性增强了
    开发的原则：高内聚低耦合；内聚：就是自己完成某件事情的能力；耦合；类与类的关系
匿名对象：没有名字的对象
应用场景：当方法只调用一次的时候可以使用匿名对象
注意：匿名对象可以调用成员变量并赋值，但赋值并没有意义，

关键字：final
final：修饰符，可以用于修饰类、成员
final所修饰的类，不能被继承，不能有子类
final修饰的方法不能被重写
final修饰的变量不可修改，是常量

常量：
    字面值常量：123....
    自定义常量：被final修饰的成员变量，一旦初始化则不可改变
注意：自定义常量必须初始化，可以选择显示初始化和构造初始化。

关键字    abstract（用于修饰方法和类）
抽象方法：不同类的方法是相似的但是具体的内容又不太一样，所有我们只能抽取他的申明，没有具体的方法体，没有具体方法体的的方法就是抽象方法   
抽象类：有抽象方法的类必须是抽象类

注意：一个类继承了抽象类需要重写他的所有抽象方法，否则这个类就是抽象类
抽象类的特点：
    抽象方法只能在抽象类里面
    抽象类和抽象方法必须被abstract修饰
    抽象类不能创建对象（不能实例化）
    抽象类中可以有非抽象的方法
    抽象类和类的关系也是继承
    一个类继承了抽象类要么重写所有方法要么他自己是抽象类
抽象类成员的特点
    成员变量：
    可以有成员变量
    可有常量
    成员方法:
    可以有抽象方法
    可以有非抽象方法
    构造方法
    可以有构造方法，给成员变量抽象类的成员变量初始化

抽象类的细节：
    抽象类的关键字不能和final、private公存
    抽象类中有构造函数，需要对成员变量初始化，子类的继承需要调用父类的构造方法
    抽象类中也可以没有抽象方法，没有抽象方法的作用是不让别人创建对象，抽象类的抽象方法不能实例化

接口：
接口的作用
    为实现类扩展出接口具有的功能
    弥补Java只能单一继承的局限性，抽象类只能单继承接口实现多实现
implements（实现）
interface（接口）
    接口是一个比抽象类还抽象的类，接口里所有的方法全是抽象方法接口和类的关系是实现
格式：
    interface 接口名{}
接口的特点：
    只能有抽象方法；
    只能有常量；
    默认使用public static final修饰变量（常量）
    默认且只能使用public&abstract修饰方法
   
建议：手动加public和abstract
**注意**
    不能创建对象（不能实例化
    类与接口的关系是实现关系，一个类的实现一个接口必须实现他所有的方法（因为所有的方法都是抽象方都是抽象方法）
     
    类与类：继承关系，单一继承，多层继承
    类与接口：实现关系，多实现
    接口与接口的关系，继承，多继承

接口的优点：
    类与接口的关系，实现关系，而且是多实现一个类可以实现多个接口打破了局限性
    对外提供规则（USB）接口
    降低了程序的耦合性
接口和抽象类的区别：
    共性：不断地抽取，抽取出抽象的概念
    区别：
    1：与类的关系
        类与接口是实现关系，而且是多实现，一个类可以实现多个接口
        类与抽象类的是继承关系，Java中的继承是单一继承，一个类只能有一个父类
    2：成员的区别
        成员变量：
        抽象类可以有成员变量，也可以有常量
        接口只能有常量
        成员方法：
        抽象类可以有抽象方法也可以有非抽象方法
        接口只能有抽象方法
        构造方法：
        抽象类有构造方法
        接口没有构造方法
多态的前提：
    子类的继承关系
    方法的重写
    父类引用指向子类对象

    动态绑定：运行期间调用的方法，是根据其具体的类型

多态的成员特点：
    编译时看的是左边，运行时成员方法看的是右边，其他（成员变量和静态方法）看的都是左边
    变量没有重写的概念，也没有动态绑定的问题
多态的向上转型和向下转型
    引用类型之间的转换
        向上转换
            由小到大
        向下转型
            由大到小
多态的有缺点
    缺点：无法直接问子类的特有成员
    优点，可以提高可维护性，（多态所保证的）提高代码的可扩展性
包的特点：
    可以有多层
    不同的包下文件名可以重复
    包的声明必须在第一行
不同包之间的访问
    使用类的全名
    使用关键字import将类导入

注意
    --*代表的是通配符，代表导入了这个包下的所有的类，并没有导入子包下的类

权限修饰符
    public 当前类，相同包下不同的类，不同包下的类
    default 当前类，相同包下的不同类（默认但是不要自己去写）
    private 当前类
    protected 当前类，相同包下不同类
    default：当前包下使用
    protected：让子类对象使用

常见规则（并不一定）：
        类：
        使用public来修饰，一个Java文件中只有一个如果有多个类，类名和文件名一样的类必须用public修饰

        以后所有的成员变量都使用private修饰
        所有的方法都使用public修饰，不想让别的类访问就用private修饰，想让子类使用就用protected
        以后所有的构造方法public修饰    不想让创建对象就用private

内部类：
    成员内部类：
        位置：在类的成员位置，和成员变量及成员方法的位置是一样的
        使用时机：可以在外部类的成员方法中创建对象
        在内部类中，可以直接访问外部类的成员，包括私有成员

我们可以用权限修饰符来修饰成员内部类，private来修饰的只能在当前类中使用，其他类访问不到
我们可以使用static修饰成员内部类，不用创建外部类的对象了

也可以使用abstracted final修饰成员内部类




collection接口(集合的最顶层，是层次结构的最顶层，定义了一些规范和规则)
| boolean add(Object e)//返回Boolean值，永远为true因为ArrayList允许重复
| void clear（）//清空集合
| boolean cotains(Object o)是否包含指定元素
| boolean isEmpty()是否为空有一个就返回false
| boolean remove(Object o)删除成功就true没有就返回false
| int size（） 返回集合中元素个数
| Object[] toArray() 将集合转换成Object类型的数组（因为不知道什么类型）
|****
迭代器的概述
| Iterator：可以用来遍历集合
| E next() 返回下一个元素
| boolean hasNext()  ：判断是否有元素可以获取
|Exception in thread "main" java.util.ConcurrentModificationException:并发修改异常
    迭代器是依赖于集合的，相当于集合的一个副本，当迭代器在操作的时候，如果发现和集合不一样，则抛出异常
|泛型：是一种广泛的类型，把明确数据类型的工作提前到了编译时期，借鉴了数组的特点
* 泛型好处：
*             避免了类型转换的问题
*             可以减少黄色警告线
*             可以简化我们代码的书写
|- List
|    ListIterator:可以对集合进行增删改查操作
   ArrayList

LinkedList类(底层是链表, 查询慢, 增删快)
    void addFirst(E e): 添加元素到集合的开头
    void addLast(E e): 添加元素到集合的末尾
    E getFirst(): 获取集合开头的元素
    E getLast(): 获取集合末尾的元素
    E removeFirst(): 删除开头的元素, 并返回
    E removeLast(): 删除末尾的元素, 并返回