Sera que existe?

martinezfabio · Junho 18, 2005, 7:27pm

ola

Estou começando a aprender Java na Faculdade (Eclipse), e o prof. pediu pra gente fazer um programa de impressão de cheque, gostaria de saber se tem como quando eu digitar por exemplo R$100,00 escreva Cem reais

Obrigado a todos que responderem…

Mauricio_Linhares · Junho 18, 2005, 7:43pm

Pronto, eu acredito que ainda não exista, mas você pode ser o primeiro :mrgreen:

louds · Junho 18, 2005, 7:53pm

Claro que tem, é só você programar isso. Boa sorte.

martinezfabio · Junho 18, 2005, 8:07pm

Tudo bem eu sei que tem que programar…
só que eu queria saber se existe um jeito mais facil ou se existe alguma coisa pronta, do que e fazer um milhao de ifs comparando os valores

Mauricio_Linhares · Junho 18, 2005, 8:10pm

Que ifs, primeiro você conta as casas decimais, depois você vai pegando os números de um em um.

Tipo, 123, tem três casas, começa com 1, então você já tem cem(ou cento), aí você pega o segundo, que é dois, então você já tem vinte, e pega o último, que é três e fica três.

Isso vai furar nos que tem a dezena 1 e 0, mas aí bota os ifs, na internet tem essas coisas prontas em Delphi e VB fácil, dá uma caçada aí, talvez sirvam pra alguma coisa.

vamorim · Junho 18, 2005, 9:59pm

Poxa Maurício, não estraga a diversão do cara.

Fabio, deixa eu te lembrar uma coisinha bem básica. Você já deve saber que quando um professor pede para você fazer uma tarefa, o que ele realmente quer não é a tarefa pronta. Ele quer que você exercite a sua capacidade de desenvolver soluções.

O que você pode não saber é que a hora de exercitar é agora! Não tenha preguiça de desenvolver o seu potencial. A menos que queira ser um profissional fajuto que só sabe obedecer o que as pessoas mandam ele fazer. (Leia-se: profissional que ganha pouco dinheiro).

Obs: tô treinando prá falar isso pro meu filho. :mrgreen:

farribeiro · Junho 18, 2005, 11:08pm

Comecei a resolução(19:45), mais ainda está incompleta, acho que vou disponibilizar para o BrazilUtil API :lol: que ainda estou a ver :roll:

Gostaria de dizer como fiz mas não posso estragar o profissional né?

Mauricio_Linhares · Junho 19, 2005, 12:54am

Comecei a resolução(19:45), mais ainda está incompleta, acho que vou disponibilizar para o BrazilUtil API :lol: que ainda estou a ver :roll:

Gostaria de dizer como fiz mas não posso estragar o profissional né?[/quote]

Ei, seria massa colocar isso na BrazilUtil!

O meu professor de Ferramenta RAD (Delphi, ECA!) tem uma DLL que faz isso, mas ele não dá ela pra ninguém não, acho que ele anda com medo da concorrência no mercado :lol:

farribeiro · Junho 19, 2005, 1:55am

[quote=Maurício Linhares]

Ei, seria massa colocar isso na BrazilUtil!

O meu professor de Ferramenta RAD (Delphi, ECA!) tem uma DLL que faz isso, mas ele não dá ela pra ninguém não, acho que ele anda com medo da concorrência no mercado :lol: [/quote]

Olhei o tópico do BrazilUtils e já existe o mesmo.

Para mim foi bom o aprendizado, usei somente conversão de String para int o daí do int para o switch() … case()

E está funcionando numa boa! :lol:

Editado
Fiz a partir do zero, sem ajuda! :shock:

Ironlynx · Junho 19, 2005, 2:40am

Pessoal, a que deve existir na BrazilUtils API é para três casas decimais,
essas tem até centavos apenas!É só uma questão de modificação,mas dah um trabalhinho!Ah, o exemplo de 2 casas:

