Java学习日记（个人记录 整篇）
配置环境与基本知识
-
Java程序运行机制及运行过程
1.Java虚拟机可以理解成一个以字节码为机器指令的CPU
2.对于不同平台的，有不同的虚拟机
3.Java虚拟机机制屏蔽了底层运行平台的差别，实现“一次编译，随处运行”
*.java文件编译生成 *.class文件然后在各个平台运行 -
垃圾收集
1.garbage collector
2.不在使用的内存空间应回收
3.Java语言替代了程序员回收无用内存空间的责任；提供了一种系统级线程跟踪存储空间的分配情况。并在JVM的空闲时，检查并释放哪些可被释放的存储器空间。
4.垃圾收集在Java程序运行过程中自动进行，程序员无法精确控制和干预. -
windows环境下的安装配置
1.安装JDK软件包
2.设置环境变量
我的电脑–>属性–>高级–>环境变量–>新建JAVA_HOME=JDK
编辑：path=在原来的path路径前增加JDK安装目录/bin
测试 运行cmd
java javac java -version 这三个命令都能运行，则安装成功 -
DJK安装目录树介绍
Bin 编译器和工具
Demo 演示
sample JDK自带的实例代码
Includ 用于编译本地方法的文件
Jre Java运行环境文件
Lib 类库文件
Src 类库源文件
2. Java Application初步
- Java源文件以“.`java”为扩展名，源文件的基本组成部分是类（class）。
- 一个源文件中最多只能有一个public 类。其它类的个数不限，如果源文件包含一个public 类，它必需按该类名命名。
- 一个源文件中最多只能有一个public 类。其它类的个数不限，如果源文件包含一个public 类，它必需按该类名命名。
- Java 语言中严格区分大小写。
- Java语言有三种注释方式：
1.// 用于单行注释
2./*
/用于多行注释
3./*
*
*/用于多行注释，且能被doc解析
3.Java SE之基础语法
- 标识符（Identifier）
- 关键字（Key word）
- Java 基本数据类型
- 运算符（Operator）
- 表达式和语句（Expression and Sentence）
- 分支（Filiation）
- 循环
- 方法（Method）
- 变量的作用域
- 数组
问题提问
为什么可以跨平台？
- 将java文件转换成class文件 各个平台已经安装了JVM 之后就可以识别class文件 所以可以实现跨平台。
Day1
- 标识符： 以字母开头或以_和$开头，后面可以是字母或者数字
- 类名标识符：第一个字母大写，其他字母小写，第二单词字母大写
- main方法名标识符，第一个字母小写，其他字母小写，第二单词字母大写
- args 变量标识符，第一个字母小写，其他字母小写，第二单词字母大写
强制类型转换，谁转换谁负责（转换会不会溢出）
8种基本数据类型
-
数字类型
1.整数 byte 8位 short 16位 int 32位 long 64位
2.浮点数 float 32位 double 64位 -
布尔类型 boolean
-
字符类型 char
-
其余的为引用类型 类（class）；接口（interface）；数组等。
运算符
-逻辑运算符: &&（短路与），第一条件为false，后边不运行
&（与），第一条件为false，后边还会运行
||（短路或），第一条件为true，后边不运行
|（或），第一条件为true，后边还会运行
循环
- 1.要有初始化的值
- 2.有一个条件判断，能够进入循环
- 3.修改条件的语句,最终能退出循环
循环（均有初始化的值）
1.for 容易确定循环次数
2.do while 先做后循环
3.while
数组
- 1.同种类型放一起
- 2.不变性，确定好数组个数之后，不可以再扩展长度
- 3.会进行初始化 数字类型为0,char为 ‘’,boolean为false; 引用类型为null
Day2
叙述
学生管理系统，来管理学生
现实生活中存在的对像（学生，老师，宿舍）
-
观察—》抽取—》现实生活中存在的对像（看得到的，摸得到，能描述的）–
分类–，抽像出这个类别的行为、特征----
学生类别
｛
姓名 特征
年纪 特征
学习行为（） 行为
｛
｝java
class Student
{
String name; 属性
int age;属性
public void show() 方法
{
system.out.println(“我叫”+name);
}
}写类不是最终的目的，
new Student(“张三”，10)；
new Student(“张1”，12)；
new Student(“张2”，10)；
new Student(“张3”，10)；
二维数组
1.二维表数组
2.数组的数组
类
类就是一个模板，有了这个模板才能创建对象。
抽象的数据类型，用来描述某一类具有相同特性的对象。
封装
-隐藏实现细节
-为用户提供统一界面（get（）和set（）方法）
-增强可维护性
- 1.一般类中的方法提供private属性，public方法
2. 提供无参构造方法
this：指向当前类的对象
构造方法
- 每个类都有构造方法。
- 如果程序员在定义类时没有定义构造方法的话，Java将自动为该类添加一个公开的空参空实现的构造方法。
如果定义了一个有参数的构造方法的时候，要自己再定义一个无参的构造方法。
方法调用
- 方法直接允许相互调用，不需要知道对方方法的具体实现，提高了效率。
- 1.类Student 的方法a()调用Student类的方法b()，直接调用
- 2.类Student的方法a()调用类Teacher的方法b()，先创建类对象，然后使用“.”调用
方法的重载
- 重载，它是一种静态多态（在生成.class文件时，已确定了调用哪个方法）
- 在一个类内部，方法名相同
- 参数类型一定不同
- 返回值可以相同也可以不同
----方法的重载是一种静态的重载----
构造器
- 构造器就是和类名相同但无返回类型的方法。用于当前或某一对象的实例化，并将当前或某一对象返回。要得到一个类的实例时，往往是要运行其构造函数的。
交换
- 完成两个数的交换
- 基本数据类型，完成的是值的传递
- 参数是引用类型，它传的是地址
代码如下:
/**
* 学生的姓名，年龄
* @author FDL
*
*/
public class Student {
private String name;
private int age;
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
/**
* 构造方法重载，无参
*/
public Student() {
super();
}
/**
* 构造方法重载，有参
*/
public Student(String name, int age) {
super();
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) {
getAge();
this.age = age;
}
}
/**
* 测试交换
* @author FDL
*
*/
public class TestStudent {
public static void main(String[] args) {
Student stu=new Student("王为峰", 12);
TestStudent testStudent=new TestStudent();
testStudent.change(stu);//也就是stu和stu2指向同一片内存区域,当stu2改变值 时，stu在取值就得到改变后的值
System.out.println(stu);
System.out.println();
}
public void change(Student stu2) //对像方法, 参数是引用类型，它传的是地址，也就是stu和stu2指向同一片内存区域
{
stu2.setName("wangwei_feng");
stu2.setAge(21);
}
}
第二天作业分析
动物特性的面向对象描述项目
一．问题描述
- 1.狗生活在陆地上（是一种陆生动物），既是哺乳类的也是肉食性的。狗通常的时候和人打招呼会通过“摇摇尾巴”，在被抚摸感到舒服的时候，会“旺旺叫”，而在受到惊吓情绪烦躁时，会发出“呜呜”声；
- 2.猫也生活在陆地上（是一种陆生动物），既是哺乳类的也是肉食性的。猫通常的时候和人打招呼会发出“喵～”的声音，在被抚摸情绪很好时，会发出“咕噜咕噜”声，而在受到惊吓时，会发出“嘶嘶”声；
- 3.青蛙是一种两栖动物（既是水生动物也是陆生动物），既不是哺乳类的也不是肉食性的，属于卵生。当青蛙情绪好的时候，会在岸边“呱呱呱”的唱歌，而在受到惊吓时，会“扑通一声跳入水中”；
二．问题分析
1.首先需要抽取问题描述中对象
2.分析每个对象所具有的特征
3.分析每个对象所发出的动作
4.从这些对象的特征中，抽取类的属性和方法
5.分析类之间的关系，画出类结构图
三．难点分析
抽象类和对象的基本方法：
- 1.抽取对象的基本的方法：找出句子中所使用的名词
例如：在句子“小猫喵喵叫”中，我们能够确定一个对象：猫； - 2.确定对象发出的行为动作的基本的方法：找出句子中的动词
例如：“旺旺叫”、“喵喵叫”都属于对象发出的动作； - 3.确定对象的属性或者特征的基本的方法：找出句子中的形容词
例如：“水生的”“陆生的”“两栖的”等等； - 4.“是”的关系一般抽象为继承
例如：狗是一种动物，意味着：“狗”类 继承自“动物”类； - 5.“有”的关系一般抽象为类的属性
例如：动物都有情绪，意味着：“情绪”是“动物”类的一个属性；
代码如下:
Animal.java
package FDL02;
public abstract class Animal {
protected boolean mammal=true; // 哺乳动物
protected boolean carnivorous=true; //食肉动物
public static final int scared=0; //情绪不好
public static final int comforted=1; //情绪好
protected int mood=comforted;
public boolean ismammal() {
return (mammal);
}
public boolean iscarnivorous() {
return (carnivorous);
}
abstract String SayHello();
abstract String SayHello(int moodval);
public void setMood(int newValue)
{
mood=newValue;
}
public int getMood()
{
return(mood);
};
}
LandAnimal.java
package FDL02;
public interface LandAnimal {
public int getNumberOfLegs();
}
WaterAnimal.java
package FDL02;
public interface WaterAnimal {
public boolean isGillFlag();//返回是否有腮
public boolean isLaysEggs();//返回是否产卵
}
Cat.java
package FDL02;
public class Cat extends Animal implements LandAnimal{
private int numberOfLegs = 4;
public String SayHello() {
return "喵喵叫";
};
public String SayHello(int moodval) {
this.setMood(moodval);
switch (mood) {
case scared:
return ("嘶嘶");
case comforted:
return ("咕噜咕噜");
}
return ("喵喵叫");
}
public int getNumberOfLegs() {
return numberOfLegs;
}
}
Dog.java
package FDL02;
public class Dog extends Animal implements LandAnimal{
private int numberOfLegs = 4;
public String SayHello() {
return "摇摇尾巴";
};
public String SayHello(int moodval) {
this.setMood(moodval);
switch (mood) {
case scared:
return ("呜呜叫");
case comforted:
return ("汪汪叫");
}
return ("摇摇尾巴");
}
public int getNumberOfLegs() {
return numberOfLegs;
}
}
Frog.java
package FDL02;
public class Dog extends Animal implements LandAnimal{
private int numberOfLegs = 4;
public String SayHello() {
return "摇摇尾巴";
};
public String SayHello(int moodval) {
this.setMood(moodval);
switch (mood) {
case scared:
return ("呜呜叫");
case comforted:
return ("汪汪叫");
}
return ("摇摇尾巴");
}
public int getNumberOfLegs() {
return numberOfLegs;
}
}
Main.java
package FDL02;
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Dog dog = new Dog();
Cat cat = new Cat();
Frog frog = new Frog();
System.out.println("~欢迎光临动物园~ ");
for (;;) {
System.out.println("请输入动物名称：dog，cat或者frog ，退出exit！");
String name = new String();
@SuppressWarnings("resource")
Scanner sc = new Scanner(System.in);
name = sc.next();
switch (name) {
case "dog":
System.out
.println("该动物是陆生动物，它有" + dog.getNumberOfLegs() + "条腿");
System.out.println("狗通常情况下，跟人的打招呼方式为：" + dog.SayHello());
break;
case "cat":
System.out
.println("该动物是陆生动物，它有" + cat.getNumberOfLegs() + "条腿");
System.out.println("猫通常情况下，跟人的打招呼方式为：" + cat.SayHello());
break;
case "frog":
if (frog.isLaysEggs() && frog.isGillFlag())
System.out.println("该动物是陆生动物，它有" + frog.getNumberOfLegs()
+ "条腿。" + "有腮" + "," + "产卵");
System.out.println("青蛙通常情况下，跟人的打招呼方式为：" + frog.SayHello());
break;
case "exit":
System.out.println("再见！");
System.exit(0);
default:
System.out.println("输入有误 ！请重新输入！");
}
System.out.println("请输入动物的心情：1-心情好，2-心情不好");
int i;
@SuppressWarnings("resource")
Scanner sc1 = new Scanner(System.in);
i = sc1.nextInt();
switch (i) {
case 1:
System.out.println("它心情是：心情好");
break;
case 2:
System.out.println("它心情是：心情不好");
break;
default:
System.out.println("输入有误 ！请重新输入！");
}
switch (name) {
case "dog":
if (i == 1) {
System.out
.println("狗心情好：" + dog.SayHello(Animal.comforted));
} else if (i == 2) {
System.out.println("狗心情不好：" + dog.SayHello(Animal.scared));
} else {
System.out.println("输入错误！");
}
break;
case "cat":
if (i == 1) {
System.out
.println("猫心情好：" + cat.SayHello(Animal.comforted));
} else if (i == 2) {
System.out.println("猫心情不好：" + cat.SayHello(Animal.scared));
} else {
System.out.println("输入错误！");
}
break;
case "frog":
if (i == 1) {
System.out.println("青蛙心情好："
+ frog.SayHello(Animal.comforted));
} else if (i == 2) {
System.out
.println("青蛙心情不好：" + frog.SayHello(Animal.scared));
} else {
System.out.println("输入错误！");
}
break;
default:
System.out.println("输入有误 ！请重新输入！");
break;
}
}
}
}
Day3
继承
- 是 “is a”的关系
- 声明的形式
- public class Manager extends Employee{…0}
- Java是一个单一继承的语言(一个类只有一个直接父类，如果没有声明父类，则默认的父类为java.lang.Object)
### 注释: ###
- 1.构造方法不能被继承
- 2.属性和方法可以继承
- 3.子类的构造方法隐含的调用父类的默认构造方法
- 4.如果父类中没有默认的构造方法，则应该在子类的构造方法的第一行明确的声明调用父类中其他的构造方法。如下形式：
super(…)
super关键字的应用
- 代表指向父类的引用
- super.age //调用父类的属性
- super.addAge() //调用父类的方法 - 代表调用父类的构造方法
- super();
- super(“wangcai”,8);
继承条件创建对象
- 当构造一个对象的时候，系统先构造父类对象，再构造子类对象。
- 构造一个对象的顺序：（注意：构造父类对象的时候也是这几步）
注释
- 递归地构造父类对象；
- 顺序地调用本类成员属性赋初值语句；
- 本类的构造方法。
类型转换
- is instanceof 用来判断指定的对象是否是当前类的对象
- 子类对象可以隐含扩展为父类型
- Student stu = new Student();
- Person p= stu;
- Person p1=new Teacher();
- 父类型必须明确声明转化为子类型
- Student stu1 =(Student)p;//转换者必须确定p指向的就是学生才可以转换
- 不是所有的父类型对象都能转化为子类型
- Teacher t=(Teacher)p1;√
- Teacher t=(Teacher)p; ×
- 子类对象可以隐含扩展为父类型
强制转换：谁转换谁负责
对父类方法进行重写（覆盖）–>多态（动态多态即运行时结果多态）
- 加上override，编译器会进行检查是否被重写
- 1.一定有两个类，这两个类有继承关系
- 2.子类对父类中的进行重新编写，方法的名称要相同，参数个数、类型也要相同
注释
- 重写方法的时候，子类的权限要比父类更开放。
静态变量（类变量）
- 一个类只有一份，被类的所有实例共享
- 能在没有生成任何类的实例时就被访问到
- 在某种意义上类似于全局变量
- 直接使用类名来访问
静态方法（类方法）
- 可以在没有任何实例时调用
- 不能再static方法内部访问非static成员
- 不能被非static方法覆盖
静态块
- 使用static声明的代码块，称为静态块，静态块主要目的是为静态属性进行初始化。
final关键字
- final用来修饰一个类,方法,属性或局部变量
- final类不能被继承
- final方法不能被覆盖
- final变量的值不能被改变
static final 就相当于常量
抽象类
- 抽象类他的存在就是给子类去继承实现的 （is a）。
- 如果一个方法没有实现的代码，那么它必须被声明为抽象的方法。
- 如果一个类包含有抽象方法，那么它必须被声明为抽象类。
- 抽象类不能实例化----不能生成对象。
- 可以定义一个抽象类的引用。
Day4 11.4
面向接口编程
- 开发系统时，主体构架使用接口，接口构成系统的骨架
- 这样就可以通过更换接口的实现类来更换系统的实现
例子
1.Introduceable.java
访问权限控制
- public
- 类内可以访问
- protected
- default（no modifier）
- private
Object类和String类
比较两个数的值
- == 引用类型比较的是地址
- equals（自动生成） 内容比较
字符符串转数字
如果您要将输入的字符串转换为整型、浮点数等等数据类型，您可以使用以下各包装类别所提供的各个静态剖析方法：
- Byte.parseByte(字符串) 将字符串剖析为位元
- Short.parseShort(字符串) 将字符串剖析为short整型
- Integer.parseInt(字符串) 将字符串剖析为integer整型
- Long.parseLong(字符串) 将字符串剖析为long整型
- Float.parseFloat(字符串) 将字符串剖析为float浮点数
- Double.parseDouble(字符串) 将字符串剖析为double浮点数
注意
如果指定的字符串无法剖析为指定的数据类型数值，则会发生NumberFormatException异常。
Character字符包装类的常用方法
- static boolean isDigit(char ch)
- 确定指定字符是否为数字
- static boolean isLetter(char ch)
- 确定指定字符是否为字母。
- static char toLowerCase(char ch)
- 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为小写。
- static char toUpperCase(char ch)
- 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为大写。
- static Character valueOf(char c)
- 返回一个表示指定 char 值的 Character 实例。
String类
推荐使用equals比较string类型的 不推荐使用==
- Java中为了给String对象提高效率，所以就为String类提供了字符串池。在StringTest1中就使用了串池。当你重新声明一个String型变量为abc时，将使用串池里原来的那个abc，而不重新分配内存。在str3和str4中使用了普通对象的声明方式，即new关键字，系统将会为str3和str4各分配一块内存。
代码如下：
public class StringTest1{
public static void main(String[] args) {
String str1 = "abc";
String str2 = "abc";
System.out.println(str1 == str2);
String str3 = new String(“abc");
String str4 = new String(“abc");
System.out.println(str1 == str3);
System.out.println(str3 == str4);
}
}
string、stringBuilder与stringBuffer区别
- 字符修改上的区别
- string：不可变字符序列
- stringBuffer 可变字符序列、效率低、线程安全
- stringBuilder 可变字符序列、效率高、线程不安全用（更多使用）
- 初始化上的区别
- String可以赋空值，后者不行
- (1)如果要操作少量的数据使用String
- (2)多线程操作字符串缓冲区下操作大量数据用StringBuffer；
- (3)单线程操作字符串缓冲区下操作大量数据用StringBuilder。
date类(日期转换)
- 日期格式化输出 SimpleDateFormat
- java.text.SimpleDateFormat sdf =new SimpleDateFormat(“yyyy-MM-dd hh:mm:ss”);
- (date -> text)
代码
DateTest.java
public class DateTest {
public static void main(String[] args) {
//java.util.Date utilDate;
//java.sql.Date sqlDate;
//得到系统当前时间日期
java.util.Date utilDate =new Date();
System.out.println(utilDate);
//得到日期格式化类
java.text.SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd HH:mm:ss");
String strDate=sdf.format(utilDate); //完成将java.util.Date转成字符串
System.out.println(strDate);
String sDate="2019年11月04 16:12:01";
java.util.Date strToDate=null;
try {
//用日期格式化类将字符串转java.util.Date
strToDate=sdf.parse(sDate);
System.out.println(strToDate);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//java.util.Date utilDate;
long longDate=strToDate.getTime();
System.out.println(longDate);
//将java.sql.Date转java.util.Date
java.sql.Date d=new java.sql.Date(longDate);
//java.util.Date转java.sql.Date
java.util.Date dd=new java.util.Date(d.getTime());
}
}
运行结果
Tue Nov 05 08:49:26 CST 2019
2019年11月05 08:49:26
Mon Nov 04 16:12:01 CST 2019
1572855121000
2019-11-04
Mon Nov 04 16:12:01 CST 2019
更新日期：2019/11/5 星期二 9:06:07
Day5 11.5
集合(面试比重大)
Set集合
- set
- HashSet() 无序列表 如果放入自定义的类，必须重写hashCode()和equals()方法
- TreeSet() 有序列表 使用***自定义类*** 时，必须重写hashCode()和equals()方法，还要在类里实现比较器接口Compareble
代码
public int compareTo(Object o) {
//将此对象与指定的对象进行比较以进行排序。
//返回一个负整数，零或正整数，因为该对象小于，等于或大于指定对象。
Student stu=(Student)o;
int i=0;
if(this.age==stu.age)
{i=0;}
if(this.age>stu.age)
{i=1;}
if(this.age注释
set可以放一个null，但是不能够放入重复的元素
List
- List（采用线性列表的存储方式，长度可动态改变）
- ArrayList
- ArrayList类是List接口的一个具体实现类
- ArrayList 对象实现了可变大小的数组
- 随机访问和遍历元素时，它提供更好的性能
- LinkedList(链接列表)
- 调用remove方法会调用equals方法 来找到内容相同的元素 完成删除
注释
- 具有顺序的集合
- 元素可以通过其整型下标访问
- 可以包含重复元素
Map 映射(键值对形式)
- Map（采用键-值对的存储方式，长度可动态改变）
- HashMap 不考虑线程安全 都是先put值 在entrySet() 最后foreach遍历输出
- HashTable 线程安全
注释
- Map(K,V) K值相同时 会覆盖之前的值
注释:一个类只做一件事情 去写代码
作业
- 1．使用集合ArrayList存放如下的联系地址信息, 并打印输出
- 提示:
- 1)定义描述地址信息的类Address, 并重写toString()方法
- 2)构建集合 List addressList = new ArrayList();
代码如下
Address.java
/**
*
* @author FDL
*
*/
public class Address {
private String name;
private String street;
private String city;
private String province;
private String country;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getStreet() {
return street;
}
public void setStreet(String street) {
this.street = street;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
@Override
public String toString() {
return "[\n姓名:" + name + "\n街道:" + street + "\n市(县):" + city
+ "\n省(自治区):" + province + "\n国家(地区):" + country + "\n]";
}
public Address(String name, String street, String city, String province,
String country) {
super();
this.name = name;
this.street = street;
this.city = city;
this.province = province;
this.country = country;
}
public Address() {
super();
}
}
TestAddress.java
import java.util.ArrayList;
import java.util.List;
public class TestAddress {
public static void main(String[] args) {
List addressList =new ArrayList();
Address a1=new Address("张三", "王府井", "北京", "北京", "中国");
Address a2=new Address("李四", "张扬路", "上海", "上海", "中国");
Address a3=new Address("John lenon", "12 Park Avenue", "California", "CaliforniaState", "USA");
addressList.add(a1);
addressList.add(a2);
addressList.add(a3);
for (Address address : addressList) {
System.out.println(address);
}
}
}
运行结果：
-
2．构建描述学生的类Student, 属性：姓名和年龄
构建集合来存放学生对象信息，但要保证学生的年龄按大小顺序进行排序
最后遍历输出格式如下图所示
-
提示:
- 1）使用Set来存放
- 2）对于Student类要实现Comparable 接口
代码如下
Student2.java
public class Student2 implements java.lang.Comparable{
private String name;
private int 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;
}
public Student2(String name, int age) {
super();
this.name = name;
this.age = age;
}
public Student2() {
super();
}
@Override
public String toString() {
return " " + name + " " + age + " ";
}
@Override
public int compareTo(Object o) {
//将此对象与指定的对象进行比较以进行排序。
//返回一个负整数，零或正整数，因为该对象小于，等于或大于指定对象。
//基础是二叉树
Student2 stu=(Student2)o;
//由大到小排列
int i=0;
if(this.age==stu.age) //不处理
{
i=0;// 相等 不处理
}
if(this.agestu.age)
{
i=-1;//大于 往左放
}
return i;
}
}
TestStudent2.java
import java.util.HashMap;
import java.util.Map.Entry;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
public class TestStudent2 {
public static void main(String[] args) {
TreeSet tree = new TreeSet();
tree.add(new Student2("Linda", 21));
tree.add(new Student2("Mary", 28));
tree.add(new Student2("John", 26));
tree.add(new Student2("Tom", 25));
tree.add(new Student2("Jack", 24));
tree.add(new Student2("Lisa", 22));
show(tree);
}
public static void show(Set set) {
System.out.println("---------------------------");
System.out.println(" 姓名年龄");
for (Student2 s : set) {
System.out.println("---------------------------");
System.out.println(s);
}
System.out.println("---------------------------");
}
}
运行结果
Day6 2019.11.6
异常处理
- try 执行可能产生异常的代码
- catch 捕获异常
- finally 无论是否发生异常，代码总能执行 一般用来完成资源的释放
- throw
- throws
Java异常类
- Exception
- RuntimeException
- FileNotFoundException
- IOExceotion
- NullPointerException
- NumberFormatException
- InputMismatchException
多重的catch块
根据异常的类型，抛出不同类型的异常
练习
TryCatchTest.java
import java.util.InputMismatchException;
import java.util.Scanner;
public class TryCatchTest {
public static void main(String[] args) {
System.out.println("请输入1-5之间的数字进行选课:");
Scanner in=new Scanner(System.in);
try{
int courseCode =in.nextInt();//从键盘输入数
switch (courseCode) {
case 1:
System.out.println("C语言");
break;
case 2:
System.out.println("J2EE");
break;
case 3:
System.out.println("数据库");
break;
case 4:
System.out.println("计算机网络");
break;
case 5:
System.out.println("JSP");
break;
}
}catch(InputMismatchException e){
System.out.println("输入类型不对，请输入数字！");
System.out.println("发生错误:"+e);
}catch(Exception e){
System.out.println("发生错误:"+e.getMessage());
e.printStackTrace();
}finally{
System.out.println("结束");
}
}
}
throw 抛出异常##
如果在当前环境无法解决一个异常，就要将其抛出，把异常交给调用者处理
- 向外抛出一个运行时异常
- 向外抛出一个非运行时异常，需要声明方法有异常 方法定义
throws 声明异常##
- 1.声明该方法可能会产生异常
- 2.由调用者捕获异常
method constructor
- method.invoke（）;//调用这个方法 传入对象参数和要对这个对象设置的值
- constructor.newInstance();
Day7 2019.11.7
关系型数据库
查询(sql)
-
1.select 列名(此时不区分大小写) from 表名;
-
注释
- 连接两个列名要用 || 进行连接
- as 可以更改查询后的列名(as可以省略)
- nvl（列名，0） --如果该列为null 设为默认值为0；
- DISTINCT 用来去除重复项
-
2.条件查询
- select 列名1 ，列名1 from 表名 where 条件1 and(or) 条件2；
- 查询内容时 要用单引号扩住 '内容’
- in（ ） 指定查询若干个满足条件的数据
- 查询空值时 条件要用 is null
-
3.排序
- 排序 order by 列名 （默认升序ASC 也可以降序 DESC 大小写不区分） 一般放在最后
Day7 2019.11.7
查询(sql)
-
1.select 列名(此时不区分大小写) from 表名;
-
注释
- 连接两个列名要用 || 进行连接
- as 可以更改查询后的列名(as可以省略)
- nvl（列名，0） --如果该列为null 设为默认值为0；
- DISTINCT 用来去除重复项
-
2.条件查询
- select 列名1 ，列名1 from 表名 where 条件1 and(or) 条件2；
- 查询内容时 要用单引号扩住 '内容’
- in（ ） 指定查询若干个满足条件的数据
- 查询空值时 条件要用 is null
-
3.排序
- 排序 order by 列名 （默认升序ASC 也可以降序 DESC 大小写不区分） 一般放在最后
单行函数
- Character函数
- lower 将字符串转换成小写
- upper 将字符串转换成大写
- initcap 将字符串的第一个字母变为大写
- concat 拼接两个字符串 与||相同
- substr 取子符串的子串
- length 以字符给出字符串的长度
- nvl 以一个值来替换空值
- Number函数
- toNumber（） 将字符串转换为number类型
- Date函数
- toDate（） 将字符串转换为date类型
数字函数
- round（value,precision） 按precision精度4舍5入
- trunc（value,precision） 按precision截取value
日期函数
- months_between（date2，date1） 给出date2-date1的月数
- add_months 增加或减去月数
- next_day(date,’ day’) 给出date日期后的 day天
转换函数
- 将日期转换成字符串
- select to_char(sysdate,‘yyyy-MM-dd’) from dual;
- 用下列格式显示字符为数字：
- 9 代表一个数字.
- 0 显示前缀零.
- $ 根据本地语言环境显示货币.
- L 采用当地货币符号
- . 打印一个小数点.
- , 千位计算法显示.
连接
内连接
- 方式一 笛卡尔积方式连接
- select 列名 1,列名2 from 表1, 表2 where 表1.外键列=表2.主键列
- 方式二
- select 列名1 from 表1 inner join 表2 on 表1.外键列=表2.主键列
外连接
- 左外连接
- left join 或者(+)放在where条件=的右边
- 表示左表中的数据一定会出现在结果中
- 右外连接 表示右表中的数据一定会出现在结果中
- right join 或者(+)放在where条件=的左边
- 表示右表中的数据一定会出现在结果中
Day8 2019.11.8
聚合函数
- AVG (DISTINCT|ALL|n)
- COUNT (DISTINCT|ALL|expr|*)
- MAX (DISTINCT|ALL|expr)
- MIN (DISTINCT|ALL|expr)
- SUM (DISTINCT|ALL|n)
groupBy
- selcet后只能放 group by 后的 分组列或者聚合函数
语法格式
SELECT column, group_function
FROM table
[WHERE condition]
[GROUP BY group_by_expression]
[HAVING group_condition]
[ORDER BY column];
JDBC
JDBC工作原理
-
JDBC API 供程序员调用的类和接口被包装在java.sql中如
DriverManager类 Connection接口 Statement接口 ResultSet接口 -
DriverManager（作用：载入不同的JDBC驱动）
-
JDBC驱动（作用：负责连接各种不同的数据库）
连接数据库
- JDBC中通过提供DriverManager类和Connection对象实现数据库的连接。
- 使用TYPE 4与数据库连接
注释
DriverManager ：依据数据库的不同，管理JDBC驱动
Connection ：负责连接数据库并担任传送数据的任务
Statement ：由 Connection 产生、负责执行SQL语句
ResultSet：负责保存Statement执行后所产生的查询结果
DriverManager
- DriverManager 类是JDBC 的管理层，作用于用户和驱动程序之间。
- 它跟踪可用的驱动程序，并在数据库和相应驱动程序之间建立连接。
- 该类负责加载、注册JDBC驱动程序，管理应用程序和已注册的驱动程序的连接。
StateMent
-
Statement接口用于执行不带参数的简单SQL语句，用来向数据库提交SQL语句交返回SQL语句的执行结果。
-
创建一个Statement接口的一般形式如下：
Connectioncon=DriverManager.getConnection(URL,“user”,“password”);
con=DriverManager.getConnection(URL,“user”,“password”)
执行语句
- 创建了Statement接口的实例后，可调用其中的方法执行SQL语句，JDBC中提供了三种执行方法:
- execute()、executeQuery()和executeUpdate()。
- executeUpdate()：执行insert update 和 delete语句
- executeQuery()： 执行select语句。它的返回值是执行SQL语句后产生的一个ResultSet接口的实例(结果集)
- execute()：一般是在用户不知道执行SQL语句后会产生什么结果或可能有多种类型的结果产生时才会使用。execute()的执行结果包括如下两种情况：
- 1.包含多个ResultSet（结果集）；
-
- 多条记录被影响；
ResultSet接口
- ResultSet 对象包含了Statement和PreparedStatement的executeQuery方法中SELECT查询的结果集，即符合指定SQL 语句中条件的所有行。
ResultSet 提供检索不同类型字段的方法，常用的有：
- getString(int index)、getString(String columnName)：获得在数据库里是 varchar、char 等类型的数据对象。
- getFloat(int index)、getFloat(String columnName)：获得在数据库里是 Float 类型的数据对象。
- getDate(int index)、getDate(String columnName)：获得在数据库里是 Date 类型的数据。
- getBoolean(int index)、getBoolean(String columnName)：获得在数据库里是 Boolean 类型的数据。
- getObject(int index)、getObject(String columnName)：获取在数据库里任意类型的数据。
ResultSet 还提供了对结果集进行滚动的方法：
- next()：移动到下一行 结果集一般是一个表，其中有查询所返回的列标题及相应的值。
- Previous()：移动到前一行
- absolute(int row)：移动到指定行
- beforeFirst()：移动 resultSet 的最前面。
- afterLast() ：移动到 resultSet 的最后面。
- 使用后依次关闭对象及连接：ResultSet → Statement → Connection
执行代码
public class TestJdbc {
public static void main(String[] args) {
// 1.准备好数据库的连接字符串
String url = "jdbc:oracle:thin:@192.168.1.126:1521:xe";
String driClass = "oracle.jdbc.OracleDriver";
String userName = "fdl";
String userPwd = "fdl";
// 2.在创建的项目里添加驱动类
Connection conn = null;
try {
// 3.将加驱动类加载到内存中
Class.forName(driClass);
// 4.w使用驱动管理类来管理,可以通过驱动管理类来得到连接对像
conn = DriverManager.getConnection(url, userName, userPwd);
// 5,使用连接对像，得到处理器
Statement stat = conn.createStatement();
// 6 使用处理器,来发送sql语句
// stat.executeUpdate(sql) insert update delete 用这个，返加一个int影响的行数
// stat.executeQuery(sql) select语句，返回一个结果集
String insertSql="insert into student(stuNo,stuName,stuBirthday,stuAddress,stuSex) values(SNO.NEXTVAL,'bbb','6-11月-19','巢湖','女')";
//String insertSql = "delete student where stuname='bbb'";
int i = stat.executeUpdate(insertSql);
if (i > 0) {
System.out.println("insert ok");
} else {
System.out.println("insert ng");
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
Day9 2019-11-11
PreparedStatement
PreparedStatement接口是Statement接口的子接口，它直接继承并重载了Statement的方法。
-
创建PreparedStatement对象形式如下
- String sql=" ";
- PreparedStatement pre=con.prepareStatement(sql);
-
输入参数的赋值
PreparedStatement中提供了大量的setXXX方法对输入参数进行赋值。根据输入参数的SQL类型应选用合适的setXXX方法。
JDBC的工具类
数据库连接类（oracle）
代码如下：
package com.fdl.common;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class ConnectionManage {
public static java.sql.Connection getConn()
{
String url="jdbc:oracle:thin:@192.168.1.126:1521:xe";
String driClass="oracle.jdbc.OracleDriver";
String userName="fdl";
String userPwd="fdl";
Connection conn=null;
try {
Class.forName(driClass);
conn = DriverManager.getConnection(url, userName, userPwd);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return conn;
}
public static void closeConn(java.sql.Connection conn)
{
if(conn!=null)
{
try {
if(!conn.isClosed())
{
conn.close();
}
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
日期转换格式类
代码如下：
package com.fdl.common;
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
public class Tools {
//SQL类型的Date转化为String类型的
public static String fmtDateToString(java.sql.Date sqlDate)
{
java.util.Date uDate= fmtDateToUtilDate(sqlDate);
java.text.SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd");
return sdf.format(uDate) ;
}
//SQL类型的Date转化为Util类型的Date
public static java.util.Date fmtDateToUtilDate(java.sql.Date sqlDate)
{
return new java.util.Date(sqlDate.getTime());
}
//Util类型的Date转化为SQL类型的Date
public static java.sql.Date fmtDateTosqlDate(java.util.Date lDate)
{
return new java.sql.Date(lDate.getTime());
}
}
分层模型类
例子：Student的增删改查
pojo
代码如下：
package com.fdl.pojo;
import java.util.Date;
public class Student {
private int stuNo;
private String stuSex;
private String stuAddress;
private String stuName;
private Date stuBirthday;
public int getStuNo() {
return stuNo;
}
public void setStuNo(int stuNo) {
this.stuNo = stuNo;
}
public String getStuSex() {
return stuSex;
}
public void setStuSex(String stuSex) {
this.stuSex = stuSex;
}
public String getStuAddress() {
return stuAddress;
}
public void setStuAddress(String stuAddress) {
this.stuAddress = stuAddress;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public Date getStuBirthday() {
return stuBirthday;
}
public void setStuBirthday(Date stuBirthday) {
this.stuBirthday = stuBirthday;
}
public Student(int stuNo, String stuSex, String stuAddress, String stuName, Date stuBirthday) {
super();
this.stuNo = stuNo;
this.stuSex = stuSex;
this.stuAddress = stuAddress;
this.stuName = stuName;
this.stuBirthday = stuBirthday;
}
public Student() {
super();
}
@Override
public String toString() {
return "Student [stuNo=" + stuNo + ", stuSex=" + stuSex + ", stuAddress=" + stuAddress + ", stuName=" + stuName
+ ", stuBirthday=" + stuBirthday + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((stuAddress == null) ? 0 : stuAddress.hashCode());
result = prime * result + ((stuBirthday == null) ? 0 : stuBirthday.hashCode());
result = prime * result + ((stuName == null) ? 0 : stuName.hashCode());
result = prime * result + stuNo;
result = prime * result + ((stuSex == null) ? 0 : stuSex.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
if (stuAddress == null) {
if (other.stuAddress != null)
return false;
} else if (!stuAddress.equals(other.stuAddress))
return false;
if (stuBirthday == null) {
if (other.stuBirthday != null)
return false;
} else if (!stuBirthday.equals(other.stuBirthday))
return false;
if (stuName == null) {
if (other.stuName != null)
return false;
} else if (!stuName.equals(other.stuName))
return false;
if (stuNo != other.stuNo)
return false;
if (stuSex == null) {
if (other.stuSex != null)
return false;
} else if (!stuSex.equals(other.stuSex))
return false;
return true;
}
}
dao
代码如下：
package com.fdl.dao;
import java.util.ArrayList;
import com.fdl.pojo.Student;
public interface IStudentDao {
public boolean insertStudent(Student stu);
public boolean updateStudent(Student stu);
public boolean deleteStudent(int stuNo);
public ArrayList getAllStudent();
public Student getStudentByStuNo(int stuNo);
public ArrayList getStudentBySql(String sql);
}
daoImplments
代码如下:
package com.fdl.dao.impl;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import com.fdl.common.ConnectionManage;
import com.fdl.common.Tools;
import com.fdl.dao.IStudentDao;
import com.fdl.pojo.Student;
public class StudentDaoImpl implements IStudentDao {
@Override
public boolean insertStudent(Student stu) {
boolean b = false;
Connection conn = ConnectionManage.getConn();
String sql = "insert into student(stuNo,stuName,stuBirthday,stuAddress,stuSex) values(SNO.NEXTVAL,?,?,?,?)";
try {
PreparedStatement pre = conn.prepareStatement(sql);
// stuName,
pre.setString(1, stu.getStuName());
// stuBirthday,
pre.setDate(2, Tools.fmtDateTosqlDate(stu.getStuBirthday()));
// stuAddress,
pre.setString(3, stu.getStuAddress());
// stuSex
pre.setString(4, stu.getStuSex());
b = pre.executeUpdate() > 0 ? true : false;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
ConnectionManage.closeConn(conn);
}
return b;
}
@Override
public boolean updateStudent(Student stu) {
boolean b = false;
Connection conn = ConnectionManage.getConn();
String sql = " update student set stuAddress=?,stuName=?,stuBirthday=?,stuSex=? WHERE stuno=?";
try {
PreparedStatement pre = conn.prepareStatement(sql);
pre.setString(1, stu.getStuAddress());
pre.setString(2, stu.getStuName());
pre.setDate(3, Tools.fmtDateTosqlDate(stu.getStuBirthday()));
pre.setString(4, stu.getStuSex());
pre.setInt(5, stu.getStuNo());
b = pre.executeUpdate() > 0 ? true : false;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
ConnectionManage.closeConn(conn);
}
return b;
}
@Override
public boolean deleteStudent(int stuNo) {
boolean b = false;
Connection conn = ConnectionManage.getConn();
String sql = "delete student where stuNo=?";
try {
PreparedStatement pre = conn.prepareStatement(sql);
pre.setInt(1, stuNo);
b = pre.executeUpdate() > 0 ? true : false;
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
ConnectionManage.closeConn(conn);
}
return b;
}
@Override
public ArrayList getAllStudent() {
ArrayList list = new ArrayList();
Connection conn = ConnectionManage.getConn();
String sql = "select * from student";
try {
PreparedStatement pre = conn.prepareStatement(sql);
ResultSet rs = pre.executeQuery();
while (rs.next()) {
Student stu = new Student();
// stuNo number primary key,
int stuNo = rs.getInt("stuNo");
stu.setStuNo(stuNo);
// stuName nvarchar2(10) not null,
String stuName = rs.getString("stuName");
stu.setStuName(stuName);
// stuBirthday date,
java.sql.Date stuBirthday = rs.getDate("stuBirthday");
stu.setStuBirthday(Tools.fmtDateToUtilDate(stuBirthday));
// stuSex Nchar(1) default '男',
String stuSex = rs.getString("stuSex");
stu.setStuSex(stuSex);
// stuAddress nvarchar2(50)
String stuAddress = rs.getString("stuAddress");
stu.setStuAddress(stuAddress);
list.add(stu);
}
//
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
ConnectionManage.closeConn(conn);
}
return list;
}
@Override
public Student getStudentByStuNo(int stuNo) {
Student stu = null;
Connection conn = ConnectionManage.getConn();
String sql = "select * from student where stuNo=?";
try {
PreparedStatement pre = conn.prepareStatement(sql);
pre.setInt(1, stuNo);
ResultSet rs = pre.executeQuery();
if (rs.next()) {
stu = new Student();
// stuNo number primary key,
int stuNo1 = rs.getInt("stuNo");
stu.setStuNo(stuNo1);
// stuName nvarchar2(10) not null,
String stuName = rs.getString("stuName");
stu.setStuName(stuName);
// stuBirthday date,
java.sql.Date stuBirthday = rs.getDate("stuBirthday");
stu.setStuBirthday(Tools.fmtDateToUtilDate(stuBirthday));
// stuSex Nchar(1) default '男',
String stuSex = rs.getString("stuSex");
stu.setStuSex(stuSex);
// stuAddress nvarchar2(50)
String stuAddress = rs.getString("stuAddress");
stu.setStuAddress(stuAddress);
}
//
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
ConnectionManage.closeConn(conn);
}
return stu;
}
@Override
public ArrayList getStudentBySql(String sql) {
ArrayList list = new ArrayList();
Connection conn = ConnectionManage.getConn();
try {
PreparedStatement pre = conn.prepareStatement(sql);
ResultSet rs = pre.executeQuery();
while (rs.next()) {
Student stu = new Student();
// stuNo number primary key,
int stuNo = rs.getInt("stuNo");
stu.setStuNo(stuNo);
// stuName nvarchar2(10) not null,
String stuName = rs.getString("stuName");
stu.setStuName(stuName);
// stuBirthday date,
java.sql.Date stuBirthday = rs.getDate("stuBirthday");
stu.setStuBirthday(Tools.fmtDateToUtilDate(stuBirthday));
// stuSex Nchar(1) default '男',
String stuSex = rs.getString("stuSex");
stu.setStuSex(stuSex);
// stuAddress nvarchar2(50)
String stuAddress = rs.getString("stuAddress");
stu.setStuAddress(stuAddress);
list.add(stu);
}
//
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
ConnectionManage.closeConn(conn);
}
return list;
}
}
tools
在前面 一个连接类 一个日期转化类
HTML基本格式
index.html
This is a html page.
HTML中的标签
- body —通常在这里写主体部分
- —标题，标题一的字体最大，标题六的字体最小
- —段落标签
—换行
—水平线
表格基本结构
---表格
---表示一行
text文本域常用属性
- name 文本域的名称 例如：name=“textname”
- maxlength 文本域输入的最大字符 例如：maxlength=“6”
- size 文本域的宽度 例如：size=“10”
- value 文本域的默认值 例如：value=“认真听讲”
- readonly 文本域只读 例如：readonly
选择性输入元素
- select进行项目的多项选择
- 基本属性：
- name 文本域的名称
- size 显示的选项的数目
- multiple 列表中的项目多选
- 基本格式
Day10 2019.11.12
表单的提交
- form的数据要实现提交，必须要做到
- 1.所有要提交的数据都必须设置name属性
- 2.form标签正确设置action属性与method属性，指定数据接收的页面
- 3.form标签内有submit项
- 表单属性
- action 指定接收数据的页面
- method 设置提交方式
- 1.get将表单内容附加在url地址后面，提交信息不能超过8192个字符，提交的信息在浏览器上可以看到
- 2.post将用户在表单中填写的包含在主表单中一起传送到服务器上的处理程序中，这样提交方法没有字符的限制，并且提交的信息在浏览器上不显示提交的信息
注释
ID值唯一 name值可以不唯一
CSS样式
选择符
- 选择符
-
- 通配选择符，表示所有标签的样式都是这样
- E{ } 类型选择符，直接通过标签设计样式，E表示HTML中的标签
- .E{ } 类选择符，在HTML中使用class属性选择，E表示class属性的名字，如：class=“E”
- #ID{ } ID选择符，使用id属性选择,E代表id
- E F{ } 包含选择符，E标签下包含F标签
- E，F，G{ } 分组选择符，只要在E，F，G标签中都使用这个样式
- E[type=""]{ } 属性选择符
-
属性
- 属性
- 字体 font
- 文本 text:
- text-align 文字水平对齐 left right center
- vertical-align 文字垂直对齐 top middle bottom
- 背景 background
- 定位 position
- 布局 layout：宽度 width；高度 height
- 边框 border：边框外设置距离 margin;边框内设置距离 padding
- 滤镜 opacity
- 列表
- 显示 display:none 不显示且会释放位置；display:block 显示
- 隐藏 visibility:hidden 不释放位置
尺寸
- height 高度
- width 宽度
- margin 控制div的外边距
- padding 控制内边距
边框
border
背景
background
文本
- text_align 文本位置属性（居左 居中 居右）
- vertical_align 文本垂直属性 （居顶 居中 居底）
- 文本装饰 text_decoration
布局
- float 浮点类型
- li{float：left；width：100px} 变成水平的列表
- display 控制显示（不显示时候 释放位置）
- clear
- visibility 控制显示 （不显示时 不释放位置）
Day11 2019.11.13
Servlet的生命周期
客户端与服务器运行
Servlet解决乱码(三句话)
request.setCharacterEncoding("utf-8"); //设置请求对象的字符集编码
response.setCharacterEncoding("utf-8");//设置响应对象的字符集编码
response.setContentType("text/html;charset=utf-8");//指导浏览器响应编码
Servlet生命周期三阶段
Servlet 的生命周期包含三个阶段
- init()
在服务器构造了 Servlet 实例后即被服务器调用
在 Servlet 处理第一个请求之前调用
用于执行 Servlet 初始化 - service()
服务阶段是使用请求和响应模式进行通信的阶段 - destroy()
在要卸载 Servlet 时，将调用 destroy() 方法
只有在所有服务调用都完成之后，或者在经过服务器指定的特定秒数之后（不管哪种先发生），才调用
实现servlet接口
自定义的 servlet 要继承 HttpServlet
- 一般要覆盖 doPost 或者 doGet 方法
- doGet 方法用于接收 Get 请求
- doPost 方法用于接收 Post 请求
HttpServlet类响应过程
请求和响应
请求和响应可按两种方式进行：
- 接收请求的方式包括
- 1.ServletRequest
- 2.HttpServletRequest
- 作出响应的方式包括
- 1.ServletResponse
- 2.HttpServletResponse
ServletRequest的常用方法
HttpServletRequest的常用方法
ServletResponse的常用方法
HttpServletResponse的常用方法
Servlet的部署
