【JDBC以及内部类的讲解】

(点击跳转即可哦)

java学习专栏

LeetCode刷题专栏

---

JDBC及内部类

JDBC

JDBC套路代码，修改 excuteUpdate(), 查询 excuteQuery()

所有Java操作关系型数据库，无论是哪种数据库，套路都是一样的。JPA、MyBatis 都是JDBC 的封装。

---

Java.sql下的接口

1. 获取数据源 DataSource ,配置连接地址，用户名、密码等
2. 获取连接对象，就是发送网络请求，建立和数据库的连接 Connection
3. 获取执行 SQL 的对象 PreparedStatement 对象，封装的SQL语句

Connection connection = dataSource.getConnection();

String sql = “select password from user where username = ?”;

PreparedStatement statement = connection.prepareStatement(sql);

statement.setString(1,“姓名”);

4. 执行更新操作 executeUpdate => int 本次更新受影响的行数

​ 执行查询 executeQuery => Result 结果集

ResultSet resultSet = statement.executeQuery();

5. 遍历结果集 ResultSet 对象，每当调用一次next 方法，就从结果集中取出一行数据 resule.getXX(“列名”) => 获取本行数据的具体属性值

while(resultSet.next())

6. 操作之后 关闭资源，resultSet,Connection对象

---

获取数据源 有 两种方式：

一个是DataSource方式（实际用到的）

另一个是DriverManager(不推荐使用)

DataSource :

在内部创建 Connection 对象的连接池， “池”：资源重复利用

当一个Connection 对象调用close方法之后 他不是真正关闭，这个对象会被 DataSource 回收，进入连接池。

若此时有别的用户需要建立连接，不是创建一个新的连接，若此时连接池中有空闲连接，直接使用此连接。

数据库连接的建立和销毁操作还是很耗时耗资源的

---

DriverManager 类来获取的Connection 连接，是无法重复利用的，每次使用完以后释放资源时，通过connection.close() 都是关闭物理连接

---

具体执行SQL的对象也有两种方式，

一个是 PreparedStatement对象（推荐使用）

另外一个是 Statement对象

---

Statement : 用于执行不带参数的简单SQL语句

PreparedStatement:

用于执行带或者不带参数的SQL语句

SQL 语句会预编译在数据库系统中

执行速度快于 Statement 对象

---

内部类

所谓的内部类，就是将一个类嵌套到另一个类的内部的操作

其实就是把 内部类 当前类中的一个属性来看待

内部类 分为：

1. 成员内部类
2. 静态内部类
3. 方法内部类
4. 匿名内部类（Lambda表达式的前身）

1 和2都是定义在类中的， 3和4 是定义在方法区中的

内部类存在的原因：

1. 内部类和外部类可以方便的访问彼此的私有域（属性和方法）
2. 内部类可以对 外部类的外部完全隐藏（把内部类就当作外部类的属性来看待）访问修饰符 private < default < protected < public 内部类可以使用private关键字
3. 内部类可以变相实现多继承（了解即可）

成员内部类

1、成员内部类：在外部类的内部不使用static 关键字定义的内部类就是成员内部类。类比成员属性和成员方法 - 成员内部类需要依赖外部类对象（先有外部类对象，才有内部类对象）

关于成员内部类产生对象的两种方式：

1. 在外部类的内部产生 成员内部类对象 ：就和普通类没啥区别。内部类名称 内部类引用 = new 内部类();
2. 若内部类对外部可见（不是private修饰的内部类）。在外部类的外部创建内部类对象， 外部类名称.内部类名称 内部类引用 = new 外部类().new 内部类(); eg: Outter.Inner inner = new Outter().new Inner();

2、成员内部类需要依靠外部类的对象，先产生外部类对象，然后产生内部类对象 - 类比成员属性或成员方法。

成员方法可以访问类中的实例变量和静态变量，但是不能定义静态变量

静态方法可以访问类中的静态变量，不可以访问成员变量

3、成员内部类可以直接访问外部类的私有属性

问题1：

成员内部类 能否访问外部类中的静态域 能否在当前内部类中自己定义静态域？

答：可以访问外部类中的静态域，因为成员内部类已经拥有了外部类的对象，都有外部类对象了，当然可以访问静态属性

不能在当前内部类中自己定义静态域。假设可以的话，成员内部类的静态属性不需要产生对象就能够调用， 这和 成员内部类必须要依赖外部类对象才能产生 是互相矛盾的。

静态内部类

使用static 关键字 定义在另一个类的内部的类 —— 静态方法或属性

静态内部类和成员内部类最大的区别是：静态内部类不需要外部类的对象，和外部类是一个相对独立的关系，只是套在外部类的内部定义而已。

