QImage img;
    img.load("D:\\Qt_project\\QTimer\\1.jpg");
    ui->label->setPixmap(QPixmap::fromImage(img));

connect(timer, &QTimer::timeout, this, &Widget::timeoutSlot);

void Widget::timeoutSlot()
{
    QString path("D:\\Qt_project\\QTimer\\");
    path += QString::number(pictureId);
    path += ".jpg";

    //创建图片对象
    QImage img;
    img.load(path);
    //显示图片
    ui->label->setPixmap(QPixmap::fromImage(img));

    pictureId++;
    if(6 == pictureId)
    {
        pictureId = 1;
    }

}

//打开 槽函数具体实现
void MainWindow::openActionSlot()
{
    //跳出对话框(记住，使用了类 QFileDialog)
    //QFileDialog::getOpenFileName(this, tr("Open File"),
    //                                                  "/home",
    //                                                  tr("Images (*.png *.xpm *.jpg)"));

    QString fileName = QFileDialog::getOpenFileName(this, "选择一个文件",
                           QCoreApplication::applicationFilePath(), //获取当前路径
                                 "*.cpp");                          //只显示.cpp类型文件
    if(fileName.isEmpty())
    {
        //如果为空，弹出一个提示的对话框
        QMessageBox::warning(this, "警告", "请选择一个文件");
    }
    else
    {
        //如果不为空，将该文件的名字打印出来。Qt如何打印？类似与c++的cout 使用QDebug类
        //qDebug() << fileName;

        //打开该文件并显示内容
        QFile file(fileName);             //创建文件对象
        file.open(QIODevice::ReadOnly);    //如果文件比较少，可以用该方式。如果文件内容比较多，涉及效率问题，需采用其他方式
        QByteArray ba = file.readAll();         //返回值类型QByteArray
        //显示内容
        ui->textEdit->setText(QString(ba));            //将内容转为QString类型，并作为入参
        file.close();
    }
}

//保存 槽函数具体实现
void MainWindow::saveActionSlot()
{
    //跳转对话框，找到路径
    QString fileName = QFileDialog::getSaveFileName(this, "请选择一个文件", QCoreApplication::applicationFilePath());
    if(fileName.isEmpty())
    {
        QMessageBox::warning(this, "警告", "请选择一个文件");
    }
    else
    {
        QFile file(fileName);
        file.open(QIODevice::WriteOnly);    //写内容
        //ui->textEdit->toPlainText();        //显示内容
        QByteArray ba;                      //创建QByteArray对象
        ba.append(ui->textEdit->toPlainText());                        //将显示的内容追加到QByteArray对象后面
        file.write(ba);
        file.close();
    }
}

键盘事件：按键按下和松开
鼠标事件：鼠标移动，鼠标按键的按下和松开
拖放事件：用鼠标进行拖放
滚轮事件：鼠标滚轮滚动
绘屏事件：重绘屏幕的某些部分
定时事件：定时器到时
焦点事件：键盘焦点移动
进入和离开事件：鼠标移入widget之内，或是移出
移动事件：widget的位置改变
大小改变事件：widget的大小改变
显示和隐藏事件：widget显示和隐藏
窗口事件：窗口是否为当前窗口

key : int

This property holds the code of the key that was pressed or released.
See Qt.Key （点击进去可以查到几乎所有按键宏定义）for the list of keyboard codes. These codes are independent of the underlying window system. Note that this function does not distinguish between capital and non-capital letters; use the text property for this purpose.
A value of either 0 or Qt.Key_Unknown means that the event is not the result of a known key; for example, it may be the result of a compose sequence, a keyboard macro, or due to key event compression.

modifiers : int

