实训二笔记
Jvav学习笔记
一.操作系统
- BS:从网页访问服务器
- CS：从客户端访问服务器
| 区别 | 举例 | |
|---|---|---|
| BS | 从网页访问服务器 | 淘宝 |
| OS | 从客户端访问服务器 | 微信，QQ |
二.Java 的入门
1.Java 体系（面向对象）
- Java SE: Java标准平台
- Java ME：一般用来做嵌入式
- Java EE：平台企业级
2.Java版本
jdk1.0 --> jdk1.2 --> jdk 1.5 -->jdk7–> jdk8–>…–>jdk12
3.JDK 安装与配置
4.JDK，JVM与JRE
| JDK | Java开发工具包 |
| JRE | Java运行环境 |
| JVM | Java虚拟机 |
5.java程序过程
xx.java通过编译变成xx.class文件，Java虚拟机（JVM）是Java跨平台的保障
三.Java语法
1.变量，常量
-
常量可以用final修饰
final int a=1; //final修饰，无法改变其值final关键字：
- final修饰类时，被修饰的类无法被继承
- final修饰方法时，当子类继承这个类时，该方法不能被重写 ，不能被隐藏，不能被任何串改
- final修饰变量时，变量变成常量，其值不能被修改
-
\是转义字符
-
\n是换行符 \t是制表符
2.表达式
- = 表示把后面的值赋值给前面的变量
- == 表示两个是否相等，结果一般是boolean类型
3.数据类型
数据类型解析
| 数据类型 | 类型说明 | 长度 | 注意要点 |
|---|---|---|---|
| int | 普通长度整型数据 | -231~231-1(四个字节) | |
| byte | 字节长度整型数据 | -27~27-1（一个字节） | 没有常量 |
| short | 短长度整型数据 | -215~215-1(两个字节) | 没有常量 |
| long | 长整形数据 | -263-263-1(八个字节) | 常量后加L |
| char | 字符数据 | 0~65536 | |
| float | 浮点数数据 | 10-38~1038和-1038~10-38 | 常量后面加F或f |
| double | 双精度浮点数数据 | 10-308~10308和-10308~10-308 | 常量后可以加D |
| boolean | 布尔数据 | 只有ture和false |
数据类型按精度从低到高排序
byte–>short–>char–>int–>long–>float–>double
数据类型转换注意事项
- 将数据从低到高转换系统自动完成
- 将数据从高到底转换需要使用显示类型转换：（类型名）要转换的值 但是精度会损失
基本类型的包装
| byte | Byte |
|---|---|
| short | Short |
| int | Integer |
| long | Long |
| boolean | Boolean |
| char | Charctar |
| float | Float |
| double | Double |
包装类型去基本类型的区别：
- 基本类型不能去在集合中使用
- 包装类型的默认类型是Null，基本类型的默认类型是0，因为包装类型的是类
4.输入输出
//创建一个扫描器
System.out.println("请输入整型数据");
//接受用户输入数据
Scanner reader=new Scanner(System.in);
//输出
System.out.println(3);5.分支语句
模式
- 顺序
- 选择
if-else
- if
boolean e=true;
if(e){ //如果if中的判断语句为真则执行if中的代码块
System.out.println(1);
} - if-else
boolean e=false;
if(e){ //如果if中的判断语句为真则执行if中的代码块
System.out.println(1);
}
else{
System.out.println(2);
}- 多if-else
//多If-else
System.out.println("请输入成绩");
Scanner scanner=new Scanner(System.in);
int i=scanner.nextInt();
if(i<=100&&i>=90){System.out.println("A");}
else {
if (i<90&&i>=80) {System.out.println("B");}
else {
if (i<80&&i>=70) {System.out.println("C");}
else {
if (i<70&&i>=60) {System.out.println("D");}
else {if(i<60&&i>=0){System.out.println("E");}
else {System.out.println("请输入0到100的成绩");}
}
}
}
}swith-case
System.out.println("请输入整型数据");
Scanner reader=new Scanner(System.in);
int i=reader.nextInt();
switch (i) {
case 1:
System.out.println(1);
break; //如果没有break的话回往下一直执行到有break或者程序终止结束
case 2:
System.out.println(2);
break;
default:
System.out.println(3);
break;
}
/**
*1.如果没有break可以运行
*2.如果没有default也可以允许
*3.不允许有两个相同值的case
*/
6.循环语句
for循环
for(int i=0;i<10;i++){
int x=i+1;
System.out.println("这是第"+x+"个"+"hello world");
}
//这样无法运行
for(int i=0;i<-2;i++){
System.out.println("1");
}while循环
while(判断体){
循环体；
}do-while循环
do{
循环体 //先做一次循环体然后在进行判断
}while(判断体)break与continue
- break：直接结束当前所在的整个循环
- continue：结束当前值的循环进行下一个值的循环
7.数组
申明数组 ：数组类型[] 数组名；
创建数组：数组名=new 数组类型[]；
数组的初始化：
//静态初始化
int a[]={1,23,45};
//动态初始化
int a[]=new int[10];
Scanner read=new Scanner(System.in)
for(int i=0;i<a.length-1;i++ ){
a[i]=read.nextInt();
}删除数组某一个元素后将该元素后的值往前移一位
import java.util.Scanner;
public class Demo1 {
public static void main(String[] args) {
int a[]={1,2,3,4,5,6,7,8,9};
int y;
System.out.println("输入要删除的元素");
Scanner scanner=new Scanner(System.in);
int x=scanner.nextInt();
for(int i=0;i<a.length-1;i++){
if(a[i]==x){
for(int j=i;j<=a.length-2;j++){
a[j]=a[j+1];
}
a[a.length-1]=0;
}
}
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}System.out.println(a.length);
}
}
数组的遍历
//第一种方法
for(int i=0;i<数组名.length-1;i++ ){
System.out.println(数组名[i]);
}
//第二种方法
System.out.println（Arrays.toString(数组名)）;数组的冒泡排序
//冒泡排序
int[] a={4,5,1,8,6,7,2,9,3};
for(int j=a.length;j>=0;j--){
for (int i = 0; i < j-1; i++) {
if (a[i]>a[i+1]) {
int temp=0;
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
}
}
for(int i = 0; i < a.length; i++){
System.out.println(a[i]);
}
//也可使直接调用Array类的sort方法
Arrays.sort(数组名)；8.队列
队列queue中的方法
9.关键字
final
- final修饰类时，被修饰的类无法被继承
- final修饰方法时，当子类继承这个类时，该方法不能被重写 ，不能被隐藏，不能被任何串改
- final修饰变量时，变量变成常量，其值不能被修改
static
- static修饰变量时，所有对象都共用一个变量，若一个变量改变，所有对象里的该属性都要改变
- static修饰方法时，可以不创建该类的对象，不使用对象创建，直接通过类型调用
this
-
this在构造方法中时，表示修饰这个类的变量，所有该类的对象中在这个类里面使用同一个内存空间
可以调用该类中类中的构造器
-
this在实例方法中表示实例方法变量
super
- 可以调用父类的构造方法
- 可以去操作被隐藏的成员变量和构造方法
abstract
- 修饰类是表示该类是抽象类，继承抽象类的子类一定要重写抽象类里的抽象方法
- 修饰方法是表示是抽象方法，在抽象类中抽象方法不能被实现
10.访问权限
私有变量和私有方法
在方法和变量前面使用private修饰，私有变量和私有方法只有在该类里创建该类的对象才能调用，其他的类都不能使用
一般在类里设置set与get方法去让外部创建该类的对象去获取该对象的属性
公共变量和公共方法
在方法和变量前面使用public修饰，任何类可以使用
受保护的方法和变量
在方法或变量前面使用protacted修饰，只有在一个包里面的方法才能调用
友好变量和友好方法吗，友好类
没有任何修饰词修饰的
| 修饰符 | 同一个类中 | 同一个包中 | 不同包 **(**子类中) | 全局 |
|---|---|---|---|---|
| Private | Yes | |||
| Default | Yes | Yes | ||
| Protected | Yes | Yes | Yes | |
| Public | Yes | Yes | Yes | yes |
四.类与对象
1.面向对象与面向过程（编程思想）
面向对象：模块化的设计 ，重点在于规范（标准）
面向过程：完成自己所需要的过程，但是这种缺少维护性
2.面向对象的三大特征
- 封装：保护内部对外部不可见
- 继承：一代代的传承
- 多态：一定范围内的状态改变
3.类与对象的关系
类： 使用class表明这是一个类 ，是一类有相同属性的事物的抽象集合
对象：类的实体化就是对象，是一种个性的描述
对象是类的描述，类是对象的
4.静态
使用static修饰的成员变量和方法
- static修饰变量时，所有对象都共用一个变量，若一个变量改变，所有对象里的该属性都要改变
- static修饰方法时，可以不创建该类的对象，不使用对象创建，直接通过类型调用
5.继承
extend关键字继承，若类A继承了类B，那么，B中的所有属性在A中都有，只是看不见被隐藏了，方法也是这样。
6.重写
使用和父类一样名字和传参方式，可以重写父类的方法
7.Object类
Object是所有类的父类，也叫做超类或基类
8.接口
在申明接口时使用interface修饰表明这是一个接口，接口是一个特殊的类，属于程序的拓展功能。
接口可以继承接口，并且可以继承多个接口。
当一个类实现两个接口，并且两个接口的方法一样时，只需要实现一个方法就可以
接口向下转型：
申明接口对象，但是创建的时候是使用实现接口的类去创建，接口对象就可以去调用实现接口方法的类的接口方法。
接口的多态：
多个实现了接口的类，在一个新的类里声明接口对象作为参数去调用接口方法，然后在调用这个类的对象去调用接口方法，这个时候再去使用实现接口的类去创建一个接口对象，就可以调用实现该接口的类中的方法。
//A,B 实现了接口C
class A implements C{
public abstract void test(){
System.out.println("1");
}
}
class B implements C{
public abstract void test(){
System.out.println("2");
}
}
interface C{
public abstract void test();
}
class D{
public void test1(C c){
c.test();
}
}
//主类
class Demo(){
public static void main(String args{}){
D d=new D();
d.test1(new A());
d.test1(new B());
}
}五.常用实用类
A .String类
-
由final修饰的，创建对象后其值不可改变的类。
-
String类的常用类：
//查询字符串长度 public int length(); //比较两个字符串是否内容相同 public boolean equals(String string); //判断字符串前缀和后缀是否是指定的字符串 public boolean startWith(String s); public boolean endWith(String s); //判断字符串是否含有指定字符串 public boolean contains(String s); //查询字符串中是否有指定字符串并返回索引 public int indexOf(String s); //取出字符串中指定索引的字符串 public String subString(int i);//i以后的所有字符 public String subString(int i,int x);//从i开始到x结束，取i不取x //取出字符串中的空格 public String trim();
B.StringBuffer
-
String，StringBuffer，StringBuilder三个类的比较
性能：StringBuiler>StringBuffer>String
安全：StringBuffer>String>Stringbuilder
C.date
-
获取当前时间：System.currentTimeMillis
-
时间的三种表现方式（long，data，String）
long time= System.currentTimeMillis//输出的是long型时间 /* *yyyy 年 *MM 月 *DD 日 *HH 时 *mm 分 *ss 秒 */ Date date=new Date(); //时间可视化，将data时间变成String类型 SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-DD HH:mm:ss"); //设置格式化参数 sdf.format(date);//接受data类型返回String类型 parse();//将String时间转化成date时间
Random类
Random random =new Random();
//创造随机数
random.nextInt(max-min+1)+min;
random.nextBoolean();System类
六.泛型和集合框架
1.泛型
(泛型的主要目的是建立具有类型安全的数据结构)，JDK1.4之前不能时候泛型
不加泛型的缺点：
- 集合任何数据都可以放进去
- 集合里面的类型全部都时Object
A.泛型类的声明
class People<E> //People是泛型的名字，E是其中的泛型
//其中E可以是对象或者接口，但是不能是基本数据类型，也可以不使用E表示泛型，使用任何一个合理的标识符都可以class People<E>{
double i;
E bottom; //泛型声明变量
public Cone(E b){
bottom=b;
b.toString()；//泛型变量只能使用从Object类继承来的或者重写的方法
}
}B.使用泛型类声明对象
People<Phone> people=new People<Phone>(new Phone);eg：
//
public class Cone<E> {
double height;
E bottom;
public Cone(E b){
bottom=b;
}
public void setHeight(double h){
height=h;
}
public double computerVolume(){
String s=bottom.toString();
double area=Double.parseDouble(s);
return 1.0/3.0*area*height;
}
}public class Cricle {
double area,radius;
public Cricle() {
// TODO Auto-generated constructor stub
}
Cricle(double r){
radius=r;
}
@Override
public String toString() {
area=radius*radius*Math.PI;
return ""+area;
}
}
public class Rect {
double sideA,sideB,area;
public Rect() {
// TODO Auto-generated constructor stub
}
Rect(double a,double b){
sideA=a;
sideB=b;
}
@Override
public String toString() {
area=sideA*sideB;
return ""+area;
}
}
public class Demo {
public static void main(String[] args) {
Cricle cricle=new Cricle(10);
/*
使用泛型类生成泛型对象、格式为
泛型类名<具体类名> 对象名=new 泛型对象名<具体类型名>（具体类的对象名）
创建泛型对象是需要给泛型对象注入一个具体类的对象，即创造泛型对象前要先创建一个具体对象
*/
Cone<Cricle> coneOne=new Cone<Cricle>(cricle);
coneOne.setHeight(16);
System.out.println(coneOne.computerVolume());
Rect rect=new Rect(15,23);
Cone<Rect> coneTwo=new Cone<Rect>(rect);
coneTwo.setHeight(98);
System.out.println(coneTwo.computerVolume());
}
}C.泛型接口
泛型接口的声明格式
interface 接口名<E> //只有泛型类才可以使用泛型接口D.链表
优点：长度不限。
链表是由若干个被称为结点的对象组成的一种数据类型，每个结点含有一个数据和下一个结点的引用（单链表）或这是含有一个数据并含有一上一个结点的引用和下一个结点的引用（双链表）
声明并创建一个链表
LinkedList<数据类型> 对象名=new linkedList<数据类型>();LinkedList泛型类的常用方法
LinkedList<String> mylist=new LinkedList<String>();
mylist.add("123"); //add方法向链表的最后一个结点添加一个新的结点。
myList.add("123",E); //向指定的E结点添加一个结点
myList.clear(); //删除指定链表上的所有结点
。。。。。链表的遍历
第一种方式：使用迭代器，使用迭代器不能改变list长度
-
为什么迭代器使用的时候不能改变集合的大小？？
@SuppressWarnings("unchecked") public E next() { checkForComodification(); int i = cursor; if (i >= size) throw new NoSuchElementException(); Object[] elementData = ArrayList.this.elementData; if (i >= elementData.length) throw new ConcurrentModificationException(); cursor = i + 1; return (E) elementData[lastRet = i]; } //在使用next（）方法去遍历list表时，会先判断list表中的元素个数和迭代次数是否相等 //迭代次数是在创建Iterator对象是就已经确定的 //因此是删除或者增加list表中的元素的时候list表的大小会改变，每次遍历的时候就都会查看两者是否相等 final void checkForComodification() { if (modCount != expectedModCount) throw new ConcurrentModificationException(); } -
为什么可以删除倒数第二个元素？
//在使用hasNext()函数时，会比较要迭代的元素索引加一和list表中的大小是不是相等，到倒数第二个的时候，获取的索引时最后一个元素的索引，删除元素后list的表大小减一，因此两个相等，所以会退出while循环，不会进行naxt（）方法 public boolean hasNext() { return cursor != size; }
//先创建一个链表，并且初始化
LinkedList<String> myLinkedList=new LinkedList<String>();
for(int i=0;i<60096;i++){
myLinkedList.add("speed"+i);
}
//然后使用myLinkedList去创建一个迭代器iterator
Iterator<String> iterator=myLinkedList.iterator();
//使用hasNest()方法判断是否读取完，读取完后输出false
while(iterator.hasNest()){
//使用next()方法可以将节点中的数据提取出来
String te=iterator.next();
}第二种方式：使用get（）方法
//接着上面的写
//使用链表的size（）方法判断链表中有多少个结点
for（int i=0;i<myLinkedList.size(）;i++){
String te=myLinkedList.get(i);
}如果使用之前版本的LinkedList这个类（并非泛型）去创建链表的时候需要在get方法前面加一个转型。这个转型有可能使得数据出现精度丢失等影响。
第三种方式：foreach，使用foreach不能改变list长度
foreach(Object object:list){
String te=object;
}三种方法中，迭代器的性能是最好的。
E.堆栈
堆栈：是一种后进先出的数据结构，相对堆栈中输入数据称之为压栈，拿出堆栈中的数据称之为弹栈。
如何创建一个堆栈？
//使用Stack去创建一个堆栈
Stack<String> myStack=new Stack<String>()堆栈中常用的方法
//压栈，相对堆栈中加入元素
myStack.pash("123");
//弹栈，拿出数据中的元素
myStack.pop();
// 判断堆栈中是否还有元素,铀元素则返回false，没有元素则返回true
myStack.empty();
//获取栈顶的元素但是从栈中删除元素
myStack.peek();
//获取数据在堆栈中的位置,最顶端的位置是1，依次向下增加，空站的话返回-1
myStack.search("123");F.散列映射
-
散列映射如何创建
HashMap<K,V> myMap=new HashMap<K,V>(); -
散列映射常用方法
//清空散列映射中的所有键值对 public void clear(); //返回当前散列映射的一个克隆 public Object clone(); //是否在散列映射中存在key或者value值 public boolean containsKey(Object key); public boolean containsValue(Object value); //返回散列映射中含有制定key中的calue值 public V get(Object value); //查看散列映射是否为空 public boolean isEmpty(); //移除散列映射中含有指定key值的键值对并返回其value值 public V remove(Object value); //查看散列映射的大小 public int size(); -
遍历散列映射中的多有键值对
//使用迭代器就可以 -
散列映射的遍历
//第一种方式 //使用get方法获得value值 Set<String> mySet=new HashSet<String>(); mySet=myMap.keySet(); for (String string : mySet) { System.out.println(string+":"+myMap.get(string)); }//第二种方式 for (Map.Entry<String, String> entry : myMap.entrySet()) { System.out.println(entry.getKey()+":"+entry.getValue()); }//第三种方式，使用迭代器 Iterator<Map.Entry<String, String>> iterator=myMap.entrySet().iterator(); while(iterator.hasNext()){ Entry<String, String> entry1=iterator.next(); System.out.println(entry1.getKey()+":"+entry1.getValue()); }
G. 树集
- TreeSet实现了Set接口，并且它的结点时是从下往上结点越来越大，同一层结点时从左往右结点越来越大。
H.树映射
总结
| 泛型结构 | 实现接口 | |
|---|---|---|
| 链表 | List(E)接口 | |
| 堆栈 | ||
| 散列映射 | Map |
|
| 树集 | Set(E)接口 | |
| 树映射 | Map(E)接口 |
七.集合框架
- 集合可以动态的存放多个对象，但是不能存放基本数据类型
集合可以分为两大类，一个是实现collection接口，一个是实现map接口
list：有序，可以重复
set: 无序，不能重复
1.集合框架：list
-
list常用方法（list是关键字）:有序可重复
/*实现list接口,list底层时数组 */ List list=new List();//不过给长度限制 //list中添加原元素 public List add(Object object); //查看list中有多少元素 public int size(); //查看list是否为空 public boolean isEmpty(); //获取list中的元素，底层时数组，因此从0开始 public Object get(int i); //清空list中的所有元素 public void clear(); //移除集合中的元素 public List remove(int i); public boolean remove(Object object);//移除成功返回true //集合中是否包含指定元素 public boolean contains(Object object); //在list中查找指定元素所有 public int indexOf(Object object); //没有则返回-1 //替换元素，并返回被替换的元素 public Object set(int index,Object object); //把集合变成数组 public Object[] toArray(); //迭代器，用来遍历list Iterator iterator=list.iterator(); while(iterator.hasNext()){ String te=iterator.next(); }
2.集合框架：set
3.集合框架Map
八.内部类与异常类
异常类
-
异常对象通过调用以下方法得到异常信息
//得到或者输出异常信息的方法 public String getMessage(); public void printStackTrace(); public String toString(); -
异常的类级结构
-
异常的处理
//1. 捕获 使用try-catch //2.抛出 使用throws关键字抛出相关异常 -
自定义异常类
自定义的异常类需要继承Exception类，从而去拓展，在自定义的异常类的构造体中做出对异常的处理，这里的异常可以是数据类型不符合自己的要求，或者是输入的数太大等等，判断他是一个异常后，可以通过throw关键字去new一个异常对象并抛出。
内部类
匿名类
JDBC学习记录
JDBC原理
从图中可以得知，JDBC是连接java程序与数据库的中介
任何数据库想使用JDBC应该在制作数据库时进行相关的JDBC配置
使用JDBC
-
首先先将相应的JDBC文件添加到程序中，什么数据库，什么版本都有要求
-
配置环境，右键点击文件中的build path进行环境配置
-
在java程序中代码实现
-
启用JDBC驱动器
Class.forName("com.mysql.JDBC.Driver") -
创建数据库连接
Conectent coectent=DriverManager.getConnection("访问路径", "用户名", "密码"); -
进行数据库操作
String sql="delete from student where id = ?"; PrepardStatement preparedStatement =connection.prepareStatement(sql); preparedStatement.setInt(1, 3);//问号时从一开始的 preparedStatement.executeUpdate()；//进行数据库操作，一般是增加，删除，修改 preparedStatement.executeQuery(); //进行查询操作 //一般查询结果放在ResultSet里面 -
关闭数据库的各个连接
public static void guangbi(Connection connection,PreparedStatement preparedStatement,ResultSet resultSet){ if (connection!=null) { try { connection.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } if (preparedStatement!=null) { try { preparedStatement.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } if (resultSet!=null) { try { resultSet.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } -
JDBC工具类DBmanage
-