Javaweb学习笔记的预整理（详细看具体每天的整理，没有的就是还没有整理好）

day2--------If、While、For、Switch

1. if（boolean）{}进行判断，在需要多次进行判断的时候，可以使用卫语句进行判断（一般是判断特殊情况和违法输入）违法输入可以用return；直接退出操作
2. while(boolean){}，是进行循环操作时使用的语句，一般逻辑判断循环时使用 （条件不确定的循环 或者需要等待用户输入特定的条件结束的循环）
3. for（）{}，也是进行循环操作时使用的语句，一般数值判断进行循环时使用（遍历操作 或者 是要执行固定次数操作的循环 就是已知）
4. while和for的无限循环时的应用：while(true) for(;;) 然后退出循环使用break；或者return；
5. switch（ byte short int整数类型，char，String）不支持long
6. 循环中需要注意的 continue ：跳出此次循环 break：结束离他最近的那层循环
7. 还有一个特殊的判断语句用法： boolean ? 数1 ：数2； boolean为true时输出数1，为false时输出数2
8. ”+“ 运算符 ，两边是数字时是进行加法；有一边是字符串时进行的是字符串的拼接。 1+2+""+3 输出33字符串。""+1+2+3输出123字符串
9. 双重for循环：典型的双重for是冒泡排序。

day3---------数组

1. 数组的定义： 元素类型[] 数组名 = new 元素类型[元素大小]； 初始赋值：int[] num = {1,2,3,4,5}; 或 int[] num = new int[]{1,2,3,4,5};
2. 数组他的长度是固定的，后面会学到集合框架里的ArraysList 和LinedList 和HashList 来弥补这个缺陷；
3. 数组的访问： 数组名[下标]
4. 数组的下标越界异常 ：java.lang.Array Index OutOf Bounds Exception: 4
5. 数组中最重要的操作是遍历操作。 通过遍历操作array.fori可以进行求最大值、最小值 和 累加和，还可以用增强for循环 array.f。
6. 数组的复制：下面的数组的复制都是和扩容都是复制到一个新的数组里，不对原数组进行改变。

1. 数组的高效复制：System.arraycopy(source, 0, dest, 0, source.length);

                         source:原数组。第一个0：原数组的起始位置。dest：存放复制后数据的数组。第二个0：目标数组的起始位置。 length：复制的长度

     2.  int[] array = Arrays.copyOf(source, source.length) 复制整个数组，也可以用来扩容（改变后面的length的值）

     3.int[] array = Arrays.copyOfRange(source, 1, 4); // 复制索引 1 到 3 的元素 source：原数组 1,4 表示的是[ ),所以是复制的索引1-3的

     4.int[] array = source.clone(); 简单复制一个数组

     5.手动遍历进行复制

    7.几种输入语句 Scanner scanner = new Scanner(System.in); //定义一个scanner 对象

              输入整数： int num = scanner.nextInt(); 输入浮点型 ：double num = scanner.nextDouble; 输入不带空格的字符串：String str = scanner.next();

              输入带空格的字符串 String str = scanner.nextLine();

    8.char[] array = str.toCharArray(); //将字符串转换成字符数组

day4---------类（封装、构造方法）继承、重载、重写、多态类、抽象类

1.类的定义

        类是对现实事物的抽象：Student 对象是现实中具体的个体：student1（具体的某个学生） 基于对象的共同特征抽象出类。         

        OOP：面对对象。 面对对象的特征：抽象、封装、继承、多态

 2.定义一个简单的类

        public class Student{} 定义一个简单的对象：Student student = new Student(); 这是无参构造方法

3.继承

父类中存在的所有属性一定是所有子类所共有的。

封装是前面加上private 继承是父类前面加上protected然后子类用extends 进行连接父类

     例如： public class Student extends Person{}

     super(); 这个方法是new一个父类 。 所有的类共有的父类是Object。

