本文详细介绍了Java编程的基础知识，包括Java的开场白、变量、常量、数据类型、关键字、标识符、转义字符、运算符、程序流程控制和数组。此外，还讲解了面向对象设计的原理，如类、对象、构造方法、方法、继承、多态、抽象类和接口。最后，简要讨论了异常处理和集合框架，如ArrayList、LinkedList、Map和线程的概念。
目录
Java开场白
认识Java程序
main（）函数
public static void main(String[] args){…}
public:关键字访问权限
static：告诉编译器main函数是一个静态函数存储在静态区域
void:该函数没有返回类型
main:main是函数名
String[] args:方法的参数public class Main {
public static void main(String[] args) throws Exception {
// write your code here
String[] s = {“test01”, “test02”, “test03”};
if (s == null || s.length == 0) {
System.out.println(“没有传递参数”);
return;
}
for (int i = 0; i < s.length; i++) {
System.out.println(s[i] + " ");
}
}
}
Java代码组织习惯
代码块：用大括号括起来的程序块
public class HelloWorld{
public static void main(Strings[] args){
System.out.println(“Hello World”);
}
}
认识变量
变量的申明
Java是强类型语言变量必须声明才能使用
声明：类型 变量名；
命名规范
变量命名只能以$、字母、下划线、数字组合这种方式，并且只能以$、字母、下划线开头，不能以数字开头。
八种基本类型变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bplorHtw-1617798717612)(media/528321547bf98b5f22c3c0b49678a0a8.png)]
变量的范围
变量的范围：变量定义开始，到块结束。
局部变量：在方法内定义的变量
注意：1.Java的局部变量，必须初始化才能使用；2.变量是有作用域的，也就是范围；3.变量名是不可以重复的；
public static void main(String[] args) throws Exception {
// write your code here
if(5>3){
int i=0;
}
int i=5;
}
这种代码运行成功
Reason:两个变量i，这个i是在代码块里，作用域就是这个if代码块，超过这个代码块，就被回收了。
public static void main(String[] args) throws Exception {
// write your code here
int i=2;
if(5>3){
int i=0;
}
}
}
这种代码运行不成功
Reason：第一个变量i作用域就是这个main函数代码块，所以在这个范围内的任何地方，包括if代码块都是i的作用域，所以if代码块里的变量i与第一个变量i冲突，所以错误。
认识常量
常量：常量定义之后，就不会再发生变化。
public static final + 类型名 +变量 = …
eg. public static final double PI= 3.14;
常量作用：固定变量数值不改变。
数据的类型
类型的转换
值域大的类型不能直接转换成智育类型小的的类型，但是可以强转
强转语法：类型A 变量名 ＝ ｛类型Ａ｝变量名
public static void main(String[] args) throws Exception {
// write your code here
double i = 9.2;
int a = (int) i;
System.out.println(a);
}
虽然可以强转类型，但是丢失了精度。输出结果：a=9
Java关键字
Java中关键字：Java中的保留字（我们定义的变量不能和Java的关键字重名）
认识标识符名
Java中标识符：类名（【n】每个单首字母大写）、变量名（【n】首字母小写）、方法名（【v】首字母小写）、包名（通常全部小写）
转义字符
常见转义字符
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M2W3NKcJ-1617798717619)(media/493fa42b919f84432878b4d7b3ced4d1.png)]
Java运算符
算术运算符
“+”“-”“*”“/”“%”“++”{（++a）前++：变量先加1后再算表达式}{（a++）后++：先算表达式后变量加1}
赋值运算符
“=”
扩展赋值运算符：在赋值运算符“=”前加上其它运算符。
“+=”“-=”“/=”“%=”“&=”…
关系运算符
关系运算符：用来比较两个值，返回布尔类型：true或者false。
关系运算符都是二元运算符
“>”“>=”“<”“<=”“==”“！=”
逻辑运算符
&&：与串联 c=a&&b :如果a为false，c直接为false;如果a为true，b也为true，c为true；
||：或并联 c=a||b :如果a为ture,c直接为true；如果a为false,b也为false,c为false
！：非 !c 布尔值直接取反
其它运算符
instanceof
实例运算符：用于测试一个对象是否是一个指定类的实例（判断对象是否为某个类或者接口类型）
new 对象实例化运算符：实例化一个对象，即对象分配的内存
三目运算符 布尔表达式?值1：值2
public static void main(String[] args) throws Exception {
// write your code here
int Num= 5> 3? 1:2;
System.out.println(Num);
}
输出结果：1
运算符号之优先级
优先级别高的运算符号先运算，级别低的运算符后计算
程序流程控制
顺序结构
执行顺序自上而下
选择结构
if语句：
if语法:
if(布尔表达式){…}
在if中如果布尔表达式为true,就执行里面的代码，否则不执行。
if…elseif语句
if…elseif语法：
if（布尔表达式1）{…}
else if(布尔表达式2){…}
else {…}
switch语句 只能操作整型（byte、short、int）和char类型
switch语法：
switch（整型变量或者char变量）{
case 值1：
break;
case 值2：
break;
case 值n:
break;
default;
}
Scanner con =new Scanner(System.in);//此类方法从控制台输入
int num =con.nextInt();//从控制台输入整数
switch (num){
case 1:
System.out.println(“大根子我爱你”);
break;
case 2:
System.out.println(“大根子不行了”);
break;
case 3:
System.out.println(“大根子啊”);
default:
System.out.println(“大根子小鸡鸡”);
}
循环结构
循环结构：可以减少资源重复书写的工作量
while循环
while语句重复执行循环，直到条件式的布尔值为假为止，如果第一次条件就不满足，那么这个循环体就一次也不执行。
语法：while(布尔条件式){
程序语句
}
do while循环 do
while循环重复执行循环，直到条件式的布尔值为假为止，如果第一次条件不满足，那么这个循环体也会执行一次。
语法：do{
程序语句
}while（条件式）；
for循环 循环重复执行循环
语法：for(表达式1，表达式2，表达式3){
程序语句
}
表达式1：指定一个初始值
表达式2：检查循环是否为真（真：继续 假：退出循环）
表达式3：定义每次循环后变量应做的修改
break 1.在switch语句中用来终止一个语句序列 2.用来退出一个循环
1. 在switch语句中用来终止一个语句序列
for(int i=0;i<=5;i++){
System.out.println(“i=”+i);
if(i==2){
break;
}
}
输出结果：
i=0
i=1
i=2
2. 用来退出一个循环
break只能跳出当前的循环，不能跳出其它的循环
但是可以用特殊手段让break跳出多层循环，特殊手段：分别在外层循环加上“标记”，在该程序中，在外层循环加上out标记，内层循环加上in标记；
out :for(int i=0;i<=5;i++){
System.out.println(“i=”+i);
System.out.println("{");
in:for(int j=0;j<5;j++){
System.out.println(“j=”+j+"\t");
if(i2&&j3){
break out;//跳出最外循环
}
}
System.out.println("}");
}
}
输出结果：
i=0
{
j=0
j=1
j=2
j=3
j=4
}
i=1
{
j=0
j=1
j=2
j=3
j=4
}
i=2
{
j=0
j=1
j=2
j=3
continue 回到循环的开始处，继续向下执行
for(int i=0;i<5;i++){
if(i==2){
continue;
}
System.out.println(“i=”+i);
}
输出结果：
i=0
i=1
i=3
i=4
数组
一维数组
一维数组：可以存储多个值，缓解存储单个值得局限性
定义 两种方式：1.先声明，然后初始化 2.直接初始化
1.先声明，然后初始化
类型[] 名称；//先声明
名称=new 类型[] {元素1，元素2，…,元素n}；
2. 直接初始化
类型[] 名称 = {元素1，元素2，…,元素n}；
数组的下标
数组下标表示数组的位置，在Java中数组下标从0开始，下标数组长度减一表示最后一个元素
数组的长度
在Java中数组长度用length表示 “数组名称.length”:数组长度
数组的打印
数组的打印除了可以用for循环，也可以用Arrays类中的to String方法
int[] a= {1,2,3,4,5};
System.out.println(Arrays.toString(a));
二维数组
二维数组：一维的一维
二维数组的声明：
类型[][] 名称；
二维数组里存放的是一维数组
类型[][] 名称 ={{数组1},{数组2}}
二维数组的下标
int[][] a= {{1,2,3},{4,5,6}}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dhl1Kg4t-1617798717622)(media/02441ced9bfe8dc8f7fa49e1756fc04d.png)]
多维数组
多维数组：一维的多维
Java面向对象程序设计
面向对象设计思想
Java语言：OOP（Object-Oriented Programming）：考虑我要做什么，然后才是怎么做
面向对象：对象各司其职；一个对象绝对不能直接对另一个对象内部的数据（成员变量）进行计算，可以对象通过调用另一个对象的方法来进行。
类
类的概念
对象：程序的基本单位。相似的对象：变量和方法的关系相似的一类对象
类：一种对象类型，就是对象实现的模板，也相当于相似的对象之间共同的属性。
一个类可以产生很多对象。产生对象的过程，称之为实例。一个对象的内部状态（私有属性private），只能让对象自己来修改，其它任何对象都不能直接修改它，但是可以通过调用它的方法来修改它。
封装
封装：把相关的数据和方法都组织在类内，构成一个组件；也称组件
封装意义：一种信息隐藏技术，对象内部对用户是透明的，用户只能通过接口去调用对象种的方法，不能直接去修改对象内部的信息。包就体现了封装的好处。
类的创建
Java的开发实质上就是设计类，具体执行就是CPU按照用户所编写的类去执行。类有两种基本成分：1.变量（成员变量）：基本类型的数据或者数组；类的实例2.方法（成员方法）：类似与函数，但是与函数的区别是只能在类中定义，调用方法时，实际上是对象与对象之间或者用户与对象之间的消息传递。
注意：变量一般设置为共有（public），方法一般设置为私有（private）
字段:类中的数据，也叫做类的变量；属性：类的变量的值；方法：类中的函数
//class 类名 {类体}
public class Main {
public static void main(String[] args) throws Exception {
// write your code here
GirlFriend jia = new GirlFriend();//创建一个GirlFriend实例
jia.setMoney(200);
System.out.println(“jia的私房钱有:”+jia.getMoney());
}
}
class GirlFriend {
private int money;
public void setMoney(int x){
money =x;
}
public int getMoney(){
return money;
}
}
对象的创建与使用
对象（Object）是类的实例，程序运行时就会占用内存单元。Java语言是建立在类的基础上，所以对象就是Java语言的核心。
对象的创建
对象需要先声明，然后需要用new进行实例化
GirlFriend caosijia;
caosijia= new GirlFriend();
访问对象实质上就是访问对象的成员变量，对象的成员变量的访问使用“.”运算符。
caosijia.sex=“女”;
创建对象的意义就是可以访问对象的属性，其次可以通过对象来调用该对象的方法。对象调用方法也是要用到“.”运算符。对象名.方法()。
caosijia.getmoney();
注意：如果是静态方法（static修饰的方法），可以直接使用类名访问
public static void getMoney01(){
System.out.println(“no money”);
}
Main：GirlFriend.getMoney01();
输出结果：no money
Java中的方法
Java程序执行分析过程
JVM执行Java程序，先编译（虚拟机根据Java语言的规则进行语法分析，词法分析，语义分析，以及类变量常量的提取，然后依据class文件的格式转换为字节码文件，用Javac命令），后运行（JVM用解释器来完成，用Java命令）。
方法分类
类方法（静态方法）：该方法，系统只为该类创建一个版本，这个版本被该类和该类所创建的所有对象所共享。注意：类方法只能操作静态变量（用static修饰的变量），不能访问实例变量。
static void m(){…}
实例方法：可以操作对象的实例变量，还可以访问类变量。
构造方法
**构造方法（构造器）：**和类名同名（大小写也要一致）的方法，而且不能有返回值。如果不写构造方法，Java会自动创建一个构造方法。
class Demo{
public Demo(){}
}
除了无参构造方法，构造方法也会有参数
class Demo{
public Demo(int x){}
}
构造方法作用：通过构造方法创建对象，分为有参构造方法构造和无参构造方法构造。
1.Demo a =new Demo();
2. Demo a =new Demo(2);
自定义方法
方法除了系统默认的构造方法以外，其它都是自定义方法。
声明语法：访问修饰符 返回类型 方法名（参数列表）{ }
修饰符：public private 缺省 protected
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5UDaTLd5-1617798717626)(media/f53290eea85eca25249ea66798ff6897.png)]
返回值：方法体必须返回一个return语句，返回的类型必须和返回值一致
方法参数类型：参数个数，各参数的类型，参数之间用逗号分隔
形参：在方法定义是括号里面的参数 实参：调用方法传入具体的值
带static关键字的方法（静态方法）：public static void test(){…}
带final修饰的方法：该方法不能被重载也不能被覆盖。public final void test(){…}
注意：final和static的顺序可以互换。
方法的重载
**重载（overloaded）：**同一个类中两个或者两个以上的方法有相同的名字，但是参数声明不同。注意：参数字母不同，返回值类型不同也不能称之为重载。
public int add (int x,int y){…}
public void add(int a,int b){…}
这两个方法都不能称之为重载。
方法的调用
非静态方法调用：对象名.方法() 静态方法调用：类名.方法（）
方法与方法之间的调用：主要是在于一个方法内部如何调用其它方法。
方法参数极其传递
方法参数传递分为两种类型：基本类型和引用类型
基本类型：传入的是基本类型的时候，实参会复制一份，传入方法内，在方法内修改数值不会影响原实参。
public class Main {
private static int x=10;
public static void main(String[] args) throws Exception {
Main a = new Main();
getX(x);
System.out.println(“x:”+x);
}
public static void getX(int x){
x–;
}
}
输出结果：x：10，这就代表方法内部不会修改实参的值
引用类型传递：在栈中声明对象，之后在堆内存中分配内存。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YrnDjez7-1617798717629)(media/85185a9122d8f0835e25dbb62d01fd15.png)]
注意：如果没有给对象初始化，会报空指针报错，NullPointException异常。
“对象名.属性名”实际是就是每一个对应的堆内存空间的属性，只要存在new关键字，Java就会新开辟一个堆空间。
一个堆内存可以被多个对象同时指向（一个堆内存被多个栈内存所指向）
public class Main {
private static int x=10;
public static void main(String[] args) throws Exception {
// write your code here
P p =new P();
p.name=“jia”;
p.age=30;
P p2= new P();
p2.name=“jiajia”;
p2.age=20;
p2.t();
}
}
class P{
String name;
int age;
public void t(){
System.out.println(“姓名：”+name+",age:"+age);
}
}
输出结果：姓名：jiajia,age:20
p的属性被p2修改了。原因：一个堆内存可以同时被多个栈所指向。
类的属性
属性
属性包括 成员属性（全局） 局部属性（在方法内部）
this关键字
this指的是当前对象。在Java中用户可以通过this关键字访问类中的属性、方法。
public class Main {
int x=5;
public static void main(String[] args) throws Exception {
Main a =new Main();
}
public Main() {
System.out.println(this.x);
}
}
输出结果：5
包
包类似于文件夹，主要是给类分类工作，便于维护和管理。
包导入类型：1.导入包所有类 import 包名.* 2.导入包中具体的类 import 包名.类名
类的继承和多态
继承
Object类
Java中所有类都默认继承Obejct类，Object类是所有Java的父类。
object是类层次结构的根类，每个类都使用Obeject作为超类（父类）。
Java中继承
Java中继承使用关键字“extends” class 子类 extends 父类{}
继承类作用：使用继承，子类可以拥有父类中的非私有属性，父类中非私有方法。
public class Main {
int x=5;
public static void main(String[] args) throws Exception {
// write your code here
student a= new student();
}
}
class person{
public String name=“大根子”;
public String sex=“男”;
public int age=10;
public void setName(String name){
this.name=name;
}
}
class student extends person{
private int grade=10;
student(){
System.out.println(“姓名:”+name+" 性别:"+sex+" 年龄:"+age+" 成绩:"+grade);
}
}
输出结果：姓名:大根子 性别:男 年龄:10 成绩:10
super关键字
子类可以用super关键字调用父类的非私有属性和非私有方法，还可以调用父类的非私有构造方法。
用法：super.父类属性 super.父类方法
public class Student extends Person{
private int grade;
String name = super.name;
public void test(){
super.getAge();
}
}
super调用父类的构造方法
调用无参构造方法super();(super关键字可以省略)
调用有参数构造方法super（参数）；super(参数)
super执行顺序：执行完父类构造方法之后再调用本类的构造方法
多态
Java中多态的实现
多态体现再重载和覆盖；覆盖：子类重写了父类的方法。
class father{
public void say(){
System.out.println(“father say()”);
}
}
class son extends father{
public void say(){
System.out.println(“son say()”);
}
}
类型检测—向上转型/向下转型
向上转型：父类对象引用指向子类对象。
父类 对象 = new 子类（）
father a = new son( );
向下转型：在向上转型的基础上再次指向子类的对象
父类 对象1 =new 子类（）；
子类 对象2= (子类) 对象1；//强类型转换
注意：向下转型有时候丢失子类特有的方法
Static关键字
被static修饰的
静态变量访问：“类名.变量名”直接访问
静态方法：“类名.方法名”
静态代码块：被static修饰的静态代码块，位置可以随便放，不在任何的方法体内。static会优先与构造器执行。如果有多个static修饰的代码块，JVM会在它们类中出现的先后顺序依次执行，每个代码块只会执行一次。
public class Main {
public static void main(String[] args) throws Exception {
// write your code here
father a= new father();
}
}
class father{
static{
System.out.println(“static way”);
}
father(){
System.out.println(“构造方法”);
}
public void say(){
System.out.println(“father say()”);
}
}
输出结果：static way
构造方法
Final关键字
使用final修饰的类，表示该类不能被继承
Abstract关键字
抽象类
被abstract修饰的类。抽象类必须由子类继承，才能实例化对象。
abstract class 类名{ }
抽象方法
被abstract修饰的方法。该方法只有方法头，没有方法体。
public abstract class Type(){没有方法体}
总结：抽象类中既有抽象方法，也有非抽象方法；有抽象方法的类一定是抽象类。
接口
接口例子
接口就是一种特殊的抽象类，接口中只提供了方法的原形，没有方法体，具体实现还是要靠子类的继承来覆盖。接口和抽象类一样，可以定义抽象方法，包含抽象的方法和常量，但是不能有变量、初始化块和构造函数。接口中的方法必须都要由接口的实现类来实现，这就是一种规范。
interface Student{
int class=10;//常量
void learn();
}
class student1 implements student{
public void learn(){
System.out.println(“我正在学习”);
}
}
接口声明
Java接口的声明类似于Java类。并且Java文件名（接口文件名）必须与接口名一致。
修饰符 interface 接口名 [extends 父类接口名] {
[public] [static] [final] 常量;
[public] [abstract] 方法；
}
使用接口
接口不能单独实例化，必须通过类来继承接口来实现。接口的实现类必须要实现接口中的所有方法。这就是一种规范。
接口的使用
类在实现接口的语法：
[修饰符] class <类名> [extends 父类名] [implements 接口列表] {}
注意：接口也可以实例化，但是必须由接口的实现类来实现。
接口 对象名 = new 接口的实现类（）;
Java接口的特征
接口中所有的变量都是常量，接口中所有的方法都是抽象方法；类实例化接口，必须要实现接口中所有的方法，一个类不可以继承多个类，但是可以继承多个接口。
接口可以继承
接口可以实现多继承，原因：Java中类只能实现单继承，如果一个子类继承多个父类，父类中出现同一个方法D，这个时候子类就不知道该继承哪一个，但是接口不一样，都是抽象方法，继承谁都无所谓。注意：接口只能继承接口，不能继承普通类和抽象类。
public interface A extends B{}
interface B{public void b();}
程序的异常
异常的声明，捕获和处理
异常机制概述
Java把程序运行中遇到非致命的，通过某种修正后还能继续执行的错误称为异常。通常Java的异常：表达式的计算违反了Java定义，如整数被0除；使用了太多内存；程序代码中throw语句被使用；异步异常发生（Thread的stop方法被调用；Java虚拟机内部错误发生）
Java异常处理通过5个关键字来处理：try、catch、throw、throws、finally
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qz5RiDtF-1617798717631)(media/c51af03d19b347a34984905f34c142ff.png)]
Error通常是错误，程序员是不可能通过代码来修改。
Exception指的是异常。分为运行时异常（RuntimeException；Java编译器可以允许程序不做处理）和非运行时异常(java.lang库中定义；Java编译器要求程序必须捕获或者声明抛出这种异常)。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VS3p9vuc-1617798717633)(media/42711783abafbbd2110fbe5f6f921350.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T3I0M7S3-1617798717634)(media/f915a37a4915c3ddbe8e2d891b5324dc.png)]
在Java中如何进行异常处理
Java中处理异常有两种方法：try…catch…finally…和throws来操作
try…catch…finally…捕获命名为异常类的异常；finally语句是可以省略的，catch语句可以有多个，如果用户要捕获多个异常，按照异常的范围从小到大顺序叠放。
public class Main {
public static void main(String[] args) throws Exception {
try{
int x=5;
int y=x/0;
System.out.println(y);
}catch(Exception e){
e.printStackTrace();//将错误打印到堆栈
}finally {
System.out.println(“Over!”);
}
}
}
输出结果：
java.lang.ArithmeticException: / by zero
at com.company.Main.main(Main.java:11)
Over!
使用throw抛出的异常，throw子句通过是可以指明多个异常，说明该方法将不对这些异常进行处理，而是声明抛弃它们。
public static void main(String[] args) throws IllegalArgumentException {
{
int x=5;
int y=x/0;
System.out.println(y);
}
}
}
手动异常：抛弃的对象是通过throw语句来实现的，可以抛出的异常必须是Throwable或者其子类的实例。（throw
异常名；throw关键字主要是用在try块中）
try{
System.out.println(“正在运行的程序…”);
throw new IOException(“用户自行产生的异常”);
}catch (IOException e){
e.printStackTrace();
}finally {
System.out.println(“over!”);
}
自定义异常：建立自己的异常类型，只要定义Exception的一个子类就可以了。
class 自定义异常 extends 父异常类名{类体}
public class Main {
public static void main(String[] args) throws IllegalArgumentException {
// write your code here
Main a= new Main();
try{
a.add(2,2);
}catch (MyException e){
e.printStackTrace();
}
}
private void add(int a,int b)throws MyException{
if(a==b){
throw new MyException(“输入两个数相等”);
}
}
}
class MyException extends Exception{
public MyException(String msg){
super(msg);
}
public MyException(String message,Throwable cause){
super(message,cause);
}
}
输出结果：com.company.MyException: 输入两个数相等
at com.company.Main.add(Main.java:19)
at com.company.Main.main(Main.java:12)
用Log4J记录异常日志信息
log4j是Apache的一个开放源代码项目。是一个日志操作包，可以通过使用log4j指定日志信息输出的目的地，控制每一条日志的输出格式，定义日志信息的级别。所有的这些功能都是通过一个日志配置文件来实现的。
日志：记录程序的运行情况，如错误信息、系统管理员的登录情况等。
如何使用log4j记录日志：log4j主要是由三大组件组成：Logger:决定什么日志信息应该被输出、什么日志信息应该被忽略。Appender：指定日志信息应该被输出到什么地方。Layout：指定日志信息的输出格式。
一个日志可以多个Appender，（日志信息可以同时输出到多个设备上）一个Appender对应一个Layout。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Q1OuFC8X-1617798717636)(media/927a66f656cd2a55b7c6557d1abd07bf.png)]
**Logger组件：**log4j核心组件，代表日志记录器，对日志信息进行筛选。由org.apache.log4j.Logger类实现。源代码如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ebhn4If8-1617798717637)(media/dbb785d9446e29f666fa518b97f0ad50.png)]
配置文件中配置Logger组件：
log4j.logger.myLogger=WARN
//定义了一个Logger组件，名称为myLogger,日志级别为WARN。
日志种类一共有五种，级别由高到低依次是fatal、error、warn、info、debug。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3eqnUeCW-1617798717639)(media/27e83a944e10b47574f62924fec4763c.png)]
以上方法只有级别大于或等于Logger组件配置的日志级别才被调用。
**Appender组件：**决定将日志信息输出到什么地方。支持：控制台（console）、文件（file）、GUI组件、套接口服务器等。
log4j.logger.myAppender=WARN,file,console
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=log.txt
log4j.apender.console=org.apache.log4j.ConsoleAppender
//mylogger配置了两个Appender：一个是file，一个是console
Layout组件：决定日志输出格式
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1T2pnbjU-1617798717640)(media/361c4f99a53f896d0bafd0028cac103b.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WjSh6n2D-1617798717641)(media/9e58be1f3895ffad5c0bd748cf731fd7.png)]
log4j.appender.console.layout=org.apache.log4j.SimpleLayout//配置日志输出格式为SimpleLayout。
patternLayout让开发者依照ConversionPattern定义输出格式。ConversionPattern一些指定日志内容和格式预定义符号如下：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oe2Z6SUG-1617798717643)(media/368c2226876c69d89ab5d02e2373fc72.png)]
定义配置文件：log4j支持两种配置文件：XML和Java属性文件（采用“键=值”形式）
常见的是log4j.properties文件
### set log levels ###
log4j.rootLogger = debug , C , D , E
### console ###
log4j.appender.C = org.apache.log4j.ConsoleAppender
log4j.appender.C.Target = System.out
log4j.appender.C.layout = org.apache.log4j.PatternLayout
log4j.appender.C.layout.ConversionPattern = [%d] [%t] (%F:%L) %-5p %c - %m%n
### log file ###
log4j.appender.D = org.apache.log4j.DailyRollingFileAppender
log4j.appender.D.File = …/logs/project_logs/ssm_demo/ssm_demo_info.log
log4j.appender.D.Append = true
log4j.appender.D.Threshold = INFO
log4j.appender.D.layout = org.apache.log4j.PatternLayout
log4j.appender.D.layout.ConversionPattern = [%d] [%t] (%F:%L) %-5p %c - %m%n
### exception ###
log4j.appender.E = org.apache.log4j.DailyRollingFileAppender
log4j.appender.E.File = …/logs/project_logs/ssm_demo/ssm_demo_error.log
log4j.appender.E.Append = true
log4j.appender.E.Threshold = ERROR
log4j.appender.E.layout = org.apache.log4j.PatternLayout
log4j.appender.E.layout.ConversionPattern = [%d] [%t] (%F:%L) %-5p %c - %m%n
具体使用：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VbWkSRgs-1617798717645)(media/6fe89bba0479737947de084c4c55db31.png)]
集合
Java集合
集合可以认为是一种可变的数组，大小可以随着元素的增加而增加。
集合与数组的区别
数组是一个线性的序列，数组容量是不变的，生命周期也是不变的，Java数组会做边界检查，如果越过边界会报RuntimeException异常错误。集合容量是可变的，扩展性比较好，内部实现基于数组，所以综上数组的效率要高于集合。
集合包结构
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p5Htq9f2-1617798717646)(media/daaca421951aea8214a84ca77f6d7ec8.png)]
容器类
Collection接口
Collection接口（最基本的接口）List、Set；这些接口主要用于操作集合，如集合的增删改查。
ArrayList：允许集合存储的元素可以重复，并且可以将null存储到集合中，有一个默认容量并且集合长度是自动增长的。注意：线程是不安全的，如果多个线程同时访问一个ArrayList实例，有肯能会出现访问数据不一样的情况。
List lis= new ArrayList();
lis.add(“大根子”);
lis.add(“大根子”);
lis.add(520);
lis.add(‘a’);
System.out.println(lis);
输出结果：[大根子, 大根子, 520, a]
但是注意：List集合既增加了字符串类型的数据，又增加了整型的数据，会给程序带来危险。JDK1.5提出了泛型的概念，不允许不同类型的数组存在一个集合。
list<类型> 变量名 = new ArrayList<类型>（）;
List <String> lis= new ArrayList<String>();
lis.add(“大根子”);
lis.add(“大根子”);
lis.add(520);//报错
System.out.println(lis);
LinkedList:可以在集合的前面后面增加元素。注意：线程不安全，多个线程同时访问一个链接列表，有可能造成集合访问不同步。LinkedList类的iterator和listiterator方法可以遍历集合元素。
LinkedList <String> lis= new LinkedList<>();
lis.add(“大根子”);
lis.addFirst(“小根子”);
lis.addLast(“老根子”);
System.out.println(lis);
输出结果：[小根子, 大根子, 老根子]
HashSet：顺序不确定，允许使用null元素，不允许集合添加重复的元素，如果添加重复的元素将会覆盖之前的元素，注意：线程不同步，多个线程访问同一个HashSet,至少一个线程修改了该集合，可能造成数据访问不一致的情况发生。
Set<String> set =new HashSet<String>();
set.add(“大根子”);
set.add(“大根子”);
set.add(“小根子”);
System.out.println(set);
输出结果：[小根子, 大根子]
TreeSet：用来集合元素内部进行排序使用的；注意：TreeSet集合是线程不同步的。
Set<String> set=new TreeSet<String>(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.compareTo(o2);
}
});
set.add(“大根子”);
set.add(“小根子”);
set.add(“老根子”);
System.out.println(set);
输出结果：[大根子, 小根子, 老根子]
Comparable/comparable接口
Comparable接口主要用来对对象排序使用，这种排序被称为类的自然排序，类的comparaTo方法可以由用户自定义排序规则。Comparable接口中只有一个方法compareTo,定义如下：int
compareTo(To):比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回整数、零或正整数。
Iterator接口
Iterator接口用来遍历集合用的。
public interface Iterator<E>可以使用Iterator接口删除元素。
public static void main(String[] args) throws IllegalArgumentException {
// write your code here
iterator2List();
iterator2set();
}
public static void iterator2List() {
List<String> lis = new ArrayList<String>();
lis.add(“大根子”);
lis.add(“小根子”);
Iterator<String> it = lis.iterator();
while (it.hasNext()) {
String obj = it.next();
System.out.println(obj);
}
}
public static void iterator2set(){
//创建HashSet对象
Set<String> set =new HashSet<String>();
set.add(“大根子”);
set.add(“小根子”);
//获得Iterator接口
Iterator<String> it =set.iterator();
while(it.hasNext()){
String obj =it.next();
System.out.println(obj);
}
//删除
Iterator<String> it2 =set.iterator();
while(it2.hasNext()){
String obj =it2.next();
if(“大根子”.equals(obj)){
it2.remove();
}
for(String s:set){
System.out.println(s);
}
}
}
Map接口
Map接口可以存储键值对，并允许使用null值和null键，Map接口不保证映射的顺序。key-value。注意：线程不同步。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2et2sFDc-1617798717648)(media/06d963749ac527f483d04d209f80432e.png)]
public class Main {
public static void main(String[] args) throws IllegalArgumentException {
// write your code here
add();
}
public static void add(){
//创建HashMap对象
Map<String,String> map =new HashMap<String,String>();
//增加元素
map.put(“国家”,“中国”);
map.put(“国家”,“美国”);
map.put(“身份证”,“1234”);
String id = map.get(“身份证”);
System.out.println(id);
//取出所有的key
Set<String> keys =map.keySet();
for (String s:keys){
System.out.println(s);
}
//取出所有的value
Collection<String> cs=map.values();
for(String s:cs){
System.out.println(s);
}
//取出所有的key-value值
Set<Map.Entry<String,String>> sets =map.entrySet();
for(Map.Entry<String,String> s:sets){
String key = s.getKey();
String value= s.getValue();
System.out.println(key+":"+value);
}
}
}
输出结果：1234
国家
身份证
美国
1234
国家:美国
身份证:1234
容器选择原则
只需要增加值，可以考虑ArrayList集合，不重复使用HashSet集合，如果采用Key-Value这种情形，可以选择HashMap集合。
线程
线程简介和Java实现
进程是资源分配的最小单位，线程是CPU调度的最小单位。做个简单的比喻：进程=火车，线程=车厢；线程在进程下进行（单纯的车厢无法运行），一个进程可以包括很多线程（一个火车可以有很多车厢）不同进程之间数据很难共享（一辆火车上的乘客很难换到另一辆火车上），同一进程上的不同线程数据容易共享（A车厢到B车厢很容易），进程比线程更消耗计算机资源（多列火车比多个车厢更消耗资源）进程之间不相互影响，但是一个线程挂掉将会影响整个进程（一辆火车不会影响到另一个火车，但是一列火车中的一个车厢着火将会影响所有车厢）进程可以拓展到多级，线程最多适合多核（不同火车可以开在多个轨道上，同一火车的车厢不能在进行的轨道上）线程使用的内存地址可以上锁（一个线程使用某些共享内存，其它线程必须等待;互斥锁）进程使用的内存地址可以限定使用量（信号量）
主线程
每个Java都有一个主线程，也就是main函数
线程的创建和启动
创建有两种方式，分别继承Thread类和继承Runable接口
继承Thread类：当一个类需要按照多线程的方式处理，只需要继承Thread类，并且还要覆盖该类的run（）方法。run方法作为线程的主体
public void run(){}
继承Thread类
public class Main {
public static void main(String[] args) throws IllegalArgumentException {
// write your code here
MyThread a = new MyThread();
a.start();
}
}
class MyThread extends Thread{
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println(“i=”+i);
}
}
}
输出结果：[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M3XPxI2Q-1617798717649)(media/2d0bc301101bccef259c8306a2372d33.png)]
启动线程调用start方法而不是run方法，主要是由Java的内部实现机制决定的。
实现Runnable接口：启动时首先创建一个Thread对象，并将实现Runable接口类的实例放入Thread的构造器中。使用Runnable接口可以实现资源（对象属性）共享，但是Thread不可以。
public class Main {
public static void main(String[] args) throws IllegalArgumentException {
// write your code here
run a =new run();
Thread t= new Thread(a);
t.start();
}
}
class run implements Runnable{
@Override
public void run() {
for(int i=0;i<10;i++){
System.out.println(“i=”+i);
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-prhFTtcF-1617798717651)(media/2d0bc301101bccef259c8306a2372d33.png)]
线程组
线程组：线程组成的管理线程的类，这个类就是Java.lang.ThreadGroup类。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-072vcWmk-1617798717652)(media/aee6c8a20e8e821d14486a9697717f2b.png)]
线程状态
线程状态
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eUsAK9ab-1617798717653)(media/d28bfdf03f936610b9ce2f5ca7ad3bc2.png)]
初始：创建一个线程；可执行：调用start（）方法；运行：调用run（）方法；
停止：线程运行都需要占用CPU资源，一个线程运行完，其它线程都在等待，所以停止了；死亡：线程运行结束，中止。
线程状态转换
线程名字的取得和设置：线程运行不固定，取得线程名字，可以很好的知道线程情况。取得当前进程名字具体方法如下：
public static Thread currentThread()
public class Main {
public static void main(String[] args){
// write your code here
MyThread a1 =new MyThread();
MyThread a2 =new MyThread();
MyThread a3 =new MyThread();
a1.start();
a2.start();
a3.start();
}
}
class MyThread extends Thread{
public void run(){
System.out.println(“当前进程的名字为：”+Thread.currentThread().getName());
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uMAW7bWH-1617798717655)(media/485e5adeea91ec0bf10daf63e80bcc50.png)]
设置名字：对象.setName(“线程1”)
线程的休眠：线程在运行期间，会休息一段时间后再执行，休眠后，线程进入可运行状态。
public static void sleep(long millis) throws InterruptedException
倒计时效果：
public class Main {
private final static int count=20;
public static void main(String[] args){
// write your code here
new Thread() {
public void run(){
int temp = count;
for(int i=temp;i>=0;i–){
try{
Thread.sleep(1000);
}catch (InterruptedException e){
e.printStackTrace();
}
System.out.println(“还剩：”+(temp–)+“秒”);
}
}
}.start();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FQXlaxzG-1617798717656)(media/875d0e72f79cb7f627f0841b966ab0f0.png)]
让线程之间通信
同步：给方法加锁，其它线程调用该方法时，如果锁解开了才能调用。关键字：synchronized，具体使用synchronized(对象){}包裹。锁代码块时，不必创建一个新的对象，直接使用this对象即可。但是锁不住静态方法，因为静态方法是属于整个类。
public class Main {
public static void main(String[] args){
// write your code here
final Main a = new Main();
//开辟两个线程
new Thread() {
public void run(){
while(true){
a.setName(“大根子”);
}
}
}.start();
new Thread() {
public void run(){
while(true){
a.setName(“小根子”);
}
}
}.start();
}
public void setName(String name){
String str =“hello”;
synchronized (str){
for(int i=0;i<name.length();i++){
System.out.println(name.charAt(i));
}
System.out.println();
}
}
}
异步：没有秩序，线程随机占用电脑资源。
死锁：多个线程同时被堵塞。
守护进程（后台进程或者精灵进程）：所有前台线程运行完，不管后台线程有没有结束，守护线程都必须停止。
用I/O进行数据处理
文件
Java中文件操作所有类都在Java.io包里面，File类，只能创建文件、删除文件、对文件属性进行操作，不能对文件里面的内容进行读写操作。
目录管理：File中有一个listFiles()方法可以搜索某个目录下面所有的方法。
流和流的分类
文件的读写、网络收发和进程通信，几乎所有需要输入和输出的地方都要用到流。流是有源端和目的端。可以是计算机内存的某些区域，也可以是磁盘文件，甚至是Internet上的某个URL。在Java中，每个流都是一个对象。流通常分为两种，输入流和输出流。输入和输出的方向是对于程序而言，向程序中读入数据就是输入流，程序向外写出数据就是输出流。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C6Qc1qpJ-1617798717658)(media/1a681be0c1fbb2f7d89ff8f4e5ac3e8c.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uYo64IvJ-1617798717659)(media/8794cddac121e69aa83800fc0a2f1676.png)]
字节流和字符流
字节流：主要操作字节序列的对象，如二进制文件、图片及影像文件的操作
输出字节流：OutputStream（一个抽象类）ByteArrayOutputStream、FileOutputStream是两种基本的介质流，分别向Byte数组和本地文件写入数据。使用OutputStream定义如下：
public abstract class OutputStream extends object implements Closeable,Flushable
使用字节流输出内容：
public class Main {
public static void main(String[] args) throws IOException{
// write your code here
out();
}
public static void out() throws IOException{
OutputStream out = new FileOutputStream(“D:/hello.txt”);//获取对象
String info = “Hello java！！”;//输出的内容
byte[] buf =info.getBytes();//将内容转换成字节数组
out.write(buf);//写到文件里
out.close();//关闭文件
System.out.println(“over！”);
}
}
加强版的
public class Main {
public static void main(String[] args) throws IOException{
// write your code here
out();
}
public static void out() throws IOException{
OutputStream out =null;
try{
out= new FileOutputStream(“D:/Hello.txt”,true);//获取对象
String info =“Hello PHP!”;//输出的内容
byte[] buf =info.getBytes();//将内容转换成字节数组
out.write(buf);//写到文件
}catch(IOException e){
e.printStackTrace();
}finally {
try{
if(out!=null)
out.close();
}catch (IOException e){
e.printStackTrace();
}
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kfm62jqp-1617798717661)(media/60e4e0e6d77165b91c48277eb5648e6b.png)]
输入字节流InputStream是所有的输入字节流的父类，是一个抽象类。ByteArrayInputStream、StringBufferInputStream、FileInputStream分别向Byte数组、StringBuffer和本地文件中读取数据。InputStream完成输入字节流定义如下：
public abstract class InputStream extends Object implements Closeable
实例：使用字节流读取文件内容
public class Main {
public static void main(String[] args) throws IOException {
// write your code here
in();
}
public static void in() throws IOException{
FileInputStream in =null;//获取对象
try{
in=new FileInputStream(“D:/Hello.txt”);//开辟一个空间
byte[] buf= new byte[1024];//读文件
int len=-1;
while((len=in.read(buf))!=-1){
String s =new String(buf,0,len);
System.out.println(s);
}
}catch (IOException e){
e.printStackTrace();
}finally {
try{
if(in!=null)
in.close();
}catch (IOException e){
e.printStackTrace();
}
}
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VxHCJa7i-1617798717662)(media/cdf62ee968de4943cf977ea6fa45094c.png)]
字符流：可以对流数据以一个字符的长度为单位来处理，并进行适当的字符编码转换处理。
字符输出流：Writer是字符输出流，该类是一个抽象类，需要子类FileWriter类来操作文件。
实例：public class Main {
public static void main(String[] args) throws IOException {
// write your code here
write();
}
public static void write() throws IOException{
FileWriter fw = new FileWriter(“D:/Hello.txt”,true);//获取对象
fw.write(“Hello C++”);//直接输出字节符
fw.close();//关闭
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FsIp2yzk-1617798717664)(media/a42b221f7d13cfbea9571b846f5fcc37.png)]
字符输入流：Reader是字符输入流，是一个抽象类，必须由子类FileReader来是例化。
public class Main {
public static void main(String[] args) throws IOException {
// write your code here
reader();
}
public static void reader() throws IOException{
Reader r =new FileReader(“D:/Hello.txt”);
char[] buf =new char[1024];
int len=0;
while((len=r.read(buf))!=-1){
String s =new String(buf,0,len);
System.out.println(s);
}
r.close();
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8A9q1BmO-1617798717666)(media/8973e8f55e8c5a30e621dbb7aaf7185c.png)]
过滤（处理）流
字节流通常只具有读写字节内容的方法，只能在文件中读取或者向文件中写入字节，但是在实际开发中需要在文件中写入各种类型的数据，如整型、布尔类型等数据，就必须先将其它类型的数据转换成字节数组后写入文件，或者将字节数组转换成其它数据类型。这个时候就需要包装类，这个类提供了向各种输出流写入各种类型数据的方法。
DataOutputStream必须给它一个输出流对象，完成类似DataOutputStream功能的类，就是处理流类。
DataInputStream与DataOutputStream类似，必须给一个输入流对象，才能完成过滤流的功能。
public class Main {
public static void main(String[] args) throws IOException {
// write your code here
writer();
reader();
}
public static void writer() throws IOException{
OutputStream os =new FileOutputStream(“D:/Hello.txt”);
DataOutputStream dos = new DataOutputStream(os);
dos.writeInt(123);
dos.writeBoolean(true);
dos.flush();//输出缓冲
dos.close();//关闭
}
public static void reader() throws IOException{
InputStream in =new FileInputStream(“D:/Hello.txt”);
DataInputStream dis =new DataInputStream(in);
int a= dis.readInt();
boolean flag= dis.readBoolean();
dis.close();
System.out.println(a);
System.out.println(flag);
}
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qTWqPKah-1617798717667)(media/1b1eab3ce77d72aef6bc1cae472fd5ab.png)]
内存操作流：输入输出的位置改为内存
缓冲流：数据先缓存起来，然后一起写入或者读取出来，使用缓冲流读写文件。BufferedReader、BufferedWriter、BufferedInputStream和BufferedOutputStream。
对象序列化与反序列化
序列化：将一个内存中保存的对象变成一个二进制的数据流进行传输，如果一个对象需要被序列化，则对象所在的类必须实现Serializable接口。使用ObjectOutputStream将对象写到文件中去。
反序列化：将文件中读取对象的过程。使用ObjeInputStream可以实现反序列化。
transient关键字：使用该关键字，可以是类中的某个属性不被序列化
序列化一组对象可以使用数组来解决。
打印流：Java提供了打印流PrintStream可以方便打印出文件
RandomAccessFile随机访问文件：可以随机读写文件
反射与注解
反射概念
反射机制可以在程序运行过程中获取对象的属性和方法。在一些底层技术上，如Struts、Hibernate、Spring框架上，反射会经常使用到。
class类
获取Class对象三种方法；
1．通过对象获取getClass()方法 对象名.getClass(); 2.通过Class.forName()获取
Class.forName(“包名.类名”); 3.通过类名.class获得Class对象 类名.class
public class Main {
public static void main(String[] args) throws ClassNotFoundException{
// write your code here
Class clazz =Class.forName(“com.company.Person”);
Class claz =Person.class;
Person p =new Person();
Class cla=p.getClass();
}
}
用反射获取类的属性
public class Main {
public static void main(String[] args) throws Exception{
// write your code here
Class clazz =Person.class;//第一步获取Class对象
Object obj =clazz.newInstance();//将对象实例化
Field filed =clazz.getField(“id”);//获取Field字段对象
String idname= filed.getName();//获取Field字段名称
Integer idValue=(Integer) filed.get(obj);//获取Field的值
System.out.println(“获取的”+idname+"="+idValue);
filed.set(obj,10);//设置id值
Integer idV=(Integer) filed.get(obj);
System.out.println(“设置的”+idname+"="+idV);
}
}
public class Person implements Serializable {
private transient String name;
private int age;
public int id=-1;
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rZxYDfFY-1617798717669)(media/0c7057ca4a0531a811a42fec53f8a9b0.png)]
用反射可以获取类的方法、构造方法、操作数组。
注解
annotation注解：功能类似于代码中的注释，但是可以实现程序功能。在Java中常见的注解有@Override和@SuperssWarnings，@Override（标记注解）只需要在方法前面声明即可。使用@SuperssWarnings语法：@SuperssWarnings（{“uncheck”,“unused”}）
括号内容为该注解可供配置的值；注解作用：生成文档，跟踪代码（替代配置文件），在编译时进行格式检查，如@Override放在方法面前，如果这个方法并不是覆盖了超类方法，编译就会出错。
常用注解
@Override：覆盖超类方法 @Deprecated:表示当前元素是不赞成使用的 @
SuperssWarnings：表示关闭一些不当的编译器警告信息
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Uxc7wu54-1617798717670)(media/60d740933e2305f95f9a920f9b43a0a6.png)]
数据库技术
MySQL
SQL（Structed Query
language）j结构化查询语言，主要访问和处理数据库的计算机语言。在MySQL中有一个大单位叫数据库（Database），MySQL中可以建立多个数据库（Database）都有若干个表（table）。
MySQL的数据类型：数值类型、字符串类型、日期和时间类型。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SIjdqTtb-1617798717671)(media/2206adab16a315aa9ddee49cd99c7a77.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TinhmoMp-1617798717673)(media/8f0e605b60b456172a77ec722402ab02.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OBe0vjh3-1617798717674)(media/d986751af2abeeab67fd7e8dcfc87d5a.png)]
**创建数据库：**create database xuru default character set
utf8；//创建数据设置编码为utf8
**创建表：**表必须在数据库中创建，use xuru;之后创建表create table 表名（z字段
字段类型…）
create table gongwuyaun(
id int primary key auto_increment,
name varchar(32),
salary double;
age int;
)
primary key:主键，代表唯一标识的，并且不能重复
auto_increment：自动增长，每插入一条新的记录，数据库会自动生成一个值。
对表中的数据进行增删改查
**insert语句（在表中插入数据）：**insert into
表名（字段1，字段2…）values（值1，值2…）
insert into
gongwuyuan(name,salary,age)values(‘xuru’,2000,20)数据库字符串类型使用单引号表示。
**select语句（在表中查询数据）：**select * from 表名//查询所有数据 select
字段1，字段2…from表名 //查询某几个字段的数据
update语句（在表中对数据进行修改）：update 表名 set 字段1=值1，字段2=值2……
update gongwuyuan set age= 30;
**delete语句（在表中删除语句）：**delete from 表名
delete from gongwuyuan;
where语句（关键字进行过滤）：select * from 表名 where 条件表达式
update from 表名 set 字段1=值1,…where条件表达式
delete from 表名 where 条件表达式
条件表达式运算符：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YhPlgYVl-1617798717676)(media/06f17363013781a7baf4ba92bd8d75e3.png)]
查询字段id不等于2的所有数据
select * from gongwuyuan where id<>2;
聚合函数与having：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7KbllRew-1617798717677)(media/1e6a905f41892ebc4db60bad0a2cea1e.png)]
goup
by语句（通过一定的规则将一个数据集划分成若干个小的区域，然后针对性的对若干个小区域进行数据处理）
select count（*）,name from gongwuyuan froup by name;
用JDBC与数据库交互
JDBC(Java Data base Connectivity)是一种用于执行SQL语句的Java
API，由Java语言编写的类和接口组成。JDBC设有两种接口，一个是面向应用程序层（开发成员通过SQL调用数据），一个是驱动程序层（利用JDBC
API使得Java可以方便的操作数据库）。客户端程序调用Java.sql包下面的API，Java.sql下的API调用相应的驱动程序，驱动程序调用相应的数据库，从而完成对数据库的操作。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hP4uwhdu-1617798717679)(media/3c1059cc3a752bf5d59a58890c78e26c.png)]
Java与MySQL连接
Java连接MySQL数据库分为几大步骤：
-
加载驱动程序 Class.forName(“com.mysql.jdbc.Driver”);
-
创建数据连接对象（通过DriverManager类创建数据库连接对象Connection）,DriverManager类作用于Java程序和JDBC驱动程序之间，用于检查它们之间是否可以连接，然后通过getConnection方法，根据数据库的URL、用户名、密码，创建一个JDBC
Connection对象
Connection connection = DriverMannager.getConnection(“URL”,“用户名”，“密码”);
(3)创建Statement对象（Statement对象主要是执行静态SQL语句并返回它所生成结果的对象）
Statement statement = conn.createStatement();
(4)调用Statement对象相关方法去执行对于SQL语句
例：通过execuUpdate()方法来数据的更新，包括插入和删除操作
statement.execuUpdate(“insert into gongwuyuan (name,salary,age) values
(‘s’,2000,20)”);
之后查询的结果会得到ResulSet对象
ResulSet resulSel = statement.executeQuery(“select * from gongwuyuan”)；
（5）关闭数据库连接
conn.close();
XML技术
XML
XML是标记扩展语言，用来存储数据的。作用：作为软件的配置文件使用；存储传输数据，而非显示数据。
XML分为文档声明、元素、属性、注释、CDATA区、处理命令。一个XML文档只能允许一个根元素，根元素下面可以拥有多个子元素，每个子元素有多个属性。
文档声明：声明文档类型
<?xml version=“1.0”encoding=“GB2312”standalone=“yes”?>
encoding属性说明文档的字符编码；standalone属性说明文档是否独立
**元素就是标签：**标签分为开始标签和结束标签。注意：标签中出现的所有空格和换行，XML解析程序都会当作标签内容进行处理。
**属性：**每个属性都有它自己的名称和取值
<input type=“text”>也可以改用子元素来使用
<input>
<name>text</name>
</input>
注释：<!–注释–>
CDATA区：在编写XML文件时，如果希望一些特殊的字符显现出来可以使用CDATA语法。
软件工程
MVC；分为视图层（View）表现界面、控制层（Controller）负责业务层与表现层的交互、业务层（Model）对数据库进行一些操作
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wWBChg4D-1617798717681)(media/8a1bdddb73dc78cec98d2041324f62c3.png)]
359
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
