Java学习记录Day8

最新推荐文章于 2024-07-31 23:05:14 发布

SecretJFJ

最新推荐文章于 2024-07-31 23:05:14 发布

阅读量237

点赞数 7

文章标签： java 学习开发语言

本文链接：https://blog.csdn.net/SecretJFJ/article/details/135950687

版权

文章介绍了Java中的反射机制，包括如何获取Class对象，类加载器的工作原理，特别是双亲委派模型，以及JDBC的基本使用，如连接数据库、预编译语句等操作。

摘要由CSDN通过智能技术生成

一、反射

Java反射机制是在运行状态中，获取任意一个类（不存在的类也可）的结构，创建对象、得到方法、执行方法、属性。这种在运行状态动态获取信息以及动态调用对象方法的功能被称为Java语言的反射机制。

类加载器

Java类加载器（Java Classloader）是Java运行时环境（Java Runtime Environment）的一部分，负责动态加载Java类到Java虚拟机的内存空间中。

类通常是按需加载，即第一次使用该类时才加载。

双亲委派模型

如果一个类加载器收到了一个类加载的请求，它不会自己去尝试加载这个类，而是把这个请求转交给父类加载器去完成。每一层次的类加载器都是如此。因此所有的类加载请求都应该传递到最顶层的启动类加载器中，只有到父类加载器反馈自己无法完成这个加载请求（在它的搜索范围没有找到这个类）时，子类加载器才会尝试自己去加载。委派的好处就是避免有些类被重复加载。

得到Class的三种方式

package com.java;

import org.junit.Test;

public class GetClassTest {
    @Test
    public void getClassTest() throws ClassNotFoundException {
        //获取Class对象
        //方式一：通过全类名.class的方式获取，已知一个类存在
        Class c1 = Person.class;
        System.out.println(c1); //class com.java.Person

        //方式二：对象.getClass()得到类的Class对象
        Class c2 = new Person().getClass();
        System.out.println(c2); //class com.java.Person
        System.out.println(c1 == c2); //true

        //（推荐）方式三：Class.forName("全类名")，所谓全类名就是包名+类名，类未知也可使用（ClassNotFoundException）
        Class c3 = Class.forName("com.java.Person");
        System.out.println(c3); //class com.java.Person
        System.out.println(c1 == c3 && c2 == c3); //true
    }
}

package com.java;

import org.junit.Test;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class GetClassTest {
    @Test
    public void getClassTest() throws ClassNotFoundException {
        //获取Class对象
        //方式一：通过全类名.class的方式获取，已知一个类存在
        Class c1 = Person.class;
        System.out.println(c1); //class com.java.Person

        //方式二：对象.getClass()得到类的Class对象
        Class c2 = new Person().getClass();
        System.out.println(c2); //class com.java.Person
        System.out.println(c1 == c2); //true

        //（推荐）方式三：Class.forName("全类名")，所谓全类名就是包名+类名，类未知也可使用（ClassNotFoundException）
        Class c3 = Class.forName("com.java.Person");
        System.out.println(c3); //class com.java.Person
        System.out.println(c1 == c3 && c2 == c3); //true
    }

    @Test
    public void getConstructorTest() throws Exception {
        //获取类的Class对象
        Class c = Class.forName("com.java.Person");

        //获取构造器
        Constructor constructor = c.getConstructor();
        //Constructor创建对象 - newInstance(Object... para)
        Object o = constructor.newInstance();
        System.out.println(o);
        System.out.println("----------------------------------------");

        //获取Person类中私有的构造器
        //获取所有权限的单个构造方法 - getDeclaredConstructor(参数类型的class对象数组)
        Constructor declaredConstructor = c.getDeclaredConstructor(String.class);
        //setAccessible(boolean flag) - 如果flag为true，则忽视访问权限检测
        declaredConstructor.setAccessible(true);
        Object o1 = declaredConstructor.newInstance("17836194667");
        System.out.println(o1);
    }

    @Test
    public void getMethodTest() throws Exception {
        Class c = Class.forName("com.java.Person");

        Constructor constructor = c.getConstructor();
        Object o = constructor.newInstance();

        Method setName = c.getMethod("setName", String.class);
        setName.invoke(o, "张三");
        System.out.println(o);
        System.out.println("-----------------------------");

        Method show = c.getDeclaredMethod("show");
        show.setAccessible(true);
        show.invoke(o);
        System.out.println(o);
    }
}