• 当父类存在无参构造方法时，子类构造方法中的 super() 可以省略，因为编译器会自动添加。
• 当父类没有无参构造方法时，子类的构造方法中必须显式调用 super() 并传递相应的参数，以确保父类的构造方法被正确调用。

this、super总结：

1. this:代表当前类的对象 this.id=id
2. super：代表父类对象
3. this():调用当前类的构造方法,.
4. super():调用父类构造方法

在封装类中一个构造方法可以使用另一种构造方法，内部也可以调用new

public class Rectangle { 
    private int width; 
    private int height; 

    public Rectangle() { 
        this(1, 1);//new Rectangle(1, 1) 
// this.width = 1; 
// this.height = 1; 
    } 
public Rectangle(int width, int height) { 
    this.width = width; 
    this.height = height; 
    } 
}

4.重载

    重载（Overload）是指在同一个类中可以有多个方法拥有相同的名称，但是它们的参数列表不同。   Java通过方法的参数类型、个数或顺序来区分不同的重载方法

典型的重载方法就是构造方法！！！！！！！

    1、重写（覆盖）@Override 这个一定要在定义方法前面加上（像@Test）

父类中定义的方法子类不满意，子类重新定义这个方法，最典型的重写就是toString()

    2、子类覆盖父类，必须保证子类权限大于父类权限才可以覆盖，否则会编译失败。

    解释：权限从大到小：public > protected > (default) > private

例如下面代码就是一个典型错误的重写：

class Parent {
    public void display() {
        System.out.println("Parent's display method");
    }
}

class Child extends Parent {
    // 错误的重写，使用 protected 修饰符，权限小于父类的 public
    @Override
    protected void display() {
        System.out.println("Child's display method");
    }
}

    3、如果父类是private的方法，子类是默认方法，那么子类是不知道这个方法的，不是覆盖。

重载和重写的对比：

重载（Overload）：同一个类中方法名一样参数列表不一样（构造方法重载）

重写（Override）：父子类中方法（父类中定义的方法子类不满意，子类重新定义这个方法）

5.多态：

Java 多态（Polymorphism）是面向对象编程的一项核心概念，它允许对象以多种形式出现。

多态性在Java中有两个主要的表现形式：

    1.编译时多态（也称为静态多态）

    2.运行时多态（也称为动态多态）

编译时多态是通过方法重载（Method Overloading）实现的。这意味着在同一个类中可以定义多个方法，这些方法具有相同的名字但参数列表不同。编译器在编译时根据参数列表来决定调用哪个具体的方法。（编译时多态就是因为方法重载实现的）

这里大家只要知道多态还有编译时多态这种形式就可以，重点还是运行时多态。

多态存在的三个必要条件：

    1.继承    2.重写    3.父类引用指向子类对象   Cal cal = new Add();

        总结上面图片代码：多态存在的意义就是在继承后，子类重写了父类的函数，然后父类的那个函数是return 0; 这样子类重写之后，在父类引用指向子类对象调用方法时就会调用子类中的方法。但是这样就有一个问题，如果子类忘记重写了，不会报错，会执行父类的方法。这个问题在下面的抽象类、抽象方法中会得到解决。（看IDEA上的代码）还有一个问题：可以new一个父类对象，这是不合理的，因为父类对象不应该被实体化。。！！重点整理！！！

6.抽象类、抽象方法

        1、抽象方法是没有方法体，如果这个类里面有抽象方法，这个类必须变成抽象类。

        2、如果这个类是抽象类，并不要求这个类一定要有抽象方法

        3、抽象类里面可以有普通方法，也可以有抽象方法。

        4、如果一个类是抽象类，那么这个类就不能被new实例化，只能被其他类继承。

        5、抽象方法可以理解为父类（抽象类）定义的一个模板或者规范（自己本身不实现），子类必须实现这个抽象方法，如果子类不想实现这个方法，那么这个子类也必须要变成抽象类。 就是必须要进行重写。

抽象类定义：public abstract class Cal {}     (abstract 抽象的意思)

抽象方法定义：public abstract int getResult();

这样之后上面多态中可能会出现的问题就不会出现，那种情况就会报错。

