Como posso colocar um metodo recursivo em uma opção do switch ?Não consigo monta-la

[Luiz_Pereira_de_Alme]

Triângulos com maior perímetro. Escrever o valor do maior perímetro seguido da posição no arranjo de cada triângulo com perímetro igual ao maior do arranjo, bem como os valores de cada um de seus lados e seu tipo. O método deverá ser recursivo.
Preciso fazer esse método em uma opção do meu menu mas não tenho ideia como fazer . E a case 8.

import java.util.*;
class Triangulo{
   private double a;
   private double b;
   private double c;
   
   Triangulo(){   
     this.setLados(0,0,0);
     }    
   
   Triangulo(double a, double b, double c){ 
      this.setLados(a,b,c);
      }
   
   public void setLadoA(double a){
     this.a=a;} 
  
   public void setLadoB(double b){
     this.b=b;} 
   
   public void setLadoC(double c){
     this.c=c;}
   
   public void setLados(double a ,double b,double c){  
     this.setLadoA(a);
     this.setLadoB(b);
     this.setLadoC(c);}
        
   public double getLadoA(){
      return this.a; }
   public double getLadoB(){
      return this.b;}
   public double getLadoC(){
      return this.c;}
  
   public void escreve(){
      System.out.println("\nLados: " + this.getLadoA() + ", " 
                                     + this.getLadoB() + ", "
                                     + this.getLadoC() );
      System.out.println("Perimetro: " + this.perimetro() );
      
      }

    
   public int Tipo(){
      
      if(ehTriangulo()){
         
         if(this.getLadoA()==this.getLadoB() && this.getLadoB()==this.getLadoC()){
            return 1;}
         else if(this.getLadoA()!=this.getLadoB() && this.getLadoB()!=this.getLadoC() && this.getLadoA()!=this.getLadoC()){
            return 3;}
         else {
            return 2;}
      }else {
         return 0;}
   }
   
   public void escreveTipo(){
      if(Tipo()==1){
         System.out.println("Equilatero.");}
      else if(Tipo()==2){
         System.out.println("Isosceles.");}
      else if(Tipo()==3){
         System.out.println("Escaleno.");
      } else {
         System.out.println("Nao e triangulo.");}
   }
   public boolean ehTriangulo(){
      return (Math.abs(this.getLadoA()-this.getLadoB())<this.getLadoC() && this.getLadoC()<(this.getLadoA()+this.getLadoB()));}  
   
   public double perimetro(){
      return this.getLadoA()+this.getLadoB()+this.getLadoC();}
      
   public void lelados(){
      Scanner leia=new Scanner(System.in);
      System.out.println("Digite os lados:");
      double a=leia.nextDouble();
      double b=leia.nextDouble();
      double c=leia.nextDouble();
      this.setLados(a,b,c);}
      }
   
   public class TP1{
   public static void main(String[] args){
      Scanner s=new Scanner(System.in);
      Triangulo T1 = new Triangulo();
      T1.setLadoA(1);
      T1.setLadoB(2);
      T1.setLadoC(3);
      
      Triangulo T2=new Triangulo(4,5,6);
      
      Triangulo T[]= new Triangulo[2];
      for(int i=0;i<2;i++){
        T[i]= new Triangulo();
      } 
      for(int i=0;i<2;i++){
        T[i].lelados();}
      int menu;
      System.out.print("Digite uma opççcao do menu a seguir\n"+  
                   "1. Ler um novo triaângulo. Sugerir a leitura de novos valores caso não seja atendida a condicação de existeência do triaângulo.\n "+  
                   "2. Listar todos os triângulos criados.\n "+  
                   "3. Escrever o triâangulo posicionado na posiçãcao k do arranjo, sendo k um valor lido.\n" +  
                   "4. Verificar o tipo de um triâangulo armazenado na posiçãcao k do arranjo, sendo k um valor lido.\n" +  
                   "5. Verificar o períimetro de um triâangulo armazenado na posicação k do arranjo, sendo k um valor lido.\n" +  
                   "6. Listar todos os triaângulos do arranjo, seguido de seu periímetro e de seu tipo.\n" +  
                   "7. Listar todos os triaângulos cujos valores dos lados precisam ser corrigidos por não atender à sua condicação de existeência. Oferecer a leitura de novos valores para cada um..\n"+
                   "8. Triângulos com maior perímetro. Escrever o valor do maior perímetro seguido da posição no arranjo de cada triângulo com perímetro igual ao maior do arranjo, bem como os valores de cada um de seus lados e seu tipo. \n"+
                   "0.Sair: \n");
       menu =s.nextInt();
 
       switch( menu )
        {
            case 0:
                  System.out.println("Acabou o programa!");
                  break;
            case 1:
                int i=0;
                T[i].lelados();
                if(T[i].ehTriangulo()){  
                  System.out.println("Ok!!");
                }else{
                
                System.out.println("Digite novamente!!");
                  T[i].lelados();}
                break;
            case 2:
                System.out.println("Triangulos do arranjo: ");
                for(i=0;i<2;i++){
                T[i].escreve();}
                break;
            case 3: 
                int r;
                System.out.println("Digite a posiçcao: ");
                r=s.nextInt();
                T[r].escreve();
                T[r].escreveTipo();
                break;
            case 4: 
                int z;
                System.out.println("Digite a posiçcao: ");
                z=s.nextInt();
                T[z].escreveTipo();
                break;
            case 5:
               int y; 
                System.out.println("Digite a posiçcao: ");
                y=s.nextInt();
                T[y].perimetro();
                
                
                break;
            case 6: 
            
                System.out.println("Triangulos do arranjo: ");
                for(i=0;i<2;i++){
                T[i].escreve();
                T[i].escreveTipo();}
                break;
            case 7: 
                for(i=0;i<2;i++){
                T[i].escreve();
                if(T[i].Tipo()==0){
                T[i].escreve();
                T[i].escreveTipo();
                System.out.println("Digite novamente: ");
                T[i].lelados();}
                }
                
                break;        
            case 8: 
            
                System.out.println("Valor errado.");
                break;
            default:
                System.out.println("Valor errado.");          
        }
 
      
      } 
   }

