Transcrições
1. Programação de programação orientando objetos, introdução: Bem-vindo, DOB. Grau de programação. Uma abordagem conceitual. Meu nome é Tevis Boulware, e eu serei o instrutor deste curso sobre o que este curso é tudo sobre. Esta unidade curricular aborda a análise, concepção e criação de programação básica orientada a
objectos, com ênfase no conceito, processos e estrutura do programa sobre os detalhes reais da programação. Programação é de vital importância, No entanto. Muitos cursos de programação introdutória saltar direto para a programação sem cobrir os conceitos
fundamentais, a base de cada programação orientada a objetos. Este curso tem um conceito de primeira abordagem. Uma das coisas a notar é que o conceito e os processos sobre o programa. Significa que o que vamos falar se aplica a qualquer linguagem de programação, seja C,
sharp, sharp, Java ou python ou qualquer que seja a sua linguagem preferida, os conceitos eram todos iguais. A única coisa que é diferente do que são os detalhes de implementação desses conceitos. O que você aprenderá neste curso, você aprenderá a projetar uma programação básica e
óbvia usando a linguagem de modelagem unificada. Não se intimide com isso. É uma maneira padrão que os programadores profissionais Incheon e engenheiros de software usaram para documentar o esquema de sua linguagem. Não é. Não é intimidador. Parece que você vai aprender a criar um design que incorpora vários objetos e que permite passar mensagens,
passando entre os objetos do motel. Minha experiência é que os alunos introdutórios têm o tempo mais difícil de trabalhar em programas com vários objetos porque eles têm que pegar dados de um e colocar enviá-los para outro e trás e para frente. Essas são geralmente as coisas mais complexas que os programadores introdutórios têm que aprender, e por isso estamos concentrados nelas. Você vai aprender a pegar esse design ou qual é o seu plano, e então traduzir esse projeto em uma óptica no seu programa agora uma das coisas que eu realmente quero me concentrar. Os conceitos e processos que abrangem este curso não dependem da linguagem de programação que vou usar. C. Sharp é a língua primária usada para demonstrar as técnicas porque eu acho que é uma das línguas mais fáceis de aprender e uma das línguas mais fáceis de ler. Mas outros exemplos de idiomas serão mostrados para ilustrar a semelhança entre a língua
diferente. O que você vai encontrar em todos os idiomas suporta os mesmos conceitos gerais. A única diferença
é, então, vai ser os detalhes específicos da linguagem que implementam esses conceitos. Agora queremos ter certeza de que entendemos o que este curso não faz também. Este curso não se concentrará na interface do usuário. Assim que começamos a falar sobre interfaces de usuário, desenhos
gráficos do usuário e coisas assim que você levantou colocar um nível de complexidade lá que tira o conceito coreano objeto. Vamos nos concentrar em programas prós baseados em conselhos para que ele possa se concentrar nesses conceitos fundamentais. E então as interfaces de usuário serão o assunto de outro curso. Não vamos cobrir nenhuma linguagem de programação de detalhes novamente. Eu vou estar usando C Sharp é o exemplo também show social alguns programas Java, alguns programas python. Mas há uma abundância de sites de programação tutorial disponíveis onde você pode aprender a trabalhar com a linguagem específica. Eu não vou cobrir especificamente quais detalhes neste curso. Não vamos fazer algoritmos de programação complexos, e não vamos cobrir alguns dos tópicos intermediários ou avançados mais imediatos , como composição. E aqui estão as classes abstratas. Esses vão ser sujeitos. Sujeite outro curso. Você quer entender o básico fora? Quais são os conceitos básicos de objetos e como eles se comunicam, como construir esses programas. E uma vez que você tem esses para baixo, então você pode ir para os conceitos intermediários mais intermediários. Então o que ele pode precisar para este curso, você precisa provavelmente ter algumas habilidades básicas e trabalhar a linguagem
de programação de computador da suposição aqui é que você tomou algum tipo de você tem algum tipo de experiência de programação. Você sabe como escrever programas simples novamente. Você poderia usar Java. Eu vou demonstrar Java Python C afiado. Não conheço todas as outras línguas. Tão pouco é em que vou me concentrar. Você provavelmente entende as estruturas básicas de controle provavelmente programação, tais suas decisões e loops. Nós não vamos criar algoritmos de programas complexos, mas você precisa ser capaz de escrever algum código usando if,
se então else instrução sloops e assim por diante. Você vai querer um editor de texto processador de texto para nos ajudar a fazer algumas das análises e design e um programa de secagem ah programação seria bom ter, mas não é necessariamente obrigatório. Há muitas ferramentas gratuitas baseadas na Web que você pode usar para desenhar,
e você sempre pode desenhar coisas com caneta e papel porque o que queremos concentrar. na Web que você pode usar para desenhar, É importante que você desenhe esses diagramas porque eles vão se tornar seu plano. Mas é o processo que queremos concentrar. Não necessariamente. As ferramentas de desenho se um pouco sobre o nome novamente. Meu nome é Thomas Boulware. Aqui está a minha educação. Tenho mestrado e engenharia de computação, matemática, matemática,
e sou bacharel em engenharia elétrica, matemática, QI, matemática e ciências gerais. Na minha experiência, passei 15 anos como pesquisa e desenvolvimento com a Força Aérea dos EUA, concentrando-se
principalmente em software,
engenharia, engenharia, pesquisa e desenvolvimento para a ofensa do Departamento de Partida, uma das melhores práticas e assim por diante e também passou mais de 15 anos de software comercial, engenharia. E também tenho 30 anos de experiência em meio período universitário e instrutor universitário. Eu leciono desde que era estudante de pós-graduação na Universidade da Ordem. Eu vou fazer neste curso. Nossa primeira lição será falar sobre o pensamento do objeto Orient. É como pensamos que são seres humanos. O que nós só queremos ser capazes de fazer é ser capaz de tomar nosso processo de pensamento natural de
como nós, seres humanos, consideramos o mundo ao nosso redor. E então como vamos aplicar esses princípios à programação orientada a objetos? Então estamos falando sobre as ferramentas que vamos precisar para fazer programação orientada a objetos. O que, você vai precisar deste curso. Então vamos pular em como você descreve um sistema. Se você não pode descrever o sistema, você não pode ser capaz de construí-lo. Então queremos ser capazes de descrever o sistema e isso se torna a base para tudo o que fazemos. partir desse ponto, uma vez que descrevemos o sistema, queremos ser capazes de ver como os diferentes componentes de deslocamento vão interagir. Esse é um conceito muito importante para se pensar antes de começar a implementação. O que entendemos como o sistema, mas a estrutura do sistema é como os componentes de ir para interagir. Então precisamos basicamente anotar, especificar os algoritmos específicos que vão usar, e novamente, não
vamos ser nada complexo, mas estamos apenas passando pelo processo. Certo, agora temos os algoritmos que vamos processar, e então esses se tornam nosso plano para implementação ou revestimento. Então esse é o processo que íamos seguir. Então vamos em frente e começar e nosso primeiro tópico vai ser objeto. Pensamento coreano É como nós, seres humanos, pensamos sobre o mundo.
2. Introdução ao desenvolvimento de software: Bem-vinda. A próxima lição. Um desenvolvimento de software de programação de objetos. Ciclo de vida O que queremos falar aqui é que, na lição a seguir, vamos entrar em processo de análise e design e o que eu gostaria de fazer um conjunto a
base geral para esse processo que estamos passando olhando para o que um ciclo de vida está em e alguns dos princípios básicos estavam indo para usar quando falamos sobre o ciclo de vida de
desenvolvimento de software, isso vai fornecer a você uma base das atividades que vamos cair . O desenvolvimento é um processo de engenharia. Agora, o que isso significa? Significa que é um processo formal, padronizado e repetível para criar produtos. Você começa com a identificação da necessidade de assistência que você precisa criar. Você pesquisa o problema, você identifica possíveis soluções, você seleciona a solução, você constrói um protótipo ah, modelo. Avalie esse protótipo e você o encontra. Implementar o projeto. Então engenharia é este processo formal e
respeitável. Novamente, é formal. Isso significa que é que tem um bem estabelecido diretrizes e padrões. É repetível, o mesmo passo para cada projeto. Ele vai seguir um ciclo de vida que é basicamente fases syriza através das quais um sistema passa através de sua vida. O ciclo de vida de desenvolvimento do sistema novamente é um fluxo lógico de atividades de desenvolvimento que representam a progressão ordenada das atividades do início ao fim. Agora, uma coisa que temos que lembrar é que mesmo que vamos criar
coisas diferentes no final, o processo é o mesmo. Por exemplo, financiar um projeto e construir um computador. Você vai passar a fase um cara a cara três. Fé para você irá definir essas fases com base em sua experiência e a experiência na empresa para a qual você trabalha. Agora, se vamos projetar e construir um site, vamos seguir as mesmas fases. Repare para baixo. Aqui está a atividade repetível. Bem, Bem, vamos fazer as mesmas coisas, as mesmas atividades, mas vamos acabar com resultados diferentes. Então é isso que queremos dizer com formal. Em um ciclo de vida repetível e do software, vamos passar por um obstáculo na análise. Design é um processo lógico formal. Agora, alguns dos princípios básicos sempre que você está passando pelo design de análise é que você quer pensar em termos de níveis de abstração. Eu sei que é uma espécie de Ah, oi vida, termo
high-falutin. Lá Mas o que nós pensaríamos é que queremos pensar no no quadro geral e, em seguida, aprofundar os detalhes necessariamente querer, em seguida, decompor nosso sistema, quebrar sistemas maiores nos componentes e esses componentes em componentes menores. Queremos fazer um refinamento gradual. Caso contrário, elaboramos incrementalmente os detalhes de um sistema até que você entenda como os componentes funcionam e reconstrua componentes menores e os integre juntos para obtê-lo. Sistema de trabalho, por exemplo, Piers no sistema. Eu trabalhei em um tempo atrás não, ou fiz uma lista de verificação piloto este ano automatizado checklist piloto eo que você chamaria de o mais alto nível de abstração. Este é o nível de 10.000 pés ou grande imagem que não podemos construir na lista de verificação automática de pilotos. Certo, você não sabe como fazer,
mas o que temos que fazer? Ele compôs esses componentes em subcomponentes. Então vamos quebrar a interface gráfica apontando dispositivo CAD software checklist de armazenamento. E então, onde você iria pegar cada um desses e decompor ainda mais e você continua este processo de decomposição até que você finalmente chegar a um ponto diz sim, eu sei como construir que há uma vez que nós construímos todos os subcomponentes, em seguida, integrá-los juntos para obter o nosso sistema de trabalho cada processo de desenvolvimento de sistemas que
eu já trabalhei em seu seguido esta abordagem. E esta é a abordagem que vamos tomar quando fizermos nosso objeto ou uma análise projetando seu curso agora desenvolvimento de software. E se você olhar para qualquer um dos livros didáticos, basicamente vai resumir-se em quatro processos básicos especificações problemáticas, que vai descrever o problema. Temos que fazer requisitos, analisar onde vamos tomar as especificações dos problemas e definir o que o sistema deve fazer. Vamos pegar os requisitos e vamos criar um design com base nos requisitos que vão definir como o sistema vai fazê-lo. E então isso se torna o nosso plano de implementação aviso aqui pela imagem, você sempre pode voltar atrás. Um dos problemas que vejo com os engenheiros iniciais é que eles estão sempre com medo de
voltar atrás. Por exemplo, eles vão projetar, vão para o design, então eles vão para a implementação. E, novamente, o processo stepwise ou bombeiro meio que significa que cada vez que você descobre um detalhe e perto você chegar
a implementação, mais detalhes estão indo para cima e você pode chegar a um especificações de design ou novo requisito. E quando isso acontecer, você deve voltar. Os requisitos que passam pelo processo de design são novamente, então não tenha medo de voltar atrás. Você nunca vai acertar na primeira vez. A outra coisa é que não nos lembraremos das especificações da linha de base para cada face. Por exemplo, se eu quiser fazer design, eu tenho que ter requisitos. Se eu vou fazer requisitos, eu tenho que ter as especificações problemáticas escritas para você. E eu realmente não posso fazer a implementação até ter o projeto de projeto e, em seguida, testes abranger todas as fases do processo. Agora, isso nem sempre é só me testando. E estamos executando um programa. Você pode fazer avaliações por pares. Você pode fazer inspeções de papel para ter certeza de que os artefatos estão sendo criados para alta qualidade. E o objetivo aqui é que você tem que construir qualidade em que correu através de
especificações do problema , análise, design, e obter a implementação com a atitude ou o pensamento de que ok, eu sou só vou testar a qualidade e eu vou colocá-lo lá fora, ver o que vai funcionar, então eles vão testá-lo. Você não pode fazer isso em cada fase. Você tem que ter certeza de que o que você está passando para a próxima fase está correto. Por exemplo, poucos você pode criar um bom requisito com base em um especificações ruins. Por exemplo, eu quero construir. Minha esposa me disse que queremos construir uma casa de quatro quartos. No entanto, quando eu vou descrever o problema, eu digo casa de três quartos. Então eu vou para os requisitos e passei Construir uma casa de três quartos na fase de
análise de requisitos . Então eu poderia fazer, ah, trabalho
perfeitamente aceitável de requisitos,
análise e, em seguida, projeto e implementação. Mas minhas especificações estavam incorretas, então eu posso construir a melhor casa de três quartos que já foi construída. No entanto, não
vai ser uma aplicação de qualidade ou uma casa de igualdade, porque eu deveria especificar uma casa de quatro quartos para que você possa ter erros
propagados em cada uma dessas fases, que significa que você tem que certifique-se de que em todas as fases antes de passar para a próxima que a entrada para a próxima fase estava correta. Então, uma das coisas que você quer ter em mente. Desenvolvimento de software, ciclos de
vida e progressão lógica e ordenada das atividades de desenvolvimento. Mas começa com a determinação da necessidade inicial através da eliminação. Você vai passar por um problema especificações, requisitos, análise, design, implementação e testes. E então vamos passar por este processo, certificar-nos de que usamos os níveis de abstração, decompõe o sistema e, em seguida, o refinamento gradual. que mais uma vez significa que cada vez que avançamos com o nível de e identificamos um nível de detalhe, mais como mais detalhes vão surgir caminho, encontrar a nossa compreensão, o problema nestas coisas. Por que maneira stepwise? Agora isso é Ah novamente, a apresentação é apenas para dar a você uma espécie de visão geral do que nós estamos indo para dio quando falamos sobre objeto ou uma análise e design nas seguintes lições, você vai ver como esses conceitos que se aplicam diretamente ao processo de engenharia
específico
3. Pensamento orientado em objetos: outro objeto. Então nós entendemos o conceito básico de eu estava indo programa porque esta é a maneira que nós
olhamos para as coisas no mundo real. Então, basicamente no objeto ou no pensamento, você pensa em classificações. Caso contrário, vamos classificar as coisas. Por exemplo, temos uma classificação de um aparelho de televisão. Ok, nós temos uma classificação de carros, classificação de casa, cada um desses, como nos foram faturados, cada um desses. Temos objetos em, ou apenas instâncias específicas ou manifestação física deles. Então temos uma classificação de TV e há centenas de milhões de óptica de TV no mundo. Temos uma classificação de carros e há 100 milhões de carros no mundo. Mas eles são classe velha compra bar nós basicamente. Então eu tenho, ah, classificação de uma casa para esperança, e então nós temos centenas de poemas diferentes acima. Então, basicamente, o que queremos pensar é que uma classe é um plano para uma coisa física . Em seguida, usamos esse blueprint para criar instância da classe. Então, por exemplo, se nós temos ah indo para criar um programa que mantém o controle de sua coleção de filmes você
vai então criar uma única chamada de classe, ele se moveu, e isso vai ser então. Há uma planta para cada outro objeto de filme que você classifica em seu programa. Lá você vai criar ou em stand em forma de objetos de filme, um para cada um dos filmes em sua coleção. Então, basicamente, quando falamos de classe para classificações, estamos criando um plano. Um projeto não é uma coisa. Esta é basicamente a direção que vamos usar o prédio, como um projeto para uma casa não é uma saúde. Uma casa não é uma casa que tiramos um projeto e traduzimos para um físico . E isso é o que vamos fazer em nosso objeto ou melhorar. Vamos identificar essas aulas, vamos criar plantas. E então basicamente, uma vez que tenhamos feito isso, nós vamos então e ficar de bochecha ou criar objetos daqueles assim e de novo. Se olharmos para analogia de casa, sistema de
home theater é um sistema de objeto onde cada objeto encapsula um
comportamento específico . Ok, ele esconde os detalhes complexos de processamento dos usuários externos ou entidades, e fornece uma interface pública simples. O que isso significa? Eu olho para o DVD player então. Ok, o que isso significa? E encapsula um comportamento específico. Só reproduz DVD. Ok, ele toca um DVD lê através de um laser. E desde que o áudio saiu desde que o vídeo saiu, não
faz nada. O DVD Dip player não tem nenhum tweeters para ressentiu a placa tocando a música aqueles ar encapsulado dentro do alto-falante. Televisão,
basicamente, em seguida, vai tanque sinais de vídeo e, em seguida, exibi-los. Receptor então basicamente tem uma função específica onde ele vai envolver os sinais, amplificar a cidade e o que é que ele se encontra até que esses escondam os detalhes complexos de processamento? Bem, por exemplo, se olharmos para o funcionamento interno do leitor de DVD, você tem blazers. Você tem motores giratórios, você tem três braços certos, coisas assim. Mas nós somos usuários do DVD player. Não os vemos lá. Nós não interativos. Quando nós apenas interagir com uma interface pública simples, temos colocado paradas agora rebobinar igreja e assim por diante. Eu não brincaria com o receptor. Nós jogamos com os botões de volume e assim detalhes do ar escondido de nós, e nós só interagir com esses sistemas fazer de que basicamente bem para encontrar interface pública . Esse é o
conceito básico por trás do encapsulamento e da altura dos dados,
embora cada componente individual encapsule o comportamento. por trás do encapsulamento e da altura dos dados, E então vamos esconder os detalhes do processamento da facilidade externa. Então encapsulamento, que é o conceito mais fundamental do programa de desenho de objeto cada componente continha recursos e funções que lógicas relacionadas ao serviço dos componentes fornecem. Este conceito simples é a característica fundamental, provavelmente análise de história, e é chamado de encapsulamento. Eles iam usar o mesmo conceito de encapsulamento no objeto ou no programa. O que vamos fazer é que, em nosso processo de análise e design, vamos combinar todas as atividades nas operações necessárias para fornecer um serviço
em um único componente e o que isso significa antipatia em nosso exemplo estéreo, várias aulas vão ser necessárias para completar o serviço completo I para livre
voltar sistema de home theater. Precisamos de uma TV, precisamos de alto-falantes, precisamos de receptor e assim por diante. Então vamos ter que combiná-los. E assim cada uma dessas classes menores e fornece uma parte do primeiro geral. Isso é o que os dados de carne de encapsulamento escondem, por outro lado, é que vamos pegar esses detalhes, esses detalhes complexos, e vamos escondê-los das outras unidades para as outras entidades em nosso por exemplo, o leitor de disco é um componente muito complexo composto por centenas de sub-circuitos internos. Executaram a tarefa de leitura, leitura, no entanto problemas. Não vemos que não entendemos o que está acontecendo dentro do laser, dos motores e coisas assim. Ok, há plugins muito fáceis. Essa é a interação. Se quiséssemos, então conecte as coisas no player. Isso geralmente é só nos dias de hoje. É só um plugue no meu cabo. Há alguns, mas fracos, usados para controlar a operação. Pare, jogue, rebobine, ok. E todos os dados de processamento complexos que são necessários para produzir música ou o som é realmente mantido escondido de componentes externos. Isto é o que eles chamam de esconderijo de dados
e informações, e protege a integridade do componente porque apenas pensar o que aconteceria se
pudéssemos entrar nos circuitos internos da tela? Er, como estava caindo que sentou-se muito rapidamente. Agora, uma coisa que eu quero salientar é que os dados de encapsulamento escondendo ou dois conceitos diferentes
da analogia são usados aqui. Tenho uma máquina de coca aqui em cima, certo? Tudo bem. Uma máquina de venda automática neste caso aqui, neste exemplo Aqui, ele encapsula todos os itens. Toda a Coca-Cola que eu cozinho eu tenho lá dentro. Mas se as portas se abrirem, não
é cabeça. Ok, que esses itens estão escondidos. Qualquer um pode entrar e pegar uma coca só por, uh, pegar e pegar. Encapsulamos o casaco, mas não escondemos as Cocas. Alguém dê agora quando fecharmos a porta, certo? Não só lemos, encapsulamos as Cocas, escondemos o código. E a única maneira de obter um ASU de Coca-Cola, que a interface pública morde de enviar dinheiro e empurrar um dos mas assim que você avançar , tenha em
mente encapsulamento dos dados ocultos. São duas coisas diferentes. Agora, se você fizer pesquisas na Internet, você verá algumas pessoas acharem que os dados de encapsulamento se escondem na mesma coisa. Eu prefiro que você, uh, que você pense sobre essas duas coisas diferentes porque nós entramos no seu aspecto de
programação , para ver como nós vamos ser capazes de nós podemos encapsular as coisas sem realmente esconder e em um bom sólido do objeto bem formado. Programação atual que você queria não apenas encapsular coisas, você também deseja ocultá-la. Caso contrário, não
queremos uma máquina de Coca-Cola com portas abertas, casaco
lunar entre eles que esconde os detalhes. E você tem que obter uma Coca-Cola com uma interface pública bem definida. Tudo bem, agora, esta é na verdade a parte mais difícil do objeto durante a programação por experiência com
interesse docente . Porque isso é mensagem passando. Se você pensar sobre isso. Se ele montou um sistema de home theater, o que você tem que fazer? Você vai para casa, você vai até sua loja de eletrônicos local ou qualquer coisa, e você pega todos os seus componentes, você o leva para casa, você o tira do boxe, o
coloca lá fora. Não funciona. Isso significa que você tem porque você tem que se interconectar. E a parte mais difícil de montar sistema estéreo doméstico está conectado todos os fios porque você tem que se certificar de que todos os fios na direção correta uma saída de um porque, em seguida, colocar outro. Se você se conectou aos pobres errados, isso não vai funcionar. As coisas têm que ser feitas com essa mensagem passando com essa comunicação tem que ser ah, bem definida, bem estabelecida. E é, na verdade, a parte mais difícil. Ok, então, por exemplo, desses componentes devem funcionar juntos. Produziu música. Dis player tem que ler a mesa passa o sinal para o receptor do que passa sinaliza o alto-falante para que possamos ouvir a música. Tudo bem, então, basicamente, em um objeto reprogramando os componentes devem passar mensagens entre eles e uma sequência bem definida, a fim de produzir o que cada um significa. Segundo áudio, O mesmo é verdade para o nosso design vitoriano ob. Cada objeto vai fornecer algum tipo de serviço específico, e tem havido passiva essa informação que mensagens para o outro objeto no sistema em ordem produzida pela minha experiência. É esta mensagem passando e estudantes introdutórios têm o tempo mais difícil. O que você vai encontrar é que você vai acreditar que você vai descobrir que vai ser bastante fácil para você ser capaz de criar objetos e classes e coisas assim,
mas colocá-los juntos para que eles passem informações e essa ordem bem definida se onde torna-se difícil e vamos praticar muito disso entre o curso. E se você fizer o curso intermediário depois disso, você continuar a prática agora mesmo. Então, em que se comunica lembrar do para obter a música, você deve conectar fios entre a porta e objetos interagir uns com os outros passando mensagens de
conta e que seqüência bem definida usando apenas a interface pública. E eles têm que estar conectados. Correto. E é que isso estabelecer esse conjunto de mensagens que é a parte mais difícil. Eu encontrei estudantes metade quando foram apresentados pela primeira vez, objeto no seu programa, certo? Então, novamente, uma das coisas não iria cobrir nesta aula, e eu quero ter certeza que isso é verdade. Aqueles no encapsulamento conceito básico e ocultação de dados. E neste curso que quatro vamos cobrir, vamos mostrar-lhe como basicamente analisá-lo. Caso contrário, onde os componentes, as classes de objeto não apenas você precisa construí-lo e, em seguida, basicamente, como eles, em seguida, estão indo para se comunicar uns com os outros. Esses são os blocos básicos de um programa coreano objeto. Mas novamente, como é que vamos como é que vamos
comer um elefante uma mordida do tempo? Porque a programação orientada a objetos é um campo massivo, então vamos começar. Isto é básico. Construindo essas aulas como esses escritórios se comunicam porque uma vez que você fazisso
desde que esta é a parte mais difícil,
então o conceito mais imediato de composição,
herança, Construindo essas aulas como esses escritórios se comunicam porque uma vez que você faz isso
desde que esta é a parte mais difícil, então o conceito mais imediato de composição, herança, polimorfismo, classes
abstratas,
interfaces, em seguida, tornar-se muito mais fácil. Isso será feito em um tribunal intermediário, mas novamente, como você comprar um comer um elefante? Uma mordida de cada vez, Mas vamos começar com o básico primeiro e depois de ter feito intermediário, há alguns conceitos mais avançados interfaces gráficas de usuário, padrões
projetados, arquitetura em trabalhar com bancos de dados. Os arquivos serão cobertos por este amor. Então, antes de ir para o intermediário, queremos ter certeza de que podemos andar antes de correr construindo programação simples, orientada a
objetos, identificando qual objeto precisamos projetá-los. Então, quais são os dados para esses objetos precisam das operações que eles precisam antes e como esses diferentes objetos se comunicam? Se você entender isso, então nós seremos capazes de ser capazes de passar para o curso intermediário de alguns dos tópicos
mais avançados muito
4. As ferramentas da negociação: nós também fazemos análise óptica. Nove, Precisamos de algumas ferramentas e o que vamos fazer nesta curta lição é descrito as ferramentas que você vai precisar. Você não só precisaria disso para este curso, mas se você vai fazer qualquer programação fora análise projetada, você vai querer usar essas ferramentas, tornar-se proficiente com ele e uma das coisas que você quer se lembra. Porque qualquer projeto de desenvolvimento de software é um processo de engenharia, assim como qualquer processo formal, estruturado repetível, como construir qualquer tipo de construção de uma ponte,
é um processo formal, estruturado processo. E com qualquer processo de engenharia, eles sempre terão um conjunto de ferramentas do comércio. Para este curso. As ferramentas que precisaremos é de um processador de texto. Vamos apenas desenhar programa. Mas novamente, como eu mencionei antes, caneta e papel estão bem novamente. Queremos que você vá se preocupar com o processo, preocupe-se com o processo, não necessariamente ferramenta, e então nós vamos precisar de um objeto indo em ambiente de programação em. Mas se você já tinha um programa de programação feito, você provavelmente não tem ambiente iria trabalhar para a linguagem de escolha. , Mais uma vez, qualquer programa de secagem que queira usar. Ah, esta bela caneta e papel encontrar novamente. O objetivo aqui é passar pelo processo. Não necessariamente ferramenta. Se você fizer uma pesquisa em ferramentas de modelagem UML gratuitas, você vai obter vários hits. O quando eu gosto de usar minha ferramenta gratuita é desenhar dot io. E se você vai para o desenho de áudio I o site, você pode ver que você será capaz de salvar diagramas. E, por exemplo, basta clicar no Dr Puffed Rice Criar um novo diagrama na minha conexão. Passe pelo diagrama. Mas você percebe aqui todos os tipos de diferentes tipos de ferramentas diagrama UML e, em seguida, podemos criá-lo. Basicamente, use a pasta raiz. E nós temos notado aqui em baixo nós temos nossos diagramas UML básicos e nós poderíamos ir em frente e expandir sobre estes bem não livre vídeo UML é realmente um bom negócio. Ferramenta de modelagem de fundição. Não é. Não é realmente classe profissional, mas é um muito bom para um desenhos rápidos e sujos. E usarei visual para toda minha demonstração para ferramentas de programação. Novamente, há muitas quantidades que eles dependem da linguagem que você vai usar. Você poderia usar ocioso. Se você estiver indo para usar um python, você também pode criar programas Gore Python e Visual Studio também. Se você estiver indo para usar Java, você pode usar feijão líquido ou eclipse. Há toneladas de montaria lá e de novo. Meu troll, Detroit para este curso será download de estúdio visual, comunidade
Visual Studio 2019. E se você for para o site de download, seu seethe da fazenda e o que você vai querer escolher não escolher o teste gratuito com o profissional Enterprise que você só vai obter aqueles ar destinado a grandes equipes. Hum, o único vai conseguir isso por 30 90 dias, mas você vai querer fazer é ir para a comunidade de
download gratuito , baixar e baixar o e aqueles lá em baixo ele vai baixar, e então uma vez que ele começa o download, salve o arquivo e, em
seguida, entre e execute. Este pode ser um download bastante grande. Eu não vou necessariamente passar por todo o processo, mas apenas começou e, em seguida, seguiu a queda das instruções de instalações e seu fazer muito bem. É um processo relativamente simples,
uh, uh, aqui
em baixo. Nenhum som aqui. Aqui está um artigo. E se você fizer uma pesquisa na Web, John instalando a comunidade Visual Studio 2019 ou encontrar muitos vídeos também, há uma coisa que eu vou falar é sobre e como você vai realmente querer
configurá-lo uma vez instalado. Você quer se certificar de que você tem os vídeos de oponentes corretos, downloads de estúdio
visual e começa a instalação. Se você vai eventualmente ser levado para esta tela. Agora, as instruções e alguns dos outros artigos que você vai ver, hum, se você quiser fazer o programa C Sharp e clique neste rápido para garantir que ele está selecionado. Descobri que mesmo que a direção comum diga que você só precisa disso,
eu achei que vai ser útil se você selecionar as ferramentas de desenvolvimento dot net core 2.2
e também com os programas mais recentes. Descobri que mesmo que a direção comum diga que você só precisa disso, eu achei que vai ser útil se você selecionar as ferramentas de desenvolvimento dot net core 2.2 Eu tive as ferramentas 4.7 também. Eu sempre soei. Aqueles foram úteis para fazer isso, fornecer mais flexibilidade no outro. Se você descer e selecionar Python, se você quiser comprar programação polegar, falha
apenas conflito. Vá e clique em modificar e ele continuará a operação. E então uma vez que isso é feito, você deve ser capaz de começar a abrir o Visual Studio e começar
5. Como criar uma descrição do sistema: Bem-vindos à próxima lição. Uma reprogramação óptica criando a descrição do sistema. Na minha experiência, criar a descrição do sistema é uma das atividades mais impopulares que os desenvolvedores fazem tanto, muitas vezes as atividades simplesmente ignoradas completamente ou se é tentado muitas vezes não
é. Um monte de tempo tem sido em que, disse seus desenvolvedores introdutórios. É importante dar-lhe um lugar para iniciar o processo de design de análise que eu descobri que criou a descrição do sistema é o melhor lugar para começar. Esperemos que, após esta lição, você concorde e use esse processo ao criar seus próprios programas. O objetivo da análise e design é entender as classes e objetos que você precisa para criar seu programa clássico. E você precisa entender os atributos e operações de classe e objeto,
as relações entre as classes e objetos e os dados e as mensagens que
precisam passar entre as diferentes classes de objetos. Mas muito importante saber quando você começa, você não sabe os detalhes de tudo isso que você quer ter certeza de que você sob fazer se você quer entender o que você precisa fazer sem se preocupar sobre como você vai fazer isso. É uma grande distinção entre o quê? Como, como é quando você fala sobre um dos detalhes detalhados que você precisa para realizar o que é exatamente o que você vai fazer quando entrarmos no projeto e no processo do programa , você descobre exatamente como Você deveria fazer isso. Como você faz a análise e design tentar pensar que é altos níveis possíveis e evitar detalhes de
programação durante a análise
e particularmente, e também quando você entrar no projeto, você vai ter muito tempo para pensar sobre os detalhes. Mas aqui novamente, você quer pensar sobre o que você está tentando fazer e não como você deve fazê-lo. Então, antes de começar a programação, se você não pode escrever uma descrição detalhada do que você quer que seu sistema difique, então você não vai entender o sistema bem o suficiente para realmente prosseguir. Você quer ser capaz de trabalhar na descrição do sistema até que você se assegure, e se você tiver outras pessoas com quem você está trabalhando, concorde com o que o sistema deve fazer agora. Isso pode não ser tudo excitante, mas é extremamente importante, e de uma forma ou de outra, você vai fazer isso. Ou você tem que fazê-lo é um passo separado ou fazê-lo enquanto você está tentando programar. É muito mais fácil fazê-lo como um passo separado para evitar que o cabelo em chamas tipo de ambiente de programação. O que exatamente é uma descrição do sistema? Uma descrição do sistema é uma explicação baseada em texto do que o programa se destina a fazer . Escrito em termos de costume, a descrição do sistema identifica um requisito de alto nível, começando com uma declaração geral do que o programa deve fazer. E, em seguida, através do refinamento e na aeração, níveis
mais baixos e mais baixos de requisitos são capturados e documentados. Eu não vou ler a descrição do sistema para você, e eu disse ainda sugere que você postar vídeo e ler a descrição. Vivemos em partes da descrição para ser capaz de identificar os objetos e operações e os dados desses objetos nos próximos slides. Então, o que precisamos identificar à medida que passamos pela descrição do sistema? Uma das coisas que queremos lembrar uma classe é uma coleção de nomes de membros que todos os
métodos datados que operam nos campos de dados e métodos e a classe ou chamados
campos membros da classe sendo os atributos. OK, então quando você ouve o termo membros da classe, pode ser qualquer coisa contida nas classes. Ele faz mais leitura, você ouve que esse termo é um pouco. Alguns desses campos são os atributos e que as variáveis que mantêm os dados para os métodos de
classe e funções ou as operações que fornecem o processamento nos construtores de
atributos de classe , que mencionamos vontade. Mas antes esses métodos especializados em ar em configurar ou construir o estado inicial do objeto, vamos criar getters getters, método especializado em
ar que o acesso a membros de dados de classe e, em seguida, centros são especializados métodos que modificam os dados da classe Os membros iriam ilustrar como capturamos cada um
deles e, em seguida, eventualmente, mostrar-lhe como você vai implementar. Como mencionei, a descrição do sistema é basicamente a base para tudo o que fazemos. Se fizemos um bom trabalho com a descrição do sistema, seremos capazes de identificar todos os nossos objetos e seus alunos. Ok, então nós vamos usar esse sistema de krypton para ser capaz de extrair esses objetos. Tudo bem, agora, eu sei que você não pensou que você entrou em uma aula de Inglês, mas o que nós vamos descobrir é que se olharmos para um objeto e objeto
será basicamente o que nós um substantivo da descrição do sistema, Por exemplo, atores, coisas, unidades
organizacionais, lugares, estruturas, notem aqueles eram todos os tipos de substantivos que anunciam e nós vamos ser capazes de então pegar esses, Pegue a descrição do sistema, identifique o substantivo, e vamos sublinhá-los agora. Uma vez que sublinhamos esses baixos o que fizemos, basicamente
criamos nossa lista de classes e objetos potenciais. Então agora é sempre nós vamos ter algum tipo de verbo ou associar com esses verbos em que estão associados a cada indivíduo. Agora, vamos nos tornar as operações dos objetos de vez em quando e agora e Burb que vai junto com ele vai ter um assunto desses. Agora vamos demolir, e isso vai ser os dados que vamos que cada um desses objetos vai conter. Então vamos separar a descrição do sistema e ver exatamente como isso parece. Então, quando começarmos com a descrição do sistema
, pode ser longo. Este é um pouco curto. Eu vi estes que levaram provavelmente vários anos para criar, e eles terão 2030 páginas de comprimento que você não pode lidar sem posar. O que você quer fazer é que você quer separá-lo, transmiti-lo frase por frase. Mas neste caso aqui, vamos começar com o topo. E o que vamos fazer é documentar com o que é chamado de CRC esses ar, essa responsabilidade de classe, cartão de
colaboração. E esta é apenas uma maneira de fazermos uma ferramenta para analisarmos os objetos em seus outros membros da classe. Então vamos começar. Analisamos, o que significa que vamos separá-lo e vamos linha por linha. Nós dizemos pequeno começo. Um desenvolvedor da empresa precisa criar um empregado, mas programa de pagamento Agora calcule o pagamento com os funcionários, embora ,
nessa primeira declaração, temos nossas primeiras 2 classes, temos um programa e temos um empregado. E então o que vamos fazer é colocá-los nesta tabela,
e vamos usar este dia da tabela eventualmente criar o diagrama de classes. Por exemplo, neste caso, aqui temos um aviso de funcionários principais aqui em baixo. Tipo de nome que eu renomeei de programa de pagamento é o que você vai descobrir é que cada programa vai ter uma aula onde vai ser o ponto de partida. O ponto de entrada do aplicativo, meu estilo e você vai ver estilos diferentes é usar o termo principal e, em seguida, basicamente, o nome do programa. Este é o lugar onde o ponto de entrada do aplicativo, que demonstrou. Mas mais tarde, você não quer ser capaz de descrever o que essa classe deveria ser. Qual é a responsabilidade? Ok. Por exemplo, classe de
funcionários, este vai ser o objeto de negócios que mantém informações do funcionário e processo é o pagamento . Você quer ser capaz de identificar isso? Ok, então nós identificamos neste caso aqui nossas 1ª 2 classes potenciais. Certo, então agora vamos embora. Fizemos o primeiro passo. Agora vamos abrir a segunda parte, está bem? E vamos procurar a primeira versão do programa. A empresa quer que o funcionário da folha de pagamento dê entrada. Certo, então temos um verbo e um. Ok. E depois continuamos a descer. E o salário bruto do empregado será então calculado, mas outro subúrbio e, em seguida, exibir. Então agora temos que associar os verbos que vão se transformar em nossas operações com o respectivo ou o correto com o objeto correto. Se olharmos de novo, quebramos isso de novo. Nós não olhamos para que haja um todo nós quebramos. Declaração por declaração, nós gostaríamos. A empresa quer que o funcionário da folha de pagamento dê entrada. Ok, então esse caso aqui, nós vamos colocar isso e eu vou chamar isso de obter informações de pagamento. Não, está lá em baixo. Só não usei o termo “entrada”. Coloquei nele um nome mais descritivo e, em seguida, temos um aqui em baixo que mostra os principais programas que também vão mostrar. Então eu associo isso com o nariz do programa principal aqui em baixo, há um tipo de funções de sobrecarga que não estão incluídas. Eles são basicamente eu tive que dirigir a partir da análise é um que vai ser o programa
principal vai existir nessa classe. E então cada programa que eu criar vai ter um método de programa de saída que basicamente vai limpar as coisas para o programa, sabe? Então nós temos um display principal get, e em seguida, praticamente todos os exemplos que vamos usar o nosso programa principal vai seguir esta mesma estrutura. Certo, então temos os empregados. O salário do crescimento será calculado. Então, novamente, eu digo calcular o aviso de pagamento bruto. I distância, eles calculam por dizer muito específico, salário bruto
calculado. E novamente o programa será exibido. E novamente, estamos associando a exibição com o programa principal. Isto é uma unidade de negócios. Ele não vai fazer qualquer usuário real exibindo toothy. Vamos deixar o programa principal tratar disso. E essas são todas basicamente essas coisas aqui, basicamente, então todas associadas com os objetos do empregado. Temos o nome dos empregados por
hora, aviso de trabalho por hora aqui. Eu não coloquei um método de pagamento bruto. Eu só tenho um salário bruto calculado. E o que estamos indo para então dio é onde cada vez que queremos a exibição, nós vamos calcular em tempo real também notar aqui em baixo nós não deixamos não listar juntos e centros para os atributos mostrar um pouco mais tarde. Sempre será assumido que eles são criados se você criar getters e centros para todas essas atividades, quando você tem uma longa lista de atributos aqui, seus diagramas vão ficar muito complexos. E então nós temos um, uh, este método aqui, obter informações de pagamento. Agora, isso não está listado na descrição, mas o que você tem que fazer é tipo de usar sua experiência como você começa um Z ir adiante que o que nós vamos encontrar é cada vez que nós criamos um não-objeto para esse exemplo, este funcionários caso estavam sempre indo ter que esperar e ter uma maneira de obter informações fora desse objeto. Mas neste caso aqui, vou chamá-lo, obter informações de pagamento novamente. Ele não está listado, mas nós basicamente derivamos isso dos requisitos, sabendo que onde eventualmente iria coletar esses dados. Temos um programa acadêmico simples. Eu tenho um programa aqui que vai desenhar o círculo na tela. Você notou que o mesmo tem as mesmas estruturas padrão de design são exemplo círculo principal e
temos uma classe círculo e tudo o que vamos fazer neste programa para desenhar o círculo na tela. programa acadêmico simples. No entanto, se eu quisesse criar um programa mais real. Quero deixar mais em círculos. Eu quero ser capaz de soltar programa qualquer forma que você notar aqui em baixo, a estrutura de cada um desses itens individuais, relações entre as diferentes classes. É praticamente tudo o que cobrimos. Há alguns detalhes que temos que nos preocupar. Mas a complexidade deste programa não é por causa das classes individuais. É a complexidade surge por causa do complexo geral é o número de duas classes que têm que ir para o programa, e as colaborações simples torna-se complexo apenas pelo tamanho sozinho. Agora, uma última nota Criar uma descrição significativa do sistema é um trabalho árduo. Tantos tantos desenvolvedores nem tentam. O que você quer fazer é ter certeza de que tiramos a avenida feia primeiro porque é uma atividade intensiva de comunicação. Há muito refinamento de carne de porco. Agora, a coisa sobre isso é que você vai fazer isso agora. Vai fazer isso mais tarde? Como eu mencionei, se você não fizer este sistema descrições a etapa separada certificando-se de que
você entende o que você vai fazer antes de começar a projetar antes de começar a revestir, você vai então fazê-lo. Se por que você faz design perto de Cody, você vai fazer isso de uma maneira ou de outra, e eu vou experimentar programas e todos os programas de pesquisa para cada hora que você gastar trabalhando na descrição
do sistema e na criação. Claro que está ficando correto. Vai devolver dez vezes no mínimo mais tempo. Você tem que tirar esse feio do caminho. Cedo ou tarde, ou
você faz agora um passo separado onde você vai estar fazendo isso. Por que você está realmente programando torna isso muito mais diferente. Então, o próximo passo vamos aprender, na verdade, como tomar esse diagrama CRC e, na verdade, como criar o UML um diagrama de classe.
6. Alguns pontos finos: Olá. Bem-vindo à próxima lição de programação orientada a objetos. Pontos finos aí. Alguns cinco pontos que queremos discutir antes de entrar nos detalhes da criação de diagramas de
classe Ruml . Estes também estão muito próximos dos detalhes de implementação, o que tentará evitar fazer análise e design. Mas é uma boa idéia começar a considerar esses detalhes não faria análise do conceito que vamos discutir e nesta instância de construtores Lessner, membros e compartilhados e estáticos e vamos cobrir os detalhes de implementação quando começarmos programando mais tarde. Uma coisa que queremos ter certeza de que entendemos à medida que avançamos é a diferença entre uma classe e um objeto. Temos usado o exemplo da construção da casa. Uma planta para uma casa não é uma coisa física. Está no papel. É basicamente coisas de pensamento. É basicamente como a casa deve ser construída. É basicamente como os empreiteiros em ir dedão loucos duas direções para construir uma casa . Usamos essas plantas para construir 1/2 e a casa é uma coisa física, e podemos usar o mesmo conjunto de plantas para criar muitas casas como queremos a partir dessas plantas podemos criar 100 casas, e se usarmos as mesmas plantas, Serão 100 casas idênticas. Agora usamos essa mesma ideia, um objeto. Aulas de programação coreana não são coisa física. Nós vamos criar nossas aulas, que são jantar vai ser basicamente um projeto para os objetos. Vamos usar essas classes como um plano para construir objetos. Esses objetos serão criados na memória e esses objetos em nossas coisas físicas que
poderíamos então trabalhar com a pergunta torna-se: Como então construímos um objeto na memória com base na definição da classe? Então vamos olhar para o mecanismo para criar objetos, e isso é com construtores. Nós olhamos no dicionário para a definição de construído é construir um re direto. Então, quando você criou uma instância de um objeto, caso contrário instantâneo é uma coisa física de uma classe. Precisamos construir o objeto. E essas são as etapas de execução do programa necessárias para reservar membro e inicializar a variável
óptica. Agora, novamente, vou enfatizar, tenha em
mente, um objeto é uma coisa física na memória que é construída usando a definição de classe como um projeto para a construção. Com essa definição, mente vamos definir uma classe de liberado construtivo e ter em mente que é um
método especializado que tem o mesmo nome é uma classe sem tipo de retorno, e o construtor então deve ser invocado cada vez que um novo objeto de as classes criadas. Então esta é uma aula que temos empregados com a sua “Ah, Constance”. É muito ambos e seus membros de dados. E então sempre teremos um método especializado chamado empregado notado. Esse método construtor é sempre o mesmo. Nome é um aviso de classe. Não há nenhum tipo de retorno notado. O método construtor é sempre o mesmo nome que a classe, e nunca haverá qualquer tipo de retorno. E quando queremos criar um novo objeto, temos que invocar o construtor. E nós fazemos isso. Nós usando a nova palavra-chave novos funcionários, novos funcionários que empregam o que esta declaração dizendo é basicamente então vai invocar o código dentro do construtor para criar fisicamente esses objetos de memória. Uma vez que você tenha criado esses objetos na memória, nós poderíamos manipulá-los imediatamente individualmente. Agora queremos olhar para esse outro termo que você vai ouvir um pouco e que é um instante tomou
uma definição de dicionário e instâncias, um exemplo ou único de ocorrência de algo. Em suma, se você tem um exemplo de algo, você tem uma coisa específica 10 tangível. Ambos. Por exemplo, você pode ter várias maçãs, cada uma sendo uma instância específica de maçã forno. Cada um deles é único, objeto
separado que pode ser manipulado independentemente um do outro. Agora vamos usar o mesmo conceito em nosso pro, mas, em seguida, associado a cada instância do objeto. Então, se eu criar três objetos de memória de funcionários por um funcionários para funcionários três. Estas são todas as instâncias da classe de funcionários. Cada um deles tem sua própria cópia das variáveis nome do empregado, taxa de
pagamento e horas trabalhadas. Neste caso,
Bill 45 horas funcionou de novo. Cada um desses membros de instância é recriado cada vez que um objeto é criado. Então nós temos uma instância de um objeto, e estes em nossos membros de instância chamados por que nós não vamos falar sobre agora, mas nós também vamos descobrir que métodos podem ser membros de instância também. Mas agora vamos nos preocupar com a variável. A única coisa que você quer sempre ter em mente quando colocamos um objeto de memória que é uma instância da classe. Então, se alcançado novo objeto recriar, vamos ter membros de instância que eles são criados para cada objeto. Então, o que você quer lembrar cada instância objetos. Os membros são recriados para cada instância do objeto. Se três objetos de funcionários foram criados, então haverá três cópias de funcionários. Par de nomes. Oito horas trabalhadas com cada um sendo encapsulado e, em seguida, fechando objeto. Se, em
seguida, criássemos 100 objetos de funcionários , haveria 100 cópias de cada membro de instância da classe. Agora que há uma distinção entre o que eles chamam de estático, onde você costuma ouvir o termo membros compartilhados, estáticos ou compartilhados, membros são membros que fazem parte da classe, mas não específicos de qualquer objeto da classe . Mas, por exemplo, temos nosso objeto de funcionários aqui, e a taxa mínima de nome padrão, taxa
máxima de horas mínimas máximo não são específicos para nenhum objeto específico, então não queremos ter que recriar aqueles para cada objeto. Então o que vamos fazer é definir isso é membros estáticos ou compartilhados, e o que acontece é que essas variáveis neste caso, constantes são então associadas a uma classe de funcionários. Haverá apenas uma cópia dos membros estáticos, e cada um dos objetos individuais, se precisarem de acesso a eles, compartilhará esses valores agora. Não se preocupe muito com os detalhes e como o Oregon implementa construtores e
métodos de estática . Esses detalhes serão cobertos, e começaremos a programar. No entanto, você quer se familiarizar com esses conceitos, são eles e ambos irão surgir em análise e design. Quanto mais exposição chegar a esses conceitos, mais fácil será a implementação. Agora que fomos introduzidos ao conceito de construtores, instância de objetos, membros
instantâneos e membros estáticos, poderíamos então prosseguir com o nosso no escritório e assinar.
7. Como criar a estrutura do programa: congratulou-se com a reprogramação óptica. A próxima lição nesta lição vamos discutir como você cria seu
diagrama de classe de email a partir do cartão CRC que você criou na lição anterior. Como você provavelmente descobriu, criar a descrição do sistema e as colaborações de responsabilidade de classe Guardas pode ser difícil. Os comentários que recebo de ambos os alunos introdutórios, bem como muitos desenvolvedores experientes, é que a análise inicial e capturar o coração requisitos do sistema porque é tão confuso que é, você era o cliente, e eu saber o que você quer. Cada vez que você acha que tem os requisitos pregados, alguém muda de idéia. No entanto, lentamente e passo a passo, você eventualmente cria uma versão dos requisitos de alto nível como detalhe suficiente para prosseguir. Eu acho que o que você está bem, que uma vez que você tem um alto nível requisitos capturados, o seguimento em processos são muito menos difusa e muito mais concreto e mais fácil de entender . Como você vai encontrar como desenvolvedores experientes ou dizer-lhe que quanto mais concreta a atividade, mais fácil é de entender, e quanto mais divertido é realizar nesta lição, nós vamos traduzir para cartões CRC em uma classe de linguagem de modelagem unificada diagrama, que então nos leva mais um passo em direção ao concreto para criar os elementos de design. Precisamos nos levar para programar um monte de trabalho pesado. Identificamos nossas aulas. Identificamos as operações, os atributos da classe. Colocamos no formato de cartão CRC. Eu uso um formato de tipo de tabela e que você pode fazer isso de qualquer maneira que você gosta. Mas o que fazemos é identificar as responsabilidades, operações e atributos e colaboradores entre os diferentes objetos. Então, como nós, em seguida, tomar esta informação que temos aqui e traduzido para o
diagrama de classe UML tentando usar o vídeo? Todas as ferramentas que já usei fazem basicamente a mesma coisa, tipo, as mesmas
etapas operacionais . Então, eu vou primeiro. Vou começar um novo arquivo e notar aqui quando eu for visitá-lo. meus favoritos são os que usei anteriormente estão listados. Mas você pode não ver que um fusível e vídeo excesso de uso seco. Oh, se você está fazendo este domingo em um artigo no jornal, você vai saber,
são basicamente os mesmos passos, então eu vou para o software e nariz aqui em baixo e eu tenho um diagramas de classe UML humano. Eu escolho que neste caso aqui, eu quero a unidade e então notei aqui à esquerda, eu tenho todas as formas diferentes de que poderíamos usar o novo tempo da classe média. Nós só vamos usar um casal, mas o 1º 1 diz, vamos em frente e pegar. Precisamos de uma aula. Estas duas classes, um dos principais empregados eles têm desempregados. Então é construído cada um individualmente. Então, vamos fazer os principais funcionários. Então, vou ter uma aula. Vou arrastá-lo para cima. Você sabe disso. Amplie isso um pouco. Então eu vejo um pouco mais fácil. Está bem? E então pegamos o nome da turma novamente aqui. Eu só estou indo para Eu estou apenas usando o modelo nos cartões CRC, como um modelo aqui no blueprint para criar os diagramas de classe. Então diz: “
Ok, Ok, eu vou criar algo chamado funcionários principais. Então eu digitei os principais funcionários e notei novamente. Não, não. Aqui. Eu não coloco nenhum espaço em um diagrama UML. Este bloco de cima aqui é reservado para os atributos, e o menos significa que vai ser privado B mais e, em seguida, quase todos os atributos, exceto as constantes, são quase sempre menores. Então eu entrei e disse: “
Ok, Ok, do
que eu preciso? Eu não tenho nenhum tributo real na classe principal que eu listei. Está bem? Mas agora eu preciso colocar nas operações. Então, se eu não tiver nenhum atributo, você pode acreditar lá. Ou você poderia simplesmente cortá-lo. E então não há atributos que sejam perfeitamente aceitáveis. Agora, neste caso aqui, eu vou ter uma função principal. Está lá, digite a função principal, e então eu vou tipo de Maine. Agora, neste caso aqui, nós não vamos falar um pouco mais tarde, isso vai ser uma função compartilhada ou uma função estática. Por isso, quero sublinhá-lo. Então sublinhou essa função. Não, quero adicionar outra função. Eu poderia apenas apertar “Return” neste caso. Ou eu poderia inserir um membro depois e novamente, eu vou ter um outro obter informações de pagamento, outro método. E novamente, este também vai ser um método compartilhado, sobre o
qual falamos na próxima lição. O incidente do membro Após exibir informações de pagamento. Inserir outro membro depois de mais, e vai ser excelente saída. Renomeie este programa Encerrar a classe principal de funcionários. Tenho a classe principal dos empregados. Eu tenho uma função principal, que vai ser um membro estático. Eu designei que é uma função apenas para legibilidade, mas entre parênteses para mostrar que não está aceitando qualquer informação. E eu provavelmente deveria dizer que vai ser sempre uma função vazia. Caso contrário, eu não vou retornar nenhum valor novamente. Isso talvez esteja perto de uma decisão de design que você toma, mas se você for identificado agora, não faz mal fazê-lo. Temos um método de informação de pagamento que será anulado, não aceitando valor? Os meios subjacentes. É estática exibir informações de pagamento e também encerrar programa pro. Agora vou dizer “Volta atrás”. OK, agora vamos criar classe de funcionários, então eu trago outra classe para o desenho aqui. É exatamente um nome falso agora, lembre-se que eu disse, enquanto você passa passo a passo, estamos encontrando a informação. Estamos encontrando os detalhes. Você vai estar fazendo isso como você como você faz essas traduções de 11 elemento para o próximo. Neste caso, aqui temos o que temos que fazer, o que queremos dialogar e depois descer aqui. Começamos a criar novo diagrama de Mel. Poderíamos refinar nossa informação. Poderíamos adicionar mais e mais detalhes, por exemplo, aparecer, eu decidi que ele vai estar nos funcionários médios. Decidi que estes funcionam e eles não vão aceitar nenhum argumento agora. Eu vou fazer a mesma coisa na classe de funcionários neste caso aqui. Eu vou colocar os atributos primeiro porque eles vão para o bloco superior aqui e eu realmente vou dar alguns tipos de dados. Então eu vou dizer que todos os atributos, principalmente nos programas que eu crio, serão todos privados, não criar getters e centros mais tarde. Não faça o nome dos empregados, e então aqui eu vou colocar dois pontos e vou colocar o tipo de dados. É quando eu tenho que começar a pensar nisso. Estou ficando cada vez mais perto da implementação, então você tem que começar a pensar sobre isso. Disse, uh, este tipo de informação. Agora, novamente, os processos de refinamento gradual Cada vez que damos um passo em frente, ele gera mais detalhes. Assim, o nome dos funcionários pode obter ortografia que nomeamos corretamente. E então eu coloco o carvão e isso vai ser um valor de cadeia e depois adicionar outra meia prancha e novamente, vai ser um privado. Então eu coloquei o menos na frente, e eu vou mudar em uma taxa de pagamento por hora para taxa de pagamento. E novamente, isso vai ser um valor duplo porque sabemos pelos requisitos que isso vai ser algum valor, algum número real. Então tem que ser um valor duplo. Se eu inserir depois de novo, próximo vai ser horas trabalhadas. Eu só chamo de horas trabalhadas. Uma hora de trabalho também pode ser um número real. Então isso vai ser um valor de dados duplo. Então agora está tudo bem, meus atributos para encontrar Vamos em frente e criar os métodos. Neste caso aqui, eu tenho um método chamado galo Wake Gross pay. E novamente, talvez
eu tenha que pensar sobre isso um pouco antes da Internet. O que é calcular o salário bruto como visibilidade, O que os dados vão então aceitar e assim por diante é passar pelo sótão agora análise e novamente, Eu posso refinar isso mais tarde. É quando eu começo a criar o processo Sudoku real. A Para quê? Vamos dar alguns passos e dizer: “
Bem, Bem, isto vai ser privado. Meu pensamento inicial será calcular a dor grosseira. Eu nomeio-o. Eu não vou aceitar nenhum valor porque eu vou ser capaz de usar para pagar taxa agora que nós trabalhamos na classe. Eu não tenho dedo para ir buscar valores. Eu não sei se o passado, algum valor dentro e isso vai ser evitado. Nem realmente isso vai retornar um valor duplo porque é na verdade o pagamento do crescimento. E novamente, isso é apenas design. E à medida que você avança cada passo, você pode mudar o seu. Está tudo bem de novo. Podemos não conseguir essa rachadura 100% desta primeira vez, mas estamos deixando as coisas mais esclarecidas à medida que vão para ela sempre pode mudá-la mais tarde . Nada está escrito em pedra neste momento. Então eu faço outro. Eu vou para obter informações de pagamento para que as informações de pagamento podem ser públicas porque o que eu preciso fazer neste é que eu preciso Teoh recolher todas essas informações funcionários nome horas trabalhou no salário
bruto, e eu preciso passar de volta para o principal para passado de volta para a função principal para exibição. Mas este não é o público, então eu tenho que conseguir que eu receba informações de pagamento. Eu não preciso passar nenhum parâmetro porque este portão receber informações de pagamento só vai
coletar . A informação já está lá, mas vai retornar uma string para exibição. Então, se eu voltar, eu disse: “
Ok, Ok, eu criei minhas aulas. Criei as operações em cada classe. Ok, eu tenho os atributos na classe, mas eu não coloquei os não coloquei os colaboradores. Não vamos nos preocupar muito com o dispositivo de entrada. E o dispositivo de saída faria isso. E mais eventos. Aulas avançadas. Mas por enquanto, nós somos apenas um que disse ok, qual é a relação entre os principais funcionários e empregados neste caso aqui? Podemos apenas colocar um básico o que eles chamam de associação. Mas eu vou colocar uma relação de agregação porque o que isso basicamente vai dizer é que a principal função aqui, o programa principal, vai conter um objeto empregado. Então nós vamos dizer, colocar isso lá e dizer, OK, vamos dizer OK, isso basicamente estabelece a relação que fizemos funcionários que vão usar um objeto empregado. Então é assim que temos que fazer para criar o diagrama de classe você mail e você percebe que fizemos todo o trabalho pesado aqui em nossa análise e, em seguida, a transformação de transporte da
tradução do CRC foi realmente bastante simples. Dito isto, só
temos de o fazer. Este é um programa acadêmico. Há duas aulas e, novamente, como eu mencionei antes, o que torna um programa do mundo real difícil não são os passos que realizamos, porque
vamos apenas executar os mesmos passos. Mas vamos fazer isso por centenas de aulas, possivelmente até milhares de aulas. Então, novamente, esta é a situação em que a complexidade é impulsionada pelo tamanho. Então o que queremos fazer agora é agora nós temos que então tomar este diagrama estrutural, que é basicamente o nosso diagrama arquitetônico para o nosso programa, e então nós temos que ver determinar exatamente como os principais funcionários e os funcionários classe estão realmente indo para se comunicar, e esse será o próximo passo quando falamos sobre modelos comportamentais.
8. Analisando o comportamento: Então, como vamos em frente e construir a sequência Dia, Graham, Lembre-se, enquanto estamos fazendo o processo de refinamento gradual como estamos indo a partir da descrição do sistema, então
entramos no diagrama de classes fundir esses dois juntos para chegar ao comportamento do sistema. Então, por exemplo, voltamos para a descrição do sistema e colocamos em Se retirarmos a passagem chave no
processamento vemos que a empresa quer que o programa aceite quando os funcionários nomeiam o número de horas que o funcionário trabalhou o pagamento de hora em hora o programa quando calculam o salário bruto exibido nome dos funcionários. Então isso basicamente nos diz o que devemos fazer. Agora temos mesclado que com o diagrama de classe para chegar com diagrama de seqüência. Então é isso que vamos inventar, não demonstrar como funciona e notar aqui embaixo. O que aqui diz é que temos o funcionário da folha de pagamento. Ele vai começar o programa. Nesse caso aqui, o programa principal do empregador tem que criar uma execução de objeto de funcionário
e, em seguida, retorna ao programa principal. O programa principal, em seguida, vai exibir as informações e ele vai obter as
informações da folha de pagamento Uma vez que ele recebe as informações da folha de pagamento, ele vai definir o nome no objeto funcionários. A execução retorna aos principais funcionários. Ele vai definir as horas trabalhadas, e então há vai definir a taxa de pagamento, e então ele vai para obter a informação de pagamento. É pele, então, e dentro do objetivo, o objeto empregado. Ele tem que então calculá-lo, foram transformados essa informação e, em seguida, para exibir. Então esse é basicamente o conjunto de comportamento que vamos ter que então moderno novamente. De onde é que conseguimos isso? Voltamos à descrição do nosso sistema, diz-nos o que é suposto fazermos. Então isso vai entrar e te mostrar como. Então criamos isso. Este é um bom para fazer em uma prancha antes de tentar dirigir começa a sua Haverá um monte de mudanças como você passar por isso. Se você entender isso, você sabe, 75 80% correto na primeira vez que você está indo muito bem porque isso vai mudar à medida que você obter mais e mais informações. Então, novamente, eu vou para o vídeo e novamente eu vou, em seguida, colocar em uma nova página. Vou mudar o nome desta página. Isto vai chamar de diagrama de classes. Vou criar uma nova página aqui, e esta aqui. Vou chamar o diagrama de sequência. Não, eu não tenho nenhum símbolo aqui para o diagrama de segredos. Mas se eu subir mais formas e começar todas as ferramentas terão basicamente os mesmos tipos de formas disponíveis software, e eu vou criar um diagrama de sequência UML. Então a primeira coisa que posso fazer é ter um ator Lifeline. Este é o ator. Então eu vou arrastar o ator até aqui duas vezes e eu vou chamar isso de funcionário da folha de pagamento cada revisão, o diagrama da classe média U. Vemos que o objeto Knicks que precisamos é o objeto principal dos funcionários. Então ele pegou um objeto que estende uma linha de vida. Pequenos pedaços de poderia precisar. Vamos dar um nome a isto e usamos o diagrama de correio. O objeto principal dos funcionários faz um pouco maior para que você possa vê-lo. E também vamos precisar de um objeto de empregado novamente. Nós criamos o objeto empregado, torná-lo um pouco maior, certificamo-nos de que você captura tudo em nossa linha de vida e nós
vamos chamar isso de empregado, e eu vou chamá-lo de empregado para designar que este é um objeto real na memória. Então vamos usar a descrição do sistema para especificar o processamento. Bem, a primeira coisa que aconteceu é os funcionários
do Paywall podem vir e iniciar o programa, então vamos pegar uma mensagem. Eu estava perto das âncoras de perfuração dos impostos, também, e vamos dizer começo feito. Então eles começam a execução do programa depois de iniciado no programa de execução que o
funcionário principal tem desde Stan. Ela comeu o objeto do empregado. Pegaremos outra mensagem e passaremos aqui para os empregados e chamaremos o construtor. E nós vamos apenas dizer que vai criar o objeto empregado. Isso realmente passa a execução do programa para o objeto empregado. E assim o construtor e os objetos do empregado podem executar o que é feito. Ele vai retornar o controle de execução de volta para o programa principal usa, começar como voltar, então apenas retorna a informação. Então sabemos que o programa principal que vai exibir as informações do programa então
vai ser uma mensagem privada interna e vai ser informação do programa de exibição. E então eles uma vez que ele exibe as informações do programa, ele vai obter a informação de pagamento. Outra mensagem privada interna entre si no programa principal vai dizer, Obter informações de pagamento como ele recebe essa informação de pagamento e subiu de volta. Ele tem que, em seguida, enviá-lo para o objeto empregado. Então vamos enviar outra mensagem do programa principal para o objeto empregado. Defina o nome que eles são notados aqui em baixo. Não estamos preocupados com a forma como estas coisas estavam a ser feitas. Estamos preocupados com o que está sendo feito. Estamos preocupados com os detalhes mais tarde, quando entrarmos em design e na programação. Uma vez que define seu nome, ele retorna o controle novamente porque, lembre-se, set name, na verdade peca controle sobre o objeto empregador. O objeto empregado vai processar esse nome à medida que ele entra. Isso diz,
em seguida, devolveu essa informação. Vamos então definir as horas trabalhadas novamente. Isso vai colocar informações no objeto empregado. Ele vai fazer algum processamento para validá-lo uma vez que o processamento no objeto empregado é feito, ele vai retornar o controle de volta para o programa principal. O programa principal, em seguida, vai definir a taxa de pagamento. E novamente, você vai notar o padrão que está acontecendo aqui. Nós ajustamos, voltamos, sentamos, voltamos o controle de turnos agora uma vez. Isso é Ah, as horas que o nome, horas de trabalho e taxa de pagamento foram definidos. Poderíamos então obter essa informação de pagamento. Então precisamos enviar uma mensagem para o empregado diz, obter informações de pagamento. Agora aqui o empregado tem que coletar essa informação, e ele também tem que calcular o crescimento, pagar essas operações internas aéreas para o objeto empregado. Então vai calcular o salário bruto. Ele vai então enviar essa informação de volta para E isso é tipo de colocar isso na próxima linha
aqui em cima que vai retornar essa informação de pagamento de volta para o método principal, e o método principal irá então exibir informações de pagamento e em nosso programa o que vamos fazer, vamos então encerrar a informação ou o programa nesse ponto encerrar a aplicação. Mas chamamos um programa de encerramento. Certifique-se de que consistentes com o consistente com o diagrama UML. Então é assim que você pega a descrição do sistema e fusão com destruição. O que fizemos aqui, se criamos o comportamento para o curso normal de eventos de um funcionário de folha de pagamento em informações de
pagamento verde nessa informação que está sendo exibida. Então, agora que criamos o diagrama de classes, que nos mostra a estrutura do nosso programa, criamos o diagrama de seqüência que basicamente mostra como o programa vai se comportar
ao longo do tempo, onde 2/3 do caminho através do processo de análise e design, a última peça do quebra-cabeça é identificar o algoritmo específico para funções das operações. Caso contrário, quando estabelecermos as horas, o que acontecerá quando recebermos a informação do pagamento e calcularmos as garotas pagarem como podemos fazer isso na próxima lição? O que vamos olhar é em como podemos então especificar o processamento para cada uma
dessas funções? E uma vez que fizemos isso, completamos nossa análise. Completamos nosso projeto e estamos prontos para começar a programação
9. Como criar algoritmos de código: Bem-vindo à próxima lição de programação orientada a objetos. Modelagem funcional. Esta é, na verdade, a última etapa de análise e design que vamos fazer antes de começarmos a
revestir e chamamos onde estávamos quando começamos. Estávamos muito confusos sobre o que queríamos fazer com o nosso programa. E então fizemos nossos diagramas de classe ou análise médica para criar nosso estoque de classe. E você tem um pouco mais em foco. Nós olhamos para os modelos comportamentais, nos concentramos um pouco mais. Mas agora o que vamos fazer agora, vamos olhar para o processamento funcional, começar a escrever basicamente pseudo código para nossas funções Agora, então, nesse ponto aqui estaria pronto para começar a programação. Então, até este ponto, nossa análise nós criamos uma descrição do sistema que descreve um nível muito alto do que
o aplicativo deve fazer A partir dessa descrição do sistema, nós estacionamos os objetos que precisamos junto com os objetos atributos em operações. Documentamos a instrução de aplicações DZ unificada modelagem diagrama de classe de linguagem. E então nós ligamos essa descrição do sistema e o diagrama de tempo de classe juntos para criar o modelo de comportamento para os diagramas de seqüência agora O que queremos ser capazes de fazer é agora nós queremos começar a olhar para o processamento de detalhes até este ponto. Só estamos olhando para o que nosso sistema está fazendo. Não nos preocupamos sem que as operações funcionem. É o que vamos fazer a seguir. Esse último modelo antes da programação é chamado de função do modelo. É aqui que agora olhamos para as operações individuais e para determinar o
processamento detalhado desses algoritmos. Uma vez que tenhamos concluído, estes algoritmos estarão prontos para iniciar a programação como uma nota lateral. Minha experiência me mostra que este passo que faz mais desde os programadores e, na verdade este é o passo que um monte de programadores saltar direto para sem fazer lá. Agora, a outra análise e design. Isso é porque estamos olhando para detalhes mais concretos, que são muito menos difusos do que os outros itens de análise estavam indo para criar as
especificações do método olhando para o diagrama de classes e, em seguida, um por um, vamos olhar para cada uma das operações listadas nas classes e criar um método especificações para essas operações. Onde vamos precisar ser capazes de fazer é ter certeza de que fornecemos uma
análise muito detalhada para a descrição de sua operação. E isso remonta à afirmação de que se você não pode descrevê-lo, você não pode construí-lo. Então você deve ter certeza que você poderia ter, ah, bom resumo curto do que essa operação deve fazer se nós ainda não temos
que
encontrá-lo , que os dados que serão recebidos pela operação para passar mensagens para trás e para frente. Então, para esta operação de trabalho, ele precisa de dados de outro objeto, os dados que as operações vão retornar, que a operação vai fazer algum processamento sobre os dados e o objeto que vai tomar os resultados de que o processamento está na parte de trás. Precisa identificar o que é isso. Então você vai precisar identificar o algoritmo específico, que é a receita, onde faz o que é muitas vezes chamado de pseudo código que define o processamento. Agora, uma coisa que não fizemos em nossos diagramas de classe não colocamos em getters e
centros de classe . Tenha em mente que não listamos aqueles porque você poderia ter tantos de humor apenas bagunçar seus diagramas de
classe, mas temos que assumir que vai haver para todos os atributos são muito . Mas nós colocamos as aulas. Haverá um centro de obtenção agora no mundo real, haverá exceções a isso. Mas para os nossos propósitos, para cada variável privada que vamos criar, vamos criar juntos e centralizar para. E quando fazemos isso, esses ar basicamente apenas método especializado que eles vão precisar de algoritmos especificados centros em particular exigiu algoritmos detalhados porque é através dos centros que vamos garantir que todos os nossos objetos variáveis estavam sempre indo para estar no estado válido . Com o que temos que trabalhar para criar as especificações detalhadas do algoritmo? Nós temos a descrição dos sistemas, que levou ao diagrama cruzado UML, que então levou ao diagrama de seqüência. Agora, o que queremos fazer é pegar esses dois e mesclá-los juntos para criar os
algoritmos de detalhes para cada um dos métodos individuais, obtendo a criação de especificações de método olhando para o diagrama de classe UML, e nós vamos tomar cada uma das classes e cada um dos métodos individuais um por um e criar especificações de método
para ele, por exemplo, aqui vamos começar com o método principal, e eu certamente não vou mostrar cada um deles, usando métodos, especificações, modelo que é desde que olhamos para cada um lá. Os métodos um por um. Então vamos começar com o principal. Sim, temos o método principal. Especifique a classe. Está dentro de novo. Isso é transpiração direta do diagrama de classe de diagrama UML. Nós fornecemos uma descrição novamente. Se você não pode fornecer um ou dois curto queria sentar descrição pode não entendê-lo o suficiente. E então você pode querer pensar sobre isso até que você faça este caso aqui. É o ponto de entrada do programa e controla a execução de alto nível. O programa? O que desencadeia isso? É o programa. A execução começou. Nós não precisamos de nenhum dado para este programa e nenhum dado é retornado dentro das especificações. Vamos voltar ao diagrama de sequência, e vamos traduzir o diagrama de sequência em pseudo código. Por exemplo, vemos a partir do diagrama de seqüência que vamos criar funcionários objeto. Vamos mostrar as informações do programa. Vamos conseguir a informação do pagamento. Vamos exibir a informação de pagamento, e então vamos encerrar o programa. Então o que vamos descobrir é que quando vamos construir isso e programar e
vamos usar isso como o esquema para criar isso,
criar o método e isso é o que vai começar na próxima essência várias. Descemos para o próximo e obtemos informações de pagamento. Ok, então, uh, vamos tirar a informação do pagamento um pouco fora de ordem. Mas está tudo bem. Então temos obter informações de pagamento, fez descrição de classe funcionários, fornece entrada solicitada para o funcionário da folha de pagamento, recupera as informações e define as informações no objeto empregado. É acionado pela execução do programa principal. Não precisa de nenhum trabalho no dedo do pé de dados. Não está devolvendo os dados. E então aqui estão nossas especificações de algoritmos. Vamos avisar o usuário. Vamos pedir o nome. Nós vamos pegar o nome, e depois definir um empregado, e então nós fazemos a mesma coisa para o jantar rápido da taxa de pagamento. A taxa de pagamento, nós pegamos a taxa de pagamento, definimos novamente. Aviso aqui, estamos apenas usando inglês como declarações. Isto não é código de programação. Ele só nos dá um plano que nos permite trabalhar a lógica quando vamos para o Cub, então eu continuo esse processo novamente. Aqui está a informação de programação de exibição um programa de encerramento novamente, a mesma coisa. Eu postei isso para que você pudesse baixá-lo e dar uma olhada nele. Calcular o salário bruto. Aqui está um diferente. É invocado no cálculo do salário bruto,
dadas as horas trabalhadas e a taxa de pagamento foram preenchidas, é invocado pela dor ou obter informações de pagamento metanfetamina na classe e é dos algoritmos. Bastante simples de novo. Viste como funcionava? Ele realmente não precisa receber quaisquer dados porque ele vai estar usando as horas de trabalho para pagar taxa que já está armazenado no objeto empregado. E não vai retornar nenhum dado é também. Na verdade, quer saber? Isso é uma mudança vai devolver um duplo, e vai ser ele vai ser vai ser exibido. E, na verdade, isso seria o pagamento do crescimento. E eu só vou dizer que isso vai realmente ser apenas retornar e você vê como isso vai ser implementado mais tarde e de novo,
notar aqui em baixo. Descontinuamos essa informação à medida que avançamos agora. Nós falamos sobre os centros especificamente com toda a idéia por trás de ocultação de dados é
certificar-se de que nós apenas definir valores válidos para as variáveis internas que podem manter um
estado válido para o objeto o tempo todo. Assim, o nome do conjunto, por exemplo, vai determinar que o valor de entrada está vazio. Isto vem da descrição do sistema, depois temos os nomes que vão ser definidos. Caso contrário, precisamos configurá-lo para algum valor padrão. Então o algoritmo para esse centro vai parecer que se não for um valor vazio, e seja lá o que for passado é que vamos defini-lo para o nome. Não é. Vamos enviá-lo para algum padrão pode começar. Não estamos muito preocupados com detalhes aqui, mas vamos refinar isso mais tarde. Estamos apenas olhando para a lógica geral, mas aqui está uma para a taxa de pagamento definida. É C Center for Pay Rate, e notamos pela descrição do sistema que diz, se os valores de entrada entre zero e 75 são válidos. Se não for, precisamos defini-la para algum outro valor. Então vamos até se a taxa de empregador é maior e 10,5 em sua menos de 75. Vamos pegar qualquer valor que a ISS, e vamos defini-la. Mas se temos um valor que é menor e 10,5 digamos, por exemplo, alguém em seu zero ou negativo cinco ou cinco, então nós vamos apenas enviá-lo para o salário mínimo. Se o alguém lá dentro é algo maior do que 75 nós apenas vamos reiniciá-lo de volta para 75 e nós fazemos o mesmo tipo básico de lógica para a hora para e então nós apenas continuar dessa
forma até que nós temos todos os métodos significativos em nosso diagrama passado criou o que vamos
então lidar, o que vou demonstrar nos Knicks na próxima lição passo. Se estamos agora, vamos usá-los,
na verdade, na verdade, então nos tornaremos nosso plano. Onde estão o processamento começaria a codificação, que é o assunto da próxima lição. Então lembre-se de onde começamos. Começamos com a descrição do sistema, e estava muito confuso quando ele começou basicamente fino através de uma série de refinamentos . Nós olhamos para o modelo estrutural, foram transformados módulo de comportamento de diagrama de classe para o diagrama de seqüência e o funcional modelado agora e agora que passamos, começamos primeiro. Agora temos uma compreensão muito clara do que precisamos para dio e que acreditamos que é quando deixamos o modelo de função. Agora o que vamos ser capazes de fazer é que vamos ser capazes de aguentar isso. Toda essa informação que temos e, em seguida, ir para a implementação e realmente iniciar o programa .
10. Revise os conceitos: antes de falarmos sobre implementação, vamos falar sobre alguns dos conceitos-chave da análise e do design que precisamos
implementar em nossos programas. Agora, uma das coisas que quero destacar é que em um processo de desenvolvimento de software ideal, você passa por uma fase de planejamento de quire ments. Agora é um projeto de fase e codificação, e ele vem com algum plano opcional ou algum ideal, amassar e notar aqui em baixo que o tempo gasto neste ar bastante igual, provavelmente eles vão mudar um pouco e na prática. Mas, no entanto, o que muitos desenvolvedores fazem, eles vão para o planejamento de curto-circuito, análise e design e tentar entrar em Cody e o mais rápido possível. Há muitas razões para pressões para fazer isso. Mas o que acontece é isso? Uma vez que eles estão no processo de codificação, eles têm que tomar um monte de decisões com respeito, requisitos, design e bater. Então, também se preocupe com os detalhes de implementação da codificação, e então eles estão basicamente fazendo três coisas difíceis ao mesmo tempo, e precisamos sempre que você fizer isso, você é tipicamente apressado e você vai cometer erros. Então isso significa quando você entra em testes. Você está indo para um basicamente estender seu processo de teste. E, na verdade,
você
vai ser muito mais longo do que o que você realmente planejou. Agora, novamente, o que os alunos e até mesmo algum desenvolvedor profissional eu parece que eles saltaram direto na codificação. Caso contrário, eles tentam fazer toda a análise de planejamento projetada enquanto eles estão codificando. E o que aconteceu quando você faz isso, você entra nisso. O que? Este edifício modo fixo de desenvolvimento, Você construir o seu teste que você encontrar uma correção de área depois que eles precisam fazer é mais e você
entrar neste loop infinito. E então a idéia é que você quer projetar duas vezes construído uma vez que ele realmente vai te salvar. Tempo e melhoria qualidade que você não chegar à parte de revestimento é rápido, mas você certamente a longo prazo. Você vai acabar com aplicações de alta qualidade agora. Dito isto, se você quiser maximizar a quantidade de tempo de codificação, se você realmente gosta de revestimento para ignorá-lo, vá direto para Cody. Não que você não possa construir um bom programa apenas por saltar para a codificação, mas o risco é muito maior agora. Os conceitos básicos sobre os quais queremos falar são essenciais para poder criar um programa
óptico. Falamos sobre a análise dele. Falamos de design agora precisamos implementá-lo agora. A primeira coisa que quero fazer é implementar a ocultação de dados, e vamos fazer isso com modificadores de acesso, os modificadores de acesso que vamos usar e que podemos implementar. Em cada linguagem de programação que eu vi usos, estes são privados e que é um membro privado que poderia ser uma variável ou constante ou ah, método só é acessível no próprio objeto de classe. Os membros públicos são membros acessíveis a objetos externos. Então precisamos ter certeza é quando criamos nossos objetos e seus membros que
os identificamos com o modificador de acesso apropriado. Vamos então usar getters e centros. Teoh acessar as variáveis privadas. Centros de porta são então modificar o valor da variável, e ele vai conter lógica para validar as entradas que garante que são variáveis dentro de nossos objetos. Todos têm um estado válido e getters que vamos usar para obter aqueles obter o valor de uma variável
privada para um objeto externo. Agora, então, um construtor construtor significa lembrado significa a compilação ou direta. Lembremos que uma classe é um projeto para um objeto, e objetos devem estar em Stan que ela odiava Este é um termo que você pode ouvir várias vezes enquanto você faz qualquer tipo de leitura e pesquisa. Por exemplo, em nossos funcionários objeto. Esta é a classe. Isto não é um objecto. Agora, poderíamos trabalhar com elementos disso sobre o que falar em um segundo aqui, mas principalmente vamos trabalhar. Deseja trabalhar com objetos do tipo de funcionários. Então, isso significa que o que temos que fazer, dentro do nosso programa, para cada novo objeto ou emprego que
temos, queremos criar novos funcionários. Então, se nós temos 100 funcionários estavam indo para criar 100 novos funcionários objetos e, em seguida,
vamos trabalhar nosso código, em seguida, vai trabalhar em cada objeto individual com a data do contido. Então, esses objetos de Aaron Stan sombreados e então eles estão em Stan sombreados da classe e que como esses objetos em nosso construído fazem construídos é baseado no que você os grammas gal você colocou no construtor. Agora nós temos algo chamado membros compartilhados membros lembrar nosso compartilhado por todos os objetos da mesma classe. E eles poderiam ser acessados sem em Santee e objetos, por exemplo, no exemplo estavam usando nós temos o nome padrão Deus na taxa estes ar Constance. E normalmente você não precisa de cópias para cada um desses objetos. Eles basicamente compartilham todos esses valores. Então vamos fazer esses objetos compartilhados ou estáticos, e vamos mostrar como você pode acessar esses objetos sem realmente criar objetos da classe. Certo? Então, na próxima série de vídeos, vamos demonstrar a pequena abordagem testada para construir óptico no programa. Tudo o que fizemos até agora está em preparação para criar um programa de igualdade. Agora, se você seguir cada vídeo e começar o programa de crânio, use um prédio. A estratégia dos testículos. Eu acho que você está achando que você vai ser capaz de construir seu programa com funcionalidade no final com um programa de qualidade
11. Determine a estratégia de implementação: e os fundos se preparando para começar. Não vamos pegar nosso projeto que criamos, e vamos construí-lo. No entanto, o que eu quero falar é que você quer ter algum tipo de estratégia. Quando você entra no programa, você simplesmente não quer fazer uma abordagem tipo ser grande para começar a construir coisas. Você quer ter algum tipo de estratégia, e depois isso. Vou mostrar-te a estratégia que gosto de usar. Você pode criar o seu próprio, mas você pode criar sua própria estratégia. Isso é bom. Mas uma das coisas que você quer ter certeza de que você faz é ter certeza de que você tem uma estratégia acontecendo. Só não quero fazer essa abordagem do tipo Big Bang. Ok? A primeira coisa que vou falar é que vais querer um guia de estilo, está bem? Basicamente, o que você quer se esforçar para é o que é chamado de código de auto-documentação. Ok, agora alguém incluindo você pode ler seu código e entender o programa sem qualquer tipo de documentação, o que isso significa. Você sabe que você vai criar seu código, e por exemplo, daqui a seis meses você vai voltar para ele, e você vai querer ser capaz de entender o que você fez. Outra pessoa vai querer ler seu código. Eles vão querer ser capazes de entender o que você fez, e eles querem ser capazes de fazer sem ter que ir mais duas
documentações externas . Eis algumas coisas que podemos fazer. Teoh ajudá-lo a criar a si mesmo. Documento comentários ecoados ajudam, mas não suficiente para programa completo de auto-documento. Certo. Tenha uma convenção de nomes para todos os seus membros. Ok. Eu usei a seguinte convenção de nomes. Quando eu crio meus programas novamente, a convenção que você usa, é importante que apenas ter uma convenção. Ok, então, por exemplo, o padrão que usei e tipicamente o que você vai ver. A maioria dos desenvolvedores agonias intitulado Case para nomes de classe, como empregado notou lá em baixo que o nome dos funcionários é capitalizar. Vendo que sabemos que os objetos de ar substantivo e anunciado normalmente capitalizar. Isso faz sentido. Tudo bem. Os alunos usam o que chamam de caso de camelo. Caso camelo significa que você vai juntar palavras sem espaços. E a primeira palavra no identificador vai ser minúscula e depois
palavras subsequentes depois disso novamente, nenhum caso eles vão estar com vê. Ok, aqui é onde a primeira novamente as primeiras letras. Em minúsculas
e, em seguida, cada caractere depois é maiúscula. Tudo bem, seja descritivo em seu nome de membro. Então você e seu leitor são claros E o que os membros estão fazendo? Por exemplo, estamos no programa de funcionários. Estamos usando horas de trabalho. É um bom nome que nos diz exatamente o que a variável disse a ele. São as horas de trabalho para os empregados, mas pode-se dizer horas. Tudo bem, Tudo bem, mas não é bem explícito. Isso não é tão claro. E é muito melhor do que veio. E também, enquanto a codificação não pretende recuar espaço vertical para ilustrar a estrutura do código, vamos começar a colocar estruturas de controle e coisas assim. E esse recuo no espaço em branco é muito valioso para o próprio
código de documento . Agora, a boa notícia sobre isso é que a maioria dos ambientes de desenvolvimento integrados têm
ferramentas automáticas que irão ajudá-lo com sua estrutura de código e como usá-los,
e discutiremos isso à medida que entrarmos em implementação. Agora, o que vou sugerir de novo é outra vez. Você não quer fazer disco construir seu programa. Todo programador que conheço tem algum tipo de estratégia lógica que usam para construir seu programa. Eles simplesmente não vão construir o sistema. Eles constroem programas em pequenos pedaços
lógicos e os integram para obter um sistema operacional. Tudo bem, então basicamente, o que eu vou mostrar é que você, uh você quer construir seu programa e pequenos pedaços
lógicos de funcionalidade e você não quer ir para o próximo bloco até que o bloco
atual não realmente sintaxe livre de ar, mas livre de ares lógicos. Então, toda vez que você avança, você está construindo uma base sólida de componentes. Uma vez fora, Block criou mover o próximo bloco lógico e você apenas repetir este
processo de programação até que ele esteja concluído. Por exemplo, aquele que eu vou dizer direito novamente você pode criar truque. Você é seu próprio. Mas você deveria ter uma estratégia. Por exemplo, vou criar um projeto vazio. Apenas crie isso. Certifique-se de que o projeto vazio todas as bibliotecas ar feito, tudo é construído, tudo está integrado, ligado incorretamente antes de começar. Nosso antes mesmo criar a primeira classe principal, e eu vou ir em frente e criar a classe principal. E dentro da classe principal, você sempre terá um método de empregada. O método principal, hum, novamente vai ser o ponto de entrada em seu aplicativo, e é basicamente vai ser a principal unidade de controle para seus aplicativos. Então eu vou construir isso dentro da classe principal imediatamente, e eu vou ter certeza que vai dar certo. Nesse ponto, vou construir isso, executar o projeto, e aqui podemos até ver um programa de trabalho. Coloquei algum estado de saída fictício. Tudo bem, então eu realmente não começar a construir diagramas de classes reais diagramas seqüenciais até que eu saiba que eu tenho um shell funcional de um programa. Então o que eu vou fazer é entrar e criar modificar o método de sobrecarga do aplicativo . Todas as aplicações em que trabalhei vão ter algumas coisas sobrecarregadas. Por exemplo, o que estamos fazendo é que estamos usando as informações do aplicativo de exibição, e nós temos um programa encerrar o método do programa. E então eu vou construí-los, e eu vou integrá-lo na classe principal, e eu vou trabalhar nisso até que isso funcione. Agora, neste
ponto aqui, em
seguida, ter um shell de programa de trabalho sobre o programa. O método principal funciona. Tenho meus métodos gerais concluídos. Eu poderia testá-lo. E agora, uma vez que eu tenho isso, eu tenho uma boa base para começar a construir em minhas aulas um objeto. Então eu comecei a criar o show de classe novamente. Você vai querer ter algum tipo de estratégia e que aulas você vai construir primeiro em nosso programa. Está indo bem, já que só temos um ou dois. Mas então eu vou construir essa classe e eu construir a casca. Não coloco nada nele, exceto as variáveis. Ok. E então eu basicamente ir em frente testes que certificam que ele funciona dentro. Eu me integrou no método principal. Uma vez que,
é que as classes no maior que o método principal, eu vou subir, e então nós começamos a criar getters centros para a variável, e então eu integro aqueles teste no método principal, certifique-se de que eles funcionam, e eu mantenho esse loop até saber que eu poderia recuperar e definir dados dentro dos meus objetos. E uma vez que eu não, uh, tomar cada método individualmente, trabalhar nele, certificar-se de que funciona. Integrado o programa principal. Basta manter este loop até que o método funcione. E então eu continuo com o método. E então, quando isso for feito, eu vou para a próxima aula e vou em frente, integrar isso novamente. Esse é o tipo de estratégia que vou demonstrar nos próximos vídeos, certo? E fazendo isso, você também quer ter certeza de que você usa as ferramentas e o maior desenvolvimento. A violência tem muitas ferramentas. Isso vai tornar o programa mais legal. Eles têm uma ferramenta chamada Intel um sentido. Certo, isso vai ajudar. Você pode se lembrar de nomes de identificador, orgulhoso de e lista de parâmetros. E a única coisa que eu aponto, se um método variável não aparecer no Telus em algo errado parando, corrigindo compiladores você vai ter todos os tipos de ferramentas de formatação que vão permitir que você faça horizontal automática espaçamento vertical dizendo para que você não necessariamente tem que pensar em todas as abas. É basing toe configurado para você automaticamente quando as ferramentas mais importantes é o
compilador em tempo real . Agora, uma das coisas mais difíceis, especialmente se você está apenas começando a programação, é corrigir esta sintaxe. Agora o compilador em tempo real irá verificar essa sintaxe. Faça o Aziz. Digite-o para se certificar de que está correto. Ok. Como você digita em cada linha de código como ele terminou essa linha, não mova para a próxima linha de código até que a linha que você está trabalhando em seu livre de sintaxe vai ao ar. Isso significa que você pode ter que parar e olhar e fazer alguma pesquisa sobre Go retardar você. Mas o que você não quer que aconteça é não deixar que os erros se acumulem nessa janela do problema. Se esses erros de sintaxe se acumularem, você vai chegar a um ponto onde você pode muito bem começar de novo. Você tem 30 40 erros e eles são classe de 100 linhas de código. Isso é tudo 100. E você pode apenas começar a construir uma aula novamente. Portanto, não deixe que esses erros se acumulem na janela do problema. A outra é que você vai ter um Ah integrado, desenvolvimento é tudo ter os buggers. Os buggers é o compilador procura erros de sintaxe. Caso contrário, as coisas que vão fazer seus erros de programa que impedem o seu programa de compilar e executar um bugger, em seguida, permite que você procure lógica ares lógica er são o seu programa está funcionando, mas você tem um erro em sua agua eles apenas dando-lhe, ah, resultados
inválidos. Então o desgraçado mente que você passo através de seu programa linha por linha, variável de valor
observado. Veja como o programa controlado move do objeto objeto e você pode usar para encontrar o programa . E você usa isso para encontrar erros de lógica de programação. E não só isso, é fácil. Boa ferramenta educacional porque ele podia fazer o passo, o sacana. E você pode ver como o controle é passado do objeto objeto e como valores ar mudou. Certo, então a próxima série de vídeos vai demonstrar que o pequeno testículo Bill aborda tudo de novo. Tudo o que fizemos até agora está em preparação para criar um programa de qualidade. Ok, agora, se você seguiu vídeos, uh, o programa de criadores usando esta abordagem de testículos, eu acho que você vai encontrar programação para um reembolso. Mas vai ser você ser mais bem sucedido também
12. Configurando o ambiente de programação: Aqui é onde a diversão realmente começa. Vamos começar a codificar. O que, como você chama o que fizemos, é que passamos muito tempo com estes criando esses
diagramas de classe . Este diagrama de classes nos diagramas de sequência vai ser o seu blueprint principal para criação de programas. O que queremos fazer no revestimento é que queremos traduzir esta tarefa que este diagrama de classe,
bem como um diagrama de sequência e que vai ser o nosso plano para, em seguida, ir em frente e criar o
nosso programa. Lembre-se, quando colocamos nosso kratom criou esses diagramas de classe, todos os símbolos têm significado. Por exemplo, o que estamos interessados agora é que o sinal de menos significa basicamente que é um oculto. E então nós vamos ter que usar privado nós qualquer coisa que é mais vai ser um público. Temos nossos funcionários de classe aqui. Se tivermos um método que é nomeado é o mesmo que uma classe que é o construtor. Está bem. E como você se lembra, o que nós vamos fazer então é usar essa pequena abordagem testável de construção. Por exemplo, neste vídeo, vamos criar o projeto vazio, grande a classe principal e criar modificar o principal e vamos ter certeza de que temos um ambiente de
trabalho antes de começar a construí-lo. Bem, deixe-me ir em frente e configurar essa chamada espelhada. Minha ferramenta de escolha será download gratuito da comunidade de estúdio visual, e eu vou estar no projeto C Sharp. Então a primeira coisa que quero fazer é criar um novo projeto. Neste caso, eu vou criar um aplicativo de console usando C nítido clique. Em seguida, certifique-se de que você ah, salve onde você deseja armazená-lo. Caso contrário, isso poderia estar escondido de você. Eu vou, por exemplo. Eu só vou dizer isso na pasta de download. É um arquivo temporário para mim. Eu vou dar um nome a ele. Uma calculadora? Ele trouxe a versão um porque eu vou criar as diferentes versões para demonstrar coisas. Criação rápida. Ok, então você notou o que aparece. Você percebe que o Visual Studio e outros idiomas também farão isso. Não é só o aviso do estúdio visual. Criou o programa para mim automaticamente. Já criou a minha função principal que já fez uma declaração. E se voltarmos e olharmos para o nosso ser correto. Basicamente queríamos a nossa turma principal aqui. Chamam-lhe “Semana do Programa”. Quer chamá-lo de mim? Principais funcionários. Quero mudar isso de novo. Isso está usando as ferramentas que eu quero renomear isso também. Os principais funcionários não podem ver atrás de seus ganchos. Soletre isso certo? E então eu quero dizer OK, indo. Algum comentário? Faça a mudança, Nome. Clique em, aplique. E agora não tenho anotações aqui, o nome do arquivo é diferente. Então, quando eu realmente Bobby mudou o nome do arquivo também? - Não. Algumas linguagens como Java. Certifique-se de que o nome do arquivo o nome da classe e exatamente o mesmo. Não é verdade em C. Sharp. Certo. Então agora eu basicamente, então eu fiz isso. Já fiz esta primeira parte. Agora vamos em frente e certificar-nos de que funciona. Então, o que? É construí-la. Estou expandindo isso para que você possa ver um pouco melhor, então eu estou construindo um jogo de solução. E aqui está a compilação de saída. Conseguiu um aviso aqui em baixo, se você quiser. Teoh, olha, certifica-te de que tens os teus problemas aparecerem. Certifique-se de que a lista de erros é exibida. Então, por exemplo, eu faria Não é exibido por padrão. Quero minha lista aérea exibida lá fora. Aqui está a minha lista aérea. E então o que vai aparecer? E isso é o que o compilador em tempo real se parece com isso. Então vá em frente e digite eu mesmo. Então repare aqui embaixo. Se eu apagar, isso é como um aviso de console. Essa é a essência da inteligência. Ok, então
eu não tenho que digitar agora. Eu apertei Tab e ele enche automaticamente. Eu quero uma linha certa sobre aqueles lá em baixo. Ele olha para a frente. Eu faço o que eu quero selecionar o mundo e notei lá embaixo que nós olhamos para isso. Aquele pequeno rabiscado lá é o tempo real. Venha, palácios. Ei aí. Aqui em baixo. Você precisa de um ponto semi cólon. - Semi-cólon. Certo. Então agora aqui está a janela de saída novamente. Vamos em frente e construí-lo. compilação foi bem-sucedida. Ok, agora eu posso ir em frente e executá-lo. Então eu vou e executar neste ponto, e então eu vejo um pop-up. Ok, então o que isso significa é que agora eu tenho um ambiente de trabalho. Eu poderia então expandir e nós estamos começando a olhar para como nós, em seguida, traduzir o resto do diagrama de
classes para o
13. Crie um pouco de teste: Certo, vamos dar o próximo passo na construção do nosso programa. Lembre-se do que fizemos até agora. Levamos o projeto vazio do criador. Invadimos a classe principal. Nós permanecemos método de trabalho. Agora, o próximo passo é ah, novamente, no processo que eu estou usando, eu vou criar os métodos de sobrecarga para ter certeza de que eu tenho programa de trabalho. Ok, então se eu olhar para o meu diagrama de classe o que é isso? Isso significa que é o programa de exibição. Informações e a exibição do programa Terminate notado aqui em baixo, estes ar que eles se alistaram são sublinhados, o que significa que eles são objetos compartilhados. Ok, então nós somos um método compartilhado. Eu sinto muito. Tudo bem. Então vamos em frente e construir isso. OK, então agora nós nos lembramos e E isso é verdade para cada objeto ou linguagem é que aqui está a classe. Tudo o que definimos tem que ser definido dentro dessa classe e notar aqui embaixo. Ferramentas de inteligência basicamente mostram. Ok, espere um minuto. Este é o fim da classe principal. E então clique nelas. Ele sempre mostraria as pausas correspondentes novamente. Eu tive uma coisa específica. E você não quer cobrir isso agora. Certifica-te de que aprendes a fazer a coisa certa. Aqui diz que queremos exibir as informações do programa. Então agora precisamos criá-lo. E aqui diz que é privado. O sublinhado significa que é estático. Ok, então eu vou ter que esclarecer isso, assim como está. Então vai ser privado no nariz lá em baixo e dizer que um senso aparece. Você pode digitar ou se eu acertar espaço ou tablets, muito. Neste ponto, ele o preenche. Repare lá em baixo. Azul significa que é um GTO. Observar palavra e verde significa que é um significa que é uma classe. Certo, então tenho um soldado que vou declarar. Isto é estática. Não estou retornando nenhum valor. Eu notei lá embaixo. Eu poderia dizer pelo visor que ele não retorna um valor em aviso prévio. Aqui em baixo, estes eram valores transformados. Então eu declaro que isso é nulo. A maioria das linguagens de programação usará a mesma sintaxe e, em seguida, eu tipo de mesa e exibir informações
do programa. Esses estão desligados. Agora que eu tenho a assinatura do método declarada, eu vou voltar para minhas especificações de ritmo para os algoritmos reais e código que eu vou fornecer dentro dessa função que você notar nas especificações de processamento para o exibir informações do programa exibição Um prompt onde vamos receber o programa de
calculadora de pagamento que vamos solicitar. Diz que calcula pagar por um empregado, funcionários
enterrados, e vai fornecer instruções. O nome do empregado interno Nosso trabalhou na taxa de pagamento, e então ele vai calcular o salário das meninas será exibido. Propósito. Basta ir em frente e cortar colar o código que eu tenho e isso vai ser maior em caso de aviso aqui em
baixo. Diz construtor de cordas. Este é um show correções potenciais. Ok, agora, este é um daqueles casos que você quer ter certeza de que você, uh, corrigir. Há antes de você ir para isso também é onde o poder do seu i d vai entrar. Então, por exemplo, novamente mostrar correções potenciais para este ar. Poderia dizer que é um próximo, todas as linhas rabiscadas. Se eu listar a lista deles, você pode, uh, eu vejo. Sinto muito pelo tamanho pequeno, mas certo. Então, o que você faz, você vai para o nosso show Potencial correções. E diz que usando o texto do sistema veio Isto basicamente, em seguida, vai importar essa biblioteca em I selecionar aquele aviso lá em baixo. Vire verde. Isso significa que ele o reconheceu. E reparem aqui em baixo, é que está ligado isto ao topo. Comece a maioria dos outros ambientes de programação modernos Faça a mesma coisa. Forneça essas correções para U.S. Cuide disso. Ou certifique-se de que aprende a utilizar esses ambientes novamente. Agora que tenho isto. Certo, eu criei isso. Eu quero ir para o próximo, ou eu quero olhar para este primeiro? Bem, vamos ver este primeiro, está bem? Podemos ir em frente e vazar isso. Não precisamos mais disso, porque temos nosso ambiente. Agora, eu quero chamar esta informação de exibição a partir deste método. Então exiba e observe lá embaixo que a inteligência aparece. Ok, então agora, uma vez vamos em frente e olhar para isso de novo. Tipo de exibição do aviso de exibição inicial Aqui, ele olha para a frente. Clicando sobre ele exibir informações. Então, agora, neste ponto aqui, eu tenho isso. Posso ir em frente e construí-lo. Eu não vou construir automaticamente sempre que você corredor, a
propósito, ele pré-construiu. Mas isso é ótimo. E construir uma solução construída começou agora que eu poderia ir e executar, e eu recebo minha, uh, mensagem de
exibição. Ok, então essa parte funciona. Ok, agora, eu olho aqui diz, agora vamos terminar a informação do programa. Agora, eu vou em frente, colocar em avisos privados lá novamente. É privado. Você poderia dizer por seu privado pelo menos na frente do identificador no diagrama de classes . Então é privado. Tem que ser estática. Não vai mudar nenhum valor. E o nome é encerrar programa indo rápido para fora abrir e fechá-lo. E novamente, neste ponto aqui, não
vou ter que me ver digitar código. é doloroso o suficiente, e vou escrever isso, e acho que não preciso desta agora. Então, agora eu tenho. Certo. Agora percebo que não tenho nenhuma lista de erros, está bem? Repare aqui em baixo. Ambos. Por exemplo, eu tinha saudades, então, uh, sem som. Você vai vê-lo rabiscando. Está bem, vai dizer-te onde está, por isso certifica-te de que prestas atenção àqueles ares. A música pode poupar-lhe muita dor de cabeça. Ok, então agora eu vou colocar um espaço aqui. Agora termine em para encerrar o programa. Chame-o de lá. Vá em frente. E agora de novo. Ele o reconstruiu toda vez. Então eu executei. Então aqui está a minha mensagem de exibição. Terminar o programa e ele bloqueou a saída e eles acabaram. Agora, neste ponto aqui, onde o meu no meu processo novamente. Se eu olhar para o meu processo aqui, eu rezei para o projeto vazio. Criei o programa principal e criei os métodos de sobrecarga. Agora o que eu poderia então começar a construir fora do show de classe e nosso mundo vai fazer isso
nos próximos 50.
14. Como criar seu primeiro curso e objeto: Vamos continuar a revestir os nós onde estamos. Lembre-se do que fizemos até agora. Criamos o projeto vazio. Criamos a classe principal. Criamos o método principal de maio. Também criamos o aplicativo e os métodos de sobrecarga. E neste ponto aqui temos um programa de trabalho que exibe as informações gerais e encerra as informações do programa. Agora, o que queremos fazer é começar a construir até as aulas. Ok, então neste caso aqui, vamos começar a construir a classe. E novamente, nós não vamos usar Diskant, construir o shell primeiro com as constantes e variáveis. E então a outra coisa que vamos fazer para realmente ser capaz de exibir essa informação, precisamos ser capazes de coletá-la. E nós vamos, na verdade, adicionar para obter informações de pagamento também. Então poderíamos exibi-lo. Então vamos integrar isso no programa principal. Ok, então vamos deixar isso de lado. E então vamos em frente e construir uma classe A nova classe e novamente, desta forma você construir novas classes vai depender de seu ambiente de programação. Mas o que vamos fazer aqui é clicar no projeto. Vou clicar com o botão esquerdo. Desculpe, mas que rápido na solução e eu vou adicionar novo item. Vai subir. Então, o que você quer acrescentar? Vou rolar até o visual. Vigília vê classe afiada. Vou dar-lhe um nome. E eu o nome que estou dando a isso. Se eu me certificar de que seguimos o diagrama de classe é o nosso modelo. Isto vai ser empregados. Meu clique adicionar. Agora eu tenho uma aula aqui e aviso aqui em baixo. É Ah, coloque aqui. Agora. Uma das coisas aqui é que queremos renomear isso porque isso acabou de nomear o arquivo . Temos de mudar o nome da turma, e vão ser empregados outra vez. Tudo isso depende de tudo isso. Depende do ambiente. Então nós temos nossa classe e aviso aqui embaixo, na verdade, até coloca em um padrão construído para você como você faz isso porque ele basicamente assume todos devem ter um construtor. Então agora eu vou até aqui e fazer isso um pouco maior para que você possa ver, mas tudo bem. Então agora o que eu preciso fazer é criar um padrão. E então eu também vou criar esta informação de pagamento get aqui em baixo circuito, realmente ver essa informação também. Então vamos em frente e construí-lo. E vou digitar uma das declarações. Percebemos que a constante pública contra qualquer linguagem que esteja usando, pode ser diferente. Vai ser um valor de string, e vai ser o nome padrão. E novamente, estou usando o modelo aqui na classe,
Doutor, Doutor, neste caso, sinto muito, Constant. E diz que não foi dado. Eu só vou. Decidimos colocar tudo isso aqui, certo? E então, novamente, eu faria a mesma coisa. Eu iria apenas seguir o mesmo processo e declarar tudo isso e novamente eu vou apenas copiar e colar. Isto vê estes dentro. É como observar outra pessoa. Codificação Titã é absolutamente doloroso, particularmente eu quando tenho dedos gordos. Tudo bem, então agora eu basicamente tenho essas informações, ok? E a outra coisa que eu quero fazer é então eu quero digitar as variáveis. Ok, então isso parece. Vou digitar as variáveis notar tudo aqui embaixo. E isso é verdade. Toda língua tem que ir entre essas aulas. Essa definição de classe aqui está em uma classe onde tudo tem que ir entre esses índices
externos ou esses colchetes externos. Okeanos lá embaixo até te mostra se eu clicar nele. O que eram os colchões correspondentes são mesmo? Então agora eu vou usar meu Templário aqui, e eu vou criar o Não. Vou em frente e criar as variáveis aqui que não são estáticas. Eles são privados. Ok, isso é que eles não são estáticos porque eles não são sublinhados. E o mineiro diz que eles são privados. Ok, então eu vou sair em particular e depois escrever e escrever o nome do empregado e neste caso aqui, eu não vou inicializá-lo e narrar aqui em baixo. Eu faria o mesmo pela taxa de pagamento nas horas trabalhadas. Ok? Agora, uma das coisas que eu quero digerir é o construtor. Ok, estes você sabe, é princípio geral que as variáveis dentro devem estar nesta vida. Então eu vou seguir em frente e pegar essas variáveis, e eu vou dar-lhes um novo valor inicial. É uma das coisas que o construtor poderia fazer muitas coisas. Mas este é apenas um que eu estou, hum, apontando é que eu vou usar o nome do empregado e aviso aqui em baixo. É uma vez que é destacado o tele desde olhar para a frente, bater, entrar e eu vou dizer padrão e notar lá em baixo que ele encontrou. Eu recebo guia E, novamente, Eu quero pagar taxa é igual a e eu quero que eu vou dizer que a taxa de pagamento vai ser inicializado. Os homens avaliam a conta, dentro. E as horas trabalhadas são iguais a nós. Um homem horas zero. Tudo bem, então agora isso é meio que ilustra o tipo de construtores de água que vão fazer agora. Eu realmente não posso entrar nele. Você tem alguma dessas informações quando eu ir em frente, testá-lo porque tudo é privado e eu não criei os getters e centros ainda, mas há sempre eu não digo sempre, mas na maioria dos casos você pode ter algum tipo de função ou método que vai obter a informação. Vou chamá-lo, obter informações de pagamento neste caso aqui, então vai ser um método público. Público é chamado obter informações de pagamento e eu provavelmente deveria dizer que vai ser uma cadeia a atenção para o que está aqui e agora o que eu vou fazer é recolher todas as informações de ousadia. Agora diz que você vai ver que há um erro aqui. Ele diz que nem todo o caminho de código retornando valor. Isso é porque eu tenho que ter uma declaração de retorno aqui. E eu vou apenas ir em frente e copiar e colar para codificar novamente. Este show você poderia vídeo positivo e construir isso se você quiser, mas basicamente o que eu faço, o que eu estou fazendo aqui é eu disco eleger o aviso de informação aqui em baixo. Eu recebo no mesmo ano antes porque eu não tenho ligado no arquivo de texto. Então eu vou para possíveis movimentos de correção, vou para mostrar correções potenciais, e eu preciso deste imposto do sistema Faça basicamente referência. Certo. Então agora eu basicamente tenho um shell básico do meu programa ou minha classe de funcionários da classe. Agora, eu poderia realmente voltar para o meu programa principal e eu poderia realmente usar isso, e este próximo passo é muito importante porque esta é a primeira vez que você realmente vai e Stan ela comeu em objeto. Certo, então vamos voltar ao programa principal. E novamente eu estou usando meu diagrama de classe é um guia. A primeira coisa que diz que a classe de funcionários principal tem que ter uma variável chamada funcionários . Agora que eu criei funcionários, eu poderia realmente apenas criar uma variável como essa. E fazemos essa antipatia que já fizemos antes. Você percebe que é subjacente privado significa que estático. E se vamos fazer referência dentro do programa principal, isso significa que tem que ser estático. Acho que sim. Vamos fazer estática privada. É um objeto de funcionário, o tipo de dados. E depois vou dar-lhe o seu nome. Funcionários, certo? Então eu tenho meu primeiro empregado Agora eu não quero fazer é eu quero ser capaz de exibir essas informações de
funcionários. Então, novamente, eu quero criar outro método, e eu vou seguir até aqui para exibir as informações do funcionário estratagema. Agora, toda
a idéia aqui é que lembre-se, nós colocamos todo esse código que encapsulamos colocando todas as informações para obter coletando as informações, fornecendo as informações dentro do maio dentro da classe de funcionários. Então, também precisamos fazer para exibir as informações é invocar e chamar as
informações de pagamento get da classe. Então o que precisamos para dio é novamente eu vou criar uma função apenas usando meu guia. Aqui está a informação de exibição. É privado. Está bem, é estática. Ele não retorna nas informações e exibe informações do programa. Agora podemos acessar agora, já que isso é declarado na mesma classe e é privado, podemos acessar. É a mesma jogada. Um objeto empregado sem ter Teoh Du Passage em é um parâmetro. Ok, então para mim também acessar as informações dos funcionários que vamos fazer Teoh tipo no conselho
que queremos mostrar ao conselho. Vamos fazer a linha certa, dizemos: “
Ok, Ok, tenho os meus empregados a objectar e vou obter a informação do pagamento. Você sabe, é uma chamada de função ou chamada de método, e então eu vou em frente. Isso parece bom,
mas deixa-me mostrar-te uma coisa. Isso parece bom, Fiz isso de propósito. Agora, quando eu for executar este velho primeiro de tudo, vamos executar isso e exibi-lo, e eu estou fazendo isso de propósito. Eu cometi um erro de propósito para ilustrar uma das coisas que você vai ver. Ok, então agora eu vou e executar isso. E mesmo que pareça lógico, uma vez que eu executar, eu vou obter um erro de tempo de execução. Bem, vamos tentar de novo. Porque obviamente eu cometi um erro naquele inverno que eu fiz bem. Eu não comprei exibido as informações de exibição novamente. Obter o que eu quero fazer é realmente e eu até mesmo alterar esta exibição errado informações Pay. Comece. Isso ilustra isso ilustra o problema em que a compilação um pequeno teste se aproximará. Eu trabalho no problema onde eu testei. Eu trabalho no problema até consertá-lo. Mas o que eu realmente quero aqui é exibir informações de pagamento. Ok, agora, uma vez que eu fizer isso de novo, parece bom. Ok. Tudo bem, vamos tentar de novo. Vá em frente e execute novamente e observe aqui embaixo, eu recebo um ar de tempo de execução, e isso é quando você tem que prestar atenção. Um empregado é igual a saber que vou em frente e parar a execução e o que esse ar significa. E quando você vê isso, lembre-se, o que temos que fazer é que quando criamos um objeto, isso basicamente declara um objeto. Mas não temos em Stan. Ela odiava o objeto. No entanto, isso só diz que eu não tenho objeção chamada de funcionários, mas eu realmente não criei na memória ainda. Então apareça quando eu faço isso, eu preciso fazer novos funcionários. Isto é absolutamente necessário. Há duas etapas de quando você deseja usar um objeto. Você tem que limpar a variável. Então você tem que ficar de pé. Ela comeu o objeto para separar passos distintos. Um dos erros mais comuns que programadores coreanos objeto introdutório fazem declarar a variável, em
seguida, na variável em forma de suporte. Ok, então agora o poderia realmente bonitinho isso. Agora eu tenho que obter informações sobre o meu programa. Não é dado. Aqui estão todos os padrões, eu disse. Então agora o que eu fiz então é que eu tenho um programa de trabalho shell da
classe de funcionários . Mas agora o que eu preciso fazer agora é fazer o processamento interno da classe de funcionários e não estar pronto para ir. Só usando essa conta, um pequeno teste vai se aproximar, e vamos continuar isso no próximo vídeo
15. Crie Getters e Setters robustos - Parte 1: Ok, aqui estamos nós na próxima etapa de construir as aulas é se você se lembrar onde estamos, onde fizemos. Temos o nosso projecto. Criamos a Classe Principal. Nós avaliamos rapidamente as funções aéreas. Nós basicamente criamos o show de classe quando somos capazes de realmente trabalhar com esse show de classe dentro do programa principal. Ok, agora nós queremos basicamente construir os centros e jantares. Agora, precisamos ser capazes de coletar as informações do usuário, ser capaz de definir essas informações para a classe, e então poderíamos continuar o processamento. Então, se olharmos para o nosso diagrama de classes, vemos que temos que fazer isso em duas etapas diferentes. Ok? O primeiro passo é que basicamente temos que criar os getters e centros para o objeto ou para as classes, métodos
privados. E então o que temos que fazer é que nós temos que ser capazes de obter essa informação e do usuário e realmente se orgulhar dela novamente. Vamos usar isto de forma criminosa e fazer o nome do empregado primeiro. Eles, então, foram construídos para obter informações de pagamento para isso. E então estamos na taxa de pagamento. E então nós adicionamos as horas de trabalho e apenas incrementalmente construí-la. Ok, então vamos falar sobre getters e centros, ok? Agora, por exemplo, vamos fazer os getters em centros. Toda a idéia por trás dos getters e centros é
Babe, babe ter essas variáveis privadas. E quando definimos essa informação, queremos ter certeza de que essa informação está correta. Ok, então vamos descer aqui e vamos em frente e criar o primeiro centro para a
classe de funcionários . Ok, agora, uma coisa que notamos que mencionamos é que note que getters e sábado não são necessariamente listados no diagrama de classes porque é assumido ok que, por padrão, se você tem uma variável privada, Funcionários membros conheceu pagar estupro que você está sempre indo para criar getters e centros. Você nem sempre precisa. Mas a culpa é que você vai criá-lo. Então, a primeira coisa que vamos fazer é ir em frente e criar o getter para o nome do empregado
miúdo para público. Ok, eu vou ter que retornar um valor de string, obter um aviso aqui em baixo. O padrão para o guia diz o nome dos funcionários. Esta é uma maneira padrão de nomear getters. E então tudo o que vamos fazer aqui é devolver o nome dos funcionários fácil o suficiente. Agora fica mais difícil. Agora, quando dissemos isso, nós realmente queremos ter certeza de que temos valores válidos. Então, de novo, vamos ao público. Ok, este centro não retorna nenhum valor. Então nós estamos indo Teoh dizer evitar no stand ou o é para padrões definir nome do empregado usado, um conjunto de termos e, em seguida, o nome da variável. Normalmente é assim que funciona. Agora temos que dizer, OK, que valor estava passando por ele? Então eu vou dizer que o que vai ser passado, o que vai passar vai ser o nome dos empregados. Ok, então nós vamos lá, então agora nós temos que verificar duas vezes o que faz com que ele nome valor ou valor de cadeia. Bem, não pode estar vazio. Então, qual é a lógica de determinar se um valor não está vazio? Então, lembramos quando voltamos para nossas especificações de processamento, criamos o pseudo código para o conjunto empregando nome. Então nos perguntamos se o nome do funcionário não está vazio, vamos definir o que quer que tenha passado para o nome. Se ele estiver vazio, vamos apenas configurá-lo para o nome padrão. Então, o que você ia ver? Aqui está a tradução do pseudo código para o próprio código C nítido real. O que verificamos aqui é esse nome Knoller está vazio? E nós fazemos isso? Não é assim. Se não souber que Knoller está vazio. Definimos o valor de entrada para o nome do funcionário. Se não estiver vazio, dissemos que o nome padrão. Então a lógica aqui provavelmente não é super. Você provavelmente quer expandir isso no aplicativo do mundo real. Mas o ponto aqui é que quando criamos esses centros, vamos nos certificar de que validamos a entrada para que o nome do funcionário variável e as outras variáveis que ar privado para a classe estivessem sempre em um estado válido . Agora que criamos este centro para o nome dos funcionários, o que queremos ser capazes de fazer usando nossa construção uma pequena abordagem de teste é realmente ir e testá-lo. Para garantir que funcione corretamente, vamos para um diagrama UML. Isso significa que temos que começar a construir para obter informações de pagamento e vamos construir isso e apenas testar a coleta do nome de funcionário definido nele e ver se podemos exibi-lo corretamente. Agora tenha em mente que
criamos o pseudo código e a lógica para o que queremos fazer para obter
informações de pagamento . Agora só queremos construir isso incrementalmente. E para este sacramento estavam pedindo o nome dos funcionários. Vamos pegar o nome do empregado, vamos defini-lo e então vamos ver se podemos exibi-lo corretamente. Certo, e já que estou trabalhando com o nome do empregado, vamos nos preocupar com isso. Então vamos precisar escrever um prompt para o usuário dedo do pé uma direita submarina novamente. Clique duas vezes sobre ele. Não, você vê, digite o nome dos funcionários. Ok, há o meu prompt para o usuário, Twig Lee diz que você precisa de um ponto-e-vírgula lá, e agora o que eu vou fazer agora eu vou coletar essa informação da saída e , em seguida, realmente vai armazená-lo no funcionários objeto funcionários funcionários que meu objeto que eu estou trabalhando com novamente eu tenho meu nome set e agora eu vou dizer OK, ler o conselho e armazenar o quê? Eu guardo o que tenho nesse elemento. Certo, agora só estou fazendo o nome do empregado. Tudo bem, agora eu tenho informações de exibição. Eu vou voltar aqui agora e agora eu vou dizer obter informações de pagamento. E agora, neste caso, posso escolher um cão de teste e definir as informações do empregado. Então, agora, se eu for em frente e testá-lo executado, obter um nome de funcionário Billy, e vemos que o nome do empregado foi definido. Agora, aqui é onde o sacana pode realmente estar. Uma boa ferramenta para aprender fazer é que eu vou definir uma marca vai dizer um ponto de ruptura aqui, que é e então agora eu vou definir o bugger do fazer. E para que pudéssemos ver como as coisas funcionam. Não, eu executo o programa e você percebe que aqui em baixo Sarkozy não precisamos disso. Parou a execução neste ponto aqui. Inter nome do funcionário. Certo. Então agora eu vou em frente e vou em frente e passo nele. Esta é a etapa de depuração mostrada próxima instrução. Posso ver o que acontece. Desculpe por isso. Apertando o botão errado. Ok. O nome interempregado que coloquei no Billy. E então você percebe aqui embaixo, nós vemos que ele saltou. controle de execução foi passado para o objeto empregado. Você pode ver aqui em baixo diz, Aqui está o nome. Este é o objeto com o qual estamos trabalhando. Aí está o nome que pude ver. Eu poderia então entrar nele novamente. Ok, agora vai e verifica se Billy está. O que está sendo passado não está mais vazio. Não é. E, em seguida, vá em frente e vemos que ele é chamado Verifique se isso define o nome corretamente,
e, em seguida, ele pisa para fora e controle. E então novamente, se eu bater, continue. Certo. Então essa é uma das 1ª exposição aos buggers. Sugiro que você tente usar esse desgraçado para realmente ver como o Controle de Programas estava funcionando. Hum, e então nós somos mostra mais exemplos. Vamos em frente
16. Crie Getters e Setters robustos - Parte 2: a fazer progressos. Então, onde estamos no processo? Aqui agora se lembra do processo, o que fizemos? Criamos o projeto vazio. Os professores, , antes de seguir em frente, criaram a turma principal. Comece. Nós garantimos que funcionasse antes de ele seguir em frente, criamos os métodos de sobrecarga de aplicativos. Nós criamos a concha da classe, e agora nós vamos isca. É basicamente criado Nosso primeiro centro com o nome Agora que queremos fazer é continuar neste loop e criar outros centros e getters para as variáveis de classe. Então, por exemplo, vá e faça isso um pouco maior. Vamos em frente e criar o getter e setter para taxa de pagamento e aversão. Resultado feito antes. Nós vamos criar um pegue-a primeiro, e ele vai retornar um valor duplo novamente. Notei que a convenção de nomenclatura com get e, em seguida,
o nome da variável tipicamente, o que você vai ver em aplicações e vamos retornar o par A como fizemos antes, vamos voltar para seus algoritmos especificações para o conjunto, a taxa de pagamento, e nós vamos traduzir esse pseudo código para o código de programação real. Lembre-se, estamos recebendo a taxa de pagamento no passado. Então, se a taxa de pagamento que ser passado dentro é maior do que a taxa de homens e menor que a taxa máxima ,
caso contrário, está dentro desse intervalo válido. Vamos pegar o que foi passado,
e vamos colocar isso na taxa de pagamento dos empregados se for esquerda e a taxa de homens. Caso contrário, a taxa de pagamento é, digamos, parente
negativo. Vamos então redefinir a taxa de pagamento para a taxa mínima permitida. Se for maior do que a taxa máxima, digamos, por exemplo, o 150, então vamos apenas redefini-lo para a taxa máxima. Então vamos em frente e eu só vou copiar e colar o código para que você não tenha ver meus dedos gordos digitando a enfermeira o que fizemos aqui. Nós trazemos o valor que está sendo coletado do usuário. É uma taxa dupla. Nós nos certificamos de que cospe entre a taxa mínima e a taxa máxima. Se for, vamos em frente e definir a variável local ou a variável no objeto para que os valores passados . Se for menor do que a taxa de homens, vamos em frente e definir a taxa mínima. Se for maior do que a taxa máxima, vamos em frente e colocá-lo de volta para o início máximo na aplicação do mundo real, isso vai ser um pouco mais robusto. Ah, mas você entendeu a idéia. Então, o que fazemos agora? O que precisamos para dio agora é que precisamos ir em frente e colocar o código para realmente coletar a entrada do usuário. E então vamos brincar, saltar para o método principal. Seguem-se o processo. Vamos para obter informações de pagamento pseudo código e ver o que precisamos para traduzir em código de
programação real . Parece que conseguimos informações de pagamento. Já tratamos dos empregados. Então agora o que vamos fazer para a taxa de pagamento como vamos exibir um prompt para o usuário , vamos ter o usuário inserir a taxa de pagamento. Então o que precisamos fazer é validar que as taxas de pagamento do número, por exemplo, não
queremos algo como, Ah, número
válido seria algo como 34. É uma entrada válida. Mas se algo que o usuário ou algo assim é lixo e isso fará com que seu programa a falha. Então queremos ter certeza de que essa entrada forneceu seu número real. Se é um número válido, então vamos definir a taxa de pagamento na classe empregado. Caso contrário, vamos exibir em sua mensagem. Vamos então ver como traduzimos este pseudo código no código de programação real. Está bem. E novamente, neste ponto aqui, eu vou em frente e apenas copiar e colar o código e explicar para você o que está acontecendo. Então voltamos à informação do pagamento e eu coloquei algumas variáveis temporárias aqui movimentos
locais aqui para que pudéssemos nos certificar de que poderíamos coletar os dados e
validar os dados e pagar o casaco. Vá em frente e pause a gravação para ver isso. Mas há algumas coisas que quero que perceba. Nós vamos fazer a linha direita conselho que aviso aqui em baixo, queremos ser capazes de fornecer um prompt o usuário sobre o que eles devem estar entrando seu
um par A entre alguma taxa mínima e a taxa máxima. Este é o lugar onde o conceito de uma variável compartilhada ou estática entra. Se voltarmos para a aula de funcionários, notamos que colocamos isso é público,
Constance, esses ar, esses ar, depois estático. E então eu poderia então acessar vê sem realmente criar o objeto. Então é isso que estamos fazendo com a estática agora. Eu não tenho que ter um objeto natural para obter esses valores existem para a classe empregado. E eu poderia então apenas referenciar cada um dos pontos de dados individuais individuais que eu quero e notar que você poderia fazer isso com métodos extáticos ou qualquer outro membro
estático que você criou, certo? Então, neste caso aqui, nós também vamos fazer alguma validação de entrada no código no nível da interface. Primeiro de tudo, vamos ler na corda novamente com a mesma coisa. Temos de nos lembrar que tudo o que está vermelho está a chegar é uma força. Então, por exemplo, se eu quiser digitar o valor de, digamos, 54 o que é realmente lido pelo sistema é a representação de string desse número 54. Bem, isso não é um número. Isso é uma corda, o que realmente queremos. Queremos o valor 54. Então nós temos Teoh analisar em valor no você sabe, partes adicionar valor no número real 54 agora e C nítido e novamente, todos os ambientes de linguagem commit, mas diferente. O que as partes de listras verifica para ter certeza de que você não colocou em lixo? Por exemplo, se o usuário inserir lixo eletrônico estiver bem, esse não é um número válido. E se você tentar analisar isso se você tentar Pursat, então seu programa vai quebrar o que essas partes fazem. Basicamente diz que vamos nos certificar de que é um voto e, na verdade, um número. E se não for um número, envio uma mensagem de erro. Mas se for um número um ok, defina o valor. Então, agora, neste ponto aqui, eu coloquei a taxa de pagamento. Eu defini a taxa de pagamento. Agora eu posso ir em frente e executar o testamento para fora e ir em frente e testá-lo para fora. Eu um empregado chamado Oy, nós perguntamos o que a taxa de pagamento ISS dizer. 54. Parece que preciso colocar um espaço lá dentro e reparar lá em baixo. Nós temos a taxa de pagamento definida, então eu sou uma coisa calculada ainda porque nós não fizemos os cálculos, mas eu estou começando a obter os dados que estão chegando. Tudo bem, então o que eu preciso fazer também é colocar um cólon ditado no final disso em um espaço . Então há um espaço entre a entrada na saída, certo? Isso ilustra uma das razões pelas quais você não fez essa
abordagem dos testículos do Bill . Eu me certifico de que este está correto antes de eu ir para o outro. Certo. Então a outra, as horas de trabalho, a lógica é exatamente a mesma. Então o que eu vou fazer é que isso vai acontecer agora. E nós vamos inserir a criação para getters e centros para as horas de trabalho e como antes, basta ir em frente e criar o código. É exatamente a mesma estrutura nos mesmos processos que fizemos com a taxa de pagamento. A maioria aqui em baixo. O que? Tenho as horas trabalhadas. Ok, e então onde eu trago as horas se as horas são melhores mulheres Neagle horas. Está bem, estou a ver. E é menos desigual. Horas máximas, eu disse, o que passou em caso contrário, se for menos do que as horas mínimas, eu vou aceitar, eu enviei para o mínimo. Se for maior que Max, as
horas vão definir um reset para o máximo, e temos que ter certeza também para o mesmo tempo, que é precisamos ter certeza de que temos o getter lá também. Então eu tenho que colocá-la lá dentro. E agora vou voltar para os principais funcionários. E agora eu vou apenas então basicamente reproduz, codificado. Mas tirando as horas trabalhadas, sinto muito. Então, como vemos aqui, temos basicamente a mesma lógica exata. Eu usei os métodos estáticos neste caso para Constante, para me dar o mínimo de horas e, em seguida, a máxima nossa Então eu posso fornecer uma saída para o usuário e notei que eu estou aqui. Será que eu precisava fazer o mesmo ar que eu fiz antes? Então vamos em frente e corrigir que eu li no valor que eu tento analisá-lo novamente. A ideia aqui é que queremos ter certeza de que obtemos um número e não algum salto na string se
for válido. Eu disse isso. Não é. Eu só basicamente fornecer o usuário com sua mensagem para não ir em frente e testá-lo. É um empregado chamado Billy. O nosso trabalha 50 horas, 25 dólares por hora e aviso aqui em baixo. Eu tenho o Billy 50 horas ou 50 dólares por hora em 25. 25 horas trabalhadas. Tudo bem, então agora, neste momento, o que eu preciso fazer, eu não fiz o processamento. E o próximo passo eles vão para o diagrama de classes e, em seguida, sair e construir os métodos. Precisamos processar esses dados uma vez coletados. E é isso que vamos fazer no próximo incremento. - Então não vá em frente e teste. O empregado chamado Billy trabalha 50 horas, 25 dólares por hora e aviso prévio aqui. Tenho o Billy 50 horas ou 50 dólares por hora em 25 e 25 horas trabalhadas. Tudo bem, então agora neste ponto aqui, o que eu preciso fazer, eu não fiz o processamento, e o próximo passo, então, é ir para o diagrama de classes e, em seguida, sair e construir os métodos que precisamos para realmente processar esses dados uma vez que os coletamos. E isso é o que vamos fazer no próximo incremento
17. Crie os métodos/funções: Quase pronto. Temos mais uma coisa a fazer agora. Chegando, lembre-se onde estamos Faça isso um pouco maior para que todos possam ver. Estamos neste ponto onde implementamos todos os getters e centros. Agora o que precisamos que queremos fazer é que queremos ser capazes de realmente criar os métodos. E o único método que estamos criando nesta classe ou este do programa é um cálculo salário
bruto. Então agora eu preciso ir calcular o salário bruto integrado na função principal. Agora, a coisa realmente legal sobre esta função é que eu realmente não tenho dedo atualizar o
método principal mais. Uma vez que tudo isso é encapsulado os cálculos de pagamento, tudo encapsulado em empregado, Eu posso apenas fazer tudo aqui. Ok, então eu vou seguir meu diagrama UML, e eu vou ir em frente e então dis implementar o programa de calculadora de pagamento novamente. Isso vai ficar assim. Vai calcular o salário bruto, e tudo o que faço é devolver as horas trabalhadas. Hora de pagar taxa. Agora, tenha em
mente, eu poderia usar estes aqui sem passar porque seus membros privados do ob de nesta classe um objeto. Então qualquer coisa que eu tenha declarado no nível de classe, que eu tenho neste momento aqui, e nós poderíamos olhar para isso aqui, qualquer coisa que é para parar com o declarado no nível de classe aqui agora está acessível a ele . E eu não tenho que passar os dados por aí. Tudo bem, então agora o que eu só preciso fazer agora, como eu preciso fazer, é uma atualização para obter informações de pagamento para, em seguida, calculada cada vez que eu defini , hum, as horas trabalhadas em o pagamento. Neste momento, isto é bastante fácil. Tudo o que eles precisam fazer é que eu acabei de adicionar isso uma linha de pinos que eu coloquei na declaração de saída salário bruto . Eu então chamei o método calcular o pagamento do crescimento. , Lembrem-se, sempre que coloco algo no construtor de cordas, tem
que ser uma corda. Então eu vou girar a corda, e aqui eu digo que vai ser o formato de moeda. Agora, essa coisa realmente legal é agora, já que tudo isso está encapsulado dentro da informação do funcionário, eu realmente não tenho que fazer nada para o principal. Você quer dizer classe de funcionários, porque uma vez coletada, ok, uma vez que eu coletei todas essas informações, eu vou apenas exibir as informações em uma calculadora para mim automaticamente. Vamos dar uma olhada. Então vai ser o Billy. Ei, Billy. Trabalhe 50 horas esta semana a US $45 por hora, e notamos que ele ganhou 25 2025 $250 para esta semana. Encerre o programa. Tudo bem, então o que fizemos aqui, nós realmente concluímos, está programado. Uma vez que você passou por todo este processo, foram basicamente concluídos. Nossa primeira geração do programa. Agora ainda não terminamos. Nós não testamos o suficiente para realmente verificar todo o passado. Não testamos para ver o que acontece quando colocamos dados de lixo. Não testamos o que acontece quando colocamos um intervalo de dados. Caso contrário, colocamos um negativo 10 ou 150. Mas isso seria parte do processo de teste. Lá você continua. Então, basicamente, esse é o processo. Lembra-se? Dois embriagados. Você do Bill Little Testicle se aproxima de você o que eu estou fazendo é que você crie o programa principal. Está bem. Projeto vazio para se certificar de que funciona. Você cria a classe principal. Certifique-se de que funciona. Você entra e constrói os métodos de sobrecarga, e neste ponto você tem um shell de trabalho de um programa e, em seguida, pouco a pouco, você cria cada classe que você vai para sua classe que você está indo e construindo, integra-se em seu sistema. Você integra isso na metanfetamina principal, certifique-se que funciona, tornou-se e isso é uma concha. Em seguida, você vai para a classe, você constrói cada um dos getters e centros de integração incremental aqueles no
método principal veio até que isso é feito e, em seguida, você cria e modifica seus métodos. Eles vão fazer o processamento que você precisa. E depois, quando isso for feito, você vai para a próxima aula. Então o que vamos fazer é fazer alguns pensamentos finais na próxima lição e o que eu recomendo que você faça. Você praticou tanto quanto possível?
18. Considerações finais - Coisas a lembrar: Olá. Bem-vindos à última lição. Um objeto. Programação coreana. Nesta lição, eu gostaria de fornecer alguns pensamentos finais, e espero mostrar-lhe e convencê-lo de que, embora a programação real seja muito importante, já que você não pode criar um aplicativo de software sem ser capaz de programar. Mas seus programadores introdutórios, eu acredito que é tão importante ou ainda mais importante, que você entenda que seu conceito subjacente como você vai encontrar habilidades de programação são perecíveis. E se você não praticar constantemente, as novas habilidades desaparecerão. No entanto, uma compreensão subjacente dos conceitos permanecerá com o seu longo tempo. E então quando você começar a programar novamente, ou se ele mudou para uma nova linguagem, a Fundação Conceptual irá ajudá-lo a pegar o programa. É muito mais rápido. Como você provavelmente sabe, tecnologia muda rapidamente no mundo da engenharia de software. Temos novas linguagens e novas ferramentas de desenvolvimento a cada dois anos. Algumas das línguas mais recentes ou ir longa python tem sido em torno de um tempo, mas está rapidamente se tornando muito popular. Linguagem. A linguagem está em declínio ou obsoleto, ou pascal visual básico seis pequena conversa para uma tendência e assim por diante. Também as ferramentas de todos os morph juntos, ele clipa Net beans, Microsoft Visual Studio, as ferramentas que eu usei. Terei o mesmo conjunto básico de operações que todos formaram. Designers dizer um senso compiladores em tempo real, projeto Explorers auto co geradores e controle de código-fonte. Se você aprender a usar uma dessas ferramentas, será muito mais fácil para você pegar as outras ferramentas porque elas são tão semelhantes em termos de interfaces nas operações. Por outro lado, o conceito
subjacente ao desenvolvimento de software enquanto eles amadureceram ao longo dos anos, não mudou drasticamente nas últimas décadas. A maior mudança. Quando fomos de programação de estrutura, trabalho Victoria programação no início dos anos 90 e dois milhares, os conceitos básicos coreanos óbvios não mudaram muito sentido. Além disso, considere quantas linguagem têm derivado apenas da linguagem de programação C mais Java,
mar, mar, python
afiada, javascript. Como resultado, todos
eles têm uma sintaxe muito semelhante. Outras linguagens usam as mesmas estruturas de controle básicas do mesmo. Todos eles usariam seleção de sequência, funções de
loop e parâmetros e, por outro lado,
enquanto nos movemos, enquanto nos movemos, roubaram uma programação coreana os conceitos e mesmo que o processo geral de desenvolvimento seja o mesmo para cada idioma e cada ferramenta. Todas as línguas diferentes. Java C C mais C python afiada mais C. Eles basicamente usam classes e objetos. Eles usam encapsulamento de dados escondendo que ele é herdado. Como mencionei, as competências de
implementação são importantes. Você precisa saber como programar. No entanto, é apenas importante ou, mais importante, entender os conceitos e processos gerais do que essa é a
linguagem de programação real , particularmente como um programador introdutório, Os conceitos não vão mudar. Somente a implementação detalha as alterações. Você vai de linguagem para linguagem que está olhando exemplo. Aqui está um programa acadêmico básico que vai desenhar formas na tela. Você percebe que ele olha para você. Diagrama da classe Mel. Não há nada no diagrama que é melhor é longe especifica qual linguagem de programação. O que eu vou te mostrar então. A implementação deste programa em duas linguagens, Java e C sharp, E o que você vai ver é que há muito pouca diferença em termos de estrutura, seu programa e particularmente entre Java e C afiada. Há muito pouca diferença na sintaxe geral da própria linguagem de programação. Então aqui está o programa de forma, um construído em Java com feijão líquido, o segundo construído em C afiado com estúdio visual que você notou muito rapidamente. Há uma semelhança entre as ferramentas. Ambas as ferramentas têm uma solução. Explorer, essa lista de arquivos. Eu notei o nome das classes ou o mesmo aviso aqui em baixo que pacotes ar semelhante. Ambos têm uma forma e utilitários, forma e utilitários. Se eu olhar para um dos arquivos em C Sharp, notamos que já vimos esse tipo de objeto antes. Mas se eu olhar para a classe círculo e Java, você percebe que está muito em algum lugar na estrutura. É muito semelhante em sintaxe. Se eu olhar para uma classe quadrada, compare os dois que você notar novamente. Muito semelhante em estrutura, muito semelhante em sintaxe. Se eu olhar para o programa principal para cada não, é aqui em baixo. É muito semelhante em termos de estrutura geral e como o programa é executado. Então o ponto que eu quero fazer aqui se olharmos para a implementação, eles são muito semelhantes e muito em estrutura e muito semelhantes em sintaxe. Assim, compreender os conceitos fundamentais torna a implementação muito mais fácil. E se você for entre língua e língua, se você entender esses conceitos, sua vida se torna muito mais fácil e você será capaz de fazer essa transição muito mais rapidamente. Então, o que vem a seguir em seu objeto ou jornada de programação? Neste curso, abordamos os conceitos básicos e a implementação do objeto durante o projeto de programação. Estes são conceitos fundamentais necessários para que você faça programação mais avançada no conceito
intermediário e técnicas. Claro que vamos falar sobre a composição, onde as classes constituíram uma várias classes menores como um motor de um carro, é composta de muitos componentes menores, ou seja, pistões
do bloco do motor, injetores de
combustível e assim por diante. Herança é o conceito de criação de classes pai que contêm atributos e
operações comuns e , em seguida, permitindo subclasses para ser baseado na classe pai. E então a subclasse pode ser especializada. O comportamento. Sim, o conceito de polimorfismo. Essa é a ferramenta que usamos para permitir que subclasses especializem o comportamento da
operação de classe aparente . Ao permitir que a subclasse para substituir o código da classe pai, sobrecarga nos permite definir operações com o mesmo nome. Isso, exceto entradas de dados diferentes após nossas classes, é uma extensão de herança onde criamos uma classe pai, mas nunca temos a intenção de criar um objeto de que interfaces de classe nos permitem impor um conjunto de comportamento em objetos, a fim de fornecer consistência na implementação da classe e processamento do ar técnicas avançadas criando interfaces gráficas de usuário, processamento de
banco de dados e padrão de design. Bem, este é o fim do curso do programa coreano objeto introdutório, e eu espero que você tenha gostado do curso e boa sorte em seus futuros empreendimentos.