Oi Edisson! Tudo certo?

Pelo que entendi, você quer que a sua classe FoxMcDonald mude as propriedades de Airproperties de acordo com a altitude dada, certo? Só que do jeito que a classe está, FoxMcDonald está, o código não compila porque você está trabalhando com objetos instanciados fora do método main. Uma forma de corrigir isso é extrair essa lógica para um método, assim:

public class FoxMcDonald extends AirProperties{

//            Air physical properties determined as function of the altitude }

    public double altitude;

    public FoxMcDonald(){
        super();
    }

    //            Air physical properties determined as function of the altitude }

        public void funcaoAltitude(double altitude) {
            if (0.0 <= altitude && altitude < 500.0) {
                setDenChar(1.22500e0);
                setPrChar(1.01325e5);
                setMiChar(1.78962e-5);
                setKChar(2.53154e-2);
            }

            if (500.0 <= altitude && altitude < 1000.0) {
                setDenChar(1.16730e0);
                setPrChar(9.54583e4);
                setMiChar(1.77366e-5);
                setKChar(2.50533e-2);
            }

            if (1000.0 <= altitude && altitude < 1500.0) {
                setDenChar(1.11169e0);
                setPrChar(8.98753e4);
                setMiChar(1.75809e-5);
                setKChar(2.47981e-2);
            }
        }
    }

Outra coisa que fiz foi adicionar construtores padrão tanto em Airproperties quanto na FoxMcDonald. Isso vai ser útil daqui a pouco. No caso o construtor padrão na classe Airproperties ficou assim: public AirProperties(){};

A última mudança que fiz foi usar o método funcaoAltitude(), que criamos ali em cima, na classe Atmosphere.

public class Atmosphere

{        public static void main (String[] args)

{   GeneralProperties genprop = new GeneralProperties();
    String formulation = genprop.getFormulation();

    PhysicalProperties phyprop = new PhysicalProperties();
    double altitude = phyprop.getAltitude();

//            Defining the air properties in the Earth atmosphere
    if ((formulation == "TECNE") || (formulation == "TCNE")) {
        FoxMcDonald foxMcDonald = new FoxMcDonald();
        foxMcDonald.funcaoAltitude(altitude);
    } }
    else
//        Defining the air properties in the Mars atmosphere
    {                    NasaSP8010(); } }

No caso, instanciei um objeto do tipo FoxMcDonald e chamei o método utilizando-o.

Uma última dica que gostaria de dar é que é muito provável que você tenha problemas com essa comparação: if ((formulation == "TECNE") || (formulation == "TCNE")), pois, por mais que a string que você está utilizando seja escrita exatamente como "TECNE" ou "TCNE", o Java não entende isso e vai entender como diferentes. O correto a se utilizar, para que o Java reconheça, é if ((formulation.equals("TECNE") ) || (formulation.equals("TCNE"))).

Espero ter ajudado! Abraços e bons estudos, qualquer coisa estou por aqui.

Oi Iasmim,

Bom dia. Eu fiz as modificações que você sugeriu e compilou, mas eu tenho outros métodos no programa que não precisam de uma classe "public void funcaoAltitude" e eu queria uma forma mais geral de chamar os métodos. Um colega seu sugeriu que poderia chamar por: "new FoxMcDonald", "new NasaSP8010" simplesmente. Isso ajudaria pois eu tenho várias chamadas de métodos que ficariam bem simplificadas se puder ser assim. Um outro ponto que eu queria conversar com você é que nem todos as minhas classes começam com o "public static void main(String[] args)" porque quando eu adiciona este comando, a classe apresenta uma série de erros como: definir as variáveis private e public como final, erros na definição de arrays, etc. Quando eu tiro este comando, a classe compila, mas eu não sei o que acontece que dá erro quando eu coloco, você tem ideia? Eu também fiz a modificação com os "equals" que você também sugeriu. Bem é isso, agradeço sua ajuda e se você puder esclarecer estas minhas dúvidas eu lhe agradeço. Obrigado, Edisson Sávio.

Boa tarde, Edisson!