package com.java;

public class Person {
    private String name;
    private int age;
    public String phoneNumber;

    public Person() {}

    private Person(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    public Person(String name, int age, String phoneNumber) {
        this.name = name;
        this.age = age;
        this.phoneNumber = phoneNumber;
    }

    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 String getPhoneNumber() {
        return phoneNumber;
    }

    public void setPhoneNumber(String phoneNumber) {
        this.phoneNumber = phoneNumber;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", phoneNumber='" + phoneNumber + '\'' +
                '}';
    }

    private void show() {
        System.out.println("你居然可以调用我！！！");
    }
}

二、JDBC

package com.util;

import java.io.IOException;
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;

public class DBUtils {
    private static String url = "";
    private static String username = "";
    private static String password = "";

    //静态代码块，只执行一次
    static {
        InputStream inputStream = DBUtils.class.getClassLoader().getResourceAsStream("jdbc.properties");
        Properties properties = new Properties();
        try {
            properties.load(inputStream);
            url = properties.getProperty("url");
            username = properties.getProperty("username");
            password = properties.getProperty("password");
            try {
                Class.forName("com.mysql.cj.jdbc.Driver");
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }

    public static void close(Connection connection, PreparedStatement preparedStatement, ResultSet resultSet) {
        //6、释放资源Connection、PreparedStatement、ResultSet，释放时从后往前
        //如果connection、preparedStatement、resultSet对象为null，JVM GC垃圾回收机制
        if (resultSet != null) {
            try {
                resultSet.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (preparedStatement != null) {
            try {
                preparedStatement.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
        if (connection != null) {
            try {
                connection.close();
            } catch (SQLException throwables) {
                throwables.printStackTrace();
            }
        }
    }
}

package com.util;

import org.junit.Test;

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

public class DBUtilsTest {
    private static final String INSERT_SQL = "insert into emp(empno, ename, job) values (?, ?, ?)";
    private static final String UPDATE_SQL = "update emp set ename = ?, job = ? where empno = ?";
    private static final String DELETE_SQL = "delete from emp where empno = ?";

    @Test
    public void test01() throws SQLException {
        Connection connection = DBUtils.getConnection();
        System.out.println(connection);
    }

    @Test
    public void insertTest() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = DBUtils.getConnection();
            preparedStatement = connection.prepareStatement(INSERT_SQL);
            preparedStatement.setString(1, "2024");
            preparedStatement.setString(2, "赵亮");
            preparedStatement.setString(3, "CEO");
            int i = preparedStatement.executeUpdate();
            if (i > 0) {
                System.out.println("插入成功！");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            DBUtils.close(connection, preparedStatement, null);
        }
    }

    @Test
    public void updateTest() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = DBUtils.getConnection();
            preparedStatement = connection.prepareStatement(UPDATE_SQL);
            preparedStatement.setString(1, "张辉");
            preparedStatement.setString(2, "董事长");
            preparedStatement.setString(3, "2024");
            int i = preparedStatement.executeUpdate();
            if (i > 0) {
                System.out.println("修改成功！");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            DBUtils.close(connection, preparedStatement, null);
        }
    }

    @Test
    public void deleteTest() {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try {
            connection = DBUtils.getConnection();
            preparedStatement = connection.prepareStatement(DELETE_SQL);
            preparedStatement.setString(1, "2024");
            int i = preparedStatement.executeUpdate();
            if (i > 0) {
                System.out.println("删除成功！");
            }
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        } finally {
            DBUtils.close(connection, preparedStatement, null);
        }
    }
}