java基础语法和面向对象知识框架

java基础语法

        Java安装步骤
            Oracl（甲骨文）官网下载Java1.8
            下载路径无中文，配置环境变量JAVA_HOME，选择Java路径
            配置新建CLASSPATH，输入CLASSPATH,+.
            配置PATH,找到路径Java下的bin
        Java的特点
            跨平台，一次使用到处使用
        Java开发环境
            JDK：java开发工具包
                JDK = JRE + 编译、运行等命令工具
            JRE：java运行环境
                JRE = JVM + java系统类库(小零件)
            JVM：java虚拟机
                加载.class并运行.class
            java编译运行过程
                编译期：.java源文件，经过编译，生成.class字节码文件
                运行期：JVM加载.class并运行.class
        基础数据类型
            byte
                -128到127，1个字节，整数型
            short
                -32768到32767，2个字节，整数型
            int
                -2146473648到2147483647，4个字节，整数直接量默认为int类型，但不能超出范围，若超范围则发生编译错误
两个整数相除，结果还是整数，小数位无条件舍弃(不会四舍五入)
            long
                8个字节，长整型直接量需在数字后加L或l
运算时若有可能溢出，建议在第1个数字后加L
            float
                4个字节，小数点后7位，单精度浮点型
            double
                8个字节，小数直接量默认为double类型，若想表示float，需在数字后加F或f
double和float型数据在参与运算时，有可能会发生舍入误差，精确场合不能使用
            char
                两个字节，采用Unicode编码格式，一个字符对应一个码，
表现的形式是字符char，但本质上是码int(0到65535)
ASCII码：'a'---97 'A'---65 '0'---48
字符型直接量需放在单引号中，只能有一个
特殊符号需要通过\来转义"
            boolean
                布尔类型，1个字节，只能赋值为true或false
        变量
            声明  int   a；
            初始化  a=10；
            使用输出System..out.println(a);
            使用前，必须声明并初始化
        变量命名规则
            只能包含字母、数字、_和$，不能以数字开头
                变量的重名：
作用域重叠时，变量不能同名
                    byte,short,int,long,char--0
float,double--0.0
boolean--false 默认值规则
                变量的作用域/范围：
从变量的声明开始，到包含它最近的大括号结束
            严格区分大小写
                 \t：水平制表位，固定占8位
            不能使用关键写
            允许中文命名，但是不建议
            小驼峰命名变量
                第1个单词的首字母小写，其余单词的首字母大写--变量
            大驼峰命名类
                每个单词的首字母都大写--类
        类型间的转换
            数据类型从小到大byte<short<int<long<float<doubl
            两种方式
                自动/隐式类型转换：小类型到大类型
                强制类型转换：大类型到小类型
语法：(要转换成为的数据类型)变量
注意：强转有可能溢出或丢失精度
            两点规则
                整数直接量可以直接赋值给byte,short,char，但不能超范围
byte,short,char型数据参与运算时，系统会将其一律先转换为int再运算
        内存单位换算
            1G=1024M(兆)
1M=1024KB(千字节)
1KB=1024B(字节)
1B=8bit(位)
                注释
                    单行注释//
                    多行注释/*      */
                    文档注释/**    */
        运算符
            算术：+、-、*、/、%、++、--，（a++/a--，++a/--a）自使用和被使用情况不同
                int a=5,b=5;
