Как передать массив в функцию и класс в объект?

triangle[0] = new Triangle(Point.point(15, 11),Point.point (18, 125),Point.point( 17, 13));

class Triangle {
  Point point1;
  Triangle(Point point1) {
    this.point1 = point1; 
  }
}

public class Triangle {
    private int x1, x2, x3, y1, y2, y3;
    private double sideA = findSide(x1, x2, y1, y2);
    private double sideB = findSide(x2, x3, y2, y3);;
    private double sideC = findSide(x1, x3, y1, y3);;
 
    double findSide(int x1, int x2, int y1, int y2) {
        double side = Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
        return side;
 
    }
 
    public double perimetr() {
        double perimetr = getSideA() + getSideB() + getSideC();
        return perimetr;
    }
 
    public double sqare() {
        double a = getSideA();
        double b = getSideB();
        double c = getSideC();
 
        double sqare = Math.sqrt(perimetr() / 2 * (perimetr() / 2 - a) * (perimetr() / 2 - b) * (perimetr() / 2 - c));
        return sqare;
    }
 
    public boolean equilateral() { // ravnostoronniy
        if (getSideA() == getSideB() & getSideA() == getSideC()) {
            return true;
        } else
            return false;
    }
 
    public boolean isosceles() { // ravnobedrenniy
        if (getSideA() == getSideB() | getSideB() == getSideC()) {
            return true;
        } else
            return false;
    }
 
    public boolean rectangular() { // pramougolniy
        double a = getSideA();
        double b = getSideB();
        double c = getSideC();
        if ((a * a == b * b + c * c) | (b * b == a * a + b * b) | (c * c == a * a + b * b)) {
            return true;
        } else
            return false;
    }
 
    public boolean arbitrary() { // proizvolniy
        if (getSideA() != getSideB() & getSideB() != getSideC()) {
            return true;
        } else
            return false;
    }
 
    public void countMaxAndMinPerimetr() {
 
        for (int i = triangle.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
 
                if (triangle[j].perimetr > triangle[j + 1].perimetr) {
                    int tmp = triangle[j];
                    triangle[j] = triangle[j + 1];
                    arr[j + 1] = tmp;
                }
            }
            System.out.println("minPerimetr = " + triangle[0].perimetr);
            System.out.println("maxPerimetr = " + triangle[triangle.length].perimetr);
        }
    }
 
    public void countMaxAndMinSqare() {
 
        for (int i = triangle.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
 
                if (triangle[j].sqare > triangle[j + 1].sqare) {
                    int tmp = triangle[j];
                    triangle[j] = triangle[j + 1];
                    arr[j + 1] = tmp;
                }
            }
            System.out.println("min Sqare = " + triangle[0].sqare);
            System.out.println("max Sqare = " + triangle[triangle.length].sqare);
        }
    }
 
    public void diferentTypeTriangle() {
        int equilateral, isosceles, rectangular, arbitrary;
 
        for (int i = 0; i < triangle.length; i++) {
            if (triangle[i].equilateral)
                equilateral++;
            if (triangle[i].isosceles)
                isosceles++;
            if (triangle[i].rectangular)
                rectangular++;
            if (triangle[i].arbitrary)
                arbitrary++;
        }
        System.out.println("Count equilateral" + equilateral);
        System.out.println("Count isosceles" + isosceles);
        System.out.println("Count rectangular" + rectangular);
        System.out.println("Count arbitrary" + arbitrary);
 
    }
 
    public static void main(String[] args) {
 
        Triangle[] triangle = new Triangle[10];
 
        triangle[0] = new Triangle(15, 11, 3, 5, 7, 13);
        triangle[1] = new Triangle(Point.point(5, 11), Point.point(8, 25), Point.point(17, 10));
        triangle[2] = new Triangle(Point.point(10, 6), Point.point(7, 5), Point.point(7, 13));
        triangle[3] = new Triangle(Point.point(15, 11), Point.point(6, 5), Point.point(1, 11));
        triangle[4] = new Triangle(Point.point(20, 5), Point.point(18, 25), Point.point(7, 13));
        triangle[5] = new Triangle(Point.point(15, 11), Point.point(5, 15), Point.point(17, 8));
        triangle[6] = new Triangle(Point.point(1, 5), Point.point(18, 25), Point.point(7, 3));
        triangle[7] = new Triangle(Point.point(15, 11), Point.point(1, 15), Point.point(16, 17));
        triangle[8] = new Triangle(Point.point(3, 4), Point.point(8, 15), Point.point(7, 13));
        triangle[9] = new Triangle(Point.point(15, 11), Point.point(18, 15), Point.point(17, 8));
 
        System.out.println(triangle.length);
 
    }
 
    public int getX1() {
        return x1;
    }
 
    public void setX1(int x1) {
        this.x1 = x1;
    }
 
    public int getX3() {
        return x3;
    }
 
    public void setX3(int x3) {
        this.x3 = x3;
    }
 
    public int getX2() {
        return x2;
    }
 
    public void setX2(int x2) {
        this.x2 = x2;
    }
 
    public double getSideA() {
        return sideA;
    }
 
    public void setSideA(double sideA) {
        this.sideA = sideA;
    }
 
    public double getSideC() {
        return sideC;
    }
 
    public void setSideC(double sideC) {
        this.sideC = sideC;
    }
 
    public double getSideB() {
        return sideB;
    }
 
    public void setSideB(double sideB) {
        this.sideB = sideB;
    }
 
    public int getY2() {
        return y2;
    }
 
    public void setY2(int y2) {
        this.y2 = y2;
    }
 
    public int getY3() {
        return y3;
    }
 
    public void setY3(int y3) {
        this.y3 = y3;
    }
 
    public int getY1() {
        return y1;
    }
 
    public void setY1(int y1) {
        this.y1 = y1;
    }
}

