orientação a objetos – Como atribuir no construtor de uma classe filha uma instância da classe pai em Ruby

Eu tenho uma classe filha que é inicializada com algumas instâncias:

def initialize(nome:, preco:, categoria:)
    @nome = nome
    @preco = preco
    @categoria = categoria
end

Mas preciso que a variável @categoria seja puxada do construtor da classe pai. A instância que preciso da classe pai está com outro nome e não consegui pegar utilizando o método super.

  def initialize(nome: 'Geral')
    @nome = nome
  end

Em resumo, preciso que o atributo @categoria da classe filha herde o atributo @nome da classe pai.

orientação a objetos – Como obter um código em C# que resolva o problema de baixa coesão e alto acoplamento descrito abaixo?

No desenvolvimento de sistemas temos vários conceitos importantes que podemos aplicar durante a evolução dos projetos de softwares como a análise da Coesão e do Acoplamento entre as partes do sistema. A Coesão torna o nosso projeto mais harmônico através de uma melhor distribuição de responsabilidades entre as classes, assim, podemos identificar situações de Alta Coesão ou Baixa Coesão, sendo a Alta Coesão a melhor situação. O Acoplamento significa a dependência entre as classes do projeto, onde devemos buscar um mais Baixo Acoplamento possível. Considerando o seu conhecimento sobre Coesão e Acoplamento, analise a situação em que você deverá implementar classes para um sistema de pedidos de uma loja virtual. O sistema de pedidos necessita dos objetos do tipo Pedido e ItemPedido, onde os objetos do tipo Pedido devem armazenar informações como código do pedido, data do pedido e cpf do cliente, logo, esses deverão ser os atributos declarados dentro da classe Pedido. Os objetos do tipo ItemPedido devem armazenar informações como código do item, descrição do item e valor do item, assim, a classe ItemPedido deve possuir esses atributos. Considere o tipo int para os códigos, o tipo String para data, cpf e descrição e o tipo float para valor do item. Frente a essa situação, considere que um pedido possui apenas um item de pedido, faça com que as implementações das classes Pedido e ItemPedido sejam dependentes uma da outra através de um atributo chamado item, dentro da classe Pedido. Esse atributo item deve ser do tipo ItemPedido, assim, teremos uma situação de acoplamento do tipo: uma classe A possuindo um atributo do tipo da classe B. Após essa implementação, que representa um problema de Baixa Coesão e Alto Acoplamento, apresente uma solução removendo a dependência entre as duas classes.

Curso: Fundamentos de Desenvolvimento de Aplicações com Visual C#

javascript – Gostaria de orientação para criar alguns diretórios

O que eu preciso:

Criar uma pasta na área de trabalho, dentro dessa pasta criar outra chamada “img” e dentro de img criar “home”.

A forma que consegui fazer, Porém sei que não é a forma ideal… Ainda estou aprendendo, agradeço a paciencia!

Alguma sugestão para melhorar isso?

var nome = 'teste';
const dir = `C:/Users/mathe/Desktop/${nome}`;

//Verifica se não existe
if (!fs.existsSync(dir)){
    //Efetua a criação do diretório
    fs.mkdir(dir, (err) => {
        if(err){
            console.log('Algo deu ruim...' + err)
        }else{
            dirImg = dir+'/'+'img';
            fs.mkdirSync(dirImg)
            fs.mkdirSync(dirImg+'/'+'home')
            console.log('Tudo criado!')
        }
    });
}else{
    console.log(`Arquivo ${nome} não pode ser criado pois já existe!`)
}```

orientação a objetos – POO ou Programação Funcional com Typescript?

Estou com uma seria dúvida em qual paradigma se aprofundar primeiro, eu sei uma base de programação funcional e estou aprendendo POO agora usando Typescript. Gostaria de saber se as empresas usam POO com Typescript, se vale a pena se aprofundar, estou meio perdido porque sempre usei funções pra tudo no Javascript, mas queria evoluir, sempre falam que POO é muito usado, queria saber se é uma boa usar junto com TS, valeu ai galera.

Eu realizei orientação em objetos em Python da forma correta?

Fala pessoal. Eu estou começando a aprender Orientação a Objetos em Python. Não sou um completo iniciante no assunto, no passado estudei orientação a objetos em PHP e brevemente em Java, e notei que POO em Python difere um pouco dessas linguagens. Para praticar, criei algumas classes e tentei aplicar o que aprendi, incluindo Herança e um pouco de Polimorfismo (sobreposição de métodos, apenas), mas não estou confiante de que o fiz da forma correta/ideal. Testei o código e parece que deu tudo certo, mas gostaria de saber da galera que entende mais se algo que eu fiz foi feito de maneira incorreta/ineficiente ou se algo poderia ser melhorado. Desculpem o código grande, mas ele é bem simples e rápido de analisar (essa é minha primeira pergunta aqui então não sei exatamente como funciona, desculpem se fiz algo errado). Abraços

class Animal:
    def __init__(self, peso, idade):
        self.peso = peso
        self.idade = idade

    def locomover(self):
        pass

    def alimentar(self):
        pass

    def som(self):
        pass


class Mamifero(Animal):
    def __init__(self, peso, idade):
        super().__init__(peso, idade)
        self.membros = 4

    def locomover(self):
        print("correr")

    def alimentar(self):
        print("leite materno")


class Reptil(Animal):
    def __init__(self, peso, idade):
        super().__init__(peso, idade)
        self.membros = 4

    def locomover(self):
        print("rastejar")

    def alimentar(self):
        print("pequenos animais")


class Ave(Animal):
    def __init__(self, peso, idade):
        super().__init__(peso, idade)
        self.membros = 4

    def locomover(self):
        print("voar")

    def alimentar(self):
        print("pequenos animais")


class Leao(Mamifero):
    def __init__(self, peso, idade):
        super().__init__(peso, idade)

    def alimentar(self):
        print("caça")

    def som(self):
        print("rugir")


class Morcego(Mamifero):
    def __init__(self, peso, idade):
        super().__init__(peso, idade)

    def locomover(self):
        print("voar")

    def alimentar(self):
        print("sangue")


class Tartaruga(Reptil):
    def __init__(self, peso, idade):
        super().__init__(peso, idade)

    def locomover(self):
        print("nadar")

    def alimentar(self):
        print("algas")


class Serpente(Reptil):
    def __init__(self, peso, idade):
        super().__init__(peso, idade)
        self.membros = 0

    def som(self):
        print("sibilar")


class Cisne(Ave):
    def __init__(self, peso, idade):
        super().__init__(peso, idade)

    def alimentar(self):
        print("sementes")

    def locomover(self):
        print("nadar")


class Abutre(Ave):
    def __init__(self, peso, idade):
        super().__init__(peso, idade)

    def alimentar(self):
        print("comer carcaças")

PS: a ideia da classe Animal é funcionar como uma classe abstrata. Não sei se é adequado classificá-la assim, mas a intenção é que essa classe não seja instanciada (ela possui um construtor explícito, mas não encontrei forma melhor de trabalhar com os atributos peso e idade)