использование класса в разных проектах

у меня два вопроса я создал класс G2d для своего удобства работы с графикой:

1. можно ли избавиться от аргумента g в методах что бы вызывать метод не так /G2d.drawPaint(g, x, y)/ а так /G2d.drawPaint(x, y)/

2. можно ли встроить данный класс в библиотеку и использовать в разных проектах импортировав его заголовок?

import javax.swing.*;

import java.awt.*;

public class G2d extends JPanel {
    //рисуем точку в координатах x, y
    public static void drawPoint(Graphics g, int x, int y){
        Graphics2D g2d = (Graphics2D)g;
        g2d.drawRect(x, y, 0, 0);
    }
    //рисуем круг в координатах x, y с радиусом r
    public static void drawCircle(Graphics g, int x, int y, int r){
        Graphics2D g2d = (Graphics2D)g;
        g2d.drawOval(x-r, y-r, r*2, r*2);
    }
    //рисуем косой крест в координатах x, y с длиной перекладины l
    public static void drawCrossbuck(Graphics g, int x, int y, int l){
        Graphics2D g2d = (Graphics2D)g;
        g2d.drawLine(x-l, y-l, x+l, y+l);
        g2d.drawLine(x+l, y-l, x-l, y+l);
    }
}
public class numberField extends JPanel{
    //private int numcoil = 51;//число витков спирали
    int numberСours = 3333;//число ходов
    int scale = 15;//масштаб
    private int[] arrayCoordX;//массивы координат
    private int[] arrayCoordY;//траектории шахматного коня
    private int middle = myWin.SIZE/2;//поиск
    //private int middleY = myWin.SIZE/2;//середины поля
    private int numcoil = middle/scale+1;//число витков спирали
    private int arrX = (numcoil-1)*2 + 1;//кол-во столбцов
    private int arrY = (numcoil-1)*2 + 1;//кол-во строк
    private int[][] arrbas;// = new int[arrX][arrY];//базовый массив
    private int[][] substrate = new int[arrX][arrY];//дубликат массива arrbas - подложка
    private int summa = 0;
    //конструктор
    public numberField(){
        //restrictionScale();
        arrbas = initArraySpir(numcoil);//спиральный массив в arrbas
        assemblyCoord();
}
    //ограничение масштаба
    public void restrictionScale(){
        if(myWin.SIZE/scale < arrX) scale = 12;
    }
    //определение координат с наименьшим числом при 8 ходах шахматного коня
    public int[] knightMove(int x, int y){
        int[] arr1 = new int[2];//arr[0] - координата x | arr[1] - координата y
        int[] arr8 = new int[24];//коор-x | коор-y | значение ячейки x,y
        int[] arr = new int[8];//массив индексов
        arr8[0] = x-1; arr8[1] = y-2; arr8[2] = arrbas[arr8[0]][arr8[1]];
        arr8[3] = x+1; arr8[4] = y-2; arr8[5] = arrbas[arr8[3]][arr8[4]];
        arr8[6] = x+2; arr8[7] = y-1; arr8[8] = arrbas[arr8[6]][arr8[7]];
        arr8[9] = x+2; arr8[10] = y+1; arr8[11] = arrbas[arr8[9]][arr8[10]];
        arr8[12] = x+1; arr8[13] = y+2; arr8[14] = arrbas[arr8[12]][arr8[13]];
        arr8[15] = x-1; arr8[16] = y+2; arr8[17] = arrbas[arr8[15]][arr8[16]];
        arr8[18] = x-2; arr8[19] = y+1; arr8[20] = arrbas[arr8[18]][arr8[19]];
        arr8[21] = x-2; arr8[22] = y-1; arr8[23] = arrbas[arr8[21]][arr8[22]];
        arr1[0] = arr8[0];
        arr1[1] = arr8[1];
        int min;// = arr8[2];
        //оптимизация массива - убираем использованные ячейки
        int s1 = 0;//счётчик свободных ячеек
        for(int i = 2; i < 24; i+=3){
            if(substrate[arr8[i-2]][arr8[i-1]] != 1) {
                arr[s1] = i;//заполняем массив номерами индексов свободных ячеек (на которые ещё не ходил шх.конь)
                s1++;
            }
        }
        //блок проверки
        if(s1 == 0){    //когда конь в ловушке (все ходы уже заняты)
            arr1[0] = x;//возвращаем
            arr1[1] = y;//последние координаты
            return arr1;//и выходим из метода
        }
        //поиск наименьщего значения из свободных ячеек
        int s2 = arr[0];//начальный индекс
        min = arr8[arr[0]];//начальное минимальное значение ячейки
        for(int i = 0; i < s1; i++){
            if (arr8[arr[i]] < min) {//если значение ячейки меньше min
                min = arr8[arr[i]];  //меняем значения местами
                s2 = arr[i];         //присваиваем начальному индексу новое значение
            }
        }
        arr1[0] = arr8[s2 - 2];//координата x
        arr1[1] = arr8[s2 - 1];//координата y
        return arr1;//возвращаем массив с новыми координатами
    }
    //заполнение спирального массива
    public int[][] initArraySpir(int nc){
        int[][] arr = new int[(nc-1)*2 + 1][(nc-1)*2 + 1];
        int x = nc-1;//центральная ячейка массива
        int y = nc-1;//по координатам x, y
        int counter = 1;
        arr[x][y] = counter;
        for(int i = 1; i < nc; i++){
            x++;
            counter++;
            if(y >= 0){
                for(int j = 0; j < i*2; j++){
                    arr[x][y] =counter;
                    y--;
                    counter++;
                }
                y++;
                x--;
                for(int j = 0; j < i*2; j++){
                    arr[x][y] =counter;
                    x--;
                    counter++;
                }
                x++;
                y++;
                for(int j = 0; j < i*2; j++){
                    arr[x][y] =counter;
                    y++;
                    counter++;
                }
                y--;
                x++;
                for(int j = 0; j < i*2; j++){
                    arr[x][y] =counter;
                    x++;
                    counter++;
                }
                x--;
                counter--;
            }
        }
        return arr;
    }
    //
    public void assemblyCoord() {
        arrayCoordX = new int[numberСours+1];
        arrayCoordY = new int[numberСours+1];
        int[] arr = new int[2];
        //int x, y;
        arr[0] = numcoil - 1;
        arr[1] = numcoil - 1;
        for (int i = 0; i < numberСours+1; i++) {
            substrate[arr[0]][arr[1]] = 1;
            arrayCoordX[i] = arr[0];
            arrayCoordY[i] = arr[1];
            arr = knightMove(arr[0], arr[1]);
        }
    }
    @Override//метод вывода данных в окно программы
    protected void paintComponent(Graphics g){
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D)g;
        //g2d.set.G2d(g);
        this.setBackground(Color.GRAY);
        //БЛОК-1-----отрисовка траектории шахмотного коня
        g2d.setPaint(Color.GREEN);
        for(int i = 0; i < numberСours; i++){
            //рисуем линию от текущих до последующих координат
            g2d.drawLine(arrayCoordX[i]*scale, arrayCoordY[i]*scale, arrayCoordX[i+1]*scale, arrayCoordY[i+1]*scale);
        }
        G2d.setG2d(g);
        g2d.setPaint(Color.BLUE);//синий круг↓
        G2d.drawCircle((numcoil-1)*scale, (numcoil-1)*scale, 3);//обводим начало координат
        g2d.setPaint(Color.BLACK);//чёрная точка↓
        G2d.drawPoint((numcoil-1)*scale, (numcoil-1)*scale);//начальные координаты
        g2d.setPaint(Color.RED);//красный крестик↓
        G2d.drawCrossdirect(arrayCoordX[numberСours]*scale, arrayCoordY[numberСours]*scale, 3);//конечные координаты
        //конец БЛОКА-1-----*/
        //БЛОК-2-----вывод данных в правый сайд-бар
        g2d.setPaint(Color.WHITE);//
        g2d.fillRect(myWin.SIZE, 0, myWin.SIDEBAR, myWin.SIZE);//
        //конец БЛОКА-2
    }
}