[staroski]

Você implementou todo seu programa dentro do método main.
Quebra esse código em métodos menores, que fica mais fácil de resolver.

[staroski]

Dei uma refatorada no seu código, talvez assim você consiga resolver seu problema de forma mais fácil.

class Triangulo {

	public static final int EQUILATERO = 1;
	public static final int ESCALENO = 2;
	public static final int ISOCELES = 3;
	public static final int INEXISTENTE = 0;

	private final double a;
	private final double b;
	private final double c;

	public Triangulo(double a, double b, double c) {
		this.a = a;
		this.b = b;
		this.c = c;
	}

	public double getLadoA() {
		return a;
	}

	public double getLadoB() {
		return b;
	}

	public double getLadoC() {
		return c;
	}

	public double getPerimetro() {
		return getLadoA() + getLadoB() + getLadoC();
	}

	public int getTipo() {
		if (existe()) {
			if (getLadoA() == getLadoB() && getLadoB() == getLadoC()) {
				return EQUILATERO;
			} else if (getLadoA() != getLadoB() && getLadoB() != getLadoC() && getLadoA() != getLadoC()) {
				return ESCALENO;
			} else {
				return ISOCELES;
			}
		}
		return INEXISTENTE;
	}

	public boolean existe() {
		return (Math.abs(getLadoA() - getLadoB()) < getLadoC() && getLadoC() < (getLadoA() + getLadoB()));
	}
}

import java.util.Scanner;

public class TP1 {

	private static final Scanner IN = new Scanner(System.in);

	private static final int LER_NOVO = 1;
	private static final int LISTAR_TODOS = 2;
	private static final int ESCREVER = 3;
	private static final int VERIFICAR_TIPO = 4;
	private static final int VERIFICAR_PERIMETRO = 5;
	private static final int LISTAR_TODOS_PERIMETRO_TIPO = 6;
	private static final int LISTAR_ERRADOS = 7;
	private static final int LISTAR_MAIOR_PERIMETRO = 8;
	private static final int SAIR = 0;

	public static void main(String[] args) {
		try {
			TP1 programa = new TP1();
			programa.executar();
		} catch (Throwable t) {
			t.printStackTrace();
		} finally {
			System.exit(0);
		}
	}

	private Triangulo[] triangulos;

	public void executar() {
		triangulos = lerTriangulos(2);
		int opcao = escolherOpcaoMenu();
		while (opcao != SAIR) {
			processar(opcao);
			opcao = escolherOpcaoMenu();
		}
	}

	private Triangulo criarNovoTriangulo() {
		System.out.println("Digite os lados:");
		double a = IN.nextDouble();
		double b = IN.nextDouble();
		double c = IN.nextDouble();
		return new Triangulo(a, b, c);
	}