This property holds the keyboard modifier flags that existed immediately before the event occurred.
It contains a bitwise combination of:
Qt.NoModifier - No modifier key is pressed.
Qt.ShiftModifier - A Shift key on the keyboard is pressed.
Qt.ControlModifier - A Ctrl key on the keyboard is pressed.
Qt.AltModifier - An Alt key on the keyboard is pressed.
Qt.MetaModifier - A Meta key on the keyboard is pressed.
Qt.KeypadModifier - A keypad button is pressed.
Qt.GroupSwitchModifier - X11 only. A Mode_switch key on the keyboard is pressed.
For example, to react to a Shift key + Enter key combination:

  Item {
      focus: true
      Keys.onPressed: {
          if ((event.key == Qt.Key_Enter) && (event.modifiers & Qt.ShiftModifier))
              doSomething();
      }
  }

键盘事件示例：
1、包含头文件 #include <QKeyEvent>
2、声明虚函数 void keyPressEvent(QKeyEvent *k);
3、重载虚函数
//重写虚函数
void MainWindow::keyPressEvent(QKeyEvent *k)
{
    //检测 CTRL + S 按键信号
    if(k->modifiers() == Qt::ControlModifier && k->key() == Qt::Key_S)
    {
        saveActionSlot();
    }
}

帮助--> 搜索"MouseEvent" 可以查看一些鼠标动作信号宏定义，如下：
button : enumeration

This property holds the button that caused the event. It can be one of:
Qt.LeftButton
Qt.RightButton
Qt.MiddleButton

键盘事件示例：
1、包含头文件 #include <QMouseEvent>
2、声明虚函数 void mousePressEvent(QMouseEvent *m);
3、重载事件函数
//重写虚函数，鼠标事件
void MainWindow::mousePressEvent(QMouseEvent *m)
{
    QPoint pt = m->pos();   //QPoint类，获取鼠标位置
    qDebug() << pt;         //打印鼠标位置

    //检测鼠标动作
    if(m->button() == Qt::LeftButton)
    {
        qDebug() << "左键被按下";
    }
    else if(m->button() == Qt::RightButton)
    {
        qDebug() << "右键被按下";
    }
}

服务器                               客户端
socket(创建)              |          socket
bind(绑定)                |          
listen(监听)              |         
accept(接受客户端连接)     |          connect
send/recv(发送/接收数据)   |          send/recv

1、需要在工程里加上 “network”
D:\Qt_project\TCPClient\TCPClient.pro ："QT       += core gui network"
2、创建socket对象
#include <QTcpSocket>     //包含头文件
QTcpSocket *socket;       //声明对象指针
socket = new QTcpSocket;  //创建socket对象
3、获取服务器ip地址和端口号，并连接服务器（使用socket成员函数connectToHost）
void QNetworkAccessManager::connectToHost(const QString &hostName, quint16 port = 80)
Initiates a connection to the host given by hostName at port port. This function is useful to complete the TCP handshake to a host before the HTTP request is made, resulting in a lower network latency.

//连接槽函数实现：点击"连接"时，先获取ip地址和端口号
void Widget::on_connectButton_clicked()
{
    //获取ip地址,获取QString类型，后面需转换为QHostAddress类型类型（如何转换？ QHostAddress(const QString &address)）
    QString IP = ui->ipLineEdit->text();
    //获取端口号
    QString Port = ui->portLineEdit->text();

    //连接服务器.connectToHost函数参数：主机名（QHostAddress类型）、端口号（quint16类型）
    socket->connectToHost(QHostAddress(IP), Port.toShort());

    //连接服务器成功，socket对象会发出信号
    connect(socket, &QTcpSocket::connected, [this]()
    {
       QMessageBox::information(this, "连接提示", "连接服务器成功");
    });

    //连接断开，socket也会发出信号
    connect(socket, &QTcpSocket::disconnected, [this]()
    {
        QMessageBox::warning(this, "连接提示", "连接异常 断开服务器");
    });
}

#include <QTcpSocket>     //tcp服务器头文件
#include <QHostAddress>
#include <QMessageBox>

QTcpSocket *socket;

QTcpSocket *socket;

#include "widget.h"
#include "ui_widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    server = new QTcpServer;    //创建服务器对象
    //不需要绑定
    server->listen(QHostAddress::AnyIPv4, PORT);    //监听
    //客户端发起连接,server发出信号,创建槽函数接收到信号后进行处理
    connect(server, &QTcpServer::newConnection, this, &Widget::newTcpClientConnectSlot);
}