int c = a++; //底层:1)记录a++的值5 2)a自增1变为6 3)将记录的a++的值5赋值给c--了解
//简便记法:a++的值为5，所以c就为5-----重点
int d = ++b; //底层:1)记录++b的值6 2)b自增1变为6 3)将记录的++b的值6赋值给d--了解
//简便记法:++b的值为6，所以d就为6-----重点
System.out.println(a); //6
System.out.println(b); //6
System.out.println(c); //5
System.out.println(d); //6
            关系：>、<、>=、<=、==、!=
            逻辑：&&、||、！，短路后面都不输出，与和或的优先级，与更高
            赋值：+=、-=、/=、%=、*=，包含强制转换
            字符串连接：+，包含字符串后的转换
            条件bollean：关系？数1：数2
        循环三要素
            循环变量的初始化
            循环的条件
            循环变量的改变
        分支结构
            1条路：if
            2条路：if......else
            有条件的执行某语句，并非每句必走
            switch...case结构，多条路
                优势：效率高，结构清晰
                缺点：只能对整数判断相等
                break：跳出switch
        顺序结构
            从上往下逐行执行，每句必走
                 任何复杂的程序逻辑都可以通过三种结构来实现：
顺序结构：从上往下逐行执行，每句必走
分支结构：有条件的执行某语句一次，并非每句必走
循环结构：有条件的执行某语句多次，并非每句必走
                    生成随机数：Math.random()--0.0到0.9999999999999999...
*1000--0.0到999.99999999999999...
+1--1.0到1000.9999999999999...
(int)--1到1000
                    生成整数，引用import java.untl Random;
        循环结构
            while结构：先判断后执行，有可能一次都不执行
            do...while结构：先执行后判断，至少执行一次
            建议：当第一要素和第三要素代码相同，首先do...while
            for结构：应用率高，与次数相关
            break：跳出循环
            continue：跳过循环剩余语句，进行下一次循环
            嵌套循环：越少越好，外面控制行，里面控制列
        数组Array
            定义：相同数据类型的元素集合
            初始化：int{} arr=new int{5}；
            访问数组中的元素
                数组长度.length
                下标和索引，从0开始，到length-1结束
            遍历/索引
            复制：System.arraycopy(a,1,b,2,4）
                a为源数组
                1为源数组的起始下标
                b为目标数组
                2为目标数组的起始下标
                4为复制的长度
            排序;Array.sort(数组名)
            扩容：int[] a = Arrays.copyof(a,a.length+7)
                创建一个新的长度的数组，再将a数组复制过去
                    异常：
ArrayIndexOutOfBounds：数组下标越界异常
数组的下标为0到(数组长度-1)，若超出这个范围则会发生数组下标越界异常
        引用类型数组
            给引用类型数组元素赋值时，需要new个对象
            若想访问引用类型数组元素的数据，需要通过数组元素去打点
    

面向对象
        

面向对象：以对象为核心来思考问题、解决问题的一种编程模式
            OO：面向对象
OOA：面向对象分析
OOD：面向对象设计
OOP：面向对象编程
                对象：软件中真实存在的单个的个体/东西
                高质量的代码：--复用性好、扩展性好、维护性好、可移植性好
健壮性好、可读性好、效率好.....
                类中可以包含：
对象的属性/特征/数据----成员变量
对象的行为/动作/功能-----方法
        类：类型/类别，代表一类个体
             类：是一种引用数据类型
            方法是行为、动作
        方法/函数/过程
            修饰词public static
            返回值
                无返回值：方法名(有参传参);
有返回值：数据类型，图片类型    变量 = 方法名(有参传参);
            方法名（和变量名命名一样）
            方法参数
                可有可无，有的话引用必须得输入参数
                     形参：形式参数，定义方法时的参数称为形参
实参：实际参数，调用方法时的参数称为实参
            方法体
            用于封装一段特定的业务逻辑功能
            return 值; 1) 结束方法的执行 2) 返回结果给调用方，用在有返回值的方法中
return; 1) 结束方法的执行，用在无返回值方法中
        构造方法是用来赋值或者传参数
            作用：给成员变量赋初始值
                 this：指代当前对象，哪个对象调用方法它指的就是哪个对象
 只能用在方法中，方法中访问成员变量之前默认有个this.
                    this.成员变量名-访问成员变量，注意：当成员变量与局部变量同名时，若想访问成员变量，则this不能省略
                    this.方法名()---调用方法(一般不这么写)
                    this()---调用构造方法(一般很少用)
            语法：与类同名，没有返回值类型(连void都没有)
            调用：在创建(new)对象时被自动调用
                 null：表示空，没有指向任何对象。