day5--------- 接口、静态属性、静态方法 、git基础

1.接口interface

    接口是一个纯粹的抽象类（接口里面所有的方法都是抽象方法）

    接口就是一个规范(标准)，他没有提供任何是实现，具体的功能由实现接口的子类去实现。

    接口就是一个规范，可插拔（可以被替换，首先定义一个标准（接口），大家都遵守这个标准，就可以实现互相之间替换）

接口的特点：

    1、接口是一个纯粹的抽象类，接口里面的方法都是抽象方法：public abstract

    2、接口里面所有的属性：public static final double PI = 3.14;

final总结：修饰变量、类、方法

final:最终的意思

1. final变量：这个变量就不能被修改,就是常量 public static final double PI = 3.1415;
2. final类：这个类就不能被继承
3. final方法：这个方法就不能被重写

//接口就是一个纯粹的抽象类，接口就是一个标准
public interface IFly {
    //public static final double PI = 3.14;
    double PI = 3.14;

    //public abstract void fly();
    void fly();

}

上面是一个接口的定义，包括里面的方法的定义。

如何选择接口还是抽象类

1. 继承是严格的父子关系，你继承什么你就是什么：鸽子就是鸟。

父类是抽取了所有子类的共同特征，父类里面的属性和方法是所有子类所共有的属性和方法。

1. 接口是一个标准，一般用在能不能具有某个功能。

把能不能飞定义称为一个接口IFly，实现了这个接口的类就具有了这个功能。

public class DaYan extends AbstractBird implements IFly {
    
}

这个DaYan类继承了AbstractBird类然后又接口了IFly。 当用IFly这个接口父类定义一个DaYan对象时，这个对象只能使用IFly里面的方法（用来看一个对象有没有这个功能）

2.静态属性、静态方法

如何理解静态属性、静态方法

小区里面业主的房子可以看成一个一个的对象，这些都是属于特定的业主所独有。但是小区里面也有一些公共设施（健身器材、绿地），这些公共设施是属于这个小区的。但是是可以被所有的业主对象所使用的。

非静态的属性和方法（实例属性和方法）必须通过new对象访问，而静态的属性和方法是属于类的，在类加载到内存中就可以访问，不需要new对象就可以使用，但是可以被所有对象所共享。

使用时候注意点：

1、静态的方法只能访问静态的方法和静态的属性（因为当前对象的实例可以没有创建，所以静态的方法是没办法调用非静态的方法和属性的）

2、静态的方法中不能写this、super关键字(因为当前的对象实例可能还没有创建，代表当前类对象的this还有代表父类对象的super可能都还没有创建)

3.Git 基础 (重新整理一下)

命令整理：

git init //初始化本地版本库

git status //查看当前文件的状态。

git add .  //跟踪所有改动过的文件

git commit -m "修改"

git log //查看通过git进行的所有改动

gitk& 打开gitk工具进行图形界面观察变动

git分为三个区域： 工作区域 暂存区 本地仓库

        工作区域：就是正在进行代码编辑的地方，可以通过 “git add .”将改动的代码提交到暂存区。

        暂存区：起到暂时存储的作用，可以通过“git commit -m "提交信息”将改动提交到本地仓库；

也可以通过“git checkout .”(全部撤回)将提交到暂存区的改动撤回

        本地仓库：通过“git reset HEAD .”将上次提交到本地仓库的撤回到暂存区。

        备注：也可以通过git checkout HEAD . 实现两步撤回；通过 git commit -a -m"提交信息" 可以实现两步提交

4.工具类

Math、Arrays、ArrayUtil

    1.工具类里面的方法都是静态方法，方法之间没有关联。

    2.工具类的构造方法私有，禁止外界new对象，只能通过类名.方法方式访问

这些工具类的方法一定要看到能知道是什么作用。 调用： Math.max 直接 类名.方法名调用

day6-------String、包装数据类型、集合框架

1.Sring