Widget::~Widget()
{
    delete ui;
}

//槽函数实现，处理接收到的客户端连接
void Widget::newTcpClientConnectSlot()
{
    //建立TCP连接
    QTcpSocket *socket = server->nextPendingConnection();
    //获取客户端地址(QHostAddress类型，显示出来需要转换成QString类型)和端口号(quint16类型，需要转换成QString类型)
    //socket->peerAddress();
    //socket->peerPort();

    ui->ipLineEdit->setText(socket->peerAddress().toString());
    ui->portLineEdit->setText(QString::number(socket->peerPort()));
}

//连接服务器成功，socket对象会发出信号
    connect(socket, &QTcpSocket::connected, [this]()
    {
       QMessageBox::information(this, "连接提示", "连接服务器成功");

       /*Qt启动新窗口*/
       this->hide();  //隐藏之前界面

       chart *c = new chart(socket);        //在对空间创建chart对象
       c->show();
    });

/*chart.h*/
#include <QTcpSocket>
class chart : public QWidget
{
    Q_OBJECT

public:
    //explicit chart(QWidget *parent = nullptr);
    /*修改chart构造函数，将socket传递给chart对象*/
    explicit chart(QTcpSocket *s, QWidget *parent = nullptr);
    ~chart();

private:
    Ui::chart *ui;

    QTcpSocket *socket;
};

/*chart.cpp*/
chart::chart(QTcpSocket *s, QWidget *parent) :
    QWidget(parent),
    ui(new Ui::chart)
{
    ui->setupUi(this);

    socket = s;
}

//“取消”槽函数实现
void chart::on_clearButton_clicked()
{
    ui->lineEdit->clear();
}
//“发送”槽函数实现
void chart::on_sendButton_clicked()
{
    QByteArray ba;
    ba.append(ui->lineEdit->text());    //将内容转成QByteArray类型发送（写入socket）
    socket->write(ba);
}

/*widget.h*/
private slots:
    void newTcpClientConnectSlot();

    /*Qt启动新窗口 服务器端修改*/
    void clientInfoSlot();

//槽函数实现，处理接收到的客户端连接
void Widget::newTcpClientConnectSlot()
{
    //建立TCP连接
    QTcpSocket *socket = server->nextPendingConnection();
    //获取客户端地址(QHostAddress类型，显示出来需要转换成QString类型)和端口号(quint16类型，需要转换成QString类型)
    //socket->peerAddress();
    //socket->peerPort();

    ui->ipLineEdit->setText(socket->peerAddress().toString());
    ui->portLineEdit->setText(QString::number(socket->peerPort()));

    /*Qt启动新窗口 服务器端修改*/
    //服务器接收到客户端发送的信息，socket发出readyread信号，构建一个槽函数进行处理
    connect(socket, &QTcpSocket::readyRead, this, &Widget::clientInfoSlot);

}

/*Qt启动新窗口 服务器端修改*/
//槽函数实现，接收
void Widget::clientInfoSlot()
{
    //获取信号的发出者
    QTcpSocket *s = (QTcpSocket *)sender();

    ui->lineEdit->setText(QString(s->readAll()));  //接收到的数据QByteArray类型，转成QString类型
}

/*mythread.h*/
#ifndef MYTHREAD_H
#define MYTHREAD_H

#include <QObject>
#include <QThread>
/*Qt多线程*/
#include <QTcpSocket>
#include <QDebug>

class myThread : /*public QObject,*/ public QThread       //QThread本身继承于QObject类
{
    Q_OBJECT
public:
    explicit myThread(QTcpSocket *s);    //, QObject *parent = nullptr);    /*Qt多线程 传参*/
    /*Qt多线程 重写run()函数*/
    void run();                 //线程处理函数

signals:

public slots:
    void clientInfoSlot();      /*Qt多线程 槽函数，收到客户端TCP连接信号之后处理*/

private:
    QTcpSocket *socket;
};