若引用的值为null，则该引用不能再进行任何操作了，若操作则发生NullPointerException空
指针异常
            若自己不写构造方法，则编译器默认提供一个无参构造方法，若自己写了构造方法，则不再默
认提供
            构造方法可以重载
         继承
            作用：代码复用
            通过extends来实现继承
            超类/父类：共有的属性和行为
派生类/子类：特有的属性和行为
            派生类可以访问派生类的也可以访问超类的，但超类不能访问派生类的
            一个超类可以有多个派生类，但一个派生类只能有一个超类--单一继承
            具有传递性
            java规定：构造派生类之前必须构造超类
                在派生类构造方法中若自己没有调用超类构造方法，则默认super()调用超类无参构造方
法
                在派生类构造方法中若自己调用了超类构造方法，则不再默认提供
                注意：super()调用超类构造方法，必须位于派生类构造方法的第1行
            继承一定要符合is(是)的关系
            当超类的成员变量与派生类的成员变量同名时，若不写super或this，则默认就近原则(默认访问的
是派生类的成员变量)。若想访问超类的成员变量，必须用super.成员变量名。
                super
                    指代当前对象的超类对象
                    super.成员变量名---访问超类的成员变量
                    super.方法名()-调用超类的方法
                    super()--调用超类的构造方法
         向上造型(多态)
            超类型的引用指向了派生类的对象
            能点出来什么，看引用的类型--这是规定
            何时向上造型：
                多种角色干的事都一样的时候，可以将那多种角色统一造型到超类数组中，实现代
码复用
                将超类作为参数或返回值类型，传递派生类对象或返回派生类对象，也是在复用代
码
        方法的重载overland/overlanding
            发生在同一类中，方法名称相同，参数列表不同
编译器在编译时会根据方法的签名自动绑定方法
        方法的重写override
            发生在父子类中，方法名相同，参数列表相同
                为了引用方便，在超类里面引用数组类型，可以针对对象
                    抽象类的派生类，抽象所有方法必须被重写
            重写方法被调用时，看对象的类型----规定
            重写需遵循"两同两小一大"原则：
                两同：
方法名相同
参数列表相同
                两小：
派生类方法的返回值类型小于或等于超类方法的
void和基本类型时，必须相等
引用类型时，小于或等于
派生类方法抛出的异常小于或等于超类方法的
                一大：
派生类方法的访问权限大于或等于超类方法的
        package
            声明包
            作用：避免类的命名冲突
            同包中的类不能同名，但不同包中的类可以同名
            类的全称：包名.类名
            建议：包名所有字母都小写，并且常常有层次结构
        import
            导入类
            同包中的类可以直接访问，但不同包中的类不能直接访问，若想访问：
                先import导入类，再访问类------建议
                类的全称--太繁琐，不建议
         访问控制修饰符
            保护数据的安全，实现封装，隐藏数据，暴露行为
            public：公开的，任何类
            private：私有的，本类
            protected：受保护的，本类、派生类、同包类
            默认的：什么也不写，本类、同包类-不建议默认
            注意
                1. 类的访问权限是public或默认的
                2. 类中成员的访问权限如上4种都可以
                3. 访问控制修饰符的访问权限由低到高依次为：private<默认的<protected<public
             数据(成员变量)私有化(private)，行为(方法)大部分都公开化(public)
                 成员变量分两种：
实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份，通过引用名(对
象)打点来访问
静态变量：有static修饰，属于类的，存储在方法区中，只有一份，通过类名打点来访问
                    . 内存管理：由JVM管理的
堆：new出来的对象(包括实例变量、数组的元素)
栈：局部变量(包括方法的参数)
方法区：.class字节码文件(包括静态变量、所有方法)
                    基本类型变量中存储的就是具体的数，引用类型变量中存储的是对应对象的地址
                 java规定：成员变量和局部变量是可以同名的，使用的时候默认采取就近原则
                 成员变量：写在类中、方法外，在整个类中好使