Quando você faz "new FoxMcDonald()" você está criando um objeto, ou seja, reservando um espaço na memória pra ele. Mas nada foi modificado ainda, seu código ainda não entende isso. Pra que seja entendido, você precisa criar o objeto primeiro, e depois chamar um método dele pra realizar as mudanças necessárias. No seu caso, setar tudo. Uma outra alternativa ao que eu propus seria, ao invés de ter todos esses sets dentro de um método funcaoAltitude, usar essa lógica no próprio construtor. Mais ou menos assim:

Classe AirProperties:

public class AirProperties {
    //            Definition of variables
    private double denChar;
    private double prChar;
    private double miChar;
    private double kChar;
    private double reChar;
    private double reSigma;
    private double rb;
    private double dtChar;

    public AirProperties(double denChar, double prChar, double miChar, double kChar, double reChar, double reSigma, double rb, double dtChar) {
        this.denChar = denChar;
        this.prChar = prChar;
        this.miChar = miChar;
        this.kChar = kChar;
        this.reChar = reChar;
        this.reSigma = reSigma;
        this.rb = rb;
        this.dtChar = dtChar;
    }

    public AirProperties() {}

    //            Definition of methods
    public double getDenChar() {
        return this.denChar;
    }

    public void setDenChar(double denChar) {
        this.denChar = denChar;
    }

    public double getPrChar() {
        return this.prChar;
    }

    public void setPrChar(double prChar) {
        this.prChar = prChar;
    }

    public double geMiChar() {
        return this.miChar;
    }

    public void setMiChar(double miChar) {
        this.miChar = miChar;
    }

    public double getKChar() {
        return this.kChar;
    }

    public void setKChar(double kChar) {
        this.kChar = kChar;
    }

    public double getReChar() {
        return this.reChar;
    }

    public void setReChar(double reChar) {
        this.reChar = reChar;
    }

    public double getReSigma() {
        return this.reSigma;
    }

    public void setReSigma(double reSigma) {
        this.reSigma = reSigma;
    }

    public double getRb() {
        return this.rb;
    }

    public void setRb(double rb) {
        this.rb = rb;
    }

    public double getDtChar() {
        return this.dtChar;
    }

    public void setDtChar(double dtChar) {
        this.dtChar = dtChar;
    }
}

Classe FoxMcDonald:

public class FoxMcDonald extends AirProperties{

//            Air physical properties determined as function of the altitude }

    public double altitude;

    public FoxMcDonald(){
        if (0.0 <= altitude && altitude < 500.0) {
            setDenChar(1.22500e0);
            setPrChar(1.01325e5);
            setMiChar(1.78962e-5);
            setKChar(2.53154e-2);
        }

        if (500.0 <= altitude && altitude < 1000.0) {
            setDenChar(1.16730e0);
            setPrChar(9.54583e4);
            setMiChar(1.77366e-5);
            setKChar(2.50533e-2);
        }

        if (1000.0 <= altitude && altitude < 1500.0) {
            setDenChar(1.11169e0);
            setPrChar(8.98753e4);
            setMiChar(1.75809e-5);
            setKChar(2.47981e-2);
        }
    }
}

Dessa forma, ao construir um objeto, você já está analisando a altitude e mudando os parâmetros. Mesmo assim, não recomendo que você dê apenas um new no objeto na classe Atmosphere. Isso porque, como eu disse, o new está reservando um espaço na memória, mas você precisa de uma referência, de algo pra identificar esse objeto que criou. Por isso, utilizamos o FoxMcDonald foxMcDonald = new FoxMcDonald();. Assim, todas as vezes que você precisar trabalhar com foxMcDonald você saberá qual variável deve chamar. A classe fica assim:

public class Atmosphere

{        public static void main (String[] args)

{   GeneralProperties genprop = new GeneralProperties();
    String formulation = genprop.getFormulation();

    PhysicalProperties phyprop = new PhysicalProperties();
    double altitude = phyprop.getAltitude();

//            Defining the air properties in the Earth atmosphere
    if ((formulation == "TECNE") || (formulation == "TCNE")) {
        FoxMcDonald foxMcDonald = new FoxMcDonald();

    } }
    else
    //        Defining the air properties in the Mars atmosphere
    {                    NasaSP8010 nasa = new NasaSP8010(); } }

