Java 如何使用非静态方法泛型？

我想通过以下代码获取sql：

public class Mappers {
    public static class SqlBuilder {
       //SqlImpl class implements Sql, and select,from,method,alias,where return this. 
       public static <T> SqlImpl<T> builder() {
         return new SqlImpl<>();
       }
    }
}

我的问题是上的方法

，我不能在（
A:：getAId，B:：getAId
）上使用，我得到
错误：无法从静态上下文引用非静态方法

我无法理解函数af=A:：getAId不同的

A:：getAId

修改

joinleftjoin（Sql）

to

joinleftjoin（Sql），完整源代码：

import javax.persistence.Table；
导入java.util.function.function；
接口连接{
//从a.col1=b.col2上的选项卡a左连接选项卡b中选择*
Join-leftJoin（Sql）；
//从a.col1=b.col2上的选项卡a左连接选项卡b`中选择*选项`
//1.函数实现可序列化
//2.类别。getDeclaredMethod（“WriterReplace”）
//3.get字段名
Sql on（函数bf1、函数bf2）；
}
接口构建函数{
R构建（T）；
}
类SqlCondition{
公共SqlCondition和Quals（BuilderFunction f，字符串x）{
归还这个；
}
}
接口Sql扩展联接{
//选择a、b、c。。。
Sql选择（BuilderFunction…t）；
//从选项卡a到选项卡b
来自（t类）的Sql；
//从选项卡a中选择*
Sql别名（字符串名称）；
//从选项卡a中选择*其中列=？
Sql-where（SqlCondition）；
//获取sql
字符串build（）；
}
类SqlImpl实现Sql{
@凌驾
公共连接leftJoin（Sql）{
返回null；
}
@凌驾
打开公共Sql（函数bf1、函数bf2）{
返回null；
}
@凌驾
公共Sql选择（BuilderFunction…t）{
返回null；
}
@凌驾
来自（t类）的公共Sql{
返回null；
}
@凌驾
公共Sql别名（字符串名称）{
返回null；
}
@凌驾
公共Sql where（SqlCondition）{
返回null；
}
@凌驾
公共字符串生成（）{
返回null；
}
}
@表（name=“a_tab”）
甲级{
私人长期援助；
私有字符串名称；
公共字符串getName（）{
返回名称；
}
公共长期援助{
返回援助；
}
//吸气剂设定器
}
@表（name=“b_选项卡”）
B类{
私人长期投标；
私人长期援助；
公共长期援助{
返回援助；
}
公众长期投标（）{
退还投标书；
}
//吸气剂设定器
}
公共类映射器{
公共静态类SqlBuilder{
//SqlImpl类实现Sql，并选择、from、method、alias，其中返回此值。
公共静态SqlImpl生成器（）{
返回新的SqlImpl（）；
}
}
公共静态void main（字符串[]args）{
Mappers.SqlBuilder.builder（）
.选择（A:：getAId，A:：getName）
.来自（A类）
.where（新的SqlCondition（）.andEquals（A:：getName，“x”））
.leftJoin（Mappers.SqlBuilder.builder（）
.选择（B:：getAId，B:：getBId）
.来自（B级）
.别名（“b_标签”）
)
.on（A:：getAId，B:：getAId）；//错误：无法从静态上下文“”引用非静态方法。
}
}
修改
joinleftjoin（Sql）
to
joinleftjoin（Sql），完整源代码：

import javax.persistence.Table；
导入java.util.function.function；
接口连接{
//从a.col1=b.col2上的选项卡a左连接选项卡b中选择*
Join-leftJoin（Sql）；
//从a.col1=b.col2上的选项卡a左连接选项卡b`中选择*选项`
//1.函数实现可序列化
//2.类别。getDeclaredMethod（“WriterReplace”）
//3.get字段名
Sql on（函数bf1、函数bf2）；
}
接口构建函数{
R构建（T）；
}
类SqlCondition{
公共SqlCondition和Quals（BuilderFunction f，字符串x）{
归还这个；
}
}
接口Sql扩展联接{
//选择a、b、c。。。
Sql选择（BuilderFunction…t）；
//从选项卡a到选项卡b
来自（t类）的Sql；
//从选项卡a中选择*
Sql别名（字符串名称）；
//从选项卡a中选择*其中列=？
Sql-where（SqlCondition）；
//获取sql
字符串build（）；
}
类SqlImpl实现Sql{
@凌驾
公共连接leftJoin（Sql）{
返回null；
}
@凌驾
打开公共Sql（函数bf1、函数bf2）{
返回null；
}
@凌驾
公共Sql选择（BuilderFunction…t）{
返回null；
}
@凌驾
来自（t类）的公共Sql{
返回null；
}
@凌驾
公共Sql别名（字符串名称）{
返回null；
}
@凌驾
公共Sql where（SqlCondition）{
返回null；
}
@凌驾
公共字符串生成（）{
返回null；
}
}
@表（name=“a_tab”）
甲级{
私人长期援助；
私有字符串名称；
公共字符串getName（）{
返回名称；
}
公共长期援助{
返回援助；
}
//吸气剂设定器
}
@表（name=“b_选项卡”）
B类{
私人长期投标；
私人长期援助；
公共长期援助{
返回援助；
}
公众长期投标（）{
退还投标书；
}
//吸气剂设定器
}
公共类映射器{
公共静态类SqlBuilder{
//SqlImpl类实现Sql，并选择、from、method、alias，其中返回此值。
公共静态SqlImpl生成器（）{
返回新的SqlImpl（）；
}
}
公共静态void main（字符串[]args）{
Mappers.SqlBuilder.builder（）
.选择（A:：getAId，A:：getName）
.来自（A类）
.where（新的SqlCondition（）.andEquals（A:：getName，“x”））
.leftJoin（Mappers.SqlBuilder.builder（）
.选择（B:：getAId，B:：getBId）
.来自（B级）
.别名（“b_标签”）
)
.on（A:：getAId，B:：getAId）；//错误：无法从静态上下文“”引用非静态方法。
}
}
请添加co
    public interface Join<T> {
      //select * from tab_a a left join tab_b b on a.col1 = b.col2
      Join<T> leftJoin(Sql<T> Sql); 
      //select * from tab_a a left join tab_b b `on a.col1 = b.col2`
      // 1.Function implements Serializable 
      // 2.class.getDeclaredMethod("writeReplace") 
      // 3.get field name
      <T1,T2> Sql<T> on(Function<T1,Object> bf1,Function<T2,Object> bf2)
    }

 public interface Sql<T> extends Join<T> {
        // select a,b,c ...
        Sql<T> select(BuilderFunction<T, Object>... t);
        // from tab_a,tab_b 
        Sql<T> from(Class<T> t); 
        // select * from tab_a a
        Sql<T> alias(String name); 
        //select * from tab_a where col = ?
        Sql<T> where(SqlCondition condition); 
        // get sql 
        String build(); 
    }

Mappers.SqlBuilder.<A>builder()
                             .select(A::getAId,A::getName)
                             .from(A.class)
                             .where(new SqlCondition().andEquals(A::getName,"x"))
                             .leftJoin(Mappers.SqlBuilder.<B>builder()
                                                             .select(B::getAId,B::getBId)
                                                             .from(B.class)
                                                             .alias("b_tab")
                              )
                              .on(A::getAId,B::getAId); // error: Non-static method cannot be referenced from a static context`.

@Table(name="a_tab")
class A {
  private Long aId;
  private String name;
//getter setter
}

@Table(name="b_tab")
class B {
  private Long bId;
  private Long aId;
//getter setter
}