package me.triangles;
 
import java.util.Random;
 
public class Point {
    private double x;
    private double y;
 
    public Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
 
    public double getX() {
        return x;
    }
 
    public void setX(double x) {
        this.x = x;
    }
 
    public double getY() {
        return y;
    }
 
    public void setY(double y) {
        this.y = y;
    }
    
    public static Point getRandomPoint() {
        Random rand = new Random();
        return new Point(rand.nextDouble(), rand.nextDouble());
    }
}

package me.triangles;
 
public class Triangle {
    private Point A, B, C;
    private double AB, BC, AC;
 
    public Triangle(Point A, Point B, Point C) {
        this.A = A;
        this.B = B;
        this.C = C;
 
        AB = findSide(A, B);
        BC = findSide(B, C);
        AC = findSide(A, C);
    }
 
    public double findSide(Point first, Point second) {
        return Math.sqrt((second.getX() - first.getX()) * (second.getX() - first.getX())
                + (second.getY() - first.getY()) * (second.getY() - first.getY()));
    }
 
    public double getPerimetr() {
        return AB + BC + AC;
    }
 
    public double getSquare() {
        return Math.sqrt(getPerimetr()/2*(getPerimetr()/2-AB)*(getPerimetr()/2-BC)*(getPerimetr()/2-AC));
    }
 
    public boolean isEquilateral() { // ravnostoronniy
        return Double.compare(AB, BC) == 0 && Double.compare(BC, AC) == 0;
    }
 
    public boolean isIsosceles() { // ravnobedrenniy
        return !isEquilateral() && (Double.compare(AB, BC) == 0 || Double.compare(BC, AC) == 0);
    }
 
    public boolean isRectangular() { // pramougolniy
        return (AB * AB == BC * BC + AC * AC) || (BC * BC == AB * AB + BC * BC) || (AC * AC == AB * AB + BC * BC);
    }
 