Com relação à sua dúvida sobre o public static void main(String[] args), ocorre o seguinte: em Java, qualquer arquivo deve ser uma classe. Porém, pensando nisso, há as classes que definem objetos, ou seja, que dizem quais as características de um objeto e o que ele faz, e as classes que instanciam esse objeto e fazem ele realmente existir, dando saídas para o usuário saber o que foi computado no programa. Assim, se você quer apenas definir o que seu objeto vai fazer, você não usa o método main. Se quer ver o que está sendo executado no programa, você usa.

Outra forma de ver isso é que o método main é, antes de tudo, um método! Então a gente não pode definir outros métodos lá dentro, porque o Java não entende essa sintaxe. O método main é usado apenas para chamar métodos de outras classes, e não para definir métodos dentro dele. No caso do seu código, por exemplo, a classe Atmosphere é quem está testando tudo, por isso ela tem um método main. Já as classes Airproperties e FoxMcDonald estão apenas definindo objetos, sem executar algo para o usuário. Por isso, elas não tem método main.

Espero ter ajudado a esclarecer suas dúvidas! :)

Oi Iasmim,

Boa noite. Eu vi que a forma que você abordou usando o funcaoAltitude é melhor do que os outros que testei e estou adequando o meu código a esta realidade. Eu tenho uma parte do código que está digitada abaixo:

package FiveSpeciesOneTemperatureTecne;

    import General.AirProperties;
    import General.PhysicalProperties;
    import General.AlgorithmProperties;
    import General.ComputationalProperties;

public class TemperatureField extends TemperatureComplement

//            Definition of variables    
{            private int imax;
            private int jmax;
            public double temperatures [] [] [] = new double [imax+1] [jmax+1] [2];
            public double qTecne [] [] [] = new double [imax+1] [jmax+1] [15];
            private double [] primitive = new double [15];
            private double miMag;
            private double cvMixt;
            private double dhfMixt;
            public double achar;
            public double tref;
            private int iterations;
            private double temperature;
            private String scheme;
            private double rb;

//            Order of Primitive variables:

/**          Primitive[1] = Den;
*             Primitive[2] = u;
*             Primitive[3] = v;
*             Primitive[4] = Z;
*             Primitive[5] = Bx;
*             Primitive[6] = By;
*             Primitive[7] = B;
*             Primitive[8] = En;
*             Primitive[9] = cs1;
*             Primitive[10] = cs2;
*              Primitive[11] = cs3;
*             Primitive[12] = cs4;
*             Primitive[13] = cs5;
*            Primitive[14] = ei_int;
*/
//            Cell temperatures

//            Instanciando properties
            SpeciesProperties properties [] = new SpeciesProperties [5];

//            Instanciando Computational Properties
{            ComputationalProperties comprop = new ComputationalProperties();
            iterations = comprop.getIterations();

//            Instanciando Physical Properties
            PhysicalProperties phyprop = new PhysicalProperties();
            temperature = phyprop.getTemperatureFree();

//            Instanciando Algorithm Properties
            AlgorithmProperties algprop =new AlgorithmProperties();
            scheme = algprop.getScheme();

//            Instanciando Air Properties
            AirProperties airprop =new AirProperties();
            rb = airprop.getRb();

            for (int i = 1; i <= imax; i++)
{                for (int j = 1; j <= jmax; j++)            
{//                Cell temperatures at the first iteration, determined by the initial condition
                    if (iterations == 0)
{//                    Nondimensionalized initial temperature to each cell
                        temperatures[i] [j] [1] = temperature/achar+tref; }
                    else
{//                     For the other iterations...
//                        Five species model composed of N, O, N2,O2, and NO
                        primitive [1] = qTecne[i] [j] [1];
                        primitive [2] = qTecne[i] [j] [2]/qTecne[i] [j] [1];
                        primitive [3] = qTecne[i] [j] [3]/qTecne[i] [j] [1];

//                       Calculation of the mass fractions
                        primitive[9] = qTecne[i] [j] [5]/qTecne[i] [j] [1];
                        primitive[10] = qTecne[i] [j] [6]/qTecne[i] [j] [1];
                        primitive[12] = qTecne[i] [j] [7]/qTecne[i] [j] [1];
                        primitive[13] = qTecne[i] [j] [8]/qTecne[i] [j] [1];
                        primitive[11] = 1.0-(primitive[9]+primitive[10]+primitive[12]+primitive[13]);

//                        Calculation of the mixture specific heat at constant volume
                        cvMixt = primitive[9]*properties [1].heat+primitive[10]*properties [2].heat+primitive[11]*properties [3].heat+primitive[12]*properties [4].heat+primitive[13]*properties [5].heat;

//                        Calculation of the mixture formation enthalpy
                        dhfMixt = primitive[9]*properties[1].enthalpy+primitive[10]*properties[2].enthalpy+primitive[11]*properties[3].enthalpy+primitive[12]*properties[4].enthalpy+primitive[13]*properties[5].enthalpy;

//                        Considering or not the magnetic effect

                        if ((scheme.equals("MacCormack (1969) Scheme ME")) || (scheme.equals("Maciel (2015) Scheme ME")))
{//                        Considering magnetic field
//                           Defining magnetic components and the magnetic permeability
                            primitive[4] = qTecne[i] [j] [4]/qTecne[i] [j] [1];
                            primitive[5] = qTecne[i] [j] [13];
                            primitive[6] = qTecne[i] [j] [14];
                            primitive[7] = Math.sqrt(primitive[5]*primitive[5]+primitive[6]*primitive[6]);
                            miMag = 1.0;

                            primitive[14] = primitive[4]-dhfMixt-0.5*(primitive[2]*primitive[2]+primitive[3]*primitive[3])-0.5*rb*(primitive[7]*primitive[7])/(miMag*primitive[1]); }

                        else

{//                        Magnetic field is not considered
                            primitive[8] = qTecne[i] [j] [4];

//                           Internal energy without magnetic field actuation
                            primitive[14] = primitive[8]/primitive[1]-dhfMixt-0.5*(primitive[2]*primitive[2]+primitive[3]*primitive[3]);  }

//                    Mixture translational/rotational temperature
                    temperatures[i] [j] [1] = Math.abs(primitive[14]/cvMixt)+tref; } } }

//            Complementing the temperature field
            TemperatureComplement tempcomp = new TemperatureComplement();
            tempcomp.TemperatureComp(temperatures); } }