局部变量：写在方法中，当前方法中使用
         static静态变量
            静态变量
            由static修饰
            属于类，存储在方法区中，只有一份
            常常通过类名点来访问
            何时用：所有对象所共享的数据(图片、音频、视频等)
        static静态方法
            静态方法
            由static修饰
            属于类，存储在方法区中，只有一份
            常常通过类名点来访问
            静态方法中没有隐式this传递，所以不能直接访问实例成员
            何时用：方法的操作与对象无关
            静态方法不能重写
        static静态块
            静态块
            由static修饰
            属于类，在类被加载期间自动执行，一个类只被加载一次，所以静态块也只执行一次
                类只会加载一次
            何时用：初始化/加载静态资源(图片、音频、视频等)
        final：最终的、不可改变的--单独应用率低
            修饰变量：变量不能被改变
            修饰方法：方法不能被重写
            修饰类：类不能被继承
        static final常量--应用率高
            必须声明同时初始化
            常常由类名点来访问，不能被改变
            建议：常量名所有字母都大写，多个单词用下划线(_)分隔
                调用方法的规则
                    方法有返回值，则必须声明变量来接收。方法没有返回值，则不需要声明变量来接收。
                    同一类中的方法，可以直接写方法名调用
                    不同类中的方法
                        若为实例方法(没有static)，则通过引用变量打点来调用
                        若为静态方法(有static)，则通过类名打点来调用
            编译器在编译时会将常量直接替换为具体的数，效率高
            何时用：程序运行过程中数据永远不变，并且经常使用
        抽象方法
            由abstract修饰
            只有方法的定义，没有具体的实现(连{}都没有)
        抽象方法/抽象类的疑问
            抽象方法的意义是什么？
                保证当发生向上造型时，通过超类的引用能点出那个方法来--保证能点出来
            既然抽象方法的意义是保证能点出来，那为什么不设计为普通方法呢?
                设计为普通方法，意味着派生类可以重写也可以不重写，但设计为抽象方法，则可以强
制派生类必须重写------强制派生类重写，以达到统一的目的
            不包含抽象方法的类也可以是抽象类(一般很少这么做而已
            abstract和final不能同时修饰一个类
        抽象类
            由abstract修饰
            包含抽象方法的类必须是抽象类
                设计规则
                    将派生类所共有的属性和行为，抽到超类中--抽共性
                    若派生类的行为/代码都一样，设计为普通方法
                    若派生类的行为/代码都不一样，设计为抽象方法
            抽象类不能被实例化(new对象)
            抽象类是需要被继承的，派生类
                重写所有抽象方法--变不完整为完整
                也设计为抽象类--一般不这么做
        抽象类的意义
            封装共有的属性和行为--代码复用
            为所有派生类提供统一的类型--向上造型(代码复用)
            可以包含抽象方法，为所有派生类提供统一的入口(能点出来)，同时达到强制重写的目的
        成员内部类
            应用率比较低
                类中套类，外面的称为外部类，里面的称为内部类
                内部类通常只服务于外部类，对外不具备可见性
                内部类对象通常只在外部类中创建
                内部类中可以直接访问外部类的成员(包括私有的)，
                内部类中有一个隐式的引用指向了创建它的外部类对象----外部类名.this------API时会用
                何时用：有一个类A，只能被另一个类B使用，并且还想访问类B的成员，可以设计为成员内部
类
        匿名内部类
            应用率比较高
                何时用：若想创建一个类(派生类)的对象，并且对象只被创建一次，可以设计为匿名内部类
                匿名内部类中不能修改外面局部变量的值，因为在此处该变量会默认为final的-----API时会用
         隐式的引用
            this：指代当前对象
            super：指代当前对象的超类对象
            外部类名.this：指代当前对象的外部类对象
         方法的设计
            一个方法不知道要不要参，不知道要不要返回值的时候，就统一都没有，正常去写方法
                若方法正常都能写完，说明不需要参数，若写着写着不知道某个数据怎么写了，就需要
参数
                若方法执行完之后，在其它代码中需要用到方法中的数据，意味着方法需要返回值，不
需要用到方法中的数据，意味着方法不需要返回值
        Math.random()随机生成数，范围在0-0.99999999999
            变量域：变量生成效果，距离最近一个大括号内
        接口
            是一种引用数据类型
            由interface定义
            只能包含常量和抽象方法(数据默认都是常量，方法默认都是抽象的)，权限只能是public
            接口不能被实例化(new对象)
            接口是需要被实现/继承的，实现类/派生类：必须重写所有抽象方法
            一个类可以实现多个接口，用逗号分隔。若又继承又实现时，应先继承后实现
            接口可以继承接口
        类接口关系
            类与类------------------------继承extends
            接口和接口------------------继承extends
            类和接口---------------------实现implements
        深海潜艇总结
            分析类
                战舰battleship
                    战舰属性width，height，x，y，speed，移动方法
                观察潜艇observesubmarine
                    观察潜艇属性width，height，x，y，speed，移动方法
                鱼雷潜艇tropedosubmarine
                    鱼雷潜艇属性width，height，x，y，speed，移动方法
                水雷潜艇minesubmarine
                    水雷潜艇属性width，height，x，y，speed，移动方法
                炸弹bomb
                    炸弹属性width，height，x，y，speed，移动方法
                水雷mine
                    水雷属性width，height，x，y，speed，移动方法
                分析共有属性和方法，进行超类建造seaobject，并且在超类构造方法，重写移动方法
            创造对象
                战舰对象
                    ship
                潜艇数组
                    创建submarine数组，包含观察，鱼雷，水雷对象
                炸弹对象
                    bomb数组
                水雷对象
                    mine数组
            导入图片
                导入ImageIcon，用静态变量进行图片
                初始化静态图片
                测试图片
            启动程序执行
                java.util.Timer，java.util.TimerTask
                启动时间和循环时间
                匿名内部类
                run里面隔时运行
            画出对象和背景
                设计窗口
                画窗口和背景
                再画海洋对象
            对象入场
                潜艇入场
                    
                战舰入场
                水雷入场
                炸弹入场
            对象移动
                潜艇移动
                战舰移动
                炸弹和水雷移动
            设计分数和命数
            删除海洋对象
        多态
            多种形态
            同一个对象被造型为不同的类型时，有不同的功能-------所有对象都是多态的
            同一类型的引用指向不同的对象时，有不同的实现-------所有抽象方法都是多态的
            向上造型/自动类型转换
                超类型的引用指向派生类的对象
                能点出来什么，看引用的类型
                能向上造型成为的类型有：超类+所实现的接口
            向下转型/强制类型转换
                引用所指向的对象，就是该类型
                引用所指向的对象，实现了该接口或继承了该类
                强转时若不符合如上条件，则发生ClassCastException类型转换异常
                在强转之前先通过instanceof判断引用指向的对象是否是该类型
                    instanceof返回boolean结果，它为true的条件与强转成功的条件是一样的
                    何时需要强转：若想访问的变量/方法在超类中没有，则需要强转
        内存管理
            由JVM管理的
            堆
                存储new出来的对象(包括实例变量、数组的元素)
                垃圾：没有任何引用所指向的对象
                    垃圾回收器(GC)不定时到内存堆中清扫垃圾，回收过程是透明的(看不到的)，不一定一发
现垃圾就立刻回收，通过调用System.gc()可以建议JVM尽快调度GC来回收
                实例变量的生命周期
                    创建对象时存储在堆中，对象被回收时一并被回收
                内存泄漏
                    不再使用的对象还没有被及时的回收，严重的泄漏会导致系统的崩溃
                建议：不再使用的对象应及时将引用设置为null
            栈
                存储正在调用的方法中的局部变量(包括方法的参数)
                调用方法时，会在栈中为该方法分配一块对应的栈帧，栈帧中存储局部变量(方法的参
数)，方法调用结束时，栈帧被自动清除，局部变量一并被清除
                局部变量的生命周期
                    调用方法时存储在栈中，方法调用结束时与栈帧一并被清除
            方法区
                存储.class字节码文件(包括静态变量、所有方法)
                方法只有一份，通过this来区分具体的调用对象
        面向对象总结
            封装
                类：封装的是对象的属性和行为
                方法：封装的是具体的业务逻辑功能实现
                访问控制修饰符：封装的是具体的访问权限，隐藏数据，暴露功能
            继承
                作用：代码复用
                超类：所有派生类所共有的属性和行为
                接口：部分派生类所共有的属性和行为
                派生类：派生类所特有的属性和行为
                特点：单一继承、多接口实现，具有传递性
            多态
                所有对象都是多态的----------------通过向上造型来体现
                所有抽象方法都是多态的----------通过方法的重写来体现
                向上造型、向下转型(强制类型转换)
        String字符串类型
            java.lang.String类使用final修饰，不能被继承
            String的底层封装的是一个字符数组
            String在内存中采用Unicode编码格式，每个字符占用2个字节的空间
            字符串对象一旦创建，对象内容永远无法改变，但字符串引用可以重新赋值(指向新的对象)
                将String称为不变对象
        字符串常量池
            java对String字符串有一个优化措施：字符串常量池
            java推荐我们使用字面量/直接量(直接"")的方式创建字符串对象，并且会将所有以字面量方式
创建的对象缓存到常量池中，当使用相同字面量再创建字符串对象时将会复用常量池中的对
象，以减少内存开销
        String的常用方法
            length()：获取字符串的长度(字符个数)
            trim()：去除当前字符串两边的空白字符
            toUpperCase()/toLowerCase()：将当前字符串中的英文部分给转换为全大写/全小写
            startsWith()/endsWith()：判断当前字符串是否是以给定的字符串开始的/结束的
            charAt()：返回当前字符串指定位置上的字符----根据位置找字符
            indexOf()/lastIndexOf()：检索给定字符串在当前字符串中第一次/最后一次出现的位置----根
据字符串找位置
            substring()：截取当前字符串中指定范围的字符串(含头不含尾)
            静态方法valueOf()：将其它数据类型转换为String
        StringBuilder类
            由于String是不变对象，每次修改内容都会创建新的对象，因此String不适合频繁修改操作，
为了解决这个问题，java提供了StringBuilder类。
            StringBuilder类是专门用于修改字符串的一个类，内部维护一个可变的char数组，所做操作
都是在这个数组之上进行的，修改速度、性能优秀，并且提供节修改字符串的常见方法：增、
删、改、插
            append()：追加内容------------------增
            delete()：删除部分内容--------------删
            replace()：替换部分内容------------改
            insert()：插入内容---------------------插
            数组是length属性
                String字符串是length方法
            字符串内容若需要查看，则建议用String
            字符串内容若需要频繁修改，则建议StringBuilder
        数据私有，设计getter/setter的原因
            很多框架都是基于getter/setter来配置获取数据的，可以理解为它是一种行为标准
            getter/setter时可以对数据进行控制，而public权限时无法对数据进行控制
            getter/setter并非一定要同时出现，可以只getter或只setter，需要根据需求自行选择
        正则表达式
            用于描述字符串的内容格式，使用它通常用于匹配一个字符串是否符合格式要求
            正则表达式的语法[a-zA-Z0-9_]+@[a-zA-Z0-9]+(\.[a-zA-Z]+)+
         String支持正则表达式的方法
            matches()：使用给定的正则表达式验证当前字符串的格式是否符合要求，若符合则返回
true，不符合则返回false
            replaceAll()：将当前字符串中满足正则表达式的部分给替换为指定字符串
            split()：将当前字符串按照满足正则表达式(regex)的部分进行拆分，将拆分出的以String[]形
式返回
        Objec
            是所有类的鼻祖，所有类都直接或间接继承了Object，万物皆对象，为了多态
            Object中有两个经常被派生类重写的方法：toString()和equals()
            调用Object类的toString()时默认返回：类的全称@hashcode值，没有参考意义，所以
常常重写toString()来返回具体的属性值
                String、StringBuilder都重写了toString()来返回字符串内容了
            调用Object类的equals()时默认比较的还是==(即比较地址)，没有参考意义，所以常常重
写equals()来比较具体的属性值
                 String类重写equals()来比较字符串内容了，但StringBuilder并没有。
包装类也重写了equals()来比较具体的值
                重写equals()的基本原则
                    原则上要比较两个对象的属性值是否相同
                    两个对象必须是同一类型的，若类型不则则直接返回false
        包装类
            java定义了8个包装类，目的就是为了解决基本类型不能直接参与面向对象开发的问题，使基
本类型可以通过包装类的形式存在
            包含：Integer、Character、Byte、Short、Long、Float、Double、Boolean，其中
Character和Boolean是直接继承自Object的，其余6个包装类继承自Number类。
            JDK1.5时推出了一个新特性：自动拆装箱。当编译器编译时若发现是基本类型与包装类型之
间的相互赋值，则自动补齐代码完成转换工作，这个过程叫做自动拆装箱。
        集合
            集合和数组一样，可以保存一组数据，并且提供节操作集合元素的相关方法，使用更加方便
            java.util.Collection接口：是所有集合的顶级接口，封装了所有集合所共有的方法
            java.util.List：线性表，是可以重复集合，并且有序
            java.util.Set：不可重复集合，大部分实现类是无序的
            Collection接口的常用方法
                add()：向集合中添加一个元素，成功添加则返回true
                size()：返回当前集合的元素个数
                isEmpty()：判断当前集合是否是空集，仅当size()为0时返回true
                clear()：清空集合
                contains()：判断集合是否包含给定元素
                remove()：从集合中删除给定元素，成功删除则返回true
                addAll()：将参数集合中的元素添加到当前集合中，添加后当前集合发生改变则返回true
                containsAll()：判断当前集合中是否包含参数集合中的所有元素
                retainAll()：取交集
                removeAll()：删交集
            集合的遍历
                Collection接口提供了统一的遍历集合的方式：迭代器模式。通过iterator()方法可以获取一个
用于遍历当前集合元素的迭代器(Iterator接口)
                java.util.Iterator接口：定义了迭代器遍历集合的相关操作，不同的集合都实现了用于遍历自
身元素的迭代器实现类，但是我们元素记住它们的名字，从多态的角度把它们看成Iterator即
可
                迭代器遍历遵循的步骤：问(hasNext())、取(next())、删(remove())，其中删除并不是必要操
作
                    增强for循环/新循环
                        for(元素类型 变量名 : 集合或数组){
循环体
}
            泛型
                泛型也称为参数化类型，允许我们在使用一个类时，传入某个类型来规定其内部的属性、方法
参数或返回值类型，使得我们使用时更加方便
                泛型在集合中被广泛使用，用来规定集合元素的类型
                若不指定泛型的具体类型，则默认为Object
                若指定了泛型的具体类型，则在获取泛型的值时，编译器会做强转操作
            数组和集合的length（）和size（）
                数组.length()是数组的长度，而不是数组的元素个数，元素可以为null
                集合.size（）是集合的元素个数，没有null
            isEmpty和null、空字符串的区别
                isEmpty是对象是否为空（IsNull），null是值为空（IsEmpty）
                isEmpty() 用于判断List内容是否为空,必须在 list 本身不是空的引用的情况下才行;
null 用于判断有没有这个集合对象
                null是值为空或者不是有效元素，而不是空字符串
                空字符串，是该元素没有