    public boolean isArbitrary() { // proizvolniy
        return AB != BC && BC != AC;
    }
 
    public Point getA() {
        return A;
    }
 
    public void setA(Point p) {
        A = p;
    }
 
    public Point getB() {
        return B;
    }
 
    public void setB(Point p) {
        B = p;
    }
 
    public Point getC() {
        return C;
    }
 
    public void setC(Point p) {
        C = p;
    }
 
    public double getSideAB() {
        return AB;
    }
    
    public double getSideBC() {
        return BC;
    }
    
    public double getSideAC() {
        return AC;
    }
 
    public void setSideAB(Point first, Point second) {
        AB = findSide(first, second);
    }
 
    public void setSideBC(Point first, Point second) {
        BC = findSide(first, second);
    }
 
    public void setSideAC(Point first, Point second) {
        AC = findSide(first, second);
    }
}

import me.triangles.Point;
import me.triangles.Triangle;
 
public class TriangleTest {
    public static void main(String[] args) {
        Triangle[] triangles = new Triangle[10];
        for (int i = 0; i < triangles.length; i++)
            triangles[i] = new Triangle(Point.getRandomPoint(), Point.getRandomPoint(), Point.getRandomPoint());
        
        double[] minMaxP = countMaxAndMinPerimetr(triangles);
        System.out.printf("minPerimetr=%.2f\n", minMaxP[0]);
        System.out.printf("maxPerimetr=%.2f\n\n",minMaxP[1]);
        
        double[] minMaxS = countMaxAndMinSqare(triangles);
        System.out.printf("minSquare=%.2f\n", minMaxS[0]);
        System.out.printf("maxSquare=%.2f\n\n",minMaxS[1]);
        
        int[] typesCount = countDifferentTriangleType(triangles);
        System.out.println("equilateral=" + typesCount[0]);
        System.out.println("isosceles=" + typesCount[1]);
        System.out.println("rectangular=" + typesCount[2]);
        System.out.println("arbitrary=" + typesCount[3]);
    }
    
    public static double[] countMaxAndMinPerimetr(Triangle[] triangles) {
        double min = Double.MAX_VALUE;
        double max = Double.MIN_VALUE;
        
        for (Triangle triangle : triangles) {
            if (triangle.getPerimetr() > max)
                max = triangle.getPerimetr();
            if (triangle.getPerimetr() < min)
                min = triangle.getPerimetr();
        }
        
        return new double[] { min, max };
    }
    
    public static double[] countMaxAndMinSqare(Triangle[] triangles) {
        double min = Double.MAX_VALUE;
        double max = Double.MIN_VALUE;
        
        for (Triangle triangle : triangles) {
            if (triangle.getSquare() > max)
                max = triangle.getSquare();
            if (triangle.getSquare() < min)
                min = triangle.getSquare();
        }
        
        return new double[] { min, max };
    }
    
    public static int[] countDifferentTriangleType(Triangle[] triangles) {
        int equilateral = 0;
        int isosceles = 0;
        int rectangular = 0;
        int arbitrary = 0;
        
        for (Triangle triangle : triangles) {
            if (triangle.isEquilateral())
                equilateral++;
            if (triangle.isIsosceles())
                isosceles++;
            if (triangle.isRectangular())
                rectangular++;
            if (triangle.isArbitrary())
                arbitrary++;
        }
        
        return new int[] { equilateral, isosceles, rectangular, arbitrary };
    }
}

public class Triangle {
    private Point a;
    private Point b;
    private Point c;
    private Type type;
 
    public Triangle(int ax, int ay, int bx, int by, int cx, int cy) {
        this(new Point(ax, ay), new Point(bx, by), new Point(cx, cy));
    }
 
    public Triangle(Point a, Point b, Point c) {
        this.a = a;
        this.b = b;
        this.c = c;
 
        if (rectangular()) {
            type = Type.RECTANGULAR;
        } else if (isosceles()) {
            type = Type.ISOSCELES;
        } else if (equilateral()) {
            type = Type.EQUILATERAL;
        } else {
            type = Type.ARBITRARY;
        }
    }
 