e eu tenho que enviar um array como variável de referência. Como eu faço isto?

E você se incomoda de me dar seu e-mail para eu continuar a tirar as minhas dúvidas? Por que tem hora que o programa avança e tem hora que dá um aperto e eu queria alguém para tirar as minhas dúvidas, pode ser você? Obrigado, Edisson Sávio.

E mais, como eu faço para "setar" um array porque eu só vi como setar uma variável escalar e não vi arrays?

Oi, Edisson!

Para enviar um array como variável de referência em um parâmetro de um método, podemos fazer da forma abaixo, onde temos uma função que será responsável por somar os valores do array e passamos a variável como parâmetro dessa função. Neste exemplo, vale ressaltar que o método que precisa do array como parâmetro é declarado com o tipo que ele precisa, neste caso int[][]:

public class ClasseComArray {
    public int trabalhaComArray(int[][] array){
        int soma = 0;
        for(int i = 0; i< array.length; i++){
            for(int j = 0; j< array[i].length; i++){
                soma+=array[i][j];
            }
        }
        return soma;
    }
}

public class Teste {

    public static void main(String[] args) {
        ClasseComArray classeComArray = new ClasseComArray();
        int valores[][] = {{1,2,3,4,5},{6,7,8,9,10}};

        classeComArray.trabalhaComArray(valores);
    }

}

Com relação a setar um array, você pode fazer um setter que mude o valor de uma posição específica, passada como parâmetro. Dessa forma:

public class Teste {

    private int teste[] = new int[8];

    public void setTestes(int posicao, int valor) {
        this.teste[posicao] = valor;
    }
}

Por fim, reforço que atualmente, o contato entre o suporte técnico e os alunos se dá exclusivamente pelo Fórum e pelo Discord Oficial da Alura, onde por meio deste último, além de suporte técnico da equipe da Alura em um espaço mais curto de tempo, você também encontrará outros alunos e alunas que estejam estudando os mesmos conteúdos que você e além disso, também poderá fazer networking, entrar em grupos de estudos, dentre outros. Caso ainda não faça parte deste discord, te faço o convite. Você pode entrar por este link. Se o discord for novidade para você, recomendo um alura mais da plataforma que ensina o uso dessa ferramenta:

• Como usar o Discord?

Espero ter ajudado, abraço e bons estudos!