#endif // MYTHREAD_H

/*widget.cpp*/
//槽函数实现，处理接收到的客户端连接
void Widget::newTcpClientConnectSlot()
{
    //建立TCP连接
    QTcpSocket *socket = server->nextPendingConnection();
    //获取客户端地址(QHostAddress类型，显示出来需要转换成QString类型)和端口号(quint16类型，需要转换成QString类型)
    //socket->peerAddress();
    //socket->peerPort();

    ui->ipLineEdit->setText(socket->peerAddress().toString());
    ui->portLineEdit->setText(QString::number(socket->peerPort()));

    /*Qt启动新窗口 服务器端修改*/
    //服务器接收到客户端发送的信息，socket发出readyread信号，构建一个槽函数进行处理
    //connect(socket, &QTcpSocket::readyRead, this, &Widget::clientInfoSlot); /*Qt多线程 注释*/


    /*Qt多线程*/
    //启动线程
    myThread *t = new myThread(socket);    //创建线程对象。将widget类中的socket传递到myThread类中
    t->start();                            //开始线程
}
-----------------------------------------
/*mythread.cpp*/
#include "mythread.h"

myThread::myThread(QTcpSocket *s)//,QObject *parent) //: QObject(parent)
{
    socket = s;
}

void myThread::run()
{
    //在线程里处理客户端TCP连接
    connect(socket, &QTcpSocket::readyRead, this, &myThread::clientInfoSlot);
}

//不能在其他类里面操作界面
void myThread::clientInfoSlot()
{
    qDebug() << socket->readAll();  /*Qt多线程 打印接收到的内容*/
}

/*mythread.cpp*/
//不能在其他类里面操作界面，也就是不能再线程里操作widget类里的ui
void myThread::clientInfoSlot()
{
    //qDebug() << socket->readAll();  /*Qt多线程 打印接收到的内容*/

    /*自定义信号*/
    //将接收的数据读取
    QByteArray ba = socket->readAll();
    emit sendToWidget(ba);              //发送信号,将接受的内容ba传递过去
}

/*mythread.h*/
class myThread : /*public QObject,*/ public QThread
{
    Q_OBJECT
public:
    explicit myThread(QTcpSocket *s);    //, QObject *parent = nullptr);    /*Qt多线程 传参*/
    /*Qt多线程 重写run()函数*/
    void run();

signals:
    /*自定义信号*/
    void sendToWidget(QByteArray b);    //自定义信号，信号也是函数

public slots:
    void clientInfoSlot();      /*Qt多线程 槽函数，收到客户端TCP连接信号之后处理*/

private:
    QTcpSocket *socket;
};

/*widget.cpp*/
//槽函数实现，处理接收到的客户端连接
void Widget::newTcpClientConnectSlot()
{
    //建立TCP连接
    QTcpSocket *socket = server->nextPendingConnection();
    //获取客户端地址(QHostAddress类型，显示出来需要转换成QString类型)和端口号(quint16类型，需要转换成QString类型)
    //socket->peerAddress();
    //socket->peerPort();

    ui->ipLineEdit->setText(socket->peerAddress().toString());
    ui->portLineEdit->setText(QString::number(socket->peerPort()));

    /*Qt启动新窗口 服务器端修改*/
    //服务器接收到客户端发送的信息，socket发出readyread信号，构建一个槽函数进行处理
    //connect(socket, &QTcpSocket::readyRead, this, &Widget::clientInfoSlot); /*Qt多线程*/


    /*Qt多线程*/
    //启动线程
    myThread *t = new myThread(socket);    //将widget类中的socket传递到myThread类中
    t->start();

    /*自定义信号*/
    //接受线程信号并创建槽函数处理
    connect(t, &myThread::sendToWidget, this, &Widget::threadSlot);
}

/*自定义信号*/
//处理线程信息的槽函数
void Widget::threadSlot(QByteArray b)
{
    ui->lineEdit->setText(QString(b));
}