静态内部类只能访问外部类的静态域， 没有外部类对象，无法直接访问外部类的成员域

问题：静态内部类中能否定义自己的成员域？

可以，静态内部类就是个普通类，只不过套在一个类的内部而已

---

小结：

成员内部类可以访问外部类的所有域（成员，静态），因为成员内部类依赖外部类的对象，不能拥有自己的静态域。

静态内部类 可以拥有自己的成员域，但是不能直接访问外部类的成员域（没有外部类对象）

---

方法内部类

是定义在方法内部的类

public class Main{
    
    public void fun(){
    
        //方法内部类
        class test{
    
            
        }
    }
}

注意：

1. 方法内部类不能使用任何权限修饰符(这个类出了方法就没了)
2. 对外部完全隐藏(对外部类的外部)
3. 内部类要使用该方法的形参或者局部变量，该变量必须为隐式 的final声明（方法内部类要使用外部方法中的形参或者局部变量，只有读取权，无法修改）
4. 若在方法内部类中读取了方法中的局部变量（形参或者局部变量）这个局部变量就无法修改（不仅在内部类中无法修改，在方法中也不能 修改）
5. 方法内部类中不能定义static 静态域（因为方法中不能定义静态变量 ）

匿名内部类

定义在方法中（方法中的形参或者实参）——实参用的多

没有任何权限修饰符，甚至连类名称都没有

匿名内部类也是方法内部类的一种，最多用在方法形参中

interface IMessage{
    
    void getMag(String msg);
}
public class Main{
    
    public static void main(String[] args){
    
        fun(new IMessage(){
    
            @Override
           public void getMag(String msg){
    
               
           } 
        });
    }
}

接口无法直接实例化对象的，因此我们此处new 的是 IMessage 接口的子类，只不过这个子类只在fun方法中使用一次

---

Lambda 表达式

2008年 JDK8发布，划时代的版本

Hadoop Map Reduce 里面就是各种Lambda表达式的使用

函数式编程思想 —》 Scala

java这种面向对象的定义太繁琐，在处理各种数学运算时，频繁需要定义类，对象，方法之类的

---

JDK8之后，在接口中引入了default普通方法。JDK8之前，接口中只有全局常量和抽象方法

default关键字在接口中定义的方法是普通方法（不能省略），子类不需要覆写。

不写default就认为是抽象方法

不常用，一般都是在修正上古版本接口中拓展方法使用的

---

函数式接口：一个接口有且只有一个抽象方法(普通方法不影响)，这种接口称为函数式接口

使用 @FunctionaInterface 来检查当前接口是否为函数式接口

---

Lambda表达式的前身——匿名内部类

fun(()->{
    
	...
});

能使用Lambda表达式的前提是 接口必须是函数式接口，只有唯一的一个抽象方法

---

Lambda表达式的四种情况

1 无返回值无参数

interface NoParaNoReturn{
    
    void test();
}
public static void main(String[] args){
    
    NoParaNoReturn d = ()->{
    //大括号的内部就是方法体代码 
        System.out.println("无返回值，无参数");
    };
    d.test();//调用的是覆写后 的test方法
}

规则1：若方法体只有一行代码，可以省略{}；

    NoParaNoReturn d = ()->System.out.println("无返回值，无参数");

2 无返回值有参数

interface NoParaNoReturn{
    
    void test(int a);
}
public static void main(String[] args){
    
    NoParaNoReturn d = (int x)->{
    //大括号的内部就是方法体代码 
        x += 10;
        System.out.println("无返回值，无参数");
    };
    d.test();//调用的是覆写后 的test方法
}

规则2 ：若方法体的参数只有一个，可以省略小括号,类型也要省略

规则3 ： 可以省略Lambda表达式中参数的类型，若省略类型，都需要省略

    NoParaNoReturn d = x->{
    
        x += 10;
        System.out.println("无返回值，无参数");
    };

3 有返回值 无参数

interface NoParaNoReturn{
    
    int test();
}
public static void main(String[] args){
    
    NoParaNoReturn d = ()->{
    //大括号的内部就是方法体代码 
        int a = 10;
        int b = 10;
        return a+b;
    };
    System.out.println(d.test());//调用的是覆写后 的test方法
}

规则4： 若抽象方法存在返回值 且覆写的方法体只有一行，此时方法体的大括号，return 都可以省略

    NoParaNoReturn d = ()-> 10+10;

4 有返回值有参数

interface NoParaNoReturn{
    
    int test(int a,int b);
}
public static void main(String[] args){
    
    NoParaNoReturn d = (x,y)-> x+=y;
    System.out.println(d.test(10,20));//调用的是覆写后 的test方法
}

---

要是对大家有所帮助的话，请帮我点个赞吧。