本文详细介绍了JAVA编程的基础知识，包括数据类型、变量、运算符、条件语句、循环语句、数组、字符串处理以及注释的使用。讲解了JAVA中的基本数据类型、变量命名规则、运算符的优先级、逻辑结构如if...else、switch语句，以及循环结构如while、for、do...while。此外，还提到了数组的声明、初始化和遍历，以及条件语句中的break关键字。文章最后简要提及了项目背景，展示了JAVA在实际问题解决中的应用，如租车系统的设计分析。
java:使用Eclipse开发java程序
集成开发环境(IDE)是一类软件将程序开发环境和程序调试环境集合在一起,提高开发效率
1.创建java项目
2.创建程序包(一般为域名的反向如hell.com则为com.hello)
3.编写Java源程序
4.运行Java程序
第一步我们创建一个Java项目,第二步我们在Java项目的SRC下创建了一个包,第三步我们在包里面创建一个类并且编写JAVA程序最后运行这个程序。
main():main()方法程序的入口比如拿钥匙开门一样不能从窗户进去,这里的main()方法就是程序的入口.
Java中的关键字：
abstract boolean break byte case catch char class continue default do double else
extends false final finaly float for if implements import instanceof int interface long
native new null package private protected public return short static super switch synchronized
this throw throws transient true try void volatile while(区分大小写如void是关键字但是Void就不是)
java标识符:
标识符就是用于给java程序中变量、类、方法等命名的符号。
使用标识符时,需要遵守几条规则:
1.标识符可以由字母、数字、下划线、美元符($)组成,但不能包含@、%、空格等其他字符,不能以数字开头。譬如:123name就是不合法的
2.标识符不能是java关键字和保留字(java预留的关键字,以后的升级版本中可能作为关键字),但可以包含关键字和保留字。如:不可能使用void作为标识符,但是MYvoid是可以的
3.标识符时严格区分大小写的.所以呢，一定要区分imooc和IMooc是两个不同的标识符。
4.标识符的命名最好能反映出其作用,做到见名知意.
变量:
Java中通过变量类型、变量名、变量值这三个元素来描述变量
如何命名java变量
给变量取名字需要遵守一定规则
首字母 其余部分
1.字母 任意多的:
变量名=2.下划线'_' + 1.数字
3.'$'符号 2.字母
3.下划线'_'
4.'$'符号
正确示范：
String myname=“tom”;
String _love=“imooc”;
String $hobby2=“lol”;
错误示范:
String 3hobby=“wow”;(不能以数字开头)
String %sex=“男”;(不能以下划线和美元符之外的其他特殊字符开头)
String private=“www.imooc.com”;(不能使用java关键字)
java编程习惯:
1.变量名由多个单词组成时，第一个单词的首字母小写，其后首字母大写，俗称驼峰式命名法，如myAge
2.变量命名时，尽量简短且能清楚地表达变量的作用，做到见名知意。如:定义变量名stuName保存"学生姓名"信息
PS：java变量名的长度没有限制，但是java语言是区分大小写的，所以price和Price是两个完全不同的变量
Java中的数据类型
java语言是一种强类型语言。java中存储的数据都是有类型的，而且必须在编译时就确定其类型。
java中有两类数据类型;
1.整数类型（byte、short、int、long）
1.数值型2.浮点类型（float、double）
基本数据类型 2.字符型（char）
3.布尔型（boolean）
数据类型
1.类（class）
2.接口（interface）
引用数据类型 3.数组
在java中基本数据类型变量存的是数据本身，而引用数据类型变量存的是保存数据的空间地址
通俗而言基本数据类型存储的是放在抽屉里的东西而引用数据类型则是存储打开这个抽屉的钥匙 抽屉钥匙一一对应
常用的基本数据类型有:
int 整型 4byte 用于存储整数，如年龄，个数 int age=21；
double 双精度浮点型 8byte 用于存储小数，如商品价格、成绩平均分 double price=15.5；
float 单精度浮点型 4byte 用于存储小数如身高 float height=175.2f；
char 字符型 2byte 用于存储单个字符，如性别’男’、‘女’ char sex=‘男’；
boolean 布尔型 1byte 表示“真”或“假”，取值只能为 true或flase boolean flag=true；
String 是一种常见的引用数据类型，用来表示字符串。在程序开发中，很多操作都要使用字符串来完成，例如系统中的用户名、密码、电子邮箱等。
java中变量的使用规则
1.java中的变量需要先声明后使用
2.变量使用时，可以声明变量的同时进行初始化，也可以先声明后赋值。
3.变量中每次只能赋一个值，但是可以修改多次。
4.main方法中定义的变量必须先赋值，然后才能输出。
java中的自动类型转换
不同的基本数据类型之间是需要进行相互转换的
如:int score1=82;
double score2=score1;
System.out.println(score2);
代码中将int类型score1赋值给score2并且转换为double类型。
1.目标类型与源类型兼容，如double 型兼容int型，但是char型不能兼容int型
2.目标型大于源类型，如double类型长度为8字节，int类型为4字节，因此double类型的变量里直接可以存放int类型的数据，但是反过来就不可以了。
java中的强制类型转换
java强制类型转换语法
double avg1=78.5；
int vag2=（int）avg1；
System.out.println（avg1）；
System.out.println（avg2）；
此时就强制把double类型转换成int类型。PS（强制类型容易造成数据丢失所以需要谨慎使用,
java常量的应用
所谓常量可以理解为是一种特殊的变量在程序运行过程中不允许被改变。
语法：final 常量名 =值；
java中注释的使用
java中有三种注释类型：单行，多行，文档三种注释
/** /文档注释
/ */多行注释
// 单行注释
@author 标明开发该类模块的作者
@version 标明该类模块的版本
@see 参考转向，也就是相关主题
@param 对方法中某参数的说明
@return 对方法返回值的说明
@exception 对方法可能抛出的异常进行说明
什么是运算符
运算符是一种“功能”符号，用以通知java进行相关的运算。如我们需要将变量age的值设置为20，这时则需要一个“=”号来将其连接告诉程序需要进行的辅助操作。
java语言中常用的运算符可以分为如下几种；
1.算术运算符
2.赋值运算符
3.比较运算符
4.逻辑运算符
5.条件运算符
java中的算术运算符
算术运算符主要用于基本的算术运算，如加法、减法、乘法、除法、等。
java中常用的算术运算符：
-
加法 5+12=17
-
减法 25-10=15
-
乘法 3*8=24
/ 除法 24/6=4
% 求余 24%7=3
++ 自增1 int i=5；i++
– 自减1 int i=5；i–
3 其中++和–既可以出现在操作数的左边，也可以出现在右边，但结果是不同的
java中的赋值运算符
= 赋值 c=a+b将把a+b得到的值赋给c
+= 加等于 c+=a等价于c=c+a
-= 减等于 c-=a等价于c=c-a
= 乘等于 c=a等价于c=a*c
/= 除等于 c/=a等价于c=c/a
%= 模等于 c%=a等价于c=c%a
java中的比较运算符
比较运算符用于判断两个数据的大小，例如:大于、等于、不等于。比较的结果是一个布尔值（true或false）。
< >= <= == !=
1.>、<、>=、<=只支持左右两边操作数是数值类型
2.==、!=两边的操作数既可以是数值类型也可以是引用类型
java中的逻辑运算符
&& 与 a&&b 如果a与b都为true,则返回true；
|| 或 a!!b 如果a与b任一个为true，则返回true
! 非 !a 如果a为false,则返回true，即取反
^ 异或 a^b 如果a与b有仅有一个为true，则返回true
java中的条件运算符
条件运算符（？：）也称为“三元运算符”。
语法形式:布尔表达式?表达式1:表达式2;
运算过程:如果布尔表达式的值为true,则返回表达式1的值,否则返回表达式2的值
例如:
String str=(8>5)?“8大于5”:“8不大于5”;
System.out.println(str);
因为表达式的值8>5所以返回的值为8大于5；
java中运算符的优先级
所谓优先级，就是在表达式的运算过程中的先后顺序。java中常用的运算优先级如下所示：
1 （）
2 ！+（正） -（负）++ ——
3 */%
4 +（加）-（减）
5 < <= > >=
6 == !=
7 ^
8 &&
9 ||
10 ?:
11 = += -= *= /= %=
级别为1的优先级最高，11的优先级最低。
java条件语句之if
if（条件）{
条件成立时执行的代码
}
java条件语句之if…else
语法
if（条件的布尔表达行）{
代码块1
}else{
代码块2
}
执行过程:当if中的条件满足时则执行代码块1，否则执行代码块2；和if相比 if…else不管条件是否满足都会执行一条语句；
java条件语句之多重if
语法：
if（条件1）{
代码块1
}else if（条件2）{
代码块2
}else{
代码块3
}
执行过程：先判断条件1如果满足则执行代码1，否则继续判断条件2，如果条件2满足则输出代码块2，否则输出代码块3，与前两者相比较这个会多判断一次。
java条件语句之嵌套if
嵌套if语句，只有当外层if的条件成立时，才会判断内层if的条件。
if（条件1）{
if(条件2){
代码块1
}else{
代码块2
}
}else{
代码块3
}
equals()用于判断字符串的内容是否相同，相同则返回true，反之则返回false；
java条件语句之switch
语法:
switch(表达式){
case 值1:
执行代码块1
break;
case 值2:
执行代码块2
break;
case 值n:
执行代码块n
break;
default:
默认执行的代码
}
执行过程:当switch后表达式的值和case语句后的值相同时，从该位置开始向下执行，直到遇到break语句或者switch语句块结束;如果没有匹配的case语句则执行default块的代码。
PS:
1.switch后面的小括号中表达式的值必须是整型或字符型
2.case后面的值可以是常量数值，如1.2.;也可以是一个常量表达式，如2+2；但是不能是变量或带有变量的表达式，如a*2
3.case匹配后，执行匹配快里的程序代码，如果没有遇到break会执行下一个的case块的内容，直到遇到break语句或者switch语句块结束。
java循环语句之while
java中常用的3中循环:while、do…while、for
while循环：
语法：
while(判断条件){
循环操作
}
执行过程:
<1>:判断while后面的条件是否成立(true/false)
<2>:当条件成立时，执行循环内的操作代码，然后重复执行<1>,<2>，直到循环条件不成立为止
特点:先判断，后执行
do…while
do…while循环与while循环语法有些类似，但是执行过程差别比较大。
语法:
do{
循环操作
}while(判断条件);
执行过程：
<1>:先执行一遍程序，然后判断条件是否成立
<2>:如果条件成立，继续执行<1>,<2>直到循环条件不成立为止
特点:先执行，后判断
由此可见，do…while语句保证循环至少被执行一次！
for循环
Java中的三种循环可以相互替换
语法:
for(循环变量初始化;循环条件;循环变量变化){
循环操作
}
执行过程:
<1>、执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次
<2>、进行循环条件的判断，如果条件为true，则执行循环体内代码，如果为false，则直接退出循环
<3>、执行循环变量变换部分，改变循环变量的值，以便进行下一次条件判断
<4>、依次重新执行<2>、<3>、<4>，直到退出循环
特点:相比while和do…while语句结构更加简洁易读
PS:1.for关键字后面括号中的三个表达式必须用’；‘隔开，三个表达式可以省略但是’;‘不能省略。
省略’循环变化量初始化’，可以在for语句之前由赋值语句进行变量初始化。
省略’循环条件’，即可能会造成程序一直执行下去，也就是’死循环’现象
省略循环变量的变化部分，可以在循环体中进行循环变换的部分。
2.for循环变量初始化和循环变量变化部分，可以是使用’,'同时初始化或改变多个循环变量的值。如
for(int i=1,j=5;i<=5;i++,j–){
System.out.println(i+"+"+j+"="+(i+j));
}
java循环跳转语句之break
java循环语句之continue
continue的作用是跳过循环体中剩余的语句执行下一次循环。
java循环语句之多重循环
循环体中包含循环语句的结构称为多重循环。三种循环语句可以自身嵌套，也可以相互嵌套，最常见的就是二重循环，在二重循环中，外层循环每执行一次，内层循环要执行一圈。
例子1: package com.vb;
**** import java.util.Scanner;
public class LX27 {
public static void main(String[] args) {
***** Scanner input=new Scanner(System.in);//创建Scanner对象
System.out.print("请输入考试成绩信息:");
***** int score=input.nextInt();//获取用户输入的成绩并保存在变量中
int count=0;
System.out.println("加分前成绩:"+score);
for(;score<60;score++) {
count++;
}
System.out.println("加分后成绩:"+score);
System.out.println("加分次数:"+count);
}
}
这个例子展示了Scanner类的导入
例子2
实现了三个班级的各4个学生的成绩，并且求出了他们的平均分
package com.vb;
import java.util.Scanner;
public class LX28 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);//创建Scanner对象
int classNum=3;//班级数量
int stuNum=4;//学生数量
double sum=0;//成绩总和
double avg=0;//成绩平均分
for(int i=1;i<=classNum;i++) {//外层循环控制班级的数量
System.out.println("请输入第"+i+"个班级的成绩");
for(int j=1;j<=stuNum;j++) {//内层循环控制学生的数量
System.out.print("第"+j+"个学生成绩为");
int score=input.nextInt();
sum=sum+score;//成绩累加总和
}
avg=sum/stuNum;//计算平均分
System.out.println("第"+i+"个班级学生的平均分为:"+avg);
sum=0;//成绩清0
}
}
}
java之数组
数组可以理解为是一个巨大的“盒子”，里面可以按顺序存放多个类型相同的数据，比如可以定义int型的数组scores存储45名学生的成绩
int[] scores={76,83,92,87};
数组里面每个值都有一个索引，索引从0开始；
例如可以通过scores[0]获取数组中的第一个元素，scores[2]就可以获取第三个元素。
如何使用java中的数组
java中操作数组只需要4步；
1.声明数组
语法：数据类型[] 数组名；
或者 数据类型 数组名[];
其中，数组名可以是任意合法的变量名，如：
int[] scores；
double height[]；
String[] names;
2.分配空间
简单来说就是指定数组中最多可存储多少个元素
语法：数组名=new 数据类型[数组长度]；（其中数组长度就是数组中能存放元素的个数）如：
scores=new int[5];
height=new double[5];
names=new String[5];
上面声明数组和分配空间可以合并如：
int[] scores=new int[5];
3.赋值
语法:
scores[0]=89;
scores[1]=79;
4.处理数组中数据
java中还提供了另外一种直接创建数组的方式，它将声明数组，分配空间和赋值合并完成，如
int[] scores={78,91,84,68};他等价于:
int[] scores=new int[此括号中不能指定长度不然报错]{78,91,84,68};
使用循环来操作java中的数组
如:
int[] scores={78,91,84,68};
for(int i=1;i<scores.length;i++){
System.ou.println(“数组中的第”+(i+1)“个元素的值是：”+scores[i])
}
其中，数组名.length 用于获取数组的长度
PS：
1.数组下标从0开始。因此 scores[3]，代表数组中第4个元素，而非第三个元素
2.数组下标是0到数组长度-1，如果越界访问，就会报错。
循环遍历数组
package com.vb;
public class LX31 {
public static void main(String[] args) {
String[] hobbys= {“sports”,“game”,“movie” };
System.out.println(“循环输出数组中元素的值:”);
for(int i=0;i<hobbys.length;i++) {
System.out.println(hobbys[i]);
}
}
}
例子: package com.vb;
public class LX32 {
public static void main(String[] args) {
int[] nums=new int[]{61,23,4,74,13,148,20};//定义一个整型数组
int max=nums[0];//假定最大值为数组中的第一个数
int min=nums[0];//假定最小值为数组中的第一个数
double sum=0;//累加值
double avg=0;//平均值
for(int i=0;i<nums.length;i++) {
if(nums[i]>max){
max=nums[i];}//如果当前值大于max，则替换max值
if(nums[i]<min){
min=nums[i];}
sum=sum+nums[i];
avg=sum/nums.length;
}
System.out.println("数组中的最大值为:"+max);
System.out.println("数组中的最小值为:"+min);
System.out.println("数组中的平均值为:"+avg);
}
}
使用Arrays类操作java中的数组
Arrays类是java中提供的一个工具类，在java.util包中。该类中包含了一些方法用来直接操作数组，比如可以直接实现数组的排序、搜索等。
1.排序
语法:Arrays.sort(数组名);
可以使用sort()方法实现对数组的排序，只要将数组名放在sort()方法的括号中，就可以完成对该数组的排序(按升序排序)
2.将数组转换为字符串
语法:Arrays.toString(数组名);
可以使用toString()方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开
使用foreach操作数组
语法:
for(元素类型 元素变量:遍历数组){
执行的代码
}
java中的二维数组
1.声明数组并分配空间
数据类型[][] 数组名=new 数据类型[行的个数][列的个数]；
或者
数据类型[][] 数组名；
数组名=new 数据类型[行的个数][列的个数]；
如：定义一个两行三列的二维数组
int[][] num=new int[2][3];
2.赋值
二维数组的赋值，和一维数组类似，可以通过下标来逐个赋值，注意索引从0开始
数组名[行的索引][列的索引]=值；
也可以在声明数组的同时为其赋值
数据类型[][] 数组名={{值1，值2...},{值11，值22...}};
如：
//给第1行第1列的元素赋值
num[0][0]=12;
3.处理数组
如何定义java中的方法
所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。
一般情况下，定义一个方法的语法是:
访问休止符 返回值类型 方法名(参数列表){
方法体
}
其中
1.访问休止符:方法允许被访问的权限范围，可以是pubulic、protected、private 甚至可以省略，其中public表示该方法可以被其他任何代码调用。
2.返回值类型:方法返回值的类型，如果方法不返回任何值，则返回值类型指定为void；如果方法具有返回值，则需要返回指定返回值类型，并且在方法中使用return语句返回返回值
3.方法名：定义的方法的名字，必须使用合格的标识符
4.参数列表：传递给方法的参数列表，参数可以有多个，多个参数间用逗号隔开，每个参数由参数类型和参数名组成，以空格隔开
根据方法是否带参、是否带返回值，可以将方法分四类：
*无参无返回值方法
*无参带返回值方法
*带参无返回值方法
*带参带返回值方法
Java中无参无返回值方法的使用
如果方法不包含参数，且没有返回值，我们称之为无参无返回值方法。
方法的使用分两步：
第一步，定义方法
如：public void show（）{
System.out.println（“welcome to imooc.”）；
}
其中void是返回值类型
show方法名
System.out.println（“welcome to imooc.”）方法体
PS：
1.方法体放在一对大括号中，实现特定的操作
2.方法名主要在调用这个方法时使用，需要注意命名的规范，一般采用第一个单词首字母小写，其他单词首字母大写的形式
第二步，调用方法
当需要调用方法执行某个操作时，可以先创建类的对象，然后通过对象名.方法名（）来实现；
java中无参带返回值方法的使用
如果方法不包含参数，但是有返回值，我们称为无参带返回值的方法。
如果返回值类型为int 则需要return来返回结果
PS：如果返回值为void，则方法中不能使用return返回值！
public void showInfo（）{
return “java”；//这个时候会报错
}
2.方法返回值最多只能有一个，不能返回多个
public int getInfo（）{
int score1=94;
int score2=87;
return score1,score2;//返回值只能返回一个值；
}
3.方法返回值的类型必须兼容，例如，如果返回值类型为int，则不能返回String型的值
public int getInfo(){
String name="imooc";
return name;//name为String类型但是返回值类型为int所以会报错
}
例：
package com.vb;
public class LX40 {
public static void main(String[] args) {
LX40 hello=new LX40();
int maxScore=hello.getMaxAge();
System.out.println(maxScore);
}
public int getMaxAge() {
int[] ages= {18,23,21,19,25,29,17};
int maxScore=ages[0];
for(int i=0;i<ages.length;i++) {
if(ages[i]>maxScore) {
maxScore=ages[i];
}
}
return maxScore;
}
}
java中带参无返回值方法的使用
例：public void show（String name）{
System.out.println（“欢迎您，”+name+“！”）；
HelloWorld hello=new HelloWorld（）；
hello.show（“爱慕课”）；
}
上面的代码定义了一个show方法，带有一个参数name，实现输出欢迎消息。
调用带参方法与调用无参方法的语法类似，但是调用时必须传入实际的参数值
对象名.方法名（实参1，实参2，....，实参n）
很多时候我们把定义方法时的参数称为形参，目的是用来定义方法需要传入的参数的个数和类型；把调用方法时的参数称为实参，是传递给方法真正被处理的值。
上例中String name 就是形参
“爱慕课”就是实参
一定不可以被忽视的问题：
1.调用带参方法时，必须保证实参的数量、类型、顺序与形参一一对应
2.调用方法时，实参不需要指定数据类型
3.方法的参数可以是基本数据类型，如int、double等，也可以是引用数据类型，如String、数组等’
4.当方法参数有多个时，多个参数间以逗号隔开
java中带参带返回值方法的使用
java中方法的重载
什么是方法的重载：
如果同一个类中包含了两个或两个以上方法名相同、方法参数的个数、顺序或类型不同的方法，则称为方法的重载，也可以称该方法被重载了。
如何区分调用的是哪个重载方法呢
当调用被重载的方法时，java会根据参数的个数和类型来判断应该调用哪个重载方法，参数完全匹配的方法将被执行。
判断方法重载的依据：
1.必须是在同一类中
2.方法名相同
3.方法参数的个数、顺序或类型不同
4.与方法的修饰符或返回值没有关系
重点复习:package com.vb;
import java.util.Arrays;
public class LX44 {
public static void main(String[] args) {
LX44 hello=new LX44();
int[] nums=hello.getArray(8);
System.out.println(Arrays.toString(nums));
}
public int[] getArray(int length) {
int[] nums=new int[length];
for(int i=0;i<nums.length;i++) {
nums[i]=(int)(Math.random()*100);
}
return nums;
}
}
定义类：
1.类的重要性：所有java程序都以类calss为组织单元
2.什么是类：
类是模子，确定对象将会拥有的特征（属性）和行为（方法）{属性：这个类这个东西所具有的东西比如手机所具有CPU 为多少 屏幕多大；方法是指这个东西能做什么比如手机可以打电话，发短信}
类的特点
类是对象的类型
具有相同属性和方法的一组对象的集合·
3.类的组成：属性和方法。
4.定义一个类的步骤：
a.定义类名 public class 类名(){}
java对象
使用对象的步骤:
1.创建对象:
类名 对象名=new 类名();
LX1 phone=new LX1();
2.使用对象：
引用对象的属性:对象名.属性
phone.screen=5;//给scree属性赋值5
引用对象的方法：对象名.方法名()
phone.sendMessage();//调用sendMessage()方法
成员变量和局部变量区别
1.作用域不同
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
2.初始值不同
java会给成员变量一个初始值
java不会给局部变量赋予初始值
3.在同一个方法中，不允许有同名局部变量；
在不同的方法中，可以有同名局部变量；
4.两类变量同名时，局部变量具有更高的优先级；
构造方法
1.使用new+构造方法 创建一个新的对象//意思是:比如创建了一个构造方法 public print(){} 当创建此构造方法的对象时则时 print i=new print();这时的print不是类名print而是构造方法print();
2.构造方法是定义在java类中的一个初始化对象的方法，构造方法与类名相同且没有返回值
构造方法的语句格式
没有返回值
public 构造方法名(){ //没有返回值类型 方法名与类名相同 可以指定参数
//初始化代码
}
带参构造方法的使用
5.当没有指定构造方法时，系统会自动添加无参的构造方法
6.当有指定构造方法时，无论是有参、无参的构造方法，都不会自动添加无参的构造方法
7.构造方法的重载：方法名相同，但是参数不同的多个方法调用时会自动根据不同的参数选择相应的方法
java中的static使用之静态变量
java中被static修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。当然，鉴于他作用的特殊性更推荐用类名访问。
PS：静态成员属于整个类，当系统第一次使用该类时，就会为其分配内存空间直到该类被卸载才会进行资源回收
java中的static使用之静态方法
与静态变量一样，我们可以使用static修饰方法，称为静态方法或类方法。其实之前我们一直写的main方法就是静态方法。
PS:静态方法中可以直接调用同类中的静态成员，但不鞥直接调用非静态成员。
面向对象的三大特性:封装、继承、多态
封装
1.概念:将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
2.好处:a.只能通过规定的方法访问数据 b.隐藏类的实例细节，方便修改和实现
3.封装的实现步骤1.修改属性的可见性设为private 2.创建getter/setter方法用于属性的读写3.在getter/setter方法中加入属性语句对属性值得合法性进行判断
java中的包:
1.包的作用：
管理java文件
解决同名文件冲突
2.定义包：package包名
注：必须放在java源程序的第一行
包名间可以使用“.”隔开
eg：com.imooc.MyClass
4.包的使用
（1）可以通过import关键字，在某个文件使用其他文件的类。
import com.imooc.music.MyClass
（2）java中，包的命名规范是全小写字母拼写
java中的访问修饰符
访问修饰符--可以修饰属性和方法的访问范围
访问修饰符 本类 同包 子类 其他
private √
默认 √ √
protected √ √ √
public √ √ √ √
java中的this关键字
1.this关键字代表当前对象
this.属性 操作当前的对象
this.方法 调用当前对象的方法
2.封装对象的属性的时候，经常会使用this关键字
什么是java中的内部类
内部类就是定义在另外一个类里面的类。与之对应，包含内部类的类被称为外部类。
内部类的功能是什么？
1.内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
2.内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3.内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
内部类有几种呢
1.成员内部类
2.静态内部类
3.方法内部类
4.匿名内部类
java中的成员内部类
内部类中最常见的就是成员内部表，也称为普通内部类。
PS:外部类不能直接使用内部类的成员和方法
package com.vb2;
public class Outer {//外部类Outer
private int a=99;//外部类的私有属性
public class Inner{//内部类Inner
int b=2;//内部类的成员属性
public void test() {
System.out.println("访问外部类中的a:"+a);
System.out.println("访问内部类中的b:"+b);
}
}
public static void main(String[] args) {//测试成员内部类
Outer o=new Outer();//创建外部类对象，对象名为o
Inner i=o.new Inner();//使用外部类对象创建内部类对象，对象名为i
i.test();
}
}
从上面的代码中我们可以看到，成员内部类的使用方法:
1.Inner类定义在Outer类的内部，相当于Outer类的一个成员变量的位置，Inner类可以使用任意访问控制符，如public、protected、private等
2.Inner类中定义的test()方法可以直接访问Outer类中的数据，而不受访问控制符的影响，如直接访问Outer类中的私有属性a
3.定义了成员内部类后，必须使用外部类对象来创建内部类对象，而不能直接去new一个内部类对象，即:内部类 对象名=外部类对象名.new 内部类();
PS
1.外部类是不能直接使用内部类的成员和方法的
2.如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用this 关键字。如
package com.vb2;
public class imooc {//外部类imooc
int b=1;//外部类的成员属性b
public class inner{//内部类inner
int b=2;//内部类的成员属性b
public void test() {//内部类的test方法
System.out.println("访问外部类中的b:"+imooc.this.b);
System.out.println("访问内部类中的b:"+b);
}
}
public static void main(String[] args) {
imooc o=new imooc();
inner i=o.new inner();
i.test();
}
}
java中的静态内部类
静态内部类是static修饰的内部类，这种内部类的特点是:
1.静态内部类不能直接访问外部类的非静态成员，但可以通过new 外部类().成员的方式访问
2.如果外部类的静态成员与内部类的成员相同，可以通过“类名.静态成员”访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可以通过“成员名”直接调用外部类的静态成员
3.创建静态内部类的对象，不需要为外部类的对象，可以直接创建 内部类 对象名=new 内部类（）；
java中的方法内部类
方法内部类就是内部类定义在外部类的方法中，方法内部类只在该方法的内部可见，即只在该方法内可以使用。
PS:由于方法内部类不能在外部类的方法以外的地方使用，因此方法内部类不能使用访问修饰符和static修饰符。
java中的继承
继承是类与类的一种关系，是一种“is a”的关系
PS:java中的继承类是单向的
继承的好处：
子类拥有父类的所有属性和方法
实现代码复用
3.语法规则：
class 子类 extends 父类
例：class Dog extends Animal{
....
}
方法的重写
1.什么是方法的重写：
如果子类对继承父类的方法不满意，是可以重写父类继承的方法的，当调用方法时会优先调用子类的方法。
2.语法规则：
a.返回值类型
b.方法名
c.参数类型及个数
都要与父类继承的方法相同，才叫方法的重写。
继承的初始化顺序
1.初始化父类再初始化子类
2.先执行初始化对象中属性，在执行构造方法中的初始化
final关键字
使用final关键字做标识有“最终的”含义
final可以修饰类、方法、属性和变量
final修饰类，则该类不允许被继承
final修饰方法，则该方法不允许被覆盖（重写）
final修饰属性
则该类的属性不会进行隐式的初始化（类的初始化属性必须有值）
或在构造方法中赋值（但只能选其一）
final修饰变量，则该变量的值只能赋一次值，即变为常量
super关键字:
在对象的内部使用，可以代表父类对象
1.访问父类的属性
super.age
2.访问父类的方法
super.eat()
super的应用
子类的构造的过程当中必须调用其父类的构造方法。
如果子类的构造方法中没有显示调用父类的构造方法，
则系统默认调用父类无参的构造方法
如果显示的调用构造方法，必须在子类的构造方法的第一行。
如果子类构造方法中既没有显示调用父类的构造方法，而父类中有没有无参的构造方法则编译会报错。
Object类
Object类是所有类的父类，如果一个类没有使用extends关键字明确标识继承另外一个类，那么这个类默认继承Object类。
Object类中的方法，适合所有子类。
1.toString（）方法
在Object类里面定义toString（）方法的时候返回对象的哈希code码（对象地址字符串）
可以通过重写toString（）方法表示对象的属性
2.equals（）方法
比较的是对象的引用是否指向同一块内存地址。
DOG dog=new DOG();
一般情况下比较两个对象时比较他的值是否一致，所以要进行重写
多态
对象的多种形态
1.引用多态
父类的引用指向本类的对象
父类的引用指向子类的对象
2.方法多态
创建本类对象时，调用的方法为本类方法
创建子类对象时，调用的方法为子类重写的方法或者继承的方法
引用类型转换
1.向上类型转换(隐式/自动类型转换)，最小类型到大类型的转换
2.向下类型转换(强制类型转换)，是大类型到小类型
3.instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题
抽象类
1.语法定义
抽象类前使用abstract关键字修饰，则该类为抽象类。
2.应用场景:
a.在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但是无法准确知道这些子类如何实现这些方法。
b.从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。
3.作用:
不关注子类的实现但是限制子类必须具有某些特征
4.使用规则:
a.abstract定义抽象类
b.abstract定义抽象方法，只有声明，不需要实现
c.包含抽象方法的类是抽象类
d.抽象类中可以包含普通的方法，也可以没有抽象方法
接口概念
类是一种具体实现体，而接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
2.接口定义
和类定义不同，定义接口不再使用class关键字，而是使用interface关键字。
接口定义的基本语法:
[修饰符] interface 接口名 [extends 父接口1,父接口2...]
{
零个到多个常量定义...
零个到多个抽象方法的定义...
}
接口就是用来被继承、被实现的、修饰符一般建议用public
PS:不能使用private和protected修饰接口
3.接口定义
常量:
接口中的属性是常量，即使定义时不添加
public static final 修饰符，系统也会自动加上。
方法:
接口中的方法只能是抽象方法，总是使用，即使定义时不添加public abstract修饰符，系统也会自动加上。
4.使用接口
一个类可以实现一个或多个接口，实现接口使用implements关键字。java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以做补充。
继承父类实现接口的语法为:
[修饰符]class 类名 extends 父类 implements 接口1，接口2...
{
类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。
}
如果要继承父类，继承父类必须在实现接口之前
使用接口:
接口在使用过程当中，还经常与匿名内部类配合使用
匿名内部类就是没有名字的内部类，
多用于关注实现而不关注实现类的名称
语法格式:
Interface i=new Interface(){
public void method(){
System.out.println("匿名内部类实现接口的方式")
}
};
UML
1.UML概念
Unied Modeling Language(UML)又统称一建模语言或标准建模语言
是一个支持模型化和软件系统开发的图形化语言
为软件开发的所有阶段提供模型化和可视图支持
2.UML图示
UML2.2中一共定义了12种视图
3.常用UML图
用例图(The Use Case Diagram)
用例图能够以可视化的方式，表达系统如何满足所收集的业务规则，以及特定的用户需求等信息
UML
3.常用UML图
序列图（The Sequence Diagram）
序列图用于按照交互发生的一系列顺序，显示独享之间的这些交互。
类图(The Class Diagram)
UML类图、业务逻辑和所有支持结构一同被用于定义全部的代码结构。
4.UML建模工具
Visio.Rational Rose\ PowerDesign三种建模工具应用最广
综合练习
一.项目背景介绍
根据所学知识，编写一个控制台版的“答答租车系统”
功能：
1.展示所有可租车辆
2.选择车型、租车量
3.展示租车清单，包含：总金额、总载货量及其车型、总载人量及车型
二.项目分析
1.数据模型分析
2.业务模型分析
3.显示和流程分析
数据模型分析
1.通过对现实世界的事与物主要特征的分析、抽象，为信息系统的实施提供数据存取的数据结构以及相应的约束。
2.数据结构的组成:操作(方法)、属性
业务模型分析
1.在设计应用程序之前，应该明确该应用程序必须执行那些任务。分析业务需求是应用程序开发中最重要的步骤之一。
确定业务需求的目的在于创建一个能同时满足零售商和消费者需要的解决方案。
2.答答租车系统中，只需要考虑消费者需求就可以了。
显示和流程分析
1.显示：用户可以看到的信息提示界面。
2.流程：显示信息的执行过程、步骤。
3.答答租车系统中，要以命令行的方式显示提示信息和输出结果信息，要考虑其样式，用户输入的数据不同，信息该如何提示、如何处理并显示出结果，这部分知道囊括了显示与流程的内容。
例：请选择车辆->请输入序号->输出总金额…
this.x(成员变量)=x(局部变量)
private static//修饰为静态私有属性，修饰后次属性只能被此类中的方法中使用（方法可以是静态方法也可以是非静态方法）
异常简介
异常处理的作用
java异常体系结构简介 →Error(如果Error出现则表明程序崩溃了)
Throwbale →空指针异常(NullPointerException)
处理异常 →Exception→非检查异常(RuntimeException)→数组下标越界异常(ArrayIndexOutOf)
try-catch以及try-catch-finally →类型转换异常(ClassCastException)
抛出异常 →算术异常(ArithmetiException)
自定义异常
异常链 →检查异常→文件异常(IOException)
→SQL异常(SQLException)
try-catch语法
try{
//一些会抛出异常的方法
}catch (Exception e){
//处理该异常的代码块
}catch (Exception2 e){
//处理Exception2的代码块
}...(n个catch块)...{
}
java中的异常抛出
throw
throws--声明将要抛出几何类型的异常(声明)
public void 方法名(参数列表)
throws 异常列表{
//调用会抛出异常的方法或者:
throw new Exception();
}
自定义异常
java中的异常链
实际应用中的经验与总结
1.处理运行异常时，采用逻辑去合理规避同时辅助try-catch处理
2.在多重catch块后面，可以加一个catch(Exception)来处理可能会被遗漏的异常
3.对于不确定的代码，可以加上Try-catch,处理潜在的异常
4.尽量去处理异常，切忌只是简单的调用printStackTrace()去打印输出
5.具体如何处理异常，要根据不同的业务需求和异常类型去决定
6.尽量添加finally语句块去释放占用的资源
String类的常用方法:
方法
int length() 返回当前字符串的长度
int indexOf(int ch) 查找ch字符在该字符串中第一次出现的位置
int indexOf(String str) 查找str子字符串在该字符串中第一次出现的位置
int lastIndexOf(int ch) 查找ch字符在该字符串中最后一次出现的位置
int lastIndexOf(String str) 查找str子字符串在该字符串中最后一次出现的位置
String substring(int beginIndex) 获取从beginIndex位置开始到结束的子字符串
String substring(int beginIndex,int endIndex) 获取从beginIndex位置开始到endIndex位置的子字符串
String trim() 返回去除了前后空格的字符串
boolean equals(Object obj) 将该字符串与指定对象比较，返回true或false
String toLowerCase() 将字符串转换为小写
String toUpperCase() 将字符串转换为大写
char charAt(int index) 获取字符串中指定位置的字符
String[] split(String regex,int limit) 将字符串分割为子字符串，返回字符串数组
byte[] getBytes() 将该字符串转换为byte数组
String i="piano";
String i2=new String("piano");
他们区别是内存区将会出现两个piano对象并且由i和i2分别控制。
“==”和equals（）有什么区别呢？
==：判断两个字符串在内存中首地址是否相同，即判断是否是同一个字符串对象
equals（）：比较存储在两个字符串对象中的内容是否一致
PS：字节是计算机存储信息的基本单位，1和字节等于8位，gbk编码中1个汉字字符存储需要2个字节，1个英文字符存储需要1个字节。所以我们看到上面的程序运行结果中，每个汉字对应两个字节值，如“学”对应“-47 -89”，而英文字母“j”对应“74”。同时，我们还发现汉字对应的字节值为负数，原因在于每个字是8位，最大值不能超过127，而汉字转换为字节后超过127，如果超过就会溢出，以负数的形式显示。
认识java中的StringBuilder类
在java中，除了可以使用String类来存储字符串，还可以使用StringBuilder类或StringBuffer类存储字符串，那么他们之间有什么区别呢？
String类具有是不可变性。如
String str="hello";
System.out.println(str+"world");
System.out.println(str);
java中StringBuilder类的常用方法
StringBuilder类提供了很多方法来操作字符串
方法 说明
StringBuilder append(参数) 追加内容到当前StringBuilder对象的末尾
StringBuilder insert(位置，参数) 将内容插入到StringBuilder对象的指定位置
String toString() 将StringBuilder对象转换为String对象
int length() 获取字符串的长度
java中基本类型和包装类之间的转换
Integer a=new Integer(3);
int b=a+5;
装箱:把基本类型转换成包装类，使其具有对象的性质，又可分为手动装箱和自动装箱
int i=10;
Integer x=new Integer(i);
Integer y=i;
拆箱:和装箱相反，把包装类对象转换成基本类型的值，又可分为手动拆箱和自动拆箱
Integer j=new Integer(8);
int m=j.intValue();
int n=j;
java中基本类型和字符串之间的转换
在程序开发中，我们经常需要在基本数据类型和字符串之间进行转换。
其中，基本类型转换为字符串有三种方法:
1.使用包装类的toString()方法
2.使用sTRING类的valueOf()方法
3.用一个空字符串加上基本数据类型,得到的就是基本类型数据对应的字符串
将字符串转换成基本类型有两种方法;
1.调用包装类的parseXxx静态方法
2.调用包装类valueOf()方法转换为基本类型的包装类，会自动拆箱
使用Date和SimpleDateFormat类表示时间
在程序开发中，经常需要处理日期和时间的相关数据，此时我们可以使用java.util包中的Date类。这个类最主要的作用就是获取当前的时间，我们来看下Date类的使用:
Calendar类的应用
Date类最主要的作用就是获得当前时间，同时这个类里面也具有设置时间以及一些其他的功能，但是由于本身设计的问题，这些方法却遭到众多批评，不建议使用，更推荐使用Calendar类进行时间和日期的处理。
java.util.Calendar类是一个抽象类，可以通过调用getInstance（）静态方法获取一个Calendar对象，此对象已由当前日期时间初始化，即魔人代表当前时间，如Calendar c=Calendar.getInstance（）;
使用Math类操作数据
Math类位于java.lang包中，包含用于执行基本数学运算的方法，Math类的所有方法都是静态方法，所以使用该类中的方法时，可以直接使用类名.方法名，如:Math.round();
常用的方法:
返回值 方法名 解释
long round() 返回四舍五入的整数
double floor() 返回小于参数的最大整数
double cell() 返回大于参数的最小整数
double random() 返回[0,1]之间的随机数浮点数
集合框架
集合概念
java中的集合类:是一种工具类里面是具有相同属性的内容
集合的作用
在类的内部，对数据进行组织；
简单而快速的搜索大数量的条目；
有的集合接口，提供了一系列排列有序的元素，并且可以在序列中间快速的插入或者删除有关元素
有的集合接口，提供了映射关系，可以通过关键字（key）去快捷查找对应的唯一对象，而这个关键字可以是任意类型。
与数组的对比
数组的长度固定，集合长度可变
数组只能通过下标访问元素，类型固定，而有的集合可以通过任意类型查找所映射的具体对象
java集合框架的框架
Collection map
list Queue Ste HashMap <Key,Value>Entry(键值对)
LinkedList
ArrayList LinkedList HashSet
Collection接口，子接口以及实现类
Collection接口
List接口及其实现类—ArrayList
List是元素有序并且可以重复的集合，被称为序列
List可以精确的控制每个元素的插入位置，或删除某个位置元素
ArrayList–数组序列，是List的一个重要实现类
ArrayList底层是由数组来实现的
方法的重写:有继承关系的子类中
方法名相同,参数列表相同,{参数顺序,个数,类型,方法返回值相同}
与重写方法的参数名无关
访问修饰符的限定范围大于等于父类方法。
方法的重载:在同一个类中
方法名相同
参数个数,顺序,类型不同
返回值类型,访问修饰符任意
List接口排序用
Collections.sort();方法进行排序
数组排序 Arrays.sort()
集合排序 Collections.sort();
Comparator接口中包含一个 int compare(T o1,T o2)方法的 用来比较排序的两个参数
如果o1<o2 返回负整数
如果o1==o2;返回0;
如果o1>o2,返回正整数
还包含一个 boolean equals(Obkect obj)方法 指示某个其他对象是否 “等于” 此 Comparator
此方法可以被Object类中的equals方法覆盖,不必重写
public class NameComparator implements Comparator<Cat> {
@Override
public int compare(Cat o1, Cat o2) {
int n=o1.getName().compareTo(o2.getName());
return n;
}
for(Cat n:list) {
System.out.println(n);
}
System.out.println("*********************");
Collections.sort(list, new NameComparator());
for(Cat n:list) {
System.out.println(n);
}
}
对集合中的某一个属性进行排序首先定义一个类实现(implements)接口 Comparator
然后进行重写 compare方法进行比较
public int compare(Cat o1, Cat o2) {
return o2.getMonth()-o1.getMonth();
}
compare默认返回是int类型的值,当类型不一致时直接进行加减运算就可以了
Comparable java.lang包中的
此接口强行对实现它的每个类的对象进行整体排序
这种排序被称为类的自然排序,类的 compareTo方法 被称为它的自然比较方法
对于集合,通过调用Collections.sort方法进行排序
对于数组,通过调用Arrays.sort方法进行排序.
int compareTo(T o)方法
该对象小于,等于或大于指定对象,则分别返回负整数,零或正整数.
Comparable和Comparator的区别
排序所用的的方法 collections 前者 一个参数 后者两个参数
重写compareTo方法前者直接在定义的类中重写并与之当前的属性进行比较
后者 则单独创建一个类并重写该方法在排序的参数中实例化该类对象
package com.demo25.sort;
public class Goods implements Comparable{
private String id;//商品编号
private String name;//商品名称
private double price;//商品价格
//构造方法
public Goods(String id, String name, double price) {
super();
this.id = id;
this.name = name;
this.price = price;
}
//getter/setter方法
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
@Override
public String toString() {
return "商品编号:"+id+",商品名称:"+name+",商品价格:"+price;
}
@Override
public int compareTo(Goods o) {
int n=(int)(o.getPrice()-this.getPrice());
return n;
}
}
File类
什么是文件?
文件可认为是相关记录或放在一起的数据的集合
在java中,使用java.io.File类对文件进行操作.
字节流
字节输入流 InputStream
字节输出流 OutputStream
FileInputStream
从文件系统中的某个文件中获得输入字节
try {
FileInputStream fis=new FileInputStream("imooc.txt");
int n=0;
while((n=fis.read())!=-1) {
System.out.println((char)n);
}
fis.close();
读取指定文件的数据
public class FileInputStreamDemo {
public static void main(String[] args) {
FileInputStream fis;
try {
fis = new FileInputStream("imooc.txt");
byte[] b=new byte[100];
fis.read(b,0,5 );
System.out.println(new String(b));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
通过数组形式进行输出文件内容
缓冲输入流 BufferedInputStream
缓冲输出流 BufferedOutputStream
字符输入流 Reader
字符数出流 Writer
字节字符转换流 InputStreamReader
OutputStreamWrite
对象序列化
步骤:
创建一个类,继承Serializable接口
创建对象
将对象写入文件
从文件读取对象信息
对象输入流 ObjectInputStream;
对象输出流 ObjectOutputStream;
Library
Lorem Ipsum is simply dummy text of the printing and typesetting industy
Lorem Ipsum has been the industry’s tsandard dummy text ever since the 1500s,When an unknown printer took a galley of type and scrambled it to make a tyle specimen book.
element.getAttribute//获取属性
element.setAttribute//添加或者修改属性
element.src//修改图片名称
element.href//修改网址
DOM事件不同写法
1)
请点击该文本
2)Element.οnclick=function(){displayDate()};
3)Element.addEventListener(“click”,function(){ })
DOM节点
document.createElement("");新增一个元素标签
document.createTextNode("")新增的内容
parent.appendChild(child);//把子类的元素插入到父类中
parent.removeChild(child);//移除子类中的元素
window的方法
window.open()//打开新窗口 //四个参数第一个打开的页面 第二个窗口的名字 第三个宽 第四个高
window.close()//关闭当前窗口
window.moveTo()//移动当前窗口
window.resizeTo()//调整当前窗口的尺寸
window.screen
screen.availWidth//可用的屏幕宽度
screen.availHeight//可用的屏幕高度
window.inner
window.innerWidth//当前文档可显示的宽度
window.innerHeight//当前文档可显示的高度
window.Location
location.hostname 返回web主机的域名
location.pathname返回当前页面的路径和文件名
location.protocol返回所使用的web协议(http://或https//)
location.href 返回(当前页面的)整个URL
window.aler(’’)在网页中输出警告框
document.write(’’)输出内容到网页中
document.getElementById(’’).innerHTML输出内容到html元素中
console.log(’’)输出元素到控制台
prompt() 方法用于显示可提示用户进行输入的对话框。有确定和取消选项 确定返回true 反之false
confirm(“文本”)用于提示用户需要输入的值并且创建一个接受用户输入的文本框
xml
1.标签名要有意义
2.建议使用，小写字母，单词之间使用"-"分割
3.建议多级标签之间不要存在重名的情况
适当的注释与缩进
适当的注释与缩进可以让XML文档更容易阅读
合理使用属性
1.标签属性用于描述标签不可或缺的信息
2.对标签分组或者标签设置id时常用属性表示
xml支持五中实体引用
CDATA标签
学生姓名:$(student.name)
作用域对象 EL表达式内置四种作用域对象 忽略书写作用域对象时,el则按作用域从小到大一次尝试获取 作用域对象 描述 pageScope 从当前页面取值 requestScope 从当前请求中获取属性值 sessionScope 从当前会话中获取属性值 applicationScope 从当前应用获取全局属性值 EL表达式输出 1.语法 ${[作用域.]属性名[.子属性]} 2.EL表达式支持将运算结果进行输出 3.EL支持绝大多数对象输出,本质是执行toString()方法 EL输出参数值 1.EL表达式内置param对象来简化参数的输出 2.语法:${param.参数名} JSTL标签库 1.JSTL(JSP Standard Tag Libray)JSP标准标签库 2.JSTL用于简化JSP开发,提高代码的可读性与可维护性 3.JSTL由SUN(Oracle)定义规范,由Apache Tomcat团队实现 JSTL的标签库种类 1.JSTL按功能划分可分为五类标签库 类别 核心标签库-core 格式化输出标签库-fmt SQL操作标签库-sql XML操作标签库-xml 函数标签库-functions 引用JSTL核心库 1.核心标签库(Core)是JSTL最重要的标签库,提供了JSTL的基础功能 2.<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 3.JSTL核心标签库在taglibs-standard-impl.jar由META-INF/c.tld定义 判断标签 1.JSTL核心库提供了两组判断标签 2.-单分支判断 3.、、-多分支判断 遍历集合 1.标签用于遍历集合{Collection}中的每一个对象 第${idx.index+1}位姓名:${p.name} 性别:${p.sex} 年龄:${p.age} fmt格式化标签库 1.fmt格式化标签库 URI:http://java.sun.com/jsp/jstl/fmt 2.格式化日期标签 3.格式化数字标签 web注册登录案例 MVC设计模式 Web案例开发 MVC的概述 SUN公司推出JSP技术后,同时也推荐了两个web应用程序的开发模式,一种是JSP+JavaBean模式——简单程序开发,一种是Servlet+JSP+JavaBean模式 Servlet + JSP +JavaBean(MVC)——>复杂web程序 丨 丨 丨 处理用户 数据显示 数据封装 请求 web开发模式 Servlet Servlet缺陷: 丨 1.需要配置 丨 2.显示HTML元素的时候很复杂 丨 丨 JSP JSP缺陷: 丨 1.封装和处理数据麻烦 丨 丨 JSP+JavaBean JSP+JavaBean模式优点 1.JSP显示数据 2.JavaBean封装和处理数据 Model1:使用JSP+JavaBean模式开发 Servlet 丨 丨 丨 丨 JSP Servlet+JSP+JavaBean模式优点: 丨 1.使用Servlet处理用户的请求 丨 2.JSP显示数据 丨 3.JavaBean封装和处理数据 JSP+JavaBean 丨 丨 丨 Servlet+JSP+JavaBean Model2:使用 Servlet+JSP+JavaBean模式开发称为MVC模式 M:Model模型层——JavaBean V:View视图层——JSP C:Controller控制层——Servlet 用户的请求都提交到Servlet(C)，由C统一调度JavaBean(M)封装和处理数据, 由JSP(V)进行数据显示 模式一 应用了Java Web开发中的两种技术 1.JSP完成逻辑上的处理很显示 2.JavaBean封装数据,处理数据 浏览器 request(请求) JSP 浏览器 response(响应) 丨 JavaBeans （Web服务器） 模式二 1.Model2分为三部分 1.Servlet控制显示那个JSP页面给用户、调用那个JavaBean 2.JSP响应用户请求,把结果数据展现给用户 3.JavaBean对数据库的数据的存取,复杂的业务功能和逻辑处理 浏览器 request(请求) Servlet———— 丨 丨 JSP<———>JavaBeans MVC开发流程 浏览器 ————>Servlet调用JavaBean(封装数据) 调用另外一个JavaBean(处理数据) 最后将处理的结果通过JSP响应给浏览器 Get与Post请求方法 1.Get方式是将数据通过在URL附加数据显性向服务器发送数据 http://localhost:8080/FirstServer/sam-ple?name=zhangsan 2.Post方式会将数据存放在"请求体" 中隐性向服务器发送数据 请求体:name=zhangsan Get与Post处理方式 1.所有请求-servlet()方法 2.Get请求-doGet()方法 3.Post请求-doPost（）方法 Get与Post应用场景 1.Get常用于不包含敏感信息的查询功能 2.Post用于安全性要求较高的功能或者服务器的"写"操作 1.用户登录 2.用户注册 3.更新公司账目 xml是可扩展标记语言 编写xml就是编写标签,与html很相似 良好的人机可读性 xml与html比较 xml和html非常相似,都是编写标签 xml没有预定义标签,html存在大量预定义标签 xml重在保存与传输数据,html用于显示信息 html xml 首页 三年级 1班 三年级 2班 xml用途 配置描述文件 用于保存程序产生的数据 网络间的数据传输 xml文档结构 第一行必须是xml声明 有且只有一个根节点 xml声明 xml声明说明xml文档的基本信息,包括版本号与字符集,写在xml第一行 <?xml version="1.0" encoding="UTF-8"?> version代表版本号1.0/1.1 encoding UTF-8设置字符集,用于支持中文 xml标签书写规则 1.合法的标签名 2.适当的缩进与注释 3.合理使用属性 4.特殊字符与CDATA标签 5.有序的子元素 xml支持五种实体引用 实体引用 对应符号 说明 < < 小于 > > 大于 & & 和号 ' ' 单引号 " " 双引号 CDATA标签 1.CDATA指的是不应由XML解析器进行解析的文本数据 2.从 <![CDATA[ 不需要解析的代码 ]]> 结束
有序的子元素
在xml多层嵌套的子元素中,标签前后顺序应保持一致.
xml语义约束
1.xml文档结构正确,但可能不是有效的
2.例如,员工档案xml中绝不允许出现其他类型的标签
xml语义约束有两种定义方式:DTD与xml Schema
Document Type Definition
1.DTD(Document Type Definition,文档类型定义)是一种简单易用的语义约束方式
2.DTD文件的扩展名为.dtd.
xml引用dtd文件
在xml中使用<!DOCTYPE>标签来引用DTD文件
书写格式
示例
XML Schema
1.xml schema比dtd更为复杂,提供了更多功能
2.xml schema提供了数据类型,格式限定,数据范围等特性
3.xml schema是w3c标准
DOM文档对象模型
1.DOM（Document Object Model）定义了访问和操作XML文档的标准方法,DOM把XML文档
当做树结构来查看,能够通过DOM树来读写所有元素.
DOM文档对象模型
Dom4j
1.Dom4j是一个易用的,开源的库，用于解析XML。它应用于Java平台,具有性能优异，功能强大和极其易使用的特点.
2.Dom4j将XML视为Document对象.
3.XML标签被Dom4j定义为Element对象
XPath路径表达式
1.Xpath路径表达式是XML文档中查找数据的语言
2.掌握XPath乐意极大的提高在提取数据时的开发效率。
3.学习Xpath本质就是掌握各种形式表达式的使用技巧.
XPath基本表达式
1.最常用的基本表达式
表达式 描述
nodename 选取此节点的所有子节点
/ 从根节点选取
// 从匹配选择的当前节点选择文档中的节点,而不考虑他们的位置
. 选取当前节点
… 选取当前节点的父节点
@ 选取属性
XPath基本表达式案例
路径表达式 结果
bookstore 选取bookstore元素的所有子节点
/bookstore 选取根元素bookstore。
bookstore/book 选取属于bookstore的子元素的所有book元素
//book 选取所有book子元素，而不是他们在文档的位置
//bookstore//book 选取属于bookstore元素的后代的所有book元素，而不管他们位于bookstore之下的什么位置
//@lang 选取名为lang的所有属性
XPath谓语表达式案例
路径表达式 结果
/bookstore/book[1] 选取属于bookstore子元素的第一个book元素
/bookstore/book[last()] 选取属于bookstore子元素的最后一个book元素
/bookstore/book[last()-1] 选取属于bookstore子元素的倒数第二个book元素
/bookstore/book[position()❤️] 选取最前面的两个属于bookstore元素的子元素的book元素
//title[@lang] 选取所拥有名为lang的属性的title元素
//title[@lang=‘eng’] 选取所有title元素，且这些元素拥有值为eng的lang属性
/bookstore/book[price>35.00] 选取bookstore元素的所有book元素,且其中的price元素的值须大于35.00
/bookstore/book[price>35.00]/title 选取bookstore元素的book元素的所有title元素,且其中的price元素的值须大于35.00
jaxen
1.jaxen是一个java编写的开源的XPath库，这是适应多种不同的对象模型,包括DOM，XOM，dom4j和
JDOM.
2.Dom4j底层依赖jaxen实现XPath查询
标准Java Web工程结构
组织结构 描述
tomcat Tomcat应用根目录
/web应用目录 Java Web应用目录
/web应用目录/index.html |.jsp 默认首页
/WEB-INF WEB应用的安全目录,用于存放配置文件
/WEB-INF/web.xml web.xml是"部署描述文件",是该Web项目核心配置文件
/WEB-INF/classes 存放编译后的classes文件
/WEB-INF/lib 用于存放web应用依赖的jar文件
/META-INF/MANIFEST.MF 包含Web应用的版本等信息
Servlet开发步骤
1.创建Servlet类,继承HttpServlet
2.重写service方法,编写程序代码
3.配置web.xml,绑定URL
Servlet访问方法
1.http://IP地址:端口/context-path/url-mapping
2.远程访问使用,本地访问localhost (127.0.0.1)
3.context-path称为’上下文路径’，默认工程名
请求参数
1.请求参数是指浏览器通过请求向Tomcat提交的数据
2.请求参数通常是用户输入的数据,待Sevlet进行处理
Servlet接收请求参数
request.getParameter()–接收单个参数
request.getParameterValues()—接收多个同名参数
Get与Post请求方法
1.Get方式是将数据通过在URL附加数据显性向服务器发送数据
1.http://localhost:8080/FirstServlet/sample?name=zhangsan
2.Post方式会将数据存放在"请求体"中隐性向服务器发送数据
2.请求体:name=zhangsan
request.getMethod();获取当前请求方法
Servlet生命周期
1.装载-web.xml
2.创建-构造函数
3.初始化-init()
4.提供服务-service()
5.销毁-destory()
启动时加载Servlet
1.web.xml使用设置启动加载
2.0~9999
3.启动时加载在工作中常用于系统的预处理
JSP执行过程
Tomcat 将jsp—转译为Servlet源代码-----在进行编译成Servlet字节码
JSP基本语法
1.JSP语法按功能可分为以下四种
1.JSP代码块 2.JSP声明构造块
3.JSP输出指令 4.JSP处理指令
JSP声明构造快
1.JSP声明构造快用于声明变量或方法
2.JSP声明构造快语法:<%!声明语句 %>
例如 <%! public int add(int a,int b){return a+b;} %>
JSP常用处理指令
1.<%@ page %>定于当前jsp页面全局设置
2.<%@ include %>将其他JSP页面与当前JSP页面合并
3. <%@ taglib %>引入JSP标签库
JSO九大内置对象
HTTP请求的结构
1.HTTP请求包含三部分:请求行,请求头,请求体
String userAgent = request.getHeader("User-Agent"); 获取显示形式
响应的结构
1.HTTP响应包含三部分:响应行,响应头,响应体
状态码 错误描述
200 服务器处理成功
404 无法找到文件
500 内部服务器错误
403 服务器拒绝访问
301.302 请求重定向
400 无效的请求
401 未经过授权
503 服务器超负载或正停机维护,无法处理请求
ContentType的作用
1.ContentType决定浏览器采用何种方式对响应体进行处理
MIME类型 描述
text/plain 纯文本
text/html HTML文档
text/xml XML文档
application/x-msdownload 需要下载的资源
image/jpeg 图片资源
image/gif
image/…
请求转发与重定向
1.多个Servlet(JSP)之间跳转有两种方式
2.request.getRequestDispatcher().forward() -请求转发
3.response.sendRedirect() --响应重定向
请求转发
1.请求转发是服务器跳转,只会产生一次请求
2.重定向会产生两次请求
浏览器Cookie
1.Cookie(小甜饼) 是浏览器保存在本地的文本内容
2.Cookie常用于保存登录状态,用户资料等小文本
3.Cookie具有时效性,Cookie内容会伴随请求发送给Tomcat
Session–用户会话
1.Session(用户会话) 用于保存与"浏览器窗口"对应的数据
2.Session的数据存储在Tomcat服务器的内存中,具有时效性
3.Session通过浏览器Cookie的SessionId值提取用户数据
Session原理
ServletContext
1.ServletContext(Servlet上下文对象),是Web应用全局对象
2.一个Web应用只会创建一个ServletContext对象
3.ServletContext随着Web应用启动而自动创建
Java Web三大作用域对象
1.HttpServletRequest–请求对象 作用域范围一次递增
2.HttpSession–用户会话对象
3.ServletCotext-web应用全局对象
web.xml常用配置
1.错误页面
2.映射配置
JSP九大内置对象
内置对象 描述
request 请求对象-HttpServletRequest
response 响应对象-HttpServletResponse
session 用户会话-HttpSession
application 应用全局对象-ServletContext
out 输处对象-PrintWriter
page 当前页面对象-this
pageContext 页面上下文对象-PageContext
config 应用配置对象-ServletConfig
exception 应用异常对象-Throwable
EL表达式
1.EL(Expression Language)表达式语言,用于简化JSP的输出
2.EL表达式的基本语法:${表达式}
EL的作用域对象
1.EL表达式内置四种作用域对象
作用域对象 描述
pageScope 从当前页面取值
requestScope 从当前会话中获取属性值
sessionScope 从当前会话中获取属性值
applicationScope 从当前应用获取全局属性值
El表达式的输出
1.语法:${[作用域.]属性名[.子属性]}
2.EL表达式支持将运算结果进行输出
3.EL支持绝大多数对象输出,本质是执行toString()方法
EL输出参数值
1.EL表达式内置param对象来简化参数的输出
2.语法:${param.参数名}//可以代替request.getParameter
JSTL标签库
1.JSTL(JSP Standard Tag Library),JSP标准标签库
2.JSTL用于简化JSP代码开发,提高代码的可读性与可维护性
3.JSTL由SUN(Oracle)定义规范,由Apache Tomcat实现
JSTL的标签库种类
1.JSTL按功能规划可分为五类标签库
类别
核心标签库–core
格式化输出标签库–fmt
SQL操作标签库–sql
XML操作标签库–xml
函数标签库–functions
判断标签
1.JSTL核心库提供了两组判断的标签
2.<c:if>-单分支判断
3.<c:choose>、<c:when>、<c:otherwise> -多分支判断
fmt格式化标签库
1.fmt格式化标签库 URI:http://java.sun.com/jsp/jstl/fmt
2.<fmt:formatDate value="" pattern ="" >格式化日期标签
3.<fmt:formatNumber value = “” pattern ="">格式化数字标签
MVC模式
Servlet + JSP + JavaBena(MVC)---->复杂的web程序
控制层 视图层 模型层
处理用户请求 数据显示 数据封装
*****************接收表单中存在文件类型数据时的接收方式,request.getparameter不可以接收文件
//1.创建一个磁盘文件项工厂对象
DiskFileItemFactory diskFileItemFactory = new DiskFileItemFactory();
//2.创建一个核心解析类
ServletFileUpload servletFileUpload = new ServletFileUpload(diskFileItemFactory);
//3.解析request请求,返回的是List集合，List中存放的是Fileitem对象
List list= servletFileUpload.parseRequest(request);
//4.遍历集合,获得每个Fileitem对象,判断是表单项还是文件上传项
for (FileItem fileItem:list) {
//判断是否为表单项还是普通项
if (fileItem.isFormField()) {
//普通表单项
//接收表单项参数的值
fileItem.getFieldName();//获取表单项的name
fileItem.getString(“UTF-8”);//获取表单项Value的值
} else {
//文件上传项
//文件上传功能
}
}
文件读取固定代码
int len = 0;
byte[] b = new byte[1024];
while ((len = is.read(b)) != -1) {
os.write(b,0,len);
}
JSON
1.JavaScript Object Notation(JavaScript对象表示法)
2.JSON是轻量级的文本数据交换格式
3.JSON独立于语言,具有自我描述性,更易于理解
JSON语法规则
1.数据由键(key)值(value)描述,由逗号分隔
2.大括号代表一个完整的对象,拥有多个键/值对
3.中括号保存数组,多个对象之间使用逗号分隔
JSON与字符串互相转换
1.JSON.parse()方法将字符串装换为JSON对象
2.JSON.stringify()方法将JSON对象转换为字符串
@JSONField(format = “yyyy-MM-dd”)//对时间进行注释格式化
Calendar c = Calendar.getInstance();
c.set(2019, 0, 30, 0, 0, 0); 设置时间方式
employee.setHdate(c.getTime());
JSON和JAVA的交互
JSON.toJSONString将json进行序列化返回的是一个字符串
JSON.parseObject将JSON转换为JSON对象
JSON和JavaScript的交互
JSON.stringify()将json进行序列化返回的是一个字符串
JSON.parse()将JSON转换为JSON对象
document.getElementById //选中表单Id
$("#id") ID选择器,指定id元素的对象
$(“标签”) 元素选择器,选择指定标签名的选择器
$(".class") 类选择器,选中拥有指定css类的元素
$(“S1,S2,SN”) 组合选择器,对元素进行组合
层叠选择器
1.层叠选择器是根据元素的位置关系来获取元素的选择器表达式
语法 说明
$(“ancestor descendant”) 后代选择器
$(“ancestor>descendant”) 子选择器
$(“prev~siblings”) 兄弟选择器
属性选择器
1.属性选择器是根据元素的属性值来选择元素的选择器表达式
语法 说明
$(“selector[attribute=value]”) 选中属性值等于具体值得组件
$(“selector[attribute^=value]”) 选中属性值以某值开头的组件
(
"
s
e
l
e
c
t
o
r
[
a
t
t
r
i
b
u
t
e
("selector[attribute
("selector[attribute=value]") 选中属性值以某值结尾的组件
$(“selector[attribute*=value]”) 选中属性值包含某值得组件
$(“selector:first”) 获取第一个元素
$(“selector:last”) 获取最后一个元素
$(“selector:even”) 获取偶数位置的元素
$(“selector:odd”) 获取奇数位置的元素
$(“selector:eq(n)”) 获取指定位置的元素
attr() 获取或者设置元素属性
removeAttr(name) 移除元素属性
操作元素的CSS样式
1.css() 获取或设置匹配元素的样式属性
2.addClass() 为每个匹配的元素添加指定的类名
3.removeClass() 从所有匹配的元素中删除全部或者指定的类
设置元素内容
1.val() 获取或设置输入项的值
2.text() 获取或设置元素的纯文本
3.html() 获取或设置元素内部的HTML
jQuery事件处理方法
1.on(“click”,function) 为选中的页面元素绑定单机事件
2.click(function) 是绑定事件的简写形式
3.处理方法中提供了event参数包含了事件的相关信息
Ajax的使用流程
1.创建XmlHttpRequest对象
2.发送Ajax请求
3.处理服务器响应
1.XMLHttpRequest用于在后台与服务器交换数据,是AJAX的核心
2.XMLHttpRequest并不是W3C的标准,不同浏览器的创建方式不一样
处理服务器响应
1.xmlHttp.onreadystatechange() 事件用于监听AJAX的执行过程
2.xmlhtto.readyState属性说明XMLHttpRequest当前状态
readyState = 0 请求未初始化
readyState = 1 服务器连接已建立
readyState = 2 请求已被接收
readyState = 3 请求正在处理
readyState = 4 响应文本已被接收
获取响应体的文本
var responseText = xmlhttp.responseText;
jQuery对Ajax的支持
常用设置项 说明
url 发送请求地址
type 请求类型(get|post)
data 向服务器传递的参数
dataType 服务器响应的数据类型
text|json|xml|html|jsonp|script
success 接收响应时的处理函数
error 请求失败时的处理函数
-----------------------当id为lv1的属性发生改变时自动触发后面的function()函数
$(function () {
$("#lv1").on(“change” , function () {
var parent = $(this).val(); //可以接收当前id为lv1的表单选项发生改变时对应选项的value值
})
})
正则表达式语法规则
1.[abc] a,b或c（简单类）
2.[a-zA-Z]a到z或者A到Z，两头的字母包括在内（范围）
3.\d 数字 : [0-9]
4.X{n} X,恰好n次
5.X{n,} X,至少n次
6.X{n，m} X，至少n次，但是不超过m次
1.\D:非数字
2.\s:空白字符(如空格，\t,\n换行等)
3.\S:非空白字符（除了空白字符以外的其他都可以）
4.\w：单词字符:[a-zA-Z_0-9]
5.\W:非单词字符
matches方法的含义是将获取过来的值与想匹配的正则表达式相比较,满足返回true反之false
Java过滤器概述
过滤器的作用
1.实现对web资源请求的拦截，完成特殊的操作，尤其是对请求的预处理
JSP
Servlet 大部分过滤器会对请求做预处理的操作
Web 图片 常常会忽略过滤器也会对请求处理完成后的一个响应做出后处理的操作
文件
过滤器的应用场景
1.Web资源权限访问控制
2.请求字符集的编码处理
3.内容敏感字符词汇过滤
4.响应信息压缩 //响应后处理的应用
过滤器的工作流程图解
过滤器
请求预处理
客户端 响应后处理 servlet.service()
过滤器的生命周期
1.web应用程序启动时，web服务器创建Filter的实例对象，以及对象的初始化
2.当请求访问与过滤器关联的Web资源时，过滤器拦截请求，完成指定功能
3.Filter对象创建后会驻留在内存，在web应用移除或服务器停止时才销毁
4.过滤器的创建和销毁由WEB服务器实现
过滤器的实现步骤
1.编写java类实现Filter接口，并实现其doFilter方法
2.在web.xml文件中对filter类进行注册，并设置所拦截的资源
过滤器链
1.在一个web应用中，多个过滤器组合起来称之为一个过滤器链
2.过滤器的调用顺序取决于过滤器在web.xml文件中的注册顺序
引入表单样式css文件格式
1.注册过滤器
2.拦截映射配置CharacterEncodingFiter
config.getInitParameter(“charset”)//获取初始化参数
Servlet中使用load-on-startup配合 init能够在启动的时候就初始化init
response.sendError(404)//可以使当前页面变成404页面
ServletContext
Web Web
应用服务器 监听器 HttpSession
ServletRequest
Java监听器简介
java监听器定义
1.Servlet规范定义的一种特殊类
2.用于监听ServletContext，HttpSession，ServletRequest等的创建
，销毁及其属性修改发生变化的事件
3.监听器可以在事件发生前后进行一些必要的处理操作
常见应用场景
1.统计在线人数（监听Session会话的创建来统计有多少用户人数）
2.页面访问量的统计（监听Request的请求）
3.应用启动时完成信息初始化工作（）
4.与Spring结合
监听器的实现步骤
1.编写java类实现监听器接口，并实现其接口方法
2.在web.xml文件中对实现的监听器类进行注册
多个监听器启动顺序
1.监听器的启动顺序好在web.xml中配置的顺序一致当销毁是则是逆序
Java监听器分类
按监听对象
1.ServletContext对象监听器 主要监听上下文对象
2.HttpSession对象监听器主要监听会话对象
3.ServletRequest对象监听器主要监听请求对象
按监听事件
1.域对象自身的创建和销毁事件监听器
2.域对象中属性的创建，替换和消除事件监听器
3.绑定到session中的某个对象的状态事件监听器
getAttribute
HttpSession 对属性的变化做监听
setAttribute
单例模式:
1. 构造器的私有化 private LoginCache() {
}
2. 实例化一个本身的私有静态对象 private static LoginCache instance = new LoginCache();
3. 定义一个静态的方法返回实例化的对象 public static LoginCache getInstance() {
return instance;
}
session.invalidate();//将session会话中的信息进行清除,使其失效;
charAt方法可以返回指定索引位置的字符
Linux命令格式
关机/重启命令
关机:shutdown -h now
重启:shutdown -r now 或者 reboot
Linux目录结构
使用ls命令查看目录结构
Linux目录结构
/bin 命令存放目录 /opt 第三方软件放置目录
/boot 启动目录 /root 超级用户家目录
/dev 设备文件存放目录 /tmp 临时目录
/etc 配置文件存放目录 /sbin 命令存放目录
/lib 函数库存放目录 /proc 放置数据到内存
/home 普通用户家目录 /srv 服务存放数据目录
/mnt 系统挂载目录 /usr 系统软件资源目录
/media 媒体设备挂载目录 /var 系统相关文档内容目录
目录查看，切换，显示当前目录
目录查看:ls [-al] [文件或目录名称]
目录切换:cd [目录名称]
显示当前目录:pwd
路径格式
绝对路径:
从根目录/开始写起
相对路径:
当前目录 .
上级目录 …
家目录 ~
目录创建，删除
目录创建:mkdir [-p] 目录名称
目录删除:rmdir [-p] 目录名称
文件的创建
文件创建:touch 文件名称
文件编辑模式 vi 文件名
a在光标后插入 A在当前行之后插入
i在光标前插入 I在当前行之前插入
o在当前行之下插入 O在上一行插入
文件内容查看
cat 文件名称
文件的复制，移动，删除
复制：cp [-r] 来源文件 目标文件
移动：mv 来源文件 目标文件
删除：rm [-rf] 文件或目录
用户管理
查看：who
创建用户：useradd [-g 群组] 用户名
设置密码：passwd 用户名
删除用户:userdel [-r] 用户名
群组管理
查看群组:groups[用户名]
创建群组:groupadd群组名
删除群组:groupdel群组名
用户群组修改:usermod [-g 群组名] 用户名
权限，角色的作用
符号 权限 对文件的含义 对目录的含义
r 读权限 查看文件 查看目录
w 写权限 修改文件 修改目录内容
x 执行权限 执行文件 进入目录
权限，角色的设置
修改所有者：chown[-R] 用户名 文件或目录
修改所有者和组:chown[-R]用户名:组名 文件或目录
修改所属组:chgrp[-R] 组名 文件或目录
权限修改:chmod[-R] xyz 文件或目录
x所有者权限 y所属组权限 z其他用户权限
r:4 w:2 x:1 rwx数字总和即权限
JDBC连接数据库开发步骤
1.加载驱动
Class.forName("com.mysql.cj.jdbc.Driver");
2.获得连接
Connection conn=DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jdbctest?useSSL=false&serverTimezone=Hongkong&useUnicode=true&characterEncoding=utf-8","root", "password123123");
3.创建执行SQL语句的对象，并且执行SQL
//3.1创建执行sql对象
String sql = "select * from user";
Statement stmt=conn.createStatement();
//3.2执行sql语句
ResultSet resultSet=stmt.executeQuery(sql);
while(resultSet.next()) {
int uid=resultSet.getInt("uid");
String username=resultSet.getString("username");
String password=resultSet.getString("password");
String name=resultSet.getString("name");
System.out.println(uid+" "+username+" "+password+" "+name);
}
4.释放资源
resultSet.close();
stmt.close();
conn.close();
java的反射机制
--JAVA反射机制是在运行期间，对于任意一个类，都能够知道这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制
java会被编译成.class后缀的文件然后会被ClassLoader进行记载进JVM中运行(运行期间)
可以动态获得这个类中的属性和方法以及可以通过.class动态获取实例对象这就是反射
Java的反射机制的作用
-是用来编写一些通用性较高的代码或者框架的时候使用
Class
class类的实例表示正在运行的java应用程序中的类和接口
Constructor
关于类的单个构造方法的信息以及对它的访问权限
Field
Field提供有关类或接口的单个字段信息，以及对它的动态访问权限
Method
Method提供关于类或接口上单独某个方法信息
Java中java.lang.Class类用于表示一个类的字节码（.class）文件
如何得到某个class文件对应的Class对象
--已知类和对象的情况下
类名.class
对象.getClass()--Object类提供
--未知类和对象的情况下
Class.forName（“包名.类名”）
返回的都是Class对象 例：Class class1=Class.forName("com.imooc.demo.Person");
获得无参/带参构造直接用获得的字节码文件.getConstructor 返回的对象为Constructor然后调用Constructor的对象.newInstance进行实例化
例： Constructor c = class1.getConstructor();
Person person = (Person) c.newInstance();
有参 Constructor c = class1.getConstructor(String.class,String.class);
Person person = (Person) c.newInstance();
Spring的IOC的底层原地实现
ocp原则:open-close原则，对程序扩展是open的，对修改程序代码是close
尽量做到不修改程序的源码，实现对程序的扩展
工厂模式 + 反射+ 配置文件
配置文件<bean id="us" class="com.imooc.UserServiceImpl"/>
进行发射找到配置文件然后进行类的实例化
扫一扫
1109
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