    public static void main(String[] args) {
 
        Triangle[] triangles = new Triangle[10];
 
        triangles[0] = new Triangle(15, 11, 3, 5, 7, 13);
        triangles[1] = new Triangle(5, 118, 25, 17, 10, 11);
        triangles[2] = new Triangle(10, 6, 7, 5, 7, 13);
        triangles[3] = new Triangle(15, 11, 6, 5, 1, 11);
        triangles[4] = new Triangle(20, 5, 18, 25, 7, 13);
        triangles[5] = new Triangle(15, 11, 5, 15, 17, 8);
        triangles[6] = new Triangle(1, 5, 18, 25, 7, 3);
        triangles[7] = new Triangle(15, 11, 1, 15, 16, 17);
        triangles[8] = new Triangle(3, 4, 8, 15, 7, 13);
        triangles[9] = new Triangle(15, 11, 18, 15, 17, 8);
 
        System.out.println(diferentTypeTriangle(triangles));
 
    }
 
    public static Optional<Triangle> findMaxPerimetrTriangle(Triangle[] trianlges) {
        return Stream.of(trianlges).max(comparingDouble(Triangle::perimetr));
    }
 
    public static Optional<Triangle> findMinPerimetrTriangle(Triangle[] trianlges) {
        return Stream.of(trianlges).min(comparingDouble(Triangle::perimetr));
    }
 
    public static Optional<Triangle> findMaxSquareTriangle(Triangle[] trianlges) {
        return Stream.of(trianlges).max(comparingDouble(Triangle::square));
    }
 
    public static Optional<Triangle> findMinSquareTriangle(Triangle[] trianlges) {
        return Stream.of(trianlges).min(comparingDouble(Triangle::square));
    }
 
    public double sideA() {
        return findSide(a, b);
    }
 
    public double sideB() {
        return findSide(b, c);
    }
 
    public double sideC() {
        return findSide(c, a);
    }
 
    private double findSide(Point p1, Point p2) {
        return Math.sqrt(pow((p2.x - p1.x), 2) + pow((p2.y - p1.y), 2));
    }
 
    public double perimetr() {
        return sideA() + sideB() + sideC();
    }
 
    public double square() {
        return (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y)) / 2.0;
    }
 
    private boolean equilateral() {
        return sideA() == sideB() && sideA() == sideC();
    }
 
    private boolean isosceles() {
        return !equilateral() && (sideA() == sideB() || sideB() == sideC() || sideA() == sideC());
    }
 
    private boolean rectangular() {
        return (pow(sideA(), 2) == pow(sideB(), 2) + pow(sideC(), 2))
                || (pow(sideB(), 2) == pow(sideA(), 2) + pow(sideC(), 2))
                || (pow(sideC(), 2) == pow(sideA(), 2) + pow(sideC(), 2));
    }
 
    public static Map<Type, Long> diferentTypeTriangle(Triangle[] triangles) {
        return Arrays.stream(triangles).collect(groupingBy(triangle -> triangle.type, counting()));
    }
 
    public enum Type {
        EQUILATERAL,
        ISOSCELES,
        RECTANGULAR,
        ARBITRARY;
    }
 
    public static class Point {
        public final int x;
        public final int y;
 
        private Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}

triangles[4] = new Triangle(Point.point(8, 5), Point.point(8, 6), Point.point(7, 4));

Class classObject = new Class(Parameter1, parameter2);

Point point = new Point(10, 10);

triangles[i] = new Triangle(new Point(8, 5), new Point(8,6), new Point(7, 4));

Point point1 = new Point(10, 10);
Point point2 = new Point(12, 14);
Point point3 = new Point(9, 15);
 
triangles[i] = new Triangle(point1, point2, point3);