变量名(引用)放在栈里面，指向的对象放在堆里面，变量通过存储的地址值找到堆里面的对象。

通过new出来的新对象会在对象堆里开辟一个新的区域，String str = "abc",这种方式是将存“abc”的 地址传给str这个变量。

"=="是判断这左右两边字符串是否地址相同。equals（str）是判断字符串的值是否相等。

字符串相关的方法：

1.获取字符串的相关信息：

例如：int i = str.indexOf("2");获取字符“2”在字符串str这个对象中的索引。

2.对字符串进行一些判断：

一些英文命名：

case 严格区分大小写；     equals 字符串相等；     prefix 前缀；

startswith（）用于检查字符串是否以指定的前缀开始；

isEmpty() 是否为空；

3.字符串的转换：

切割中 使用到的正则表达式是一种用于匹配和处理文本的强大工具，一种描述字符串模式的工具。在拆分操作中，它会在目标字符串中寻找与正则表达式模式相匹配的部分，然后在这些匹配的位置将字符串进行拆分。以下是一些常见的正则表达式：

字符匹配

• **普通字符**：直接匹配字符本身，例如abc匹配字符串中连续出现的abc。
• **字符类**：用方括号[]表示，匹配方括号中的任意一个字符。例如[abc]可以匹配a、b或c。
• **否定字符类**：在方括号内开头加上^表示否定，匹配不在方括号中的任意一个字符。例如[^abc]可以匹配除了a、b、c之外的任意字符。

数量限定

• **星号***：表示前面的字符或字符类可以出现0次或多次。例如a*可以匹配空字符串，也可以匹配多个连续的a。
• **加号+**：表示前面的字符或字符类必须出现1次或多次。例如a+至少匹配一个a。
• **问号?**：表示前面的字符或字符类可以出现0次或1次。例如a?可以匹配一个a或者不匹配任何字符。
• **花括号{m,n}**：表示前面的字符或字符类至少出现m次，最多出现n次。例如a{2,4}可以匹配2个、3个或4个连续的a。

边界匹配

• **脱字符^**：表示匹配字符串的开始位置。例如^abc表示匹配以abc开头的字符串。
• **美元符号$**：表示匹配字符串的结束位置。例如abc$表示匹配以abc结尾的字符串。
• **单词边界\b**：用于匹配单词的边界，即单词和非单词字符的交界处。例如\bcat\b可以匹配cat这个单词，但不会匹配category中的cat。

分组和引用

• **括号()**：用于分组，可以将多个字符或表达式组合成一个单元，以便对这个单元进行整体的操作。例如(abc)+表示abc整体出现1次或多次。
• **反向引用**：在正则表达式中，可以使用\n（n为数字）来引用前面分组匹配到的内容。例如(a(b)c)\1可以匹配abcabc，其中\1引用了前面(a(b)c)匹配到的内容。

预定义字符类

• **\d**：匹配任意一个数字，相当于[0-9]。
• **\D**：匹配任意一个非数字字符，相当于[^0-9]。
• **\w**：匹配任意一个字母、数字或下划线，相当于[a-zA-Z0-9_]。
• **\W**：匹配任意一个非字母、数字或下划线的字符，相当于[^a-zA-Z0-9_]。
• **\s**：匹配任意一个空白字符，包括空格、制表符、换行符等，相当于[\f\n\r\t\v]。
• **\S**：匹配任意一个非空白字符，相当于[^\f\n\r\t\v]。

上面的具体代码示例会在后面的发文中具体给出

2.String、StringBuffer、StringBuilder异同点

相同的：他们都是final类，都不能被继承。

不同点：

1.String长度是不变的 ，StringBuffer和StringBuilder长度是可以改变的。

String进行拼接改变，这个时候是new了一个新的字符串对象。

例如：String str = str1 + str2 + str3 + str4; 每次拼接都会生成一个新的对象，这期间构造了三个新的String对象，其中两个是临时的对象会被当成垃圾回收。

常量字符串的拼接，编译器会做优化，使用String就可以：

