Alguém consegue adaptar esse código para orientado objeto?

olá pessoal, esse e meu segundo post, já outro e vocês me ajudaram muito, estou aqui de novo por que preciso da ajuda de vocês, criei um código de um escalonador em java para um trabalho da faculdade, atualmente estou focado em programação web e não em java, sendo assim não manjo de orientação a Objetos, criei esse código simples mas preciso dele orientado a objeto! alguém consegue adaptar pra mim? desde já agradeço e desculpem o textão.

/*

  • To change this license header, choose License Headers in Project Properties.
  • To change this template file, choose Tools | Templates
  • and open the template in the editor.
    */
    package sjf;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Scanner;

/**
*

  • @author marcos
    */
    public class SJF {

    /**

    • @param args the command line arguments
      */
      public static void main(String[] args) {
      Scanner sc1 = new Scanner(System.in);

      // declaracao de variaveis
      int numero, entrada;
      ArrayList processo, inicio, copiaInicio = new ArrayList(), burst;
      int[] tempoFim = new int[1], tempoInicio = new int[1];
      int idProcessoExecutando;
      String ordemEx = “”, formatacao/formatação de numeros/, out/saida/;
      double tempoEspera, tempoExecucao, turnaround;
      int count = 0;
      DecimalFormat decimal = new DecimalFormat(“0.00”);

      System.out.println(“Quantos processos deseja armazenar?”);
      numero = sc1.nextInt();

      while (numero != 0) {
      count++;

       ordemEx = "";
       processo = new ArrayList();
       inicio = new ArrayList();
       burst = new ArrayList();
      
       tempoFim = new int[numero];
       tempoInicio = new int[numero];
      
       for (int i = 0; i < numero; i++) {
           // le e adiciona tempo de ingresso do processo
           System.out.println("Tempo de chegada do p" + (i + 1));
           entrada = sc1.nextInt();
           inicio.add(entrada);
           // le e adiciona tempo de duracao do processo
           System.out.println("Tempo de burst do p" + (i + 1));
           entrada = sc1.nextInt();
           burst.add(entrada);
       }
       // cria copia da lista de tempos de ingressos devido a modificacoes
       copiaInicio = (ArrayList) burst.clone();
      
       int execucao;
       int quantidadeProcessos = numero;
       // tempo inicial = primeiro tempo da lista de ingressos
       int tempoAtual = (int) inicio.get(0);
       while (quantidadeProcessos > 0) {
           // percorre ingressos para achar processos que ingressam nesse
           // tempo
           processo = new ArrayList();
           for (int i = 0; i < numero; i++) {
               if ((int) inicio.get(i) != -1 && (int) inicio.get(i) <= tempoAtual) {
                   // adicionar na lista de processos
                   processo.add(i);
               }
           }
      
           // assumindo que o primeiro da lista eh o de menor duracao
           if (processo.isEmpty()) {
               tempoAtual++;
           } else {
               execucao = (int) processo.get(0);
               for (int i = 0; i < processo.size(); i++) {
                   idProcessoExecutando = (int) processo.get(i);
                   /* se a duracao do processo atual for menor do que a menor duracao ja encontrada*/
                   if ((int) burst.get(idProcessoExecutando) < (int) burst.get(execucao)) {
                       // entao alteramos o processo que vai executar
                       execucao = (int) processo.get(i);
                   }
               }
      
               tempoInicio[execucao] = tempoAtual;
               tempoAtual += (int) burst.get(execucao);
               tempoFim[execucao] = tempoAtual;
               inicio.set(execucao, -1);
      
               // define ordem de execucao
               ordemEx += "P" + (execucao + 1) + " ";
               quantidadeProcessos--;
           }
       }
      
       // calculo tempo de execucao e tempo de espera
       tempoExecucao = 0;
       tempoEspera = 0;
       for (int i = 0; i < numero; i++) {
           tempoExecucao += tempoFim[i] - (int) copiaInicio.get(i);
           tempoEspera += tempoInicio[i] - (int) copiaInicio.get(i);
       }
       System.out.println("PROCESSAMENTO - PARTE" + count);
       for (int i = 0; i < numero; i++) {
           turnaround = (int) tempoFim[i] - (int) copiaInicio.get(i);
           formatacao = decimal.format(turnaround);
           out = "|Turnaround| P" + i + ": " + formatacao + "ms";
           out = out.replace(".", ",");
           System.out.println(out);
       }
       tempoExecucao = tempoExecucao / numero;
       tempoEspera = tempoEspera / numero;
      
       formatacao = decimal.format(tempoExecucao);
       out = "Tempo medio de execucao: " + formatacao + "s";
       out = out.replace(".", ",");
       System.out.println(out);
      
       formatacao = decimal.format(tempoEspera);
       out = "Tempo medio de espera: " + formatacao + "s";
       out = out.replace(".", ",");
       System.out.println(out);
      
       System.out.println(ordemEx);
       System.out.println();
       System.out.println("Deseja armazenar quantos processadores?");
       numero = sc1.nextInt();
      

      }
      }

}

Por que precisa desse código orientado a objetos? Se está querendo aprender segue esse direcionamento: https://www.caelum.com.br/apostila-java-orientacao-objetos/

E por que meu professor exige que o código seja orientado objeto, para que no processo eu detalhe o que cada função faz, exemplo public void tempoDeEspera(){
tempoExecucao = tempoExecucao / numero;
tempoEspera = tempoEspera / numero;
}

ai eu vou ter que explicar oq essa função faz, e se eu deixar do jeito que ta eu so vou ter a main, e não vou ter como detalhar nenhuma função especifica.

Então tem que aprender orientacao a objetos antes. Mas não precisa ter um modelo orientado a objetos pra ter um código organizado e dividir em funções específicas. Você pode criar classes separadas responsáveis por cada funcionalidade.