Java小农养成记第二十八天

最新推荐文章于 2024-05-31 10:46:10 发布
最新推荐文章于 2024-05-31 10:46:10 发布
阅读量976 收藏
点赞数
分类专栏： Java学习笔记 文章标签： java 数据库 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45265623/article/details/122775800
版权

day28

今日内容

  1. JDBC基本概念
  2. 快速入门
  3. 对JDBC中个接口和类详解

JDBC

  1. 概念：Java数据库连接，（Java Database Connectivity，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun Microsystems的商标。我们通常说的JDBC是面向关系型数据库的。

JDBC的本质：其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包的实现类。

  1. 快速入门：
步骤：
1.导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
	1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
	2.右键-->Add As Library
2.注册驱动
3.获取数据库连接对象Connection
4.定义sql
5.获取执行sql语句的对象Statement
6.执行sql，接受返回结果
7.处理结果
8.释放资源
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.Statement;

public class JdbcDemo01 {
    public static void main(String[] args) throws Exception {
//        1.导入驱动jar包
//        2.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
//        3.获取数据库连接对象Connection
        Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
//        4.定义sql
        String sql = "update account set balance = 500 where id = 1";
//        5.获取执行sql语句的对象Statement
        Statement statement = conn.createStatement();
//        6.执行sql，接受返回结果
        int count = statement.executeUpdate(sql);
//        7.处理结果
        System.out.println(count);
//        8.释放资源
        statement.close();
        conn.close();
    }
}
  1. 详解各个对象：
  • DriverManager：驱动管理对象，类
  • 功能：
  1. 注册驱动：告诉程序该使用哪一个数据库驱动jar
			static void registerDriver(Driver driver) 注册与给定的驱动程序 DriverManager 。 
			写代码使用：Class.forName("com.mysql.jdbc.Driver");
			通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块
			static {
                try {
                    DriverManager.registerDriver(new Driver());
                } catch (SQLException var1) {
                    throw new RuntimeException("Can't register driver!");
                }
            }
            注意：mysql 5 之后的驱动jar包可以省略注册驱动的步骤
            	Class.forName("com.mysql.jdbc.Driver");
  1. 获取数据库连接
		方法：static Connection getConnection(String url, String user, String password) 尝试建立与给定数据库URL的连接。 
		参数：
			url:指定连接的路径
				语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
				例子：jdbc:mysql://localhost:3306/db3
				细节：乳如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///数据库名称
			user:用户名
			password:密码
  • Connection：数据库连接对象，接口
    • 功能：
		1. 获取执行sql的对象
			Statement createStatement()创建一个 Statement对象，用于将SQL语句发送到数据库。
			PreparedStatement prepareStatement(String sql)创建一个 PreparedStatement对象，用于将参数化的SQL语句发送到数据库。
		2. 管理事务：
			开启事务：void setAutoCommit(boolean autoCommit)将此连接的自动提交模式设置为给定状态。调用该方法设置参数为false，即开启事务
			提交事务：void commit()使自上次提交/回滚以来所做的所有更改都将永久性，并释放此 Connection对象当前持有的任何数据库锁。  
			回滚事务：void rollback()撤消在当前事务中所做的所有更改，并释放此 Connection对象当前持有的任何数据库锁。
  • Statement：用于执行静态SQL语句并返回其生成的结果的对象，接口
    • 执行sql
		boolean execute(String sql)执行给定的SQL语句，这可能会返回多个结果。（了解）
		返回值：
		true表示第一个结果是一个ResultSet对象;
		false表示更新计数或没有结果。
		
		int executeUpdate(String sql)执行给定的SQL语句(DML)，这可能是INSERT,UPDATE,或DELETE语句，或者不返回任何内容，如DDL语句的SQL语句(create,alter,drop)。  
		返回值：
            （1）返回值>0表示sql语句影响了多少行记录，可以通过这个影响的行数判断DML语句是否执行成功，返回值>0的则执行成功，反之，则失败。
            （2）0不返回的SQL语句，如DDL语句
		ResultSet executeQuery(String sql)执行给定的SQL语句，该语句返回单个ResultSet对象。  
			一个ResultSet对象，其中包含给定查询产生的数据; 从不null
  • 练习
		import java.sql.Connection;
        import java.sql.DriverManager;
        import java.sql.SQLException;
        import java.sql.Statement;
        /*
        account表添加一条记录insert语句
         */
        public class JDBCDemo02 {
            public static void main(String[] args) {
    
                Statement statement = null;
                Connection connection = null;
                try {
                    //1.注册驱动
                    Class.forName("com.mysql.jdbc.Driver");
                    //2.定义sql
                    String sql = "insert into account values(null, '王五', 3000)";//id是自动增长的，null为占位符
                    //执行DDL语句，如创建一张表
                    //String sql = "create table student (id int, name varchar(20))";
                    //3.获取Connection对象
                    connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3", "root", "root");
                    //4.获取执行SQL的对象statement
                    statement = connection.createStatement();
                    //5.执行sql
                    int count = statement.executeUpdate(sql);
                    //处理打印结果
                    System.out.println(count);
                    if (count > 0){
                        System.out.println("添加成功");
                    }else{
                        System.out.println("添加失败");
                    }
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                } catch (SQLException e) {
                    e.printStackTrace();
                } finally {
                    //statement.close();
                    //避免空指针异常
                    if (statement != null) {
                        try {
                            statement.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                    }
                    if (connection != null){
                        try {
                            connection.close();
                        } catch (SQLException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
  • Resultset：结构集对象，接口，表示数据库结果集的数据表，通常通过执行查询数据库的语句生成。
	boolean next()将光标从当前位置向前移动一行。
	返回值：
		true表示新的当前行有效;
		false表示没有更多的行;
	getXxx(参数)获取数据
		Xxx：代表数据类型 如：int getInt() 、String getString()
		参数：
			1. int:代表列的编号，从1开始 如：getString(1)
			2. String:代表列名称 如：getDouble("balance")
	注意：
		使用步骤：
			1. 游标向下移动一行
			2. 判断是否有数据
			3. 获取数据
			//6.1循环判断游标是否是最后一行末尾
            while (resultSet.next()){
                //
                //6.2获取数据
                int id = resultSet.getInt(1);
                String name = resultSet.getString("name");
                double balance = resultSet.getDouble(3);
                System.out.println(id + "------" + name + "------" + balance);
            }
  • 练习
	/*
		定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回
		1. 定义emp类
		2. 定义方法public list<Emp> findAll(){}
		3. 实现方法select * from emp;
	*/
	package cn.itcast.domain;
    import java.util.Date;

    /*
    封装Emp表数据的javaBean
     */
    public class Emp {
        private int id;
        private String name;
        private int job_id;
        private int mgr;
        private Date joindate;
        private double salary;
        private double bonus;
        private int dept_id;

        public Emp() {
        }
    
        public Emp(int id, String name, int job_id, int mgr, Date joindate, double salary, double bonus, int dept_id) {
            this.id = id;
            this.name = name;
            this.job_id = job_id;
            this.mgr = mgr;
            this.joindate = joindate;
            this.salary = salary;
            this.bonus = bonus;
            this.dept_id = dept_id;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getJob_id() {
            return job_id;
        }
    
        public void setJob_id(int job_id) {
            this.job_id = job_id;
        }
    
        public int getMgr() {
            return mgr;
        }
    
        public void setMgr(int mgr) {
            this.mgr = mgr;
        }
    
        public Date getJoindate() {
            return joindate;
        }
    
        public void setJoindate(Date joindate) {
            this.joindate = joindate;
        }
    
        public double getSalary() {
            return salary;
        }
    
        public void setSalary(double salary) {
            this.salary = salary;
        }
    
        public double getBonus() {
            return bonus;
        }
    
        public void setBonus(double bonus) {
            this.bonus = bonus;
        }
    
        public int getDept_id() {
            return dept_id;
        }
    
        public void setDept_id(int dept_id) {
            this.dept_id = dept_id;
        }
    
        @Override
        public String toString() {
            return "Emp{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    ", job_id=" + job_id +
                    ", mgr=" + mgr +
                    ", joindate=" + joindate +
                    ", salary=" + salary +
                    ", bonus=" + bonus +
                    ", dept_id=" + dept_id +
                    '}';
        }
    }
    package cn.itcast.jdbc;

    import cn.itcast.domain.Emp;

    import java.sql.*;
    import java.util.ArrayList;
    import java.util.List;

    /*
        定义一个方法，查询emp表的数据将其封装为对象，然后装载集合，返回。
     */
    public class JDBCDemo08 {

        public static void main(String[] args) {
            List<Emp> all = new JDBCDemo08().findAll();
            System.out.println(all);
            System.out.println(all.size());
        }
        /**
         * 查询所有emp对象
         * @return
         */
        public List<Emp> findAll(){
            Connection connection = null;
            Statement statement = null;
            ResultSet resultSet = null;
            List<Emp> list = null;
            try {
                //1.注册驱动
                Class.forName("com.mysql.jdbc.Driver");
                //2.获取连接
                connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db3","root","root");
                //3.定义sql
                String sql = "select * from emp";
                //4.获取执行sql的对象
                statement = connection.createStatement();
                //5.执行sql
                resultSet = statement.executeQuery(sql);
                //6.遍历结构集，封装对象，装载集合
                Emp emp = null;
                list = new ArrayList<>();
                while (resultSet.next()){
                    int id = resultSet.getInt("id");
                    String ename = resultSet.getString("ename");
                    int job_id = resultSet.getInt("job_id");
                    int mgr = resultSet.getInt("mgr");
                    Date joindate = resultSet.getDate("joindate");
                    double salary = resultSet.getDouble("salary");
                    double bonus = resultSet.getDouble("bonus");
                    int dept_id = resultSet.getInt("dept_id");
                    //创建emp对象,并赋值
                    emp = new Emp(id, ename, job_id, mgr, joindate, salary, bonus, dept_id);
    
                    list.add(emp);
                }
    
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } catch (SQLException e) {
                e.printStackTrace();
            } finally {
                if (resultSet != null){
                    try {
                        resultSet.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                if (statement != null){
                    try {
                        statement.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
                if (connection != null){
                    try {
                        connection.close();
                    } catch (SQLException e) {
                        e.printStackTrace();
                    }
                }
            }
            return list;
        }
    }
  • 练习：
需求：
	1.通过键盘录入用户名和密码
    2.判断用户是否登录成功

    -- 创建数据库
    CREATE DATABASE db4;
    USE db4;
    CREATE TABLE USER(
        id INT PRIMARY KEY AUTO_INCREMENT,
        username VARCHAR(32),
        PASSWORD VARCHAR(32)
    );
    INSERT INTO USER VALUE
    (NULL, 'zhangsan', '123'),
    (NULL, 'lisi', '234');

    package cn.itcast.jdbc;
    import cn.itcast.util.JDBCUtils;
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    import java.util.Scanner;

    /*
    练习：
        需求：
            1.通过键盘录入用户名和密码
            2.判断用户是否登录成功
     */
    public class JDBCDemo09 {
        public static void main(String[] args) {
            //1.键盘录入，接受用户名和密码
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名:");
            String username = sc.nextLine();
            System.out.println("请输入密码：");
            String password = sc.nextLine();
            //2.调用方法
            boolean flag = new JDBCDemo09().login(username, password);
            //3.判断结果，输出不同语句
            if(flag){
                System.out.println("登录成功！");
            }else{
                System.out.println("用户名或密码错误！");
            }
        }
        /**
         * 登录方法
         */
        public boolean login(String username, String password){
            if (username == null || password == null){
                return false;
            }
            //连接数据库判断是否登录成功

            Connection conn = null;
            Statement statement = null;
            ResultSet resultSet = null;
            try {
                //1.获取连接
                conn = JDBCUtils.getConnection();
                //2.定义sql
                String sql = "select * from user where username = '" + username + "'and password = '" + password + "'";
                //3.获取执行sql的对象
                statement = conn.createStatement();
                //执行查询
                resultSet = statement.executeQuery(sql);
                //5.判断
                return resultSet.next();
            } catch (SQLException e) {
                e.printStackTrace();
            }  finally {
                JDBCUtils.close(resultSet, statement, conn);
            }
            return false;
        }
    }
  • PreparedStatement：执行sql的对象，接口，表示预编译的SQL语句的对象。
    * SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
        1. 输入用户随便，输入密码：a' or 'a' = 'a
        2. sql : select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a'
    * 解决sql注入问题：使用PreparedStatement对象来解决
    * 预编译的sql：参数使用?作为占位符
    * 步骤：
        1.导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
            1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下
            2.右键-->Add As Library
        2.注册驱动
        3.获取数据库连接对象Connection
        4.定义sql
        	* 注意：sql的参数使用?作为占位符。如：select * from user where username = ? and password = ?
        5.获取执行sql语句的对象PreparedStatement
        	PreparedStatement prepareStatement(String sql) 
创建一个 PreparedStatement对象，用于将参数化的SQL语句发送到数据库。
		6.给?赋值：
			方法：setXxx(参数1, 参数2)
				* 参数1: ?的位置编号，从1开始
				* 参数2：?的值
        7.执行sql，接受返回结果，不需要传递sql语句
        8.处理结果
        9.释放资源
	* 注意：后期都会使用Preparedstatement来完成增删改查的所有操作
		1.可以防止SQL注入
		2.效率更高

     /**
     * 登录方法:使用PreparedStatement实现
     */
    public boolean login2(String username, String password){
        if (username == null || password == null){
            return false;
        }
        //连接数据库判断是否登录成功
    
        Connection conn = null;
        ResultSet resultSet = null;
        PreparedStatement preparedStatement = null;
        try {
            //1.获取连接
            conn = JDBCUtils.getConnection();
            //2.定义sql
            String sql = "select * from user where username = ? and password = ?";
            //3.获取执行sql的对象
            preparedStatement = conn.prepareStatement(sql);
            //给?赋值
            preparedStatement.setString(1, username);
            preparedStatement.setString(2, password);
            //4.执行查询不需要传递sql
            resultSet = preparedStatement.executeQuery();
            //5.判断
            return resultSet.next();
        } catch (SQLException e) {
            e.printStackTrace();
        }  finally {
            JDBCUtils.close(resultSet, preparedStatement, conn);
        }
        return false;
    }

抽JDBC工具类：JDBCUtils

目的：简化书写
分析：
	1. 注册驱动也抽取
	2. 抽取一个方法获取连接对象
		需求：不想传递参数，还想保证工具类的通用性。
		解决：配置文件
			jdbc_properties
				url = 
				user =
				password
	3. 抽取一个方法释放资源

url = jdbc:mysql://localhost:3306/db3
user = root
password = root
driver = com.mysql.jdbc.Driver

package cn.itcast.util;

import java.io.FileReader;
import java.io.IOException;
import java.net.URL;
import java.sql.*;
import java.util.Properties;

/*
    JDBC工具类
 */
public class JDBCUtils {
    private static String url;
    private static String user;
    private static String password;
    private static String driver;
    /**
     * 文件的读取，只需要读取一次即可拿到这些值，使用静态代码块
     *
     */
    static {
        //读取资源文件，获取值
        try {
            //1.创建Properties集合类
            Properties properties = new Properties();

            //获取src路径下的文件的方式--->ClassLoader类加载器
            ClassLoader classLoader = JDBCUtils.class.getClassLoader();
            URL res = classLoader.getResource("jdbc_properties");
            String path = res.getPath();
            //2.加载文件
            //properties.load(new FileReader("E:\\Java\\JavaWorkSpace\\JDBC\\day01_jdbc\\src\\jdbc_properties"));
            properties.load(new FileReader(path));

            //3.获取数据，赋值
            url = properties.getProperty("url");
            user = properties.getProperty("user");
            password = properties.getProperty("password");
            driver = properties.getProperty("driver");

            //4. 注册驱动
            Class.forName(driver);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取连接对象
     * @return 连接对象
     */
    public static Connection getConnection() throws SQLException {

        return DriverManager.getConnection(url, user, password);
    }

    /**
     * 释放资源
     * @param statement
     * @param connection
     */
    public static void close(Statement statement, Connection connection){
        if (statement != null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 释放资源
     * @param statement
     * @param connection
     * @param resultSet
     */
    public static void close(ResultSet resultSet, Statement statement, Connection connection){
        if (resultSet != null){
            try {
                resultSet.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (statement != null){
            try {
                statement.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (connection != null){
            try {
                connection.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

JDBC控制事务：

  1. 事务：一个包含多个步骤的业务操作。如果这个业务操作被事物管理，则这多个步骤要么同时成功，要么同时失败
  2. 操作：
    1.开启事务
    2.提交事务
    3.回滚事务
  3. 使用Connection对象来管理事务
    • 开启事务：void setAutoCommit(boolean autoCommit)将此连接的自动提交模式设置为给定状态。调用该方法设置参数为false，即开启事务
      • 在执行sql之前开启事务
    • 提交事务：void commit()使自上次提交/回滚以来所做的所有更改都将永久性，并释放此 Connection对象当前持有的任何数据库锁。
      • 当所有sql都执行完提交事务
    • 回滚事务：void rollback()撤消在当前事务中所做的所有更改，并释放此 Connection对象当前持有的任何数据库锁。
      • 在catch中回滚事务
import cn.itcast.util.JDBCUtils;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/*
事务操作
 */
public class JDBCDemo10 {
    public static void main(String[] args) {
        Connection connection = null;
        PreparedStatement preparedStatement1 = null;
        PreparedStatement preparedStatement2 = null;
        try {
            //1. 获取连接
            connection = JDBCUtils.getConnection();
            // 开启事务
            connection.setAutoCommit(false);

            //2. 定义sql
            //2.1 张三 - 500
            String sql1 = "update account set balance = balance - ? where id = ?";
            //2.2 李四 + 500
            String sql2 = "update account set balance = balance + ? where id = ?";
            //3.获取执行sql对象
            preparedStatement1 = connection.prepareStatement(sql1);
            preparedStatement2 = connection.prepareStatement(sql2);
            //4.设置参数
            preparedStatement1.setDouble(1, 500);
            preparedStatement1.setInt(2, 1);

            preparedStatement2.setDouble(1, 500);
            preparedStatement2.setInt(2, 2);

            //5.执行sql
            preparedStatement1.executeUpdate();

            //手动制造异常
            int i = 3/0;

            preparedStatement2.executeUpdate();

            connection.commit();
        } catch (Exception e) {
            //事务回滚
            try {
                if (connection != null)
                    connection.rollback();
            } catch (SQLException e1) {
                e1.printStackTrace();
            }
            e.printStackTrace();
        } finally {
            JDBCUtils.close(preparedStatement1,connection);
            JDBCUtils.close(preparedStatement2,null);
        }
    }
}
舍得..
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
小农signcode算法测试源码
11-03
小农signcode算法测试源码 解压密码xiami2834
小农sign code算法源码分享，欢迎一起学习交流
11-04
小农sign code算法源码分享，欢迎一起学习交流，如需要小农，贵旅优品，黄果树，安心e购，空港商城也可以联系。解压密码：lnzhwh
Java小农养成记第十八天
qq_45265623的博客
01-22 265
java入门笔记
Java小农养成记第八天
qq_45265623的博客
01-11 64
Java入门笔记
Java小农养成记第四十天
qq_45265623的博客
02-22 73
JavaEE
Java小农养成记第五天
qq_45265623的博客
01-08 437
Java入门笔记
Java小农养成记第四天
qq_45265623的博客
01-07 474
Java入门笔记
Java小农养成记第十九天
qq_45265623的博客
01-23 98
java入门笔记
Nacos详解
星哲最开心
11-12 1414
Nacos详解
从程序员到项目经理
zzming2012的专栏
01-12 6837
从程序员到项目经理（一）：为什么要当项目经理 “从程序员到项目经理”，这个标题让我想起了很久以前一本书的名字《从Javascript到Java》。然而，从Javascript到Java充其量只是工具的更新，而从程序员到项目经理，却是一个脱胎换骨的过程。从Javascript到Java，是一个取巧的方法；而从程序员到项目经理，却并无捷径可走，必须从内而外的改变和提升。 一．为什么要当项目经理
c语言多文件编程，即main文件调用其他.c文件的方法
热门推荐
脱去三千烦恼丝
01-29 1万+
首页 博客 学院 下载 论坛 问答 活动 专题 招聘 APP VIP会员 博客之星 写博客 5 c语言多文件编程，即main文件调用其他.c文件的方法 原创 天泉证道 最后发布于2018-11-14 14:46:32 阅读数 4047 收藏 展开 c语言多文件编程，即main文件调用其他.c文件的方法。 两种方法的区别就是，gcc编译时，是否加b.c文件，不加的话，就在a.c文件里面，加#in...
安装java JDK教程.rar
11-08
64位的Java JDK安装包。博客上有免费的配套安装教程！
小农与市场化.ppt
11-29
小农与市场化.ppt
小农水安全施工方案.docx
10-01
小农水安全施工方案.docx
【STM32学习】HAL库点灯学习
2301_78895982的博客
05-26 946
STM32基于HAL库流水灯实验_hel库安装教程中文版-CSDN博客t=N7T8。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 976
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 770
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
Java手动启动jar包
liangweihao的博客
05-29 276
【代码】Java手动启动jar包。
小农耕作可持续性模型
10-07
小农耕作可持续性模型是一种为了解决全球饥饿问题而提出的农业模型。该模型通过提高农民的产出效率和农田的生产潜力，以确保农民能够养活更多的人口，同时保护土壤和环境资源。小农耕作可持续性模型的关键在于精确的农业技术和管理方法，以确保农田的最佳利用和农作物的最大产量。 在这个模型中，精准农业是一个重要的概念。通过利用先进的技术和传感器，农民可以实时监测土壤的水分含量、营养情况和农作物的生长情况。根据这些信息，农民可以采取相应的措施，如精确施肥和灌溉，以提高农田的肥力和农作物的产量。此外，小农耕作可持续性模型还鼓励农民进行适当的轮作和间奏种植，以防止土壤贫瘠和病虫害的发生。 除了技术和管理方法的改进，小农耕作可持续性模型还需要政府和农民之间的合作和支持。政府可以提供资金和培训，以帮助农民采用新的农业技术和管理方法。农民也可以通过组织合作社或农业合作社，共同分享资源和知识，以提高整个农田的生产效率和可持续性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值