Day2
/*
* 一，概念
* 面向对象是一种设计思想
*
* 面向对象：不需要执行者亲力亲为，只需要将不同的任务分配给不同的对象进行完成即可。
* 面向过程：所有的事情都需要执行者亲力亲为
*
* 面向对象：
* 在面向对象的世界里，万物皆对象
* 二，类
*类与对象的关系
* 类是对象的模板（抽象）
* 对象是类的实例
*
* 类的概念：
* 产生一个类，就是对客观存在的实体进行抽象产生的模板
*
* 类的成员：
* 属性：这一类实物所具有的共同特点，但是这邪恶属性特点是依赖于对象存在的
* 实质就是一个非静态的全局变量
*
* 成员变量：成员数据，数据成员，成员方法
* 行为功能：实质就是一个类中的非静态的方法
* 也可以叫做 成员方法 方法成员
*
* */Student.java
/**
* @Author:bit
* @Date: 2021/3/30 9:55
* */
public class Student {
// 注意：class文件中 Java的主函数在一个类中只会有一个类
// 一个类中可不可以有多个类呢？--->可以的 不建议在一个文件中同时存在多个类
// Java中有一种方式，内部类
// Java文件实质上就是一个Java类
// 类成员：属性 （共有的 私有的 同包 同项目下）
// 共有的public 私有的private 同包下protected
// 一般在一个类中，非指定的话，建议私有
protected String name; //姓名属性
private int age; //年龄属性
public String sex; //性别属性
// 构造器-->构造方法 有参构造和无参构造
public Student() {
}
// 有参数
public Student(String name, int age, String sex) {
//如果想使用属性 那么需要进行引用
this.name = name;
this.age = age;
this.sex = sex;
}
// 注意：一个类中，有参和无参构造都写
// get和set方法
// get 获取
// set 设置你的属性
//get方法
public String getName() {
//返回值 return
return name;
}
public int getAge() {
return age;
}
public String getSex() {
return sex;
}
public void setName(String name) {
this.name = name;
}
// 同样一个类中，固定的东西都存在快捷键
// 属性一点要存在，其他的构造方法，get和set
// alt+insert 出现的第一个为默认的有参构造方法 get and set 默认的方法
// 注意：一般情况下 ，Java中使用类，以上的内容就够了
// 但并不是只有这些
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
", sex='" + sex + '\'' +
'}';
}
public void NameList(){
System.out.println("我是"+getName()+"今年"+getAge()+"性别是："+getSex() );
}
/**
* @Override 方法重写
* 在方法的继承和实现的过程中，如果拿到的方法无法满足你的需求
* 此时我们可以对这个方法进行重写，对这个方法进行完善，这个过程叫做方法的重写
* 特点：保留方法名字和参数的使用，只对方法体进行完善
* @Overload 方法重载
* 一个类中，有一组方法，名字相同，参数和参数的类型不同，这样一组方法叫互为重载方法
*
*
* */
public static void main(String[] args) {
// 实例化
Student student = new Student("Jun",21,"男");
student.NameList();
}
}eg:龟兔赛跑（在这里原始的数据代入最后是小兔纸赢了，最后将兔子的速度改为跑10m休息，乌龟才赢了）
分为五个类：Animal，LetStop，MainTest，Rabbit,WuGui
Animal.java
package test;
/**
* @PACKAGE_NAME: xl
* @Author: bit
* @DATE: 2021-03-30
* @TIME: 14:08
**/
//抽象类：抽象类中可以包含抽象方法，也可以包含非抽象方法
public abstract class Animal extends Thread {
/**
* eg:龟兔赛跑
* 一条跑道，2000m，乌龟和兔子同时开跑，
* 乌龟的速度：每0.1s跑2m 不休息
* 兔子的速度：每0.1s跑5m 但是跑20m休息0.5s
* 当其中一方，到达终点，游戏结束
*
* 分析：
* 一条跑道---->属性来使用 2000 属性值
* 动物类 -->这两个类的父类 需要两个两个乌龟和兔子的子类进行继承
* 跑动的状态 线程的执行
* 只需要在父类中实现线程状态和需要继承的方法
*
* 1.动物类（父类） --->需要实现线程,重写线程的方法
* abstract 如果加在方法名前面代表这个方法是抽象方法
* 抽象方法：必须存在于接口或者抽象类中 实质就是一个被实现的方法名
* 没有自己的方法实现
* 接口：特殊的抽象类
* 2.
* */
// 属性 跑道
public int length = 2000;
// 动态的抽象方法
public abstract void running();
// 可以进行重写的run()方法
@Override
public void run() {
super.run();
//通过判断跑道的长度
while (length>0){
running();
}
}
//接口：特殊的抽象类，特点是里面的方法只会存在方法名，没有方法体，等着被实现
// interface接口关键字
public static interface callToback{
// 跑道归0了，执行这个方法让对方停止
public void win();
}
//实例化接口
public callToback callToback;
}
LetStop.java
package test;
/**
* @PACKAGE_NAME: xl
* @Author: bit
* @DATE: 2021-03-30
* @TIME: 14:54
**/
public class LetStop implements Animal.callToback{
Animal animal;
public LetStop(Animal animal){
this.animal = animal;
}
//将Animal类中的接口中的win()方法进行实现
@Override
public void win(){
animal.stop();
}
//让线程停止
}
Rabbit.java
package test;
/**
* @PACKAGE_NAME: xl
* @Author: bit
* @DATE: 2021-03-30
* @TIME: 14:13
**/
public class Rabbit extends Animal {
// 线程的名字
public Rabbit(){
//来源于 Thread类
setName("小兔纸");
}
//重写动态的方法 线程的
@Override
public void running() {
int dis = 5;
length-=dis;
System.out.println("小兔纸跑了"+dis+"m,距离终点还剩下"+length);
if (length<=0){
length=0;
System.out.println("小兔纸赢啦！！！");
//回调函数--->通过实例对象进行回调，统一跑动的线程
if (callToback!=null) {
//实质让另一方停止
callToback.win();
}
}
//每0.1s 跑5m 跑10m 休息0.5s
if ((2000-length)%10==0) {
//只要和时间有关的全部需要抓异常
try {
sleep(500);//单位毫秒 0.5s
} catch (InterruptedException e) {
e.printStackTrace();
}
}else {
try{
sleep(100);
}catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
WuGui.java
package test;
/**
* @PACKAGE_NAME: xl
* @Author: bit
* @DATE: 2021-03-30
* @TIME: 14:13
**/
public class WuGui extends Animal {
public WuGui(){
//来源于 Thread类
setName("小乌龟");
}
//重写动态的方法 线程的
@Override
public void running() {
int dis = 2;
length-=dis;
System.out.println("小乌龟跑了"+dis+"m,距离终点还剩下"+length);
if (length<=0){
length=0;
System.out.println("小乌龟赢啦！！！");
//回调函数--->通过实例对象进行回调，统一跑动的线程
if (callToback!=null) {
//实质让另一方停止
callToback.win();
}
}
try {
sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
MainTest.java
package test;
/**
* @PACKAGE_NAME: xl
* @Author: bit
* @DATE: 2021-03-30
* @TIME: 14:51
**/
public class MainTest {
//让线程开启 调用线程的执行
public static void main(String[] args){
//实例化线程的对象
WuGui wuGui = new WuGui();
Rabbit rabbit = new Rabbit();
//互相控制
LetStop letStop1 = new LetStop(rabbit);
LetStop letStop2 = new LetStop(wuGui);
rabbit.callToback = letStop2;
wuGui.callToback = letStop1;
//
rabbit.start();
wuGui.start();
}
}输出结果：（部分）
小兔纸跑了5m,距离终点还剩下325
小乌龟跑了2m,距离终点还剩下40
小兔纸跑了5m,距离终点还剩下320
小乌龟跑了2m,距离终点还剩下38
小乌龟跑了2m,距离终点还剩下36
小乌龟跑了2m,距离终点还剩下34
小乌龟跑了2m,距离终点还剩下32
小乌龟跑了2m,距离终点还剩下30
小兔纸跑了5m,距离终点还剩下315
小乌龟跑了2m,距离终点还剩下28
小兔纸跑了5m,距离终点还剩下310
小乌龟跑了2m,距离终点还剩下26
小乌龟跑了2m,距离终点还剩下24
小乌龟跑了2m,距离终点还剩下22
小乌龟跑了2m,距离终点还剩下20
小乌龟跑了2m,距离终点还剩下18
小兔纸跑了5m,距离终点还剩下305
小乌龟跑了2m,距离终点还剩下16
小兔纸跑了5m,距离终点还剩下300
小乌龟跑了2m,距离终点还剩下14
小乌龟跑了2m,距离终点还剩下12
小乌龟跑了2m,距离终点还剩下10
小乌龟跑了2m,距离终点还剩下8
小乌龟跑了2m,距离终点还剩下6
小兔纸跑了5m,距离终点还剩下295
小乌龟跑了2m,距离终点还剩下4
小兔纸跑了5m,距离终点还剩下290
小乌龟跑了2m,距离终点还剩下2
小乌龟跑了2m,距离终点还剩下0
小乌龟赢啦！！！
JDBC的介绍
/*SQL_Server 2008 微软
*
* 数据库：
* DB[DateBase],指的就是长期保存在计算机上的数据，按照一定的顺序组织，
* 可以被各种用户或者应用进行共享的数据集合。
*
* DBMS（数据库管理系统）
* 能够管理和操作数据库的大型软件
*
* 常见的数据库：
* 关系型：mysql oracle sql_server DB2:IBM postgreSql
* 非关系型：redis缓存数据库 mongodb [key:value]
*
* 语言：sql【结构化查询语言】
* DDL：操作数据库，表，列等，creat，alter，drop
* DML：对表中的数据进行操作。增删改
* insert into ,update set delete from
* DQL：执行的全部都是查询
* select where from
* DCL：控制权限
* 事务
* 提交
* 回滚
* 银行转账
*
* java连接数据库的方式:JDBC,Java连接数据的规范（标准），
* 可以使用Java进行数据库的curd等操作
*
* JDBC--->工具类封装--->数据库连接池
* jdbc一种技术，对应接口工具
*
* DriverManager:驱动管理 管理多个数据库驱动类，提供了获取数据库连接的方法
* Connection 代表一个数据库连接（判断connection不是Null，那么代表存在数据库连接）
* Statement 发送sql到数据库工具进行执行
* ResultSet 保存sql查询语句的结果数据，结果集
* SQLException 处理数据库应用是所发生的异常（所有数据库异常的父类）
* 补充：Exception是所有异常的父类
*
*
*
*
* */