	private int escolherOpcaoMenu() {
		System.out.printf("Digite uma opçao do menu a seguir:\n" //
				+ "%d. Ler um novo triangulo. Sugerir a leitura de novos valores caso não seja atendida a condição de existencia do triangulo.\n " //
				+ "%d. Listar todos os triangulos criados.\n " //
				+ "%d. Escrever o triangulo posicionado na posicao k do arranjo, sendo k um valor lido.\n" //
				+ "%d. Verificar o tipo de um triangulo armazenado na posiçãcao k do arranjo, sendo k um valor lido.\n" //
				+ "%d. Verificar o perimetro de um triangulo armazenado na poscao k do arranjo, sendo k um valor lido.\n" //
				+ "%d. Listar todos os triangulos do arranjo, seguido de seu perimetro e de seu tipo.\n" //
				+ "%d. Listar todos os triangulos cujos valores dos lados precisam ser corrigidos por nao atender a sua condicao de existencia. Oferecer a leitura de novos valores para cada um.\n" //
				+ "%d. Triangulos com maior perimetro. Escrever o valor do maior perimetro seguido da posição no arranjo de cada triângulo com perímetro igual ao maior do arranjo, bem como os valores de cada um de seus lados e seu tipo.\n" //
				+ "%d. Sair.\n", //
				// cada %d é substituído pelas constantes abaixo
				LER_NOVO, //
				LISTAR_TODOS, //
				ESCREVER, //
				VERIFICAR_TIPO, //
				VERIFICAR_PERIMETRO, //
				LISTAR_TODOS_PERIMETRO_TIPO, //
				LISTAR_ERRADOS, //
				LISTAR_MAIOR_PERIMETRO, //
				SAIR);
		return IN.nextInt();
	}

	private void escreveLadosPerimetro(Triangulo t) {
		System.out.println("Lados:     " + t.getLadoA() + ", " + t.getLadoB() + ", " + t.getLadoC());
		System.out.println("Perimetro: " + t.getPerimetro());
	}

	private void escrevePosicao() {
		System.out.println("Digite a posicao: ");
		int i = IN.nextInt();
		escreveLadosPerimetro(triangulos[i]);
		escreveTipo(triangulos[i]);
	}

	private void escreveTipo(Triangulo t) {
		switch (t.getTipo()) {
			case Triangulo.EQUILATERO:
				System.out.println("Equilatero.");
				return;
			case Triangulo.ISOCELES:
				System.out.println("Isosceles.");
				return;
			case Triangulo.ESCALENO:
				System.out.println("Escaleno.");
				return;
			case Triangulo.INEXISTENTE:
			default:
				System.out.println("Nao e triangulo.");
				return;
		}
	}

	private void lerNovoTriangulo() {
		System.out.println("Digite a posicao: ");
		int i = IN.nextInt();
		triangulos[i] = criarNovoTriangulo();
		while (!triangulos[i].existe()) {
			System.out.println("Digite novamente!!");
			triangulos[i] = criarNovoTriangulo();
		}
		System.out.println("Ok!!");
	}

	private Triangulo[] lerTriangulos(int quantidade) {
		Triangulo[] triangulos = new Triangulo[quantidade];
		for (int i = 0; i < triangulos.length; i++) {
			triangulos[i] = criarNovoTriangulo();
		}
		return triangulos;
	}

	private void listarErrados() {
		for (int i = 0; i < triangulos.length; i++) {
			escreveLadosPerimetro(triangulos[i]);
			if (triangulos[i].getTipo() == Triangulo.INEXISTENTE) {
				escreveLadosPerimetro(triangulos[i]);
				escreveTipo(triangulos[i]);
				System.out.println("Digite novamente: ");
				triangulos[i] = criarNovoTriangulo();
			}
		}
	}

	private void listarTodos() {
		System.out.println("Triangulos do arranjo: ");
		for (int i = 0; i < triangulos.length; i++) {
			escreveLadosPerimetro(triangulos[i]);
		}
	}

	private void listarTodosPerimetroTipo() {
		System.out.println("Triangulos do arranjo: ");
		for (int i = 0; i < triangulos.length; i++) {
			escreveLadosPerimetro(triangulos[i]);
			escreveTipo(triangulos[i]);
		}
	}

	private void processar(int opcao) {
		switch (opcao) {
			case SAIR:
				sair();
				return;
			case LER_NOVO:
				lerNovoTriangulo();
				return;
			case LISTAR_TODOS:
				listarTodos();
				return;
			case ESCREVER:
				escrevePosicao();
				return;
			case VERIFICAR_TIPO:
				verificarTipo();
				return;
			case VERIFICAR_PERIMETRO:
				verificarPerimetro();
				return;
			case LISTAR_TODOS_PERIMETRO_TIPO:
				listarTodosPerimetroTipo();
				return;
			case LISTAR_ERRADOS:
				listarErrados();
				return;
			case LISTAR_MAIOR_PERIMETRO:
				valorErrado();
				return;
			default:
				valorErrado();
				return;
		}
	}

	private void sair() {
		System.out.println("Acabou o programa!");
	}

	private void valorErrado() {
		System.out.println("Valor errado.");
	}

	private void verificarPerimetro() {
		System.out.println("Digite a posiçcao: ");
		int i = IN.nextInt();
		triangulos[i].getPerimetro();
	}

	private void verificarTipo() {
		System.out.println("Digite a posicao: ");
		int i = IN.nextInt();
		escreveTipo(triangulos[i]);
	}
}