[code]
package br.com.sitesolutions.financial;

import java.math.BigInteger;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Iterator;
// A classe Formatter foi incluída a partir do JDK 1.5 e
// é pesadamente inspirada na função printf da linguagem C++.
import java.util.Formatter;
import java.text.DecimalFormatSymbols;

/**

Classe: Extenso
Descrição: O programa converte um número para o seu valor em extenso.
Comentários:
A conversão aceita apenas valores monetários,

                   portanto a casa centezimal (dos centavos) admite até 3 dígitos<br/>

                   com o extenso arredondando em somente 2 dígitos e<br/>

                   a parte inteira admite até 9 grupos, chegando a casa dos septilhões.<br/>

                   Porém valores negativos não serão aceitos, somente números positivos.</p>

Exemplo:
R$ 345.678.901.234.567.890.123.456.789,01

               trezentos e quarenta e cinco septilhões e<br/>

               seiscentos e setenta e oito sextilhões e<br/>

               novecentos e um quintilhões e<br/>

               duzentos e trinta e quatro quatrilhões e<br/>

               quinhentos e sessenta e sete trilhões e<br/>

               oitocentos e noventa bilhões e<br/>

               cento e vinte e três milhões e<br/>

               quatrocentos e cinquenta e seis mil e<br/>

               setecentos e oitenta e nove reais e<br/>

```
 um centavo.
```
@author Copyright© 1996-2004 Site Informática Ltda.
@author Fernando Carvalho Santucci
@version 1.0, 30/09/2004
@see br.com.sitesolutions.financial.NegativeNumberException
@since JDK 1.5
*/
public class Extenso {

private ArrayList nro;
private BigInteger num;
private BigDecimal valorMonetario;

private String Qualificadores[][] = {
{“centavo”, “centavos”},
{"", “”},
{“mil”, “mil”},
{“milhão”, “milhões”},
{“bilhão”, “bilhões”},
{“trilhão”, “trilhões”},
{“quatrilhão”, “quatrilhões”},
{“quintilhão”, “quintilhões”},
{“sextilhão”, “sextilhões”},
{“septilhão”, “septilhões”}
};

private String Numeros[][] = {
{“zero”, “um”, “dois”, “três”, “quatro”, “cinco”, “seis”, “sete”, “oito”, “nove”, “dez”, “onze”, “doze”, “treze”, “quatorze”, “quinze”, “desesseis”, “desessete”, “dezoito”, “desenove”},
{“vinte”, “trinta”, “quarenta”, “cinquenta”, “sessenta”, “setenta”, “oitenta”, “noventa”},
{“cem”, “cento”, “duzentos”, “trezentos”, “quatrocentos”, “quinhentos”, “seiscentos”, “setecentos”, “oitocentos”, “novecentos”}
};

/**
- Construtor.
- @since JDK 1.5
 */
 public Extenso() {
 nro = new ArrayList();
 }
/**
- Construtor.
- @param dec Valor para colocar por extenso.
- @since JDK 1.5
 */
 public Extenso(BigDecimal dec) throws NumberOutOfRangeException {
 this();
 setNumber(dec);
 }
/**
- Construtor.
- @param dec Valor para colocar por extenso.
- @since JDK 1.5
 */
 public Extenso(double dec) throws NumberOutOfRangeException {
 this();
 setNumber(dec);
 }
/**
- Seta o atributo Number.
- @param dec O novo valor para Number.
- @since JDK 1.5
 */
 public void setNumber(BigDecimal dec) throws NumberOutOfRangeException {
 
 // Mantém o valor informado no escopo da classe para utilização posterior
 // pelo método DecimalFormat desta mesma classe.
 valorMonetario = dec;
 
 // Se o valor informado for negativo ou maior que 999 septilhões, dispara uma exceção.
 BigDecimal maxNumber = new BigDecimal(“999999999999999999999999999.99”);
 if ((dec.signum() == -1) || (dec.compareTo(maxNumber) == 1)) {
 throw new NumberOutOfRangeException(
 “\nNao sao suportados numeros negativos ou maiores que 999 septilhoes para a conversao de valores monetarios.” +
 “\nNumeros validos vao de 0,00 até 999.999.999.999.999.999.999.999.999,99” +
 "\nO numero informado foi: " + DecimalFormat()
 );
 }
 
 // Converte para inteiro arredondando os centavos.
 num = dec.setScale(2, BigDecimal.ROUND_HALF_UP).multiply(BigDecimal.valueOf(100)).toBigInteger();
 
 // Adiciona valores.
 nro.clear();
 if (num.equals(BigInteger.ZERO)) {
 // Centavos.
 nro.add(new Integer(0));
 // Valor.
 nro.add(new Integer(0));
 } else {
 // Adiciona centavos.
 addRemainder(100);
```
 // Adiciona grupos de 1000.
 while (!num.equals(BigInteger.ZERO)) {
 	addRemainder(1000);
 }
```
 }
 }
/**
- Seta o atributo Number.
- @param dec O novo valor para Number.
- @since JDK 1.5
 */
 public void setNumber(double dec) throws NumberOutOfRangeException {
 setNumber(new BigDecimal(dec));
 }
/**
- Mostra o valor por extenso no console.
- @since JDK 1.5
 */
 public void show() {
 Iterator valores = nro.iterator();
 
 while (valores.hasNext()) {
 System.out.println(((Integer) valores.next()).intValue());
 }
 System.out.println(toString());
 }
/**
- Mostra o valor monetário formatado pelo International Locale Default.
- @return String O valor monetário (numérico) formatado pelo International Locale Default.
- @since JDK 1.5
 */
 public String DecimalFormat() {
 // A classe Formatter() incluida desde o JDK 1.5.0 tem que ser utilizada devido
 // a class DecimalFormat() não suportar o tipo BigDecimal(),
 // somente o tipo primitivo double.
 // System.out.println(“Numero : " + (new DecimalFormat().format(Double.valueOf(args[0]))));
 Formatter formatter = new Formatter();
 DecimalFormatSymbols sym = new DecimalFormatSymbols();
 Object[] objs = new Object[1];
 objs[0] = valorMonetario;
 formatter.format(”%-,27.2f", objs);
 
 // retorna o número informado no formato de valor monetário,
 // International Locale Default.
 return sym.getCurrencySymbol() + " " + formatter.toString();
 }
/**
- Mostra o valor do número por extenso.
- @return String com o valor do número por extenso.
- @since JDK 1.5
 */
 public String toString() {
 StringBuffer buf = new StringBuffer();
 
 int numero = ((Integer) nro.get(0)).intValue();
 int ct;
 
 for (ct = nro.size() - 1; ct > 0; ct–) {
 // Se ja existe texto e o atual não é zero
 if (buf.length() > 0 && !ehGrupoZero(ct)) {
 buf.append(" e “);
 }
 buf.append(numToString(((Integer) nro.get(ct)).intValue(), ct));
 }
 if (buf.length() > 0) {
 if (ehUnicoGrupo())
 buf.append(” de “);
 while (buf.toString().endsWith(” “))
 buf.setLength(buf.length() - 1);
 if (ehPrimeiroGrupoUm())
 buf.insert(0, “h”);
 if (nro.size() == 2 && ((Integer) nro.get(1)).intValue() == 1) {
 buf.append(” real");
 } else {
 buf.append(" reais");
 }
 if (((Integer) nro.get(0)).intValue() != 0) {
 buf.append(" e ");
 }
 }
 if (((Integer) nro.get(0)).intValue() != 0) {
 buf.append(numToString(((Integer) nro.get(0)).intValue(), 0));
 }
 return buf.toString();
 }
/**
- Identifica se a quantidade de dígitos do primeiro grupo do valor for igual a uma unidade.
- @return boolean true se a quantidade de dígitos do primeiro grupo for igual a 1.
- ```
 <code>false</code> se a quantidade de dígitos do primeiro grupo for maior que 1.
```
- @since JDK 1.5
 */
 private boolean ehPrimeiroGrupoUm() {
 if (((Integer) nro.get(nro.size() - 1)).intValue() == 1)
 return true;
 return false;
 }
/**
- Adiciona uma característica para o atributo Remainder (resto de uma divisão).
- @param divisor A característica a ser adicionada ao atributo Remainder.
- @since JDK 1.5
 */
 private void addRemainder(int divisor) {
 // Encontra newNum[0] = num módulo divisor, newNum[1] = num dividido divisor.
 BigInteger[] newNum = num.divideAndRemainder(BigInteger.valueOf(divisor));
 
 // Adiciona módulo.
 nro.add(new Integer(newNum[1].intValue()));
 
 // Altera número.
 num = newNum[0];
 }
/**
- Identifica se o número possui mais grupos.
- Obs.: Grupos são também conhecidos por casas, assim como, casas decimais,
- ```
 casas de milhar, milhão, bilhão, trilhão, etc.
```
- @param ps posição do dígito no número.
- @return boolean true se a posição do dígito no número conter um valor maior que 1.
- ```
 <code>false</code> se a posição do dígito no número conter um valor igual a zero.
```
- @since JDK 1.5
 */
 private boolean temMaisGrupos(int ps) {
 for (; ps > 0; ps–) {
 if (((Integer) nro.get(ps)).intValue() != 0)
 return true;
 }
 return false;
 }
/**
- Identifica se o grupo corrente é o último a ser convertido por extenso.
- Obs.: Grupos são também conhecidos por casas, assim como, casas decimais,
- ```
 casas de milhar, milhão, bilhão, trilhão, etc.
```
- @param ps posição do dígito no número.
- @return boolean true se a posição do dígito no número conter um valor maior que 1.
- ```
 <code>false</code> se a posição do dígito no número conter um valor igual a zero.
```
- @since JDK 1.5
 */
 private boolean ehUltimoGrupo(int ps) {
 return (ps > 0) && ((Integer) nro.get(ps)).intValue() != 0 && !temMaisGrupos(ps - 1);
 }
/**
- Identifica se o número só possui a casa decimal a ser convertida por extenso,
- além da casa centezimal (dos centavos) obviamente.
- Obs.: Grupos são também conhecidos por casas, assim como, casas decimais,
- ```
 casas de milhar, milhão, bilhão, trilhão, etc.
```
- @return boolean true se a posição do dígito no número conter um valor maior que 1.
- ```
 <code>false</code> se a posição do dígito no número conter um valor igual a zero.
```
- @since JDK 1.5
 */
 private boolean ehUnicoGrupo() {
 if (nro.size() <= 3)
 return false;
 if (!ehGrupoZero(1) && !ehGrupoZero(2))
 return false;
 boolean hasOne = false;
 for (int i = 3; i < nro.size(); i++) {
 if (((Integer) nro.get(i)).intValue() != 0) {
 if (hasOne)
 return false;
 hasOne = true;
 }
 }
 return true;
 }
/**
- Identifica se o número não possui a casa decimal (valor inteiro igual a zero)
- restando apenas a casa centezimal (dos centavos) a ser convertida por extenso.
- Obs.: Grupos são também conhecidos por casas, assim como, casas decimais,
- ```
 casas de milhar, milhão, bilhão, trilhão, etc.
```
- @param ps posição do dígito no número.
- @return boolean true se a posição do dígito no número conter um valor maior que 1.
- ```
 <code>false</code> se a posição do dígito no número conter um valor igual a zero.
```
- @since JDK 1.5
 */
 private boolean ehGrupoZero(int ps) {
 if (ps <= 0 || ps >= nro.size())
 return true;
 return ((Integer) nro.get(ps)).intValue() == 0;
 }
/**
- Converte um número em uma String para identificar o posicionamento de seus dígitos.
- @param numero Parte inteira do número (do valor monetário).
- @param escala Parte centezimal do número (dos centavos).
- @return String O número informado convertido em String.
- @since JDK 1.5
 /
 private String numToString(int numero, int escala) {
 int unidade = (numero % 10);
 int dezena = (numero % 100); // nao pode dividir por 10 pois verifica
 // de 0…19
 int centena = (numero / 100);
 
 StringBuffer buf = new StringBuffer();
 
 if (numero != 0) {
 if (centena != 0) {
 if (dezena == 0 && centena == 1) {
 buf.append(Numeros[2][0]);
 } else {
 buf.append(Numeros[2][centena]);
 }
 }
```
 if ((buf.length() > 0) && (dezena != 0)) {
 	buf.append(" e ");
 }
 if (dezena > 19) {
 	dezena /= 10;
 	buf.append(Numeros[1][dezena - 2]);
 	if (unidade != 0) {
 		buf.append(" e ");
 		buf.append(Numeros[0][unidade]);
 	}
 } else if (centena == 0 || dezena != 0) {
 	buf.append(Numeros[0][dezena]);
 }

 buf.append(" ");
 if (numero == 1) {
 	buf.append(Qualificadores[escala][0]);
 } else {
 	buf.append(Qualificadores[escala][1]);
 }
```
 }
 
 return buf.toString();
 }
/**
- Módulo executor utilizado exclusivamente para testes da classe.
- @param args Número a ser convertido por extenso.
- @since JDK 1.5
 */
 public static void main(String[] args) throws NumberOutOfRangeException {
 if (args.length == 0) {
 System.out.println(“Sintaxe : …Extenso \n\nExemplo: java Extenso 123456789012,34”);
 return;
 }
 
 // Converte do tipo BigDecimal para a String por extenso.
 Extenso teste = new Extenso(new BigDecimal(args[0]));
 
 // Mostra o número informado no formato de valor monetário.
 System.out.println("Numero : " + teste.DecimalFormat());
 
 // Mostra o número informado no formato de valor por extenso.
 System.out.println("Extenso : " + teste.toString());
 }
 }[/code]
 e a classe de exceção:

[code]
package br.com.sitesolutions.financial;

/**

Dispara quando uma aplicação tenta usar um número negativo ou maior que
999 septilhões para valores monetários que deverão ser convertidos para uma
String por extenso usando:
O construtor Extenso(BigDecimal dec) na classe Extenso.
O construtor Extenso(double dec) na classe Extenso.
O método setNumber(BigDecimal dec) na classe Extenso.
O método setNumber(double dec) na classe Extenso.
O método toString() na classe Extenso.

Em conformidade com o release 1.4 do JDK, esta exceção foi reformada para se

adequar ao mecanismo “general purpose exception-chaining” mechanism. A

“exceção opcional que foi disparada enquanto carregando a classe” que deve

ser fornecida em tempo de construção e acessada via o método

{@link #getException()}é agora conhecida como a cause , e deve ser

acessada via o método {@linkThrowable#getCause()}, bem como o mencionado

“método legado.”

@author Site Informmática Ltda

@author Fernando Carvalho Santucci

@version 1.0, 30/09/2004

@see br.com.sitesolutions.financial.Extenso

@since JDK 1.5
/
public class NumberOutOfRangeException extends Exception {
/*

Use serialVersionUID do JDK 1.1.X para interoperabilidade.
Número serial originário da classe Exception.

*/
private static final long serialVersionUID = -3387516993124229948L;

/**

Este campo retém a exceção ex se o construtor
NumberOutOfRangeException(String s, Throwable ex) foi usado para instanciar o objeto.
@serial
@since JDK 1.5
*/
private Throwable ex;

/**

Constrói uma NumberOutOfRangeException sem nenhuma mensagem de detalhe.
@since JDK 1.5
*/
public NumberOutOfRangeException() {
super((Throwable) null); // Impossibilita initCause.
}

/**

Constrói uma NumberOutOfRangeException com a mensagem de detalhe especificada.
@param s A mensagem de detalhe.
@since JDK 1.5
*/
public NumberOutOfRangeException(String s) {
super(s, null); // Impossibilita initCause.
}

/**

Constrói uma NumberOutOfRangeException com a especificada
mensagem de detalhe e opcionalmente a exceção que foi disparada enquanto
convertendo o número.
@param s A mensagem de detalhe.
@param ex A exceção que foi disparada enquanto convertendo o número.
@since JDK 1.5
*/
public NumberOutOfRangeException(String s, Throwable ex) {
super(s, null); // Impossibilita initCause.
this.ex = ex;
}

/**

Retorna a exceção que foi disparada se um erro ocorreu enquanto
tentava converter o número. Caso contrário, retorna null.
Este método precede o mecanismo de "general-purpose exception chaining".
O método {@link Throwable#getCause()} é agora o meio preferido de se obter
esta informação.
@return A Exception que foi disparada se um erro ocorreu enquanto
tentava converter o número.
@since JDK 1.5
*/
public Throwable getException() {
return ex;
}

/**

Retorna a causa desta exceção (a que foi disparada se um erro ocorreu enquanto
tentava converter o número). Caso contrário, retorna null.
@return A causa desta exceção.
@since JDK 1.5
*/
public Throwable getCause() {
return ex;
}
}[/code]
Creditos a Fernando Carvalho Santucci, originalmente postada no RIOJUG

Ironlynx · Junho 19, 2005, 3:11am

NOTA:Eu só postei essa classe por que ela é relativamente fácil de se achar(via google tem algumas variações) e por isso:

Geralmente criticamos os alunos, mas professores q passam tarefas
medíocres/ou impossíveis para quem tah começando, e alguns q ainda retêm conhecimento comum, como se fosse algo especial, merece que todos colem.
Maurício, avisa ao teu professor que a mesma DLL está "digrátis"em
adilson.com.br…

martinezfabio · Junho 19, 2005, 10:22am

Ironlynx valeu pela força, não só eu como a classe toda estavamos com dificuldade de desnvolver esse exercicio. Estamos com um problema serio o nosso professor manja muito Java, só que ele tem dificuldades de explicar deixando tudo muito vago.
Não estou conseguindo absorver nada em sala de aula, então comprei um livro (Java com Programar (Deitel)).Voces conhecem é bom?.
É isso ai,  tive os dois primeiros anos da Faculdade Delphi agora os dois ultimos é Java, estou encontrando muita diferença mas vou fazer de tudo para vence-las
Começando as ferias agora de Julho vou pegar firme no Java porque estou em epoca de provas e não estou conseguindo me dedicar muito.

Obrigado a todos, e agora vou tentar fazer

Tchau

Mauricio_Linhares · Junho 19, 2005, 4:00pm

[quote=Ironlynx]NOTA:Eu só postei essa classe por que ela é relativamente fácil de se achar(via google tem algumas variações) e por isso:

Geralmente criticamos os alunos, mas professores q passam tarefas
medíocres/ou impossíveis para quem tah começando, e alguns q ainda retêm conhecimento comum, como se fosse algo especial, merece que todos colem.
Maurício, avisa ao teu professor que a mesma DLL está "digrátis"em
adilson.com.br… [/quote]

Cara, o pior foi ele ter dito na última aula, que um banco de dados bem modelado não muda nunca. Ele chegou a perfeição :lol:

LuizAvila · Junho 19, 2005, 11:20pm

hauahuahauha.

Pra fechar o Domingo, foi ótima essa Maurício.

O que pode ser considerado um banco de dados bem modelado?

Caras uma vez fiz um esquema desses de extenso em clipper, e daí em diante foi só converter código.

como o Iron disse “conhecimento comum, como se fosse algo especial”

Mauricio_Linhares · Junho 20, 2005, 12:15am

Ora, um banco de dados onde você conseguiu apreender todas as necessidades do seu cliente (atuais e futuras) de uma só vez (na primeira, como ele disse).

Outra coisa massa, foi ele falando de bancos de dados, ele disse que você deve sempre abrir uma nova conexão, carregar todos os dados (Ungh!) fechar a conexão e trabalhar com aqueles dados.

Ele só sabe programar em Delphi e disse que o Paradoxx faz tudo que os outros bancos de dados fazem, só depois de alguns milhões de registros que ele vai começar a ficar lentinho :lol:

Entretanto, ele tem uma “conversa” muito boa e já tem uma clientela forte na cidade, tá com a vida ganha e com certeza não está mais preocupado em aprender coisas novas.

Eu só espero conseguir assustar ele quando ele vir o meu projeto feito em C# (o Delphi 2005 trabalha com o .Net também) e usando um banco orientado a objetos, o DB4O :mrgreen:

vamorim · Junho 20, 2005, 6:18am

[quote=Ironlynx]NOTA:Eu só postei essa classe por que ela é relativamente fácil de se achar(via google tem algumas variações) e por isso:

Geralmente criticamos os alunos, mas professores q passam tarefas
medíocres/ou impossíveis para quem tah começando, e alguns q ainda retêm conhecimento comum, como se fosse algo especial, merece que todos colem.
Maurício, avisa ao teu professor que a mesma DLL está "digrátis"em
adilson.com.br… [/quote]

:shock: Medíocres? Impossíveis? Há 4 anos atrás, quando eu estava no primeiro período da minha graduação, meu professor passou exatamente esse mesmo trabalho. E era para fazer em C++. Na minha turma, quem tentou fazer conseguiu.

Não foi muito fácil, claro. Mas ficou redondinho. Inclusive para aquelas coisas chatas do português:

“Um milhão quatrocentos e cinco mil reais”
“Um milhão e cinco reais”
“Um milhão de reais”

Esse problema é um dos exercícios do Deitel… Claro que hoje, com o conhecimento de linguagens formais e autômatos, esse problema já me é bem mais fácil.

fernandosantucci · Junho 5, 2009, 12:42pm

PessoALL,

Fico feliz que meu código-fonte tenha servido de exemplo para vocês e seja útil no dia-a-dia.

Apesar do Copyright, disponibilizo aqui o código-fonte para uso, seja para fins educacionais ou comerciais, desde que os direitos autorais sejam preservados.

Este código foi utilizado pelo meu Sistema ERP - Enterprise Resource Planning - em diversas indústrias e distribuidores atacadistas por anos em todo território nacional, desde o Ceará até o Rio Grande do Sul. Empresas como FIAT, Bloch Editores, Rede Manchete, Secretaria de Agricultura do Estado do Rio de Janeiro, Prefeitura de São Gonçalo - RJ, bem como alguns sistemas da CEF - Caixa Econômica Federal, e etc.

O Gerador de Valores por Extenso já foi reescrito de outras linguagens, assim como Joiner (Clipper for UNIX), ZIM, Visual Basic v3, v4, v5 e v6 e Java SE v1.5 ou acima.

Venho atuando por anos como Gerente de Projetos e de vez em quando, faço o porte de código legado para Java quando visto o chapéu de Arquiteto de Software e facilito a produtividade da equipe de desenvolvedores em meus projetos.

Já não atuo como programador a mais de uma década, ainda assim nunca tive interesse em código-fechado. Meu lema é OSS - Open Source Software, portanto…

Enjoy It !!!

Cordialmente,

Fernando Santucci

system · Dezembro 23, 2015, 5:22pm

Sera que existe?

Cursos de Mobile

Cursos de Programação

Cursos de Front-end

Cursos de DevOps

Cursos de Design & UX

Cursos de Business

Cursos de Data & BI