原答案部分有误，重新回答一下。

静态变量可以作为默认实参，不需要一定是常量。实例如下：

#include <iostream>

class A {
public:
    explicit A(int mm = n) : m(mm) {}
    int get() const { return m; }
    int foo(int i = n) const { return i; }
    static void set(int nn) { n = nn; }

private:
    int m;
    static int n;
};

int A::n = 1;

int main() {
    A a1;
    A a2(2);
    std::cout << "a1: foo() " << a1.foo() << " get() " << a1.get() << std::endl;
    std::cout << "a2: foo() " << a2.foo() << " get() " << a2.get() << std::endl;
    A::set(3);  //a1.set(3);  //a2.set(3);
    std::cout << "A::set(3)" << std::endl;
    std::cout << "a1: foo() " << a1.foo() << " get() " << a1.get() << std::endl;
    std::cout << "a2: foo() " << a2.foo() << " get() " << a2.get() << std::endl;
    A a3;
    std::cout << "a3: foo() " << a3.foo() << " get() " << a3.get() << std::endl;
    
    return 0;
}

原答案

静态常量可以，如以下两种定义都可以。

static const int i;
static constexpr int i;

当然，静态常量的初始化是另一回事了。

具体例子参见《C++ Primer》第五版，7.6节，与静态成员的使用相关的部分。

因为在func(int j = i)时，this是第零个参数，第一个参数看不见this,自然没有办法取到this->i，就好比:

class A {
public:
    int a = 1;
};
class B {
public:
    int func(A* a, int j = a->i) {
    //do something
    }
};

int main(){
    A a;
    B b;
    b.func(&a);
}

这里func的第二个参数没法用到第一个参数里的a。

class TestClass
{
public:
    TestClass() = default;
    ~TestClass() = default;

public:
    int func(int j = i)
    {
        cout << i << endl;
    }

private:
    int i = 1; //这里
};

成员变量可以是成员函数的默认实参，你的出错的问题不在这里，是你的成员变量初始化有问题。
在成员变量的定义的进行初始化，这种写法不对。

你private下面只能定义成员变量，或者初始化静态变量。普通成员变量的初始化是在构造函数里完成的。

class TestClass
{
public:
    TestClass():i(1){};

public:
    int func(int j = i)
    {
        cout << i << endl;
    }

private:
    int i;
};