(C #, JavaScript) Programação orientada a objetos

Entendimento orientado a objeto (OOP)

Amigos que gostam do programa, todos deveriam ter ouvido a frase " Tudo é um objeto ", sentindo o velho X.

Programação orientada a objetos, é projetada em todo o mundo real.

Três elementos orientados a objetos: encapsulamento, herança e polimorfismo.

Podemos definir uma classe para representar o carro e definir alguns atributos e comportamento do carro. No entanto, na realidade, existem muitos tipos de carros, como ônibus, caminhões e táxis. É necessário definir a classe correspondente todas as vezes? Neste caso, é demais, podemos abstraí-los uma vez, se esses carros pertencem à categoria de carros. Nesse caso, existem muitos atributos e comportamentos que todos têm, mas são diferentes.Em seguida, definimos uma classe abstrata (Veículo), permitimos que ônibus, caminhões e táxis herdem essa classe e só precisam reescrevê-la Método ou modifique as propriedades correspondentes. Após o trabalho acima, você pode instanciar o ônibus, o caminhão e o táxi (ou seja, a nova operação), e somente após a instanciação você poderá ser chamado de objeto. A partir disso, tudo é um objeto, então entenda-o naturalmente.
(Se você não tem namorada, vamos comprar uma nova, hehehe)

Aliviar a fadiga ocular

Existem dois tipos principais de linguagens orientadas a objetos: 1. Fortemente digitado (C #, Java etc.) 2. Fracamente digitado (JavaScript).

1. Primeiro, use a linguagem C # fortemente tipada para introduzir especificamente a orientação a objetos. (Java, pessoalmente, não sabe muito ...) O
código é o seguinte:
encapsulamento

//定义一个抽象类 Vehicle 将一些属性跟行为封装在这个类里供后面的类继承
abstract class Vehicle()
{
    public string myName;//这个是字段，不是属性

    //属性
    public string Appearance { get; set; } = "red"; //外观颜色，默认是红色，而且该属性可读可写
    public string Weight { get; set; } = "1.8t" //车身重量
    public string Brand { get; set; } //品牌
    //行为（方法）
    public virtual void Run() //使用virtual关键字以供继承它的类重写该方法
    {
        //启动
    }
    public virtual void Stop()
    {
        //停车
    }
}

Herança

class Car : Vehicle()//小轿车继承Vehicle这个类
{
    //属性重新赋值---构造函数（用来构造对象的，顺便设置本类的部分属性值）
    public Car()
    {
        this.Appearance = "小轿车外观";
        this.Weight = "1.5t";
    }
    //行为（方法）  重写Vehicle里面的Run方法
    public override void Run()
    {
        //小轿车启动
    }
    public override void Stop()
    {
        //小轿车停车
    }
}
class Bus : Vehicle()
{
    //属性
    public Bus()
    {
        this.Appearance = "公交车外观";
        this.Weight = "2t";
    }
    //行为（方法）
    public override void Run()
    {
        //公交车启动
    }
    public override void Stop()
    {
        //公交车停车
    }
}

Polimorfismo

class static void Main()//程序入口
{
    Car car = new Car();//实例化一个对象
    car.Brand = "劳斯莱斯";//重新设置属性的值
    car.Run();//启动小轿车
    Bus bus = new Bus();
    bus.Run();//启动公交车
    //小轿车和公交车调用了同一个Run方法，却产生了不同的效果；
    这便是多态，不同的对象调用调用同一个方法，产生了不同的行为。也是面向对象程序设计的魅力所在
}

2. Em seguida, use a linguagem JavaScript de tipo fraco para introduzir a orientação a objetos.
O código é o seguinte:

//最简单的方式
var Vehicle={
    Appearance:"",
    Weight:"",
    Brand:"",
    Run:function(){},
    Stop:function(){}
}
//js语言也可以设置某个属性是可读还是可写，只不过稍微有些复杂
如下：
Objec.defineProperty(Vehicle,"Appearance",{
    writable: false//不可写，意思就是不能修改该属性的值
})

//组合使用构造函数模式跟原型模式---这里可能有些复杂，具体原型在之后的博客中详细介绍
function Vehicle(Appearance,Weight,Brand)
{
    this.Appearance=Appearance;
    this.Weight=Weight;
    this.Brand=Brand;
}
Vehicle.prototype={
    constructor:Vehicle,
    Run:function(){},
    Stop:function(){}
}

Veja aqui para explicar a diferença entre tipo forte e tipo fraco: tipo
forte: refere-se ao tipo de valor específico é certo, a definição da variável do tipo int, você precisa usar a palavra-chave int; a definição da variável do tipo string, é necessário usar a string Palavras-chave; agora o C # também suporta o uso da palavra-chave var para definir variáveis, mas ao definir, você deve atribuir valores. O princípio é realmente adivinhar que tipo de variável é baseada no valor atribuído, ou seja, com base no valor atribuído para adivinhar se o var se refere a int ou string.

Tipo fraco: no JavaScript, todas as variáveis ​​são definidas usando a palavra-chave var, independentemente do tipo de variável que pode ser definido usando var.

Aliviar a fadiga ocular 2

A propósito, C # (Java) também pertence às fileiras de linguagens do lado do servidor e JavaScript pertence à linguagem do lado do cliente.
Como assim?
Ou seja, o C # é executado no servidor e o JavaScript é executado no cliente. O idioma JavaScript nas páginas da Web que normalmente navegamos está em execução no navegador. Podemos ver diretamente o código JavaScript no navegador, mas não podemos ver o idioma do servidor.