String str = "Java" + "PHP" + "Python" + "C";

2.StringBuffer是线程安全（需要加锁，效率低)、StringBuilder是线程不安全（没有加锁，效率高）。解释：对一段代码加锁，就可以实现一次只能有一个用户进入这段代码，执行完了释放这个锁，下一个用户才可以进来。

StringBuffer和StringBuilder长度改变代码实现:

StringBuffer buffer = new StringBuffer();
buffer.append(str1);
buffer.append(str2);
buffer.append(str3);
buffer.append(str4);
//还可以链式编程实现
buffer.append(str1).append(str2).append(str3).append(str4);

StringBuilder builder = new Sreingbuilder();
builder.append(str1);
builder.append(str2);
builder.append(str3);
builder.append(str4);
//链式编程实现
builder.append(str1).append(str2).append(str3).append(str4);

Java 链式编程是一种编程风格，它允许你在一个对象上连续调用多个方法，每个方法都返回该对象本身，从而形成一个方法调用链。其要求主要有以下几点：

1.方法返回对象本身

链式编程要求在调用的每个方法中都返回当前对象（this），这样才能保证后续方法可以继续在同一个对象上调用。

2.方法调用的顺序性（顺序符合最后的需求）

3.可读性和维护性

3.包装数据类型：

Java是纯面向对象语言，int、double都是基本数据类型。

包装数据类型是对基本数据类型的封装

int                Integer

char             Character

double         Double

long             Long

short            Short

boolean       Boolean

byte             Byte

float             Float

@Test
public void test() {
    Integer integer = new Integer(4);
    System.out.println(integer);//4
    //自动装箱
    Integer integer1 = 5;
    System.out.println(integer1);//5
    //自动拆箱
    int num = integer1;
    System.out.println(num);//5
    
    //示例分析：
    Integer integer = 3；//装箱
    int num = integer + 4; //拆箱 通过Integer类里的方法进行拆箱
    integer = integer + 5; //先拆箱再装箱
}
//备注:虽然基本数据类型和包装数据类型互相转换有装箱和拆箱的过程，
//但是我们平时使用的时候就把包装数据类型当成基本数据类型来使用就可以。

包装数据类型最主要使用：包装数据类型和字符串之间的转换

1、把基本数据类型转换成字符串

    (1) 基本数据类型+"" : String str = 12 + ""; // "12"

    (2) 基本数据类型的包装类.toString()

        String str1 = Integer.toString(3);

        String str2 = Double.toString(3.14);

2、把字符串转换成基本数据类型（从网页的输入框中得到的都是字符串）

    (1) Integer.parseInt(String str); // "23"

         Double.parseDouble(String str); //"3.14"

         Boolean.parseBoolean(String str);//"true"

         XXXX.parseXXXX(String str);

    (2) new对象： Integer integer = new Integer(String str);

         Integer interger = new Integer("4");

         int i = integer.intValue();

Java 包装数据类型的意义主要体现在以下几个方面：

1.方便对象操作

        基本数据类型不是对象，在某些需要对象的场景中使用起来不太方便。而包装数据类型是对象，具有属性和方法，可以更方便地进行各种操作。例如，在集合框架中，只能存储对象，因此需要使用包装数据类型。

2.支持泛型

        泛型是 Java 中一种重要的特性，它允许在编写代码时使用类型参数，以提高代码的通用性和可复用性。但泛型只能用于引用类型，不能用于基本数据类型。包装数据类型使得基本数据类型也能参与泛型编程。

3.提供了更多的功能和方法

        每个包装数据类型都提供了一些有用的方法，方便对基本数据类型进行处理。比如Integer类提供了parseInt()方法用于将字符串解析为整数，valueOf()方法用于将基本数据类型转换为包装数据类型等。

4.解决基本数据类型默认值问题

        基本数据类型有默认值，如int默认值是 0，boolean默认值是false。在某些情况下，这种默认值可能会导致误解或错误。包装数据类型可以为null，表示没有值，

day7-------数据库、Sql单表和多表