java

• 关键字

含义：被java语言赋予特定含义的单词
特点：组成关键字的单词的字母全部小写
注意：goto和const作为保留字存在。目前并不使用

• 标识符

含义：就是给类、接口、方法、变量等取名字时使用的字符序列
组成规则：

• 英语大小写字符
• 数字字符
• $和_
  注意事项：
• 不能以数字开头
• 不能是java中的关键字
• 区分大小写

• 创建的命名规则：见名知意

1、包：其实就是文件夹，用于把相同的类名进行区分

       a、单级：student
       b、多级：cn.student

2、类或者接口：

      a、一个单词：单词的首字母必须是大写
      b、多个单词：每个单词的首字母必须大写

3、方法或者变量：

      a、一个单词：单词的首字母必须是大写
      b、多个单词：从第二个单词开始，每个单词首字母大写

4、常量：

      a、一个单词：全部大写
      b、多个单词：每个单词都大写，用_隔开

• 注释

含义：用于解释说明程序的文字
分类及格式：

    a、单行注释:   // 
          
    b、多行注释:   /*    */
         
    c、文档注释:  /**   */

作用：

   a、解释说明程序，提高程序的阅读性
   b、可以帮助我们调试程序

• 常量

含义：在程序执行过程中不可以发生改变的值
分类：

   a、字面值常量
          （1）字符串常量："hello"
          （2）整数常量 ：100
          （3）小数常量：100.1
          （4）字符常量：'A'
          （5）bool常量：true/false
          （6）空常量：null
   b、自定义常量

4中表示形式：

  a、二进制：由0,1组成，以0b开头
  b、八进制：由0...7组成，以0开始
  c、十进制：由0...9组成，整数默认是十进制
  b、十六进制：由0...9，a，c，d，e，f（大小写均可），以0x开头

• 任意进制转十进制
  系数：每一个位数的数据值本身的系数
  基数：x进制的基数就是x
  权：我们针对每一个位数上的数据进行编号，从右边，并且从0开始编号，这个编号就是该位上数据的权值
  每一个位上的系数*基数^权次幂相加
• 十进制转任意进制
  除基取余，直到商为0，余数反转

• 有符号数据表示法

源码：

    正数的原码最高位是0
    负数的原码最高位是1
    其余的是数值位，数值不足7位的在前面加0以满足一个字节8位数

 举例                符号位                   数值位
  +7                   0                     0000111
  -7                   1                     0000111

反码：

    正数的反码与源码相同
    负数的反码与源码是符号位不变，数值为取反，就是1变0,0变1 
  举例             符号位                  数值位
    +7                 0                  0000111
    -7                 1                  1111000

补码：

  正数的补码与原码相同
  负数的补码是反码的基础上加1
  举例             符号位               数值位
    +7              0                  0000111
    -7               1                 1111001

• 变量

含义：就是在程序的执行过程中，其值是可以在一定范围内发生改变的量
组成规则：
a、数据类型
b、变量名
c、初始化值
数据类型：

    a、基本数据类型
          （1）整数：
                                      占用字节数
                          byte：          1
                          short：         2
                          int ：          4
                          long：          8  
          （2）浮点数：
                          float：         4
                          double：        8
          （3）字符：
                          char：          2
          （4）布尔：
                          boolean         1
      定义格式：
          （a）  数据类型 变量名 = 初始化值;
          （b）  数据类型 变量名;
                     变量名 = 初始化值;
      注意：
          （a） boolean类型不能转为其他的数据类型
          （b）默认转换，小的数据类型和大的数据类型进行运算，默认以大的数据类型为计算结果的数据类型
          （c）强制转换，从大的数据类型到小的数据类型，可能会损失进度
                    格式：目标数据类型 变量 = （目标数据类型）（被转换的数据类型）；
    b、引用数据类型
           （1）类
           （2）接口 
           （3）数值

补充问题：

    1、在定义Long或者float的时候，要加L或者F
    2、byte，short在定义的时候，接收的其实是一个int类型的值
    3、byte的取值范围是 -128~127   
          byte b1 = 127; //  127
          byte b2 = (byte)128; // -128
          byte b3 = (byte)129; // -127
          byte b4 = (byte)130; // -126
    4、数据类型转换之默认转换
          byte、short、char -- int -- float -- double
    5、java语言中的字符串char可以存储一个中文汉字，因为java中的字符占用两个字节

• 运算符

含义：就是对常量和变量进行操作的符号
分类：

算数运算符
                +、-、*、/、%、++、--
                注意：
                        （a）整数相除，只能得到整数，如果想得到小数，必须把数据变成浮点数
                        （b）/获取的除法操作的商，%获取的是除法操作的余数
                        （c）++或者--放在前面先运算在赋值，放在后面是先赋值后运算
赋值运算符
               =、+=、-=、*=、/=、%=
比较运算符
              ==、!=、>=、<=
逻辑运算符
              & 逻辑与：有false则false
              |逻辑与：有true则true
              ^逻辑异或：相同为false，不同为true
              ！逻辑非:非false则true，非true则false，偶数个不改变本身
              &&：
              ||：
位运算符
             <<、>>、>>>、&、|、^、~
三目运算符
             (关系表达式)?表达式1:表达式2

• 键盘录入

格式：
1、导包 import java.util.Scanner;
2、创建键盘录入 Scanner sc = new Scanner(System.in);
3、通过对象获取数据 int x = sc.nextInt();

• if语句

语法： if (条件语句){
执行语句
}
注意事项：

       a：比较表达式 无论简单还是复杂，结果必须是boolean类型
       b：if语句控制的语句体如果是一条语句，大括号可以省略；
          如果是多条语句，就不能省略，建议都不省略
       c：一般来说，有左大括号就没有分号

选择语句：
A：if (条件语句){
执行语句
}else{
执行语句
}
B：if (条件语句){
执行语句
}else if (条件语句){
执行语句
}else{
执行语句
}

• switch语句

语法： switch(条件语句){
case 值:
执行代码
break;
default
执行代码
break;
}
注意：

    a：case 后面的只能是常量，不能是变量
    b：default可以省略，但是不建议省略
    c：break可以省略，结果不是我们想要的，会出现case穿透
    d：default可以在任意位置，建议在最后
    f：遇到break结束或者执行到最后结束

• for循环

语法：for (int i = 0; i<变量;i++){
执行代码
}

• while循环

语法：while(判断条件语句){
循环体语句
}
for和while的区别：

a、如果你想在循环结束之后继续使用控制条件的那个变量，用while，否则用for
b、如果是一个范围，用for，如果不明确，用while      

• do...while

语法： do{
循环体语句
}while(判断条件语句)

• 控制跳转语句

break：中断
使用场景：

a、switch中
b、循环语句中

continue：继续
使用场景：

a、循环语句中，离开此场景无意义

return：返回
使用场景：

a、任何地方

• 方法

定义：完成特定功能的代码块，在很多语言里有函数的定义，在java中函数被称为方法
格式：
修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2...){
方法体语句
return 返回值
}
注意事项：

a、方法不调用不执行
b、方法与方法是平级关系，不能嵌套定义
c、方法定义参数之间用逗号隔开
d、方法调用的时候不用在传递数据类型
e、如果方法有明确的返回值，一定要有return返回一个值

方法重载：

a、在同一个类中，方法名相同，参数列表不同，与返回值类型无关

• 数组

概念：数组是存储同一种数据类型多个元素的集合。数据既可以存储基本数据类型，也可以存引用数据类型
格式：

动态初始化
a、数据类型[] 数组名;
int[]  a;
b、数据类型 数组名[];
itn a[];
注意：效果都是一样的，但是念法上还是有区别的，推荐使用第一种
 静态初始化
a、 数据类型[] 数组名 = new 数据类型[] {元素1,...,元素n};
b、  数据类型[] 数组名 = {元素1,...,元素n};
注意：不要同时动态和静态进行

• 二维数组

概念：就是元素为一维数组的一个数组
格式：
动态初始化
数据类型[][] 变量名 = new 数据类型[m][n];
m：表示这个二位数组有多少个一维数组
n：表示每一个一维数组的元素个数
数据类型[][] 变量名 = new 数据类型[m][];
m：表示这个二位数组有多少个一维数组
动态的给出一维数组的元素个数
静态初始化
数据类型[][] 变量名 = new 数据类型[][] {{元素...},{元素...}};
数据类型[][] 变量名 = {{元素...},{元素...}};
Java中的参数类型传递问题：
基本类型：形式参数的改变对实际参数没有影响
引用类型：形式参数的改变直接影响实际参数

• 面向对象

概念：面向对象是基于面向过程的编程思想
面向过程：强调的是每一个功能步骤
面向对象：强调的是对象，然后由对象企去调用功能
面向对象的特征：

• 封装：指隐藏对象的属性和实现细节，仅对外提供访问方式

好处：

  * 隐藏实现细节，提供公共的访问方式
  * 提高代码的复用性
  * 提高安全性

• 继承：把多个类中相同的内容给提出出来定义到一个类中

格式：class 子类名 extends 父类名{}
好处：

  a、提高了代码的复用性
  b、提高了代码的维护性
  c、让类与类之间产生了关系，是多态的前提

弊端：

  a、类的耦合性增强
  c、打破了封装性

特点：

  a、单继承，不支持多继承
  b、支持多层继承

注意事项：

  a、子类只能继承父类所有的非私有成员(成员方法和成员变量)
  b、子类不能继承父类的构造方法，但是可以通过super关键字访问父类的构造方法
  c、不要为了部分功能而去继承

继承中成员变量的关系：

  a、子类中的成员变量和父类中的变量名称不一样
  b、子类中的成员变量和父类中的变量名称一样，就近原则

• 多态：某一个事物，在不同时刻表现出来的不同状态

多态前提和体现：

    a、有继承关系
    b、有方法重写
    c、有父类引用指向子类对象

多态中的成员访问特点：

     a、成员变量
          编译看左边，运行看左边
     b、构造方法
          创建子类对象的时候，访问父类的构造方法，对父类的数据进行初始化
     c、成员方法
          编译看左边，运行看右边
     d、静态方法
          编译看左边，运行看左边(静态和类相关，算不上方法重写，所以访问看左边)

多态的好处：

      a、提高了代码的维护性
      b、提高代码的扩展性

多态的弊端：

      a、不能使用子类特有的功能

对象的转型问题：

      a、向上转型：Fu f = new zi();
      b、向下转型：Zi z = (Zi) f;         

• 类

类：是一组相关的属性和行为的集合，是一个抽象的概念
对象：是一该类事物的具体的表现形式，具体存在的个体
定义一个类就是定义该类的成员变量和成员方法
成员变量：和以前变量的定义是一样的格式，但是位置不同，在类中方法外
成员方法：和以前的方法定义是一样的格式
类的调用： 类名 对象名 = new 类名();
成员变量和局部变量的区别：

  a、在类的位置不同
        （1）成员变量：在类中方法
        （2）局部变量：在方法定义中或者方法声明上
  b、在内存中的位置不同
        （1）成员变量：在堆内存
        （2） 局部变量：在栈内存
  c、生命周期不同
        （1）成员变量：随着对象的创建而存在，随着对象的消失而消失
        （2）局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
  d、初始化值不同
        （1）成员变量：有默认初始化值 
        （2）局部变量： 没有默认初始化值，必须定义，赋值，然后才能使用
   注意：局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则

匿名对象：就是没有名字的对象
匿名对象的应用场景：
A、调用方法，仅仅只调用一次的时候
B、匿名对象可以作为实际参数传递
注意：调用多次的时候，不适合
好处:匿名对象调用完毕就可以被回收

• 构造方法

概念：给对象的数据进行初始化
格式：

  a、方法名与类名相同
  b、没有返回值类型，连void都没有
  c、没有具体的返回值

注意事项：

  a、 如果我们没有给出构造方法，系统将默认的给出一个无惨构造方法
  b、如果我们给出了构造方法，系统将不再提供默认的无惨构造方法

• 权限修饰符

1、private ：可以修饰成员变量和成员方法，被修饰的成员只能在本类中访问

• 关键字

1、this：当前类的对象引用
2、static：修饰成员变量，成员方法

      特点
          a、随着类的加载而加载
          b、优先于对象存在
          c、被类的所有对象共享
          d、可通过类名调用，也可以通过对象名调用
      注意事项
          a、在静态方法中没有this关键字，因为静态是随着类的加载而加载，this是随着对象的创建而存在，静态比对象先存在，用oc的理解方式就是生命周期的现象
          b、静态方法只能访问静态的成员变量和静态的成员方法  

• Math函数

官方API:http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

• 代码块

局部代码块：局部位置，用于限定变量的生命周期
构造代码块：在构造方法的位置，在类中的成员位置，用{}括起来的代码，每次调用构造方法执行前，都会先执行构造代码块
作用：可以把多个构造方法中的共同代码放到一起，对对象进行初始化
静态代码块：在类中的成员位置，用{}括号括起来，用static修饰，只加载一次
作用：一般是对类进行初始化

• this和super的区别

  a、this代表本类对应的引用
  b、super代表父类存储空间的标识

使用

  a、调用成员变量
                this.成员变量      调用本类的成员变量
                super.成员变量   调用父类的成员变量
  b、调用构造方法
                this(...)     调用本类的成员方法
                super(...)  调用父类的构造方法
  c、调用成员方法
                this.成员方法     调用本类的成员方法
                super.成员方法  调用父类的成员方法 

• 方法重写

概念：子类中出现了和父类中一模一样的方法声明
特点：

a、如果方法名不同，就调用对应的方法
b、如果方法名相同，先调用子类的在调用父类的方法

注意事项：

a、父类中的私有方法不能被重写，因为子类不能被继承
b、子类重写父类方法时，访问权限不能更低
c、父类静态方法，子类也必须通过静态方法重写

• final

概念：最终的意思，可以修饰类，方法，变量
特点：

  a、修饰类，该类不能被继承
  b、修饰方法，该方法不能被重写
  c、修饰变量，该变量不能被重新赋值，其实这个变量就是常量。修饰基本类型，基本类型的值不能改变；修饰引用类型，引用类型的地址值不能改变，但是引用类型中的堆内存中的值能发生改变

final修饰变量的初始化时机：

  a、被final修饰的变量只能赋值一次
  b、在构造方法完毕前，非静态的常量

• 抽象类

概念：我们把一个不是具体的功能称为抽象的功能，而一个类中如果有抽象的功能，该类必须必须是抽象类
特点：

  a、抽象类和抽象方法必须用abstract关键字修饰
  b、抽象类中不一定有抽象方法，但是有抽象方法的类必须定义为抽象类
  c、抽象类不能被实例
        因为它不是具体的
        抽象类有构造方法，但是不能实例化
  d、抽象类的子类
        1、如果不想重写抽象方法，该子类是一个抽象类
        2、重写所有的抽象方法，这个时候子类是一个具体的类

成员特点：

 a、成员变量：既可以是变量也可以是常量
 b、构造方法：有。用于子类访问父类的初始化
 c、成员方法：既可以是抽象的也可以是非抽象的

abstract不能和哪些关键字共存：

  private：冲突
  final：冲突
  static：无意义

• 接口

特点：

  a、接口用关键字interface表示   
        interface 接口名{}
  b、类实现接口用implement表示
       class 类名  implement 接口名{}
  c、接口不能实例化 
  d、接口的子类
        1、可以是抽象类
        2、也可以是具体类，需要重写接口中的所有抽象方法

成员特点：

  a、成员变量：只能是常量，并且是静态的。默认修饰符：public static fianl
  b、构造方法：接口没有构造方法
  c、成员方法：只能是抽象方法。默认修饰符：public abstract


  类与类：继承关系，单继承，可以实现多层继承
  类与接口：实现关系，可以单实现，也可以多实现，并且还可以在继承一个类的时候实现多个接口
  接口与接口：继承关系，可以单继承也可以多继承

• 抽象类与接口的区别

  a、成员区别：
          抽象类：
                成员变量：可以变量，也可以常量
                构造方法：有
                成员方法：可以抽象，也可以非抽象
          接口：
                成员变量：只能是常量
                成员方法：只能是抽象
  b、关系区别：
         类与类：继承，单继承
         类与接口：实现，单实现，多实现
         接口与接口：继承，单继承，多继承
  c、设计理念区别
        抽象类：“is a”的关系。抽象类中定义的是该继承体现的共性功能
        接口：“like a”的关系 。接口中定义的是该继承体系的扩展功能
  

• 类名作为形式参数

基本类型：之前有提及过，这里不再过多的讲解
引用类型：
类：(匿名对象的时候之前也有提及过)需要的是一个该类的对象
抽象类名：需要的是该抽象类的子类对象
接口：需要的是该接口的实现类对象

• 返回值类型

基本类型：之前有提及过，这里不再过多的讲解
引用类型：
类：返回的是该类的对象
抽象类：返回的是该抽象类子类的对象
接口：返回的是该接口的实现类对象

• 包

概述：其实就是文件夹
作用：对类进行分类管理
定义：package 包名；多级包.分开
注意事项：

      a、package语句必须是程序的第一条可执行的代码
      b、packa语句在一个java文件中只能是一个
      c、如果没有package，默认表示无包名

• 内部类

概述：把类定义在其他类的内部，如在A类中定义一个B类
特点：

  a、内部类可以直接访问外部类的成员，包括私有
  b、外部类要访问内部类的成员，必须创建对象

内部类的位置：

   成员位置：在成员位置定义的类，被称为成员内部类
         访问内部类的成员：外部类名.内部类名 对象名 = new 外部类对象.new 内部类对象
         成员内部类的修饰符：
                            1、private：保护不被外部直接调用
                            2、static：外部类直接类名调用，只能访问外部类的静态成员  格式 ： 外部类名.内部类名 对象名 = new 外部类名.内部类名();
         注意：
                  1、外部类和内部类没有继承关系
                  2、通过外部类名限定this对象，外部类.this.成员名
   局部内部类：在局部位置定义的类，被称为局部内部类
         注意事项：
                  1、局部内部类访问局部变量必须用final修饰
                  2、局部变量是随着方法的调用而调用，随着调用完毕而消失。而堆内存的内容并不会立即消失。加入final修饰之后，这个变量就成了常量

• 匿名内部类

概念：其实就是内部类的简写方法
前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类
格式：new 类名或者接口名(){
重写方法;
}
本质：是一个继承了该类或者实现了该接口的子类匿名对象

• API概述

• Object

概念：层次结构的根类，所有类都直接或者间接的继承自该类
APi地址：http://tool.oschina.net/apidocs/apidoc?api=jdk-zh
常用方法：

public int hashCode()  ：返回该对象的哈希码值
       注意：哈希值是根据哈希算法计算出来的一个值，这个值和地址值有关，但是不是实际的地址值
public final  Class<?> getClass() ：返回此 Object 的运行时类。返回的 Class 对象是由所表示类的 static synchronized 方法锁定的对象。
public String toString()  ：返回该对象的字符串表示 。它的值等于：getClass().getName() + '@' + Integer.toHexString(hashCode())
        注意：直接输出对象的名称，其实就是调用的该对象的toString方法
public boolean equals (Object  obj) : 基本类型比较的值是否相同，引用类型比较地址值是否相等

• Scanner

API地址：http://tool.oschina.net/apidocs/apidoc?api=jdk-zh
基本格式：
public Xxx nextXxx()：获取该元素
public boolean hasNextXxx()：判断是否是某种类型的元素
问题：
先输入一个数字在输入一个字符串就会出现问题

        Scanner s = new Scanner(System.in);
        int a = s.nextInt();
        String string = s.nextLine();
        System.out.println(a+"--------"+string);// 结果是： 10--------
        //原因：换行符号的问题
        //解决方案：
        //A、重新创建新的Scanner 
        //B、把所有的数据都按照字符串获取

• String

概述：字符串是由多个字符组成，也可以看成是一个字符数组，字符串是常量，一旦被赋值就不能被改变
API地址：http://tool.oschina.net/apidocs/apidoc?api=jdk-zh
构造常用方法：

      public String()
      public String(char[] value)
      public String(char[] value, int offset, int count)
      public String(byte[] bytes)
      public String(String original)

注意：
String s = new String("hello");和String s = "hello";区别
前者会创建两个对象，后者会创建一个对象

• StringBuffer

概念：线程安全的可变字符序列
API地址：http://tool.oschina.net/apidocs/apidoc?api=jdk-zh
构造方法

  public StringBuffer()
  public StringBuffer(int capacity)
  public StringBuffer(CharSequence  seq)

• StringBuilder

概念：线程不安全的可变字符序列
API地址：http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

 String、StringBuffer、StringBuilder的区别
  a、String是内容不可变的，而StringBuffer和StringBuilder是内容可变的
  b、StringBuffer是同步的，数据安全，效率低；StringBuilder是不同步的，数据不安全，效率高
  StringBuffer和数组的区别
  a、StringBuffer的数据始终是一个字符串的数据
  b、数组可以放多种数据类型，但必须是同一种数据类型

• Arrays

API地址：http://tool.oschina.net/apidocs/apidoc?api=jdk-zh
常用构造方法

  public static void sort(long[] a)
  public static String toString(int[] a)
  public static int binarySearch(byte[] a,  byte key)

• 基本类型的引用类型

    基本类型                  引用类型
      byte                    Byte
      short                   Short
      int                     Integer
      char                    Character
      long                    Long
      float                   Float
      double                  Double
      boolean                 Boolean
  

• 正则表达式

概念：符合一定规则的字符串
API地址：http://tool.oschina.net/apidocs/apidoc?api=jdk-zh

   字符
   x       字符  x  
   \\      反斜线字符
   \n      新行（换行）符 (\u000A) 
   \r      回车符 (\u000D) 
   字符类 
   [abc]        a、b、c
   [^abc]      任何字符，除了a、b、c
   [a-zA-Z]    a到z,A到Z，包含首尾
   [0-9]       0到9的字符
   预定义字符类
    .            表示任何字符 。如果就是.用\.表示
    \d           数字：[0-9]
    \w           单词字符：[a-zA-Z_0-9]
   边界匹配器
    ^         行的开头
    $         行的结束
    \b        单词边界，就是不是单词字符的地方
   数量词
    X?       一次或一次也没有
    X*       零次或多次
    X+       一次或多次
    X{n}     恰好n次
    X{n,}    至少n次
    X{n,m}   至少n次，但是不超过m次

判断功能
public boolean matches(String regex);
分割功能
public String[] split(String regex);
替换功能
public String replaceAll(String regex,String replacement);

• Pattern和Matcher

API地址：http://tool.oschina.net/apidocs/apidoc?api=jdk-zh
获取功能
Pattern p = Pattern.compile("a*b");
Matcher m = p.matcher("aaaaab");
boolean b = m.matcher();

• Math

概念：用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。

public static int abs(int a)   绝对值
public static double ceil(double a) 向上取整
public static double floor(double a) 向下取整
public static int max(int a,int b) a和b中取较大的一个
public static double pow(double a,double b) a^b
public static double random() 随机数 [0.0,1.0)
public static int round(float a) 四舍五入
public static double sqrt(double a) 平方根

• Random

概念：产生随机数

   构造方法
   public Random();没有给种子，是当前时间的毫秒值
   public Random();给种子
   注意：0给定种子后，每次得到的随机数是相同的
   成员方法
   public int nextInt();返回的是int范围内的随机数
   public int nextInt(int n);返回的是[0,n)范围内的随机数

• System

概念：System 类包含一些有用的类字段和方法。它不能被实例化。

  public static void gc();运行垃圾回收器
  public static void exit(int status);终止当前正在运行的 Java 虚拟机。
  public static void currentTimeMillis(); 返回以毫秒为单位的当前时间
  public static void arraycopy(Object src,int srcPos,Object dest,int desPost,int Length);从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束

• BigInteger

概念：可以让超过Integer范围内的数据进行运算

• BigDecimal

概念:不可变的、任意精度的有符号十进制数

• Date（了解就可以了，过时方法）

概念：从 JDK 1.1 开始，应该使用 Calendar 类实现日期和时间字段之间转换

• Calendar

概念：Calendar替代Date

• 集合

数组和集合的区别

A：长度区别
          数组的长度是固定
          集合长度可变
B：内容不同
          数组存储的是同一种类型元素
          集合可以存储不同类型的元素
C：元素的数据类型问题
          数组可以存储基本数据类型和引用数据类型
          集合只能存储引用数据类型

Collection.png

• Collection

  1、添加
        boolean add(Object obj) 添加一个元素
        boolean addAll(Collection c) 添加一个集合的元素
  2、删除
        void clear() 移除所有元素
        boolean remove(Object o) 移除单个指定元素
        boolean removeAll(Collection c)  移除一个集合元素
  3、判断
        boolean contains(Object o) 判断集合是否包含制定元素
        boolean containsAll(Collection c) 判断集合中是否包含指定的集合元素
        boolean isEmpty()  判断集合是否为空
  4、获取
        Iterator<E> iterator() 
  5、长度
        int size() 元素的个数
  6、交集
        boolean retainAll(Collection c)  A对B做交集，最终的结果保存在A中，B不变，返回值表示的是A是否发生过改变
        Object[] toArray()
  

• Iterator

      Collection<Student> c = new ArrayList<>();
        Student s1 = new Student("小白",10);
        Student s2 = new Student("小蓝",11);
        Student s3 = new Student("小绿",12);
        Student s4 = new Student("小黄",13);
        Student s5 = new Student("小黑",14);
        c.add(s1);
        c.add(s2);
        c.add(s3);
        c.add(s4);
        c.add(s5);
        Iterator<Student> iterator = c.iterator();
        while (iterator.hasNext()){
            Student student = iterator.next();
            System.out.println(student);
        }
        for (Iterator<Student> tempIterator = c.iterator();tempIterator.hasNext();){
            Student student = tempIterator.next();
            System.out.println(student);
        }

• List
  概念：有序的 collection（也称为序列）。与 set 不同，列表通常允许重复的元素
  特点：有序（存储和去除的元素一直），可重复

  List特有的功能
  1、添加功能
  void add(int index,Object element) 在指定位置添加元素
  2、获取功能
  Object get(int index)获取指定位置的元素
  3、列表迭代器
   ListIterator listIterator() List集合特有的迭代器,继承Iterator
   boolean hasPrevious()  判断逆向是否有元素
   Object previous()  获取逆向的单个元素
   注意：ListIterator可以实现逆向遍历，但是必须正向遍历，才能逆向遍历，一般无意义
  4、删除功能
  Object remove(int index) 根据索引删除元素，返回删除的元素
  5、修改功能
  Object set(int index,Object element)  根据索引修改元素，返回被修改的元素
  

//List特有的方法
        List<String> list = new ArrayList<>();
        list.add("hello");
        list.add("world");
        list.add("java");
        for (int i = 0 ; i< list.size() ; i++){
            System.out.println(list.get(i));
        }
        System.out.println("-----------");
        ListIterator listIterator = list.listIterator();
        while (listIterator.hasNext()){
            System.out.println(listIterator.next());
        }
        //逆向的获取list中的元素，必须先正向遍历之后逆向遍历才有数据
        System.out.println("-----------");
        while (listIterator.hasPrevious()){
            System.out.println(listIterator.previous());
        }

注意：
A、迭代器迭代元素，迭代器修改元素
元素是跟在刚才迭代元素的后面
B、集合遍历元素，集合修改元素(普通for)
元素在最后添加的
栈：先进后出
队列：先进先出
数组：查询快，增删慢
链表：查询慢，增删快
ArrayList：底层数据结构是数组，查询快，增删慢，线程不安全，效率高
Vector：底层数据结构是数组，查询快，增删慢，线程安全，效率低
LinkedList：底层数据结构是链表，查询慢，增删快，线程不安全，效率高
注意：ArrayList去除重复的对象

ArrayList<Student> arrayList = new ArrayList<>();
        Student s1 = new Student("哈哈",10);
        Student s2 = new Student("嘻嘻",10);
        Student s3 = new Student("哈哈",11);
        Student s4 = new Student("哈哈",10);
        arrayList.add(s1);
        arrayList.add(s2);
        arrayList.add(s3);
        arrayList.add(s4);
        ArrayList<Student> newArrayList = new ArrayList<>();
        Iterator<Student> iterator = arrayList.iterator();
        while (iterator.hasNext()){
            Student student = iterator.next();
//如果这里只是字符串的比较直接用，如果是对象的比较重写equals方法就可以了
            if (!newArrayList.contains(student)){
                newArrayList.add(student);
            }
        }
        Iterator<Student> newIterator = newArrayList.iterator();
        while (newIterator.hasNext()){
            Student student = newIterator.next();
            System.out.println(student.getName()+"----"+student.getAge());
        }

• 泛型
  概念：是一种把类型明确的工作推迟到创建对象或者调用方法的时候擦去明确的特殊类型
  格式：<数据类型> 此处的数据类型只能是引用类型
  好处：
  A:把运行时期的问题提前到了编译时期
  B:避免了强制类型转换
  C:优化了程序设置，解决了黄色警告线

  泛型的应用
  A:把泛型定义在类上
  public class ObjectTool<E>{
      private E obj;
      public E getObject(){
          return obj;
      }
      public void setObject(E obj){
          this.obj = obj;
      }
  }
  B:把泛型定义在方法上
  public class ObjectTool{
    public void show(E e){
        System.out.println(e);
    }
  }
  C:把泛型定义在接口上
  public interface ObjectTool<E>{
      public abstract void show(E e);
  }
  public class ObjectToolImpl<E> implement ObjectTool<E>{
      public void show(E e){
         System.out.println(e);
      }
  }
  D:通配符
  1、?:任意类型，如果没用明确，那么就是Object以及任意的java类
  2、? extends E:向下限定，E及其子类
  3、? super E:向上限定，E及其父类
  

• Set
  概念：存储顺序和取出顺序不一致，唯一

• HashSet

        HashSet<String> hashSet = new HashSet<>();
        hashSet.add("hello");
        hashSet.add("world");
        hashSet.add("java");
        hashSet.add("hello");
        for (String string :hashSet){
            System.out.println(string);
        }
        \\打印结果
         world
         java
         hello

通过查看add方法的源码，底层依赖两个方法：hashCode()和equals()

• TreeSet
  特点：排序、唯一

//方法一
public class Person implements Comparable<Person>{
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Person person = (Person) o;
        return age == person.age &&
                name.equals(person.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public int compareTo(Person o) {
        int num = this.age - o.getAge();
        num = num == 0 ?    this.name.compareTo(o.getName()) : num;
        return num;
    }
}
//方法二
public static void methedThree(){
        TreeSet<Person> treeSet = new TreeSet<>(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                int num = o1.getAge() - o2.getAge();
                num = num == 0 ? o1.getName().compareTo(o2.getName()) : num;
                return num;
            }
        });
    }

Comparable 对自定义对象的排序
在public int compareTo(Person o) 返回的的是负数表示从大到小的排序，如果是正数是从小到大的排序

• Map

特点：将键映射到值的对象。一个映射不能包含重复的键，每个键组多只能映射到一个值
Map集合和Collection集合的区别
1.Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的
2.Collection集合存储元素是单独出现的，Collection的儿子set是唯一的，list是可重复的

• HashMap

public V put(K key, V value) //添加
public V remove(Object key) //删除，返回value
public boolean containsKey(Object key) //是否包含key
public boolean isEmpty()//是否存在
public V get(Object key) //返回value
public V set(Object value) //返回key

HashMap<Integer,String> hashMap = new HashMap<>();
        hashMap.put(1,"哈哈");
        hashMap.put(2,"嘻嘻");
        hashMap.put(3,"呵呵");
        Set<Integer> set = hashMap.keySet();
        for (Integer i : set){
            System.out.println(hashMap.get(i));
        }

• LinkedHashMap

特点：有序、唯一，先进先出

• TreeMap

public static void methodFive(){
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个字符串");
        String string = scanner.nextLine();
        TreeMap<Character,Integer> treeMap = new TreeMap<>();
        char[] chars = string.toCharArray();
        for(char ch : chars){
            Integer value = treeMap.get(ch);
            if (value == null){
                treeMap.put(ch,1);
            }else{
                value++;
                treeMap.put(ch,value);
            }
        }
        StringBuilder stringBuilder = new StringBuilder();
        Set<Character> set = treeMap.keySet();
        for (char ch : set){
            stringBuilder.append(ch).append("(").append(treeMap.get(ch)).append(")");
        }
        System.out.println("result"+stringBuilder);
    }

1.HashMap和Hashtable的区别
HashMap：线程不安全，效率高，允许null键和null值
Hashtable：线程安全，效率低，不允许null键和null值
2.List，Set，Map等接口是否都继承Map接口
List，Set不是继承自Map接口，它们继承自Collection接口
Map接口本身就是一个顶层接口
3.Collection和Collections的区别
Collection:单列集合的顶层接口，有子接口List和Set
Collections:针对集合操作的工具类，有对集合进行排序和二分查找的方法

Collections

public static <T> void sort(List<T> list, Comparator<? super T> c)//正序排序
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c) //二分查找
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp) //返回最大值
public static void reverse(List<?> list)//倒序排序
public static void shuffle(List<?> list) //随机排序

• IO

• Throwable

严重问题：Error 我们不处理，这种问题一般都是很严重的，比如说内存溢出
问题：Exception
编译期间问题：不是RuntimeException的异常，必须处理
运行期问题：RuntimeException， 这种问题我们也不处理，代码不够严谨

//格式一
try{
可能出现问题的代码
}catch(异常名 变量){
针对问题的处理
}finally{
释放资源
}
//格式二
try{
可能出现问题的代码
}catch(异常名 变量){
针对问题的处理
}

注意：一旦try里面出了问题，就会和catch里面的匹配，一旦匹配成功之后就会抛出错误，结束当前的try...catch代码块执行下面的代码

• File

//构造方法
public File(String pathname)//根据一个路径得到File对象
public File(String parent, String child)//根据一个目录和一个子文件得到一个File对象
public File(File parent, String child)//根据一个父File对象和一个子文件得到一个File对象
//成员方法
//创建方法
public boolean mkdir()  //创建一个文件夹
public boolean mkdirs() //创建多个文件夹
public boolean createNewFile() //创建文件
//删除方法
//java中的删除不走回收站
public boolean delete() // 删除
//重命名
//如果路径名相同就是改名，如果不同就是改名+剪切
public boolean renameTo(File dest)//重新命名
//判断功能
public boolean isDirectory()//是否是目录
public boolean isFile()//是否是文件
public boolean exists()//是否存在
public boolean canRead()//是否可读
public boolean canWrite()//是否可写
public boolean isHidden()//是否隐藏
//获取功能
public String getAbsolutePath()//获取绝对路径
public String getPath()//获取相对路径
public String getName()//获取名称
public long length()//获取长度，字节数
public long lastModified() //获取最后一次修改时间，毫秒时间
public String[] list()//获取指定目录下的所有文件或者文件夹的名称数组
public String[] list(FilenameFilter filter)
public File[] listFiles()//获取指定目录下的所有文件或者文件夹的file数组
public File[] listFiles(FilenameFilter filter)

• IO流分类

• 按照数据流向
  输入流 读入数据
  输出流 写出数据
• 按照数据类型

   字节流
         字节输入流      读取数据   InputStream
//读数据
public int read()//一次读一个字节
public int read(byte b[])//一次读一个字节数组
         字节输出流      写出数据   OutputStream
//字节写数据
public void write(int b)//一个字节
public void write(byte b[])//字节数组
public void write(byte b[], int off, int len)//写一个数组的一部分
//字节写入
FileOutputStream fileOutputStream = new FileOutputStream("file.txt",true);
//写数据
//方法一
fileOutputStream.write("hello,IO\n".getBytes());
fileOutputStream.write("haha\n".getBytes());
//释放资源
fileOutputStream.close();
//方法二
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("file.txt",true));
bos.write("xixi".getBytes());
bos.close();
//字节读取
//方法一
FileInputStream fileInputStream = new FileInputStream("file.txt");
int by = 0;
while ((by = fileInputStream.read()) != -1){
      System.out.print((char)by);
 }
 fileInputStream.close();
//方法二
FileInputStream fileInputStream = new FileInputStream("file.txt");
byte[] bytes = new byte[1024];//数组的长度为1024的倍数
int len = 0;
while ((len = fileInputStream.read(bytes)) != -1){
   System.out.print(new String(bytes,0,len));
 }
 fileInputStream.close();
//方法三
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("file.txt"));
byte[] bytes = new byte[1024];
int len = 0;
while ((len = bis.read(bytes))!= -1){
     System.out.print(new String(bytes,0,len));
}
bis.close();

   字符流
         字符输入流       读取数据   Reader

InputStreamReader isr = new InputStreamReader(new FileInputStream("file.txt"));
char[] chars = new char[1024];
int len = 0;
while ((len = isr.read(chars)) != -1){
     System.out.print(new String(chars,0,len));
}
isr.close();
//方法二
FileReader fr = new FileReader("file.txt");
char[] chars = new char[1024];
int len = 0;
while ((len = fr.read(chars)) != -1){
    System.out.print(new String(chars,0,len));
}
fr.close();
//方法三
BufferedReader br = new BufferedReader(new FileReader("file.txt"));
char[] chars = new char[1024];
int len = 0 ;
while ((len = br.read(chars))!= -1){
    System.out.print(new String(chars,0,len));
}
br.close();
         字符输出流       写出数据   Writer
//方法一
OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("file.txt",true));
osw.write("\n中国java");
osw.flush();
osw.close();
//方法二
FileWriter fw = new FileWriter("file.txt",true);
fw.write("\n哈哈");
fw.flush();
fw.close();
//方式三
 BufferedWriter bw = new BufferedWriter(new FileWriter("file.txt",true));
bw.write("\n哈哈");
bw.close();

• Properties

Hashtable的子类，属于Map集合

public synchronized Object setProperty(String key, String value)// 添加
public String getProperty(String key)//获取
public Set<String> stringPropertyNames() //获取所有键的集合

Properties properties = new Properties();
properties.put("1","哈哈");
properties.put("2","嘻嘻");
properties.put("3","呵呵");
Set<Object> set = properties.keySet();
for (Object object :set){
   System.out.println(properties.get(object));
}
//Property和IO的结合使用
public synchronized void load(Reader reader)//读取
public void store(Writer writer, String comments)//写入

Properties properties = new Properties();
properties.setProperty("1","哈哈");
properties.setProperty("2","嘻嘻");
properties.setProperty("3","呵呵");
Writer writer = new FileWriter("test1.txt");
properties.store(writer,"写入");
writer.close();
Reader reader = new FileReader("test1.txt");
properties.load(reader);
reader.close();
System.out.println(properties.getProperty("1"));

• 多线程

如果程序有一条执行路径，那么该程序就是单线程程序
如果程序有多条执行路径，那么该程序就是多线程程序

• 进程

正在运行的程序

• 线程

在同一个进程内又可以执行多个任务，而这每一个任务我就可以看出是一个线程
是程序执行单元，执行路径，是程序使用CPU的最基本单元
java程序的运行原理：
由java命令启动jvm，jvm启动相当于启动了一个进程
接着有该进程创建一个主线程去调用main方法
jvm虚拟机的启动是多线程的
jvm最低启动两个线程，其中包括垃圾回收线程和主线程

• Thread

run(); 仅仅是封装被线程执行的代码，直接调用普通的方法
start();首先启动线程，然后由jvm去调用该线程的run()方法

//方式一
public class MyThread extends Thread{
    @Override
    public void run() {
        super.run();
        for (int i = 0;i < 1000; i++){
            //获取线程的名称
            System.out.println(this.getName()+"------>"+i);
        }
    }
}
MyThread myThread1 = new MyThread();
MyThread myThread2 = new MyThread();
//设置线程的名称
myThread1.setName("1");
myThread2.setName("2");
myThread1.start();
myThread2.start();

public final void setPriority(int newPriority)//设置线程优先级 MIN_PRIORITY=1   NORM_PRIORITY=5(默认) MAX_PRIORITY=10 优先级的范文为1-10
public final int getPriority()//获取线程优先级
public static native void sleep(long millis)//线程的睡眠
public final void join()//让某一个线程先执行
public static native void yield();//线程的礼让
public final void setDaemon(boolean on)//守护线程，设置成了首付线程之后就会先一步停止执行
public final void stop()//终止线程，不安全，不建议使用
public void interrupt()//终止线程，终止当前的线程，后续代码可以继续的使用
//方式二
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++){
           System.out.println(Thread.currentThread().getName()+"--->"+i);
        }
    }
}
MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable,"1");
Thread thread2 = new Thread(myRunnable,"2");
thread1.start();
thread2.start();
//使用方式二的原因
//A:可以避免由于java单继承带来的局限性
//B:适合多个相同程序的代码处理同一个资源的情况，把线程同程序的代码，数据有效分离，较好的体现了面向对象的设计思想
//解决线程安全的方法
//synchronized (共享对象){
//      共享代码块
//}
public class MyRunnable implements Runnable {
    private int num = 100;
    private Object object = new Object();
    @Override
    public void run() {
        while (true){
            synchronized (object) {
                if (num > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + "线程在卖第" + (num--) + "张票");
                }
            }
        }
    }
}
MyRunnable myRunnable = new MyRunnable();
Thread thread1 = new Thread(myRunnable,"窗口1");
Thread thread2 = new Thread(myRunnable,"窗口2");
Thread thread3 = new Thread(myRunnable,"窗口3");
thread1.start();
thread2.start();
thread3.start();
//线程锁
void lock();//上锁
void unlock();//解锁
public class MyRunnable implements Runnable {
    private int num = 100;
    private Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true) {
            lock.lock();
            try {
                if (num > 0) {
                    System.out.println(Thread.currentThread().getName() + "---->" + (num--));
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }finally {
                lock.unlock();
            }
        }
    }
}
//线程死锁Demo
public class DieLock extends Thread {
    private boolean flag;
    private static Object objectA = new Object();
    private static Object objectB = new Object();
    public DieLock(boolean flag){
        this.flag = flag;
    }
    @Override
    public void run() {
        super.run();
        if (flag){
            synchronized (objectA){
                System.out.println("this is objectA in if");
                synchronized (objectB){
                    System.out.println("this is objecB in if");
                }
            }
        }else{
            synchronized (objectB){
                System.out.println("this is objectB in else");
                synchronized (objectA){
                    System.out.println("this is objecA in else");
                }
            }
        }
    }
}
DieLock dieLockA = new DieLock(true);
DieLock dieLockB = new DieLock(false);
dieLockA.start();
dieLockB.start();
//线程的等待和唤醒，object对象调用
public final void wait() //等待
public final native void notify();//唤醒
public class Student {
    private String name;
    private int age;
    private boolean flag;
    public Student() {
    }
    public Student(String name, int age, boolean flag) {
        this.name = name;
        this.age = age;
        this.flag = flag;
    }
    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class SetThread implements Runnable {
    private Student student;
    private int i = 0;
    public SetThread(Student student) {
        this.student = student;
    }
    @Override
    public void run() {
        while (true){
            synchronized (student) {
                if (student.isFlag()){
                    try {
                        student.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                if (i % 2 == 0) {
                    student.setName("测试");
                    student.setAge(10);
                } else {
                    student.setName("哈哈");
                    student.setAge(12);
                }
                I++;
                student.setFlag(true);
                student.notify();
            }
        }

    }
}
public class GetThread implements Runnable {
    private Student student;

    public GetThread(Student student) {
        this.student = student;
    }
    @Override
    public void run() {
        while (true){
            synchronized (student) {
                if(!student.isFlag()){
                    try {
                        student.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(student.toString());
                student.setFlag(false);
                student.notify();
            }
        }
    }
}
Student student = new Student();
SetThread setThread = new SetThread(student);
GetThread getThread = new GetThread(student);
Thread threadA = new Thread(setThread);
Thread threadB = new Thread(getThread);
threadA.start();
threadB.start();

• 线程组(ThreadGroup)

public final ThreadGroup getThreadGroup()//获取当前线程组
public final String getName()//获取当前线程组的名称

//定时器(Timer)

public Timer() //构造方法
public void schedule(TimerTask task, Date time)
public void schedule(TimerTask task, long delay, long period) 
public void cancel()//取消定时器

多线程的面试题
1:多线程有几种实现方案，分别是哪几种
两种
继承Thread
实现Runnable接口
扩展一种：实现Callable接口，这个和线程池结合
2：同步有几种，分别是什么
两种
同步代码块
同步方法
3：启动一个线程是run()还是start()？它们的区别是什么
start();
run();封装了被线程执行的代码，直接调用仅仅是普通方法的调用
start();启动线程，并由JVM自动调用run()方法
4：sleep()和wait()方法的区别
sleep();必须指时间，不释放锁
wait();可以不指定时间，也可以指定时间，释放锁
5：为什么wait(),notify(),notifyAll()等方法都定义在Object类中
因为这些方法的调用是依赖于锁对象，而同步代码块的锁对象是任意锁
而Object代码任意对象，所以，定义在这里
6：线程的生命周期图
新建  -- 就绪 -- 运行 -- 死亡
新建 -- 就绪 -- 运行 -- 阻塞 -- 就绪 -- 运行 -- 死亡
建议：画图解释

C1CDAB43-B3DD-4941-AB60-DF2A44D9CF27.png

• 面向对象思想设计原则

  A:单一职责原则
       其实就是“高内聚，低耦合”
  B:开闭原则
       一个对象对扩展开放，对修改关闭
  C:里氏替换原则
      在任何父类出现的地方都可以用它的子类来替代
  D：依赖注入原则
      要依赖于抽象，不要依赖于具体实现
  F：接口分离原则
       不应该强迫程序依赖它们不需要使用的方法
  E：迪米特原则
       一个对象应当对其他对象尽可能少的了解   

• 设计模式

设计模式不是一种方法和技术，而是一种思想

• 设计模式的几个要素
  • 名字 必须有一个简单，有含义的名字
  • 问题 描述在何时使用模式
  • 解决方案 描述设计的组成部分以及如何解决问题
  • 效果 描述模式的效果以及缺点
• 设计模式的分类
  • 创建模型式 对象的创建
  • 结构型模式 对象的组成(结构)
  • 行为型模式 对象的行为
• 单列模式

//饿汉式
public class Person{
      private Person{
      }
      private Person p = new Person();
      public static Person getPerson(){
            return p
      }
}
   //懒汉式
public class Person{
      private Person{
      }
      private Person p = null;
      public static Person getPerson(){
            if (p == null){
                p = new Person();
            }
            return p
      }
}
//线程安全的懒汉式
public synchronized static Person getPerson(){
            if (p == null){
                p = new Person();
            }
            return p
      }

• 网络编程

网络编程三要素
A:IP地址：网络中的唯一标识符

public static InetAddress getByName(String host)//静态方法创建
public String getHostName()//获取网络地址的名字
public String getHostAddress()//获取网络地址的ip地址

B:端口：正在运行的程序的标识
C:协议

• UDP：把数据打包，数据有限制，不建立连接，速度快，不可靠

public DatagramPacket(byte buf[], int length,
                          InetAddress address, int port)//UDP发送，传送的字符数组，字符数组的长度，域名，端口号
DatagramSocket datagramSocket = new DatagramSocket();
byte[] bytes = "hello, I'm coming".getBytes();
//UDP发送
datagramSocket.send(new DatagramPacket(bytes,bytes.length,InetAddress.getByName("192.168.2.142"),10086));
datagramSocket.close();
//UDP接送
DatagramSocket datagramSocket = new DatagramSocket(10086);
byte[] bytes = new byte[1024];
DatagramPacket datagramPacket = new DatagramPacket(bytes,bytes.length);
datagramSocket.receive(datagramPacket);
byte[] bytes1 = datagramPacket.getData();
String dateString = new String(bytes1,0,bytes1.length);
String ip = datagramPacket.getAddress().getHostAddress();
System.out.println("ip:"+ip+"----->"+dateString);

• TCP：建立连接通道，数据无限制，速度慢，可靠

//TCP一定要先开服务器
//开启服务
ServerSocket serverSocket = new ServerSocket(10086);
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
byte[] bytes = new byte[1024];
int len = 0;
while ((len = inputStream.read(bytes)) != -1){
     System.out.println(new String(bytes,0,len));
}
socket.close();
//开启输入
Socket socket = new Socket("192.168.2.142",10086);
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello,TCP I'm coming".getBytes());
socket.close();

• Socket：网络套接字

• 类的加载

• 反射

就是通过class文件对象，去使用该文件中的成员变量，构造方法，成员方法

//方式一
Person person = new Person();
Class c1 = person.getClass();
//方式二
Class c2 = Person.class;
//方式三 开发常用
Class c3 = Class.forName("cn.DZX.User.Person");
System.out.println(c1 == c2);//true
System.out.println(c1 == c3);//true
public Constructor<?>[] getConstructors()//获取所有公共的构造方法
public Constructor<?>[] getDeclaredConstructors()//获取所有的构造方法
public Constructor<T> getConstructor(Class<?>... parameterTypes)//获取构造方法对象

Class aClass = Class.forName("cn.DZX.User.Person");
Constructor[] constructors = aClass.getDeclaredConstructors();
for (Constructor constructors1 : constructors){
    System.out.println(constructors1);
}
//获取不带参数的构造方法
Constructor constructor1 = aClass.getConstructor();
Object object1 = constructor1.newInstance();
System.out.println(object1);
//获取带参数的构造方法
Constructor constructor2 = aClass.getConstructor(String.class,int.class);
Object object2 = constructor2.newInstance("test",10);
System.out.println(object2);
//获取私有的构造方法
Class aClass = Class.forName("cn.DZX.User.Person");
Constructor constructor = aClass.getDeclaredConstructor(String.class);
constructor.setAccessible(true);
Object object = constructor.newInstance("哈哈");
System.out.println(object);
//访问成员变量
Class aClass = Class.forName("cn.DZX.User.Person");
Constructor constructor = aClass.getDeclaredConstructor();
Object object = constructor.newInstance();
constructor.setAccessible(true);
Field field = aClass.getDeclaredField("name");
field.setAccessible(true);
field.set(object,"测试");
System.out.println(field.get(object));
//访问成员方法
Method method = aClass.getDeclaredMethod("show",String.class);
method.setAccessible(true);
System.out.println(method);
System.out.println("--------");
method.invoke(object,"测试");

• 动态代理

接口才能有动态代理，其余的非接口类都不会有动态代理

//创建一个接口
public interface UserDao {
    public abstract void add();
    public abstract void delete();
    public abstract void update();
    public abstract void search();
}
//实现这个接口
public class UserDaoImp implements UserDao {
    @Override
    public void add() {
        System.out.println("增");
    }

    @Override
    public void delete() {
        System.out.println("删");
    }

    @Override
    public void update() {
        System.out.println("改");
    }

    @Override
    public void search() {
        System.out.println("查");
    }
}
//创建一个动态代理
public class MyInvocationHandler implements InvocationHandler {
    private Object object;

    public MyInvocationHandler(Object object) {
        this.object = object;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("权限校验");
        Object result = method.invoke(object,args);
        System.out.println("日志记录");
        return result;
    }
}
//实现
UserDao userDao = new UserDaoImp();
userDao.add();
userDao.delete();
userDao.update();
userDao.search();
System.out.println("----------------");
MyInvocationHandler myInvocationHandler = new MyInvocationHandler(userDao);
UserDao userDao1 =(UserDao)Proxy.newProxyInstance(userDao.getClass().getClassLoader(),userDao.getClass().getInterfaces(),myInvocationHandler);
userDao1.add();
userDao1.delete();
userDao1.update();
userDao1.search();

• 枚举(enum)

//无参构造
public enum EnumDemo {
    FRONT,
    BEHIND,
    LEFT,
    RIGHT;
}
//带参构造
public enum EnumDemo {
    FRONT("前"),
    BEHIND("后"),
    LEFT("左"),
    RIGHT("右");
    private String name;

    EnumDemo(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
//抽象方法
public enum EnumDemo {
    FRONT("前"){
        @Override
        public void show() {
            
        }
    },
    BEHIND("后"){
        @Override
        public void show() {

        }
    },
    LEFT("左"){
        @Override
        public void show() {

        }
    },
    RIGHT("右"){
        @Override
        public void show() {

        }
    };
    private String name;

    EnumDemo(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

• html

• body
  text：用于设定文字颜色
  background：设置背景图片，可以是同一文件夹下面的也可以不是同一文件件下面的 background="./1.jpg"
  bgcolor：设置背景颜色
• div
  align：left、center、right
• span
• p
• hr
  align：设置水平线对齐方式
  size：设置水平线的厚度
  width：设置水平线的长度
  color：设置水平线的颜色
• font
  face：规定文本的字体
  size：规定文本的大小
  color：规定文本的颜色
• ul
  type：规定列表的项目符号类型
• li
  type：这个属性是适用于无序列表，用于设置项目符号
  value：这个属性只适用于有序列表，用于设定列表的项目树子
• ol
  type：这个属性规定列表中使用的标记类型
  start：这个属性规定列表的起始值
• img
  src：用于设定要引入图片的url
  alt：用于设置图像的替代文字
  width：宽度
  height：高度
  border：图片边框厚度
• a
  href：设置连接指向页面的url
  name：设定锚的名称
  target：用于页面的跳转
• table
• caption：表格的标题，必须放在table之后
• thead：表格的头部
• thbody：表格的身体
• thfoot：表格的尾部
• tr
• th：设置表头，设置之后文字居中且文字加粗
• td
  rowspan：合并行单元格
  colspan：合并列单元格
• form
  *input
• file

• css

• css样式

//内联式
<div style="border:1px solid black"></div>

//内部式 8F39B73D-41DB-49F2-8CA1-CCB6F1A30775.png

//外部式

40729F14-ACC2-42D5-9E97-09F7011A1315.png
3C2F8D73-C78E-44A2-8887-7D0B470E36FE.png
优先级问题

内联样式表>(内部样式表>=<外部样式表:就近原则)

• css选择器

//id选择器

807BF397-B45F-42A5-AF1E-C2E319269940.png
AA56A345-5C5E-4CAA-9239-ED27FD3BE94C.png

//类选择器（class选择器）

99F5D0C9-6986-4A44-8D67-129E37A8B66D.png
//元素选择器
C0D8E31E-571A-4ED4-85CD-467BCB44EFC9.png
//属性选择器
E7862D1D-8715-4A7D-A5D2-267B1356CE0C.png

//伪类

4282D21F-D927-4A97-BEE5-076C8146326D.png
FD298A1B-81BF-4475-8D21-5E448FEA216A.png
//层级选择器
BF4E50DC-57CC-46B5-8C0A-5AC780676C68.png

• css属性

• 字体
  font:简写属性，作用是把所有针对字体的属性设置在一个声明中。【style size family】
  font-family:定义字体系列
  font-size:定义字体的尺寸
  font-style:定义字体风格
• 文本
  color:定义文本颜色
  text-align:定义文本对齐方式
  letter-spacing:定义字符间隔
• 背景
  background:简写属性，作用是将背景属性设置在一个声明中
  background-color:定义背景颜色
  background-image:定义背景图片
  background-position:定义背景图片的起始位置【left,center,right】
  background-repeat:定义背景图片是否及如何重复
• 尺寸
  width:设置元素的宽度
  height:设置元素的高度
• 列表
  list-style:简写属性。用于把所有用于列表的属性设置于一个声明中。
  list-style-image:定义列表项标志为图象
  list-style-position:定义列表项标志的位置
  list-style-type:定义列表项标志的类型。
• 表格
  border-collapse:定义是否把表格边框合并为单一的边框。
  border-spacing:定义分隔单元格边框的距离
  caption-side:定义表格标题的位置【top,bottom】
• 轮廓
  outline:在一个声明中设置所有的轮廓属性
  outline-color:定义轮廓的颜色
  outline-style:定义轮廓的样式
  outline-width:定义轮廓的宽度
• 定位
  position:把元素放置到一个静态的,相对的，绝对的，或固定的位置中。
  top:定义了定位元素的上外边距边界与其包含块上边界之间的偏移量
  right: 定义了定位元素右外边距边界与其包含块右边界之间的偏移
  left: 定义了定位元素左外边距边界与其包含块左边界之间的偏移
  bottom: 定义了定位元素下外边距边界与其包含块下边界之间的偏移。
• 分类
  clear:设置一个元素的侧面是否允许其它的浮动元素
  float:定义元素在哪个方向浮动
  cursor:当指向某元素之上时显示的指针类型
  display:定义是否及如何显示元素
  visibility:定义元素是否可见或不可见

• css框模型

• 盒子模型

  
  image.png
• 边框
  border:简写属性，用于把针对于四个边的属性设置在一个声明。
  border-color:简写属性，定义元素边框中可见部分的颜色，或为四个边分别设置颜色。
  border-style:用于定义所有边框的样式，或者单独为各边设置边框样式。
  border-width:简写属性，用于为元素的所有边框设置宽度，或则单独地为各边边框设置宽度
  border-top:简写属性，用于把上边框的所有属性设置到一个声明中
  border-right:简写属性，用于把右边框所有属性设置到一个声明中
  border-bottom:简写属性，用于把下边框的所有属性设置到一个声明中
  border-left:简写属性，用于把左边框的所有属性设置到一个声明中。
• 外边距
  margin:简写属性，在一个声明中设置所有外边距属性
  margin-top:定义元素的上外边距
  margin-right:定义元素的右外边距
  margin-bottom:定义元素的下外边距
  margin-left定义元素的左外边距
  注意:在使用margin来定义所有外边距时，可以使用值复制。
  如果缺少左外边距的值，则使用右外边距的值。
  如果缺少下外边距的值，则使用上外边距的值。
  如果缺少右外边距的值，则使用上外边距的值。
• 内边距
  padding:简写属性，作用是在一个声明中设置元素的所有内边距属性
  padding-top:定义元素的上内边距
  padding-right:定义元素的右内边距
  padding-bottom:定义元素的下内边距
  padding-left:定义元素的左内边距

• js

//内部式
<script type="text/javascript">
        alert("hello,javascript");
 </script>
//外部式
<script type="text/javascript" src="demo01.js"></script>

• 数据类型

• 原始数据
  String、Boolean、Number、undefined、null
  alert(typeof y); 获取数据类型 typeof 声明对象 或者 typeof(声明对象)
• 引用类型
  var x = 10;
  数字转字符转：x.toString();
  字符串转数字：parseInt(x);
  强制转换：Number(x)、String(x)...
• 数组
  var array = new Array();
  array.push(1);//添加数据
  array.pop();//移除数组中最后一个元素
  array.splice(0,1);//从下标为0开始删除长度为1的元素
• 函数（方法）
  声明
  function 方法名称(参数列表) {
  方法体
  }
  var add = function (参数列表) {
  方法体
  }
  //编码url
  encodeURI()
  encodeURIComponent()
  //解码url
  decodeURI()
  decodeURIComponent()
  //字符串的编码
  escape()
  //字符串的解码
  unescape()
• 点击事件
  onchange//点击改变
  onfocus//获取焦点
  onblur//失去焦点
  //界面加载完成调用
  window.onload = function(){
  代码块
  }
• this
  指的当前的控件
• 事件阻止

//阻止事件的发生
function f(e) {
    if (e && e.preventDefault){
        e.preventDefault;//w3c
    }else{
        window.event.returnValue = false;//ie
    }
}
//点击的透传
function f(e) {
    if (e && e.stopPropagation){
        e.stopPropagation();//w3c
    }else{
        window.Event.cancelBubble = true;//ie
    }
}

• BOM
  alert(message?: any): void; //提示框
  confirm(message?: string): boolean; //选择框
  prompt(message?: string, _default?: string): string | null;//输入框
• DOM

//通过id获取html标签
getElementById(elementId: string): HTMLElement | null; 
//获取标签以及标签内属性的值
getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
//通过Name获取标签
getElementsByName(elementName: string): NodeListOf<HTMLElement>;
//创建html
createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, options?: ElementCreationOptions): HTMLElementTagNameMap[K];
//创建html内容
createTextNode(data: string): Text;
//添加标签或者添加内容
appendChild<T extends Node>(newChild: T): T;
//添加到指定的标签的前面，后面
insertinsertAdjacentElement(position: InsertPosition, insertedElement: Element): Element | null;
InsertPosition = "beforebegin" | "afterbegin" | "beforeend" | "afterend";

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script type="text/javascript">
        function addClick() {
            var element = document.createElement("li");
            var node = document.createTextNode("北京");
            element.appendChild(node);
            var city = document.getElementById("city");
            city.appendChild(element);

        }
        function insertClick() {
            var element = document.createElement("li");
            var node = document.createTextNode("北京");
            element.appendChild(node);
            var city = document.getElementById("city");
            var cq = document.getElementById("cq");
            alert(cq.innerHTML);
            cq.insertAdjacentElement("beforebegin",element);
        }
    </script>
</head>
<body>
<ul id="city">
    <li id="cq">重庆</li>
    <li>成都</li>
    <li>上海</li>
</ul>
<button id="add" onclick="addClick()">添加</button>
<button id="add1" onclick="insertClick()">插入</button>
</body>
</html>
//删除标签
removeChild(childNode: IXMLDOMNode): IXMLDOMNode;

• MySQL数据库

//查询
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
    //注册
     Class.forName("com.mysql.cj.jdbc.Driver");
     //登录
      String url = "jdbc:mysql://localhost:3306/myDatabase";
      connection =                 DriverManager.getConnection(url,"root","12345678");
      //获取statement
      statement = connection.createStatement();
      //查询
      resultSet = statement.executeQuery("select * from studentTable");
     //读取
      while (resultSet.next()){
           int id = resultSet.getInt(1);
           System.out.println(id);
           String name = resultSet.getString(2);
           System.out.println(name);
           int age = resultSet.getInt(3);
          System.out.println(age);
       }
}catch (Exception e){
    e.printStackTrace();;
}finally {
//关闭
  if (resultSet != null) {
        try {
           resultSet.close();
        } catch (SQLException e) {
            e.printStackTrace();
    }
}
   if (statement != null) {
       try {
           statement.close();
       } catch (SQLException e) {
            e.printStackTrace();
       }
 }
   if (connection != null) {
        try {
            connection.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
   }
}
//插入
Connection connection = DBUtils.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("insert into student(id,name ,age) values (?,?,?)");
preparedStatement.setInt(1,2);
preparedStatement.setString(2,"嘻嘻");
preparedStatement.setInt(3,12);
int number = preparedStatement.executeUpdate();
System.out.println("受影响的行数："+number);
DBUtils.close(connection,preparedStatement,null);
//修改
Connection connection = DBUtils.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("update student set name = ? where id = ?");
preparedStatement.setString(1,"呵呵");
preparedStatement.setInt(2,2);
int number = preparedStatement.executeUpdate();
System.out.println("受影响的行数："+number);
DBUtils.close(connection,preparedStatement,null);
//DBUtils class类
public class DBUtils {
    private static String driverConnection = "com.mysql.cj.jdbc.Driver";
    private static String url = "jdbc:mysql://localhost:3306/userInfo";
    private static String use = "root";
    private static String password = "1234567890";
    static {
        try {
            Class.forName(driverConnection);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url,use,password);
    }
    public static void close(Connection connection, Statement statement, ResultSet resultSet){
        if (resultSet != null){
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }else{

        }
        if (statement != null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }else{

        }
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }else{

        }
    }
}