#开启mysql windows/linux
net start nysql / service mysql start
#以root用户登录mysql，也可以用其他创建的用户登录
mysql -u root -p
输入密码
#创建数据
//创建数据
create database mydatabase;
//创建表
use mydatabase;
create table student (
	id integer unsigned primary key,
	name varchar(16) not null,
	birth date
)charset utf8;
//查看表
select * from student;
//插入数据
insert into student values (1, "Tom", "1999-9-9");

describe student;

#include "widget.h"
#include "ui_widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    //连接数据库
    db = QSqlDatabase::addDatabase("QMYSQL");    //加载MYSQL数据库驱动

    db.setDatabaseName("mydatabase");           //数据库名字，已提前在mysql中创建好的'create database mydatabase;'
    db.setHostName("localhost");                //连接数据库所在主机，此处是本地数据库本地连接
    db.setUserName("root");                     //数据库用户名
    //db.setPassword("123456");                 //数据库密码

    //打开数据库
    if(db.open())
    {
        //设置提示，需包含头文件 #include <QMessageBox>
        QMessageBox::information(this, "连接提示", "连接成功");
    }
    else
    {
        QMessageBox::warning(this, "连接提示", "连接失败");
    }

}

Widget::~Widget()
{
    delete ui;
}


void Widget::on_insertPushButton_clicked()
{
    QString id = ui->idLineEdit->text();
    QString name = ui->nameLineEdit->text();
    QString birth = ui->lineEdit_2->text();

    //QString sql = QString("insert into student values (1, "Tom", "1999-9-9");")
    QString sql = QString("insert into student values (%1, '%2', '%3');").arg(id).arg(name).arg(birth);

    //插入，建立一个操作数据库的对象
    QSqlQuery query;
    if(query.exec(sql))
    {
        QMessageBox::information(this, "插入提示", "插入成功");
    }
    else
    {
        QMessageBox::information(this, "插入提示", "插入失败");
    }

}

void Widget::on_findPushButton_clicked()
{
    QSqlQuery query;
    query.exec("select * from student;");
    while (query.next())
    {
        //将查询的结果打印出来
        qDebug() << query.value(0);
        qDebug() << query.value(1);
        qDebug() << query.value(2);
    }
}

#include "widget.h"
#include "ui_widget.h"

Widget::Widget(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::Widget)
{
    ui->setupUi(this);

    //连接远程数据库
    QSqlDatabase db = QSqlDatabase::addDatabase("QMYSQL");

    //设置连接属性，数据库ip、用户名、密码
    db.setHostName("106.55.**.**");  //远程ubuntu云服务器ip
    db.setDatabaseName("mydatabase");
    db.setUserName("test");
    db.setPassword("test");

    if(db.open())
    {
        QMessageBox::information(this, "连接提示", "连接成功");
    }
    else
    {
        QMessageBox::warning(this, "连接提示", "连接失败");
    }
}

Widget::~Widget()
{
    delete ui;
}

#mysql创建用户，%表示所有用户都可以登录
create user "test"@"%" identified by "test";
#授权该用户的操作权限
grant select, insert, create on *.* to "test"@"%";
#exit退出，然后使用test用户登录
mysql -u test -p
#密码为test
#创建一个数据库
create database mydatabase;
#使用创建的数据库
use mydatabase;
#在数据库中创建一张表
create table student (
	id integer unsigned primary key,
	name varchar(16) not null,
	birth date
)charset utf8;
#在表中插入一些数据
insert into student values (1, "tom", "1999-9-9");
insert into student values (2, "jack", "1999-9-9");
insert into student values (3, "chen", "1993-07-22");

select * from student;

...
if(db.open())
{
    QMessageBox::information(this, "连接提示", "连接成功");

    //新建模型对象
    m = new QSqlTableModel;
    m->setTable("student");
    ui->tableView->setModel(m);     //将数据模型m对象与ui界面模型tableView连接起来


}
else
...

//ui上添加了一个“查询” PushButton
void Widget::on_pushButton_clicked()
{
    m->select();  //model模型对象的成员函数select查询
}