java

2019-09-29  本文已影响0人  纳兰怮翌

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

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

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开头

源码：

    正数的原码最高位是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 (条件语句){
执行语句
}
注意事项：

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

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

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

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

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

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

a、如果你想在循环结束之后继续使用控制条件的那个变量，用while，否则用for
b、如果是一个范围，用for，如果不明确，用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、静态方法只能访问静态的成员变量和静态的成员方法

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

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

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

使用

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

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

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

注意事项：

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

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

  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


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

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

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

概述：其实就是文件夹
作用：对类进行分类管理
定义：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地址：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) : 基本类型比较的值是否相同，引用类型比较地址值是否相等

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、把所有的数据都按照字符串获取

概述：字符串是由多个字符组成，也可以看成是一个字符数组，字符串是常量，一旦被赋值就不能被改变
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";区别
前者会创建两个对象，后者会创建一个对象

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

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

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

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

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)

概念：符合一定规则的字符串
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);

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();

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

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) 平方根

概念：产生随机数

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

概念：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);从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束

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

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

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

概念：Calendar替代Date

数组和集合的区别

A：长度区别
          数组的长度是固定
          集合长度可变
B：内容不同
          数组存储的是同一种类型元素
          集合可以存储不同类型的元素
C：元素的数据类型问题
          数组可以存储基本数据类型和引用数据类型
          集合只能存储引用数据类型
Collection.png 
      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特有的方法
        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());
        }

        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()

//方法一
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集合和Collection集合的区别
1.Map集合存储元素是成对出现的，Map集合的键是唯一的，值是可重复的
2.Collection集合存储元素是单独出现的，Collection的儿子set是唯一的，list是可重复的

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));
        }

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

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) //随机排序

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

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

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

//构造方法
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)

   字节流
         字节输入流      读取数据   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();

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最低启动两个线程，其中包括垃圾回收线程和主线程

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();

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:协议

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一定要先开服务器
//开启服务
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();

就是通过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();

//无参构造
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();
}

//内联式
<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
优先级问题

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

//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 
//内部式
<script type="text/javascript">
        alert("hello,javascript");
 </script>
//外部式
<script type="text/javascript" src="demo01.js"></script>

//阻止事件的发生
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
    }
}

//通过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;

//查询
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{

        }
    }
}
上一篇 下一篇

猜你喜欢

热点阅读