Algum empregador sarcástico me pediu para melhorar o Java e, embora eu não seja o presidente da Indonésia, saí rapidamente para ficar acidentalmente intrigado por meio dia. Eu gostaria assim. O princípio geral é a simplificação máxima sem perda de controle lógico. Para isso, obviamente, é necessário não apenas adicionar à linguagem o que não estava lá, mas também remover da linguagem muito do que estava lá, continuando a boa tradição de C--.
- Capacidade de retornar mais de um resultado de uma função.
- Os valores padrão dos campos primitivos devem ser declarados explicitamente. Remova o modificador “estático” do idioma, como estático - a instância padrão, acessível por referência ao nulo digitado. Chame de tudo "instância padrão". A possibilidade do modificador "abstrato" para campos, o que significará a incapacidade de criar uma instância da classe e a necessidade de especificar o valor padrão desse campo no descendente da classe.
- Para os campos "protected", "default" e "public", os setters e getters geram automaticamente pelo compilador, sem geração automática de tipos visíveis, mas com a possibilidade de sobrecarregá-los, remova "private" do idioma, pois os "campos" serão todos "privados" sem capacidades de sobrecarga. Adicione "local" - sobre isso no parágrafo 8.
- Geração automática de interfaces públicas de todos os campos "públicos" da classe, bem como um novo tipo de protegido, etc. interfaces dos campos correspondentes ao modificador. Os tipos de classe são comparados pelo código de hash, que será gerado por nomes de campos, nomes de argumentos, tipos e valores de retorno, pois a probabilidade de tudo isso coincidir é desprezível e pode ser detectada em tempo de compilação com avisos.
Assim, “interface”, como tal, não é mais necessária, apenas “classe”, “abstrato” é apenas uma instrução que proíbe a criação de uma instância. Para herança múltipla, consulte o próximo parágrafo 5. - Adicionando regras de mesclagem para "estende". Especifique explicitamente o ancestral para todos os campos conflitantes, que serão indistinguíveis dos métodos, mais sobre isso na cláusula 8. Como resultado, o objeto herdará o código e implementará todos os tipos pai. Os tipos que não são totalmente preservados como resultado da mesclagem simplesmente desaparecem dos ancestrais formais, deixando o código, mas criando um erro de compilação ao tentar usar incorretamente o objeto.
- Tipos dinâmicos. Os modelos estão em C e não como modelos baseados em Java. A digitação não sofrerá com isso, uma vez que tipos dinâmicos não podem ser usados diretamente em amostras, mas podem ser usados em todos os casos em que tipos básicos, reflexão ou modelos são usados, nos quais também não é difícil organizar o re-planejamento expandindo o tipo de instância diretamente para o tempo de execução, sendo proibida a restrição.
- Sub-métodos como em Pascal.
- Todos os métodos são instâncias padrão completas das classes internas e são indistinguíveis dos campos. Para isso, o construtor da classe retornará um valor. O construtor da classe será o corpo do método padrão que será criado no momento da compilação, de acordo com a cláusula 2 "instâncias padrão". Nenhuma referência especial a métodos será mais necessária, como no Java 8. Uma referência a métodos significará uma referência a objetos.
A chamada de método e a criação de um objeto temporário apenas para chamar o método interno tornam-se idênticas, tudo isso pode ser otimizado pelo compilador como uma chamada de método simples. Por outro lado, criar um "método" com o operador "novo", para manipulações subsequentes com uma referência a ele, significa criar uma nova instância da "classe". Atribuindo uma referência a uma função a um campo diretamente através do nome do método sem colchetes, valores da função com colchetes e argumentos neles. Os campos com o modificador "local" não são salvos entre chamadas de método.
Todos os mesmos métodos com diferentes conjuntos de argumentos devem ser agrupados em uma subclasse, para que seja interessante agrupar a classe externa. Os campos padrão desta subclasse tornam-se, respectivamente, não absolutamente estáticos, mas estáticos em relação à classe externa. Exceto quando a própria classe externa é a instância padrão. - Em vez de "try" - "catch", também existem métodos, "throws" identifica o tipo permitido do método de chamada, "throw" faz goto no método do manipulador, cortando a pilha de chamadas, e os métodos do manipulador não são diferentes, o retorno deles é realizado da maneira usual, mas , acontece que em um dos métodos de chamada anteriores. Assim, um manipulador é chamado no nível de hierarquia mais próximo, como é o caso do try-catch. Portanto, para pular um determinado código após um determinado método no caso de uma exceção, você precisa colocar esse código, com esse método no início, em uma classe submethod na qual sobrecarregar os manipuladores necessários. Essa abordagem reduzirá significativamente os métodos longos, para dizer o mínimo, de projetos reais em Java.
"Finalmente" para adicionar um peso ao método no final, para que sem colchetes extras. - Um novo operador para o tempo de execução, criptografando todos os tipos de primitivas e matrizes de campos primitivos e String e compactando-os na memória para recuperação subsequente deles com uma chave de acesso, em massa para toda a instância da classe. Desejar diretamente descompactar-usar-pacote em um método, em vez de coçar a cabeça "como fazê-lo melhor".
- As matrizes precisam de controle de borda apenas durante a gravação, e eu daria a oportunidade de ler diretamente da memória sem controlar os limites da matriz. Assim, dada a existência de System.arraycopy, os limites da matriz serão monitorados sem sacrificar o desempenho. Como a maioria dos cálculos adicionais é realizada com mais freqüência durante a gravação e, comparada com eles, a gravação em si não leva muito tempo.
- Fornecer uma alternativa básica adicional à sincronização por bloqueadores é o método mais simples da classe Thread que envia mensagens personalizadas para outro Thread e o método pelo qual você pode receber mensagens personalizadas de outro Thread. Além disso, no método "run" do objeto Runnable, passado para o Thread, é necessário chamar explicitamente o método que interrompe o thread e sem um erro de compilação. Além disso, adicione um método que dispara eventos Runnable personalizados de outros threads, recebe e envia mensagens sempre após essa interrupção. Tudo isso fundamentalmente não muda nada, mas simplifica o desenvolvimento orientado a threads em 90% dos casos. Especialmente nos casos em que o desenvolvimento está com pressa, e essa é a maioria dos casos reais.
- De fato, o gráfico de todos os objetos na memória sempre tem apenas tipos primitivos, matrizes ou nulos ou um link para algo nativo em todos os seus vértices. Uma ferramenta básica que pode salvar todo o gráfico em qualquer formato de texto será muito útil. Grandes matrizes de primitivas podem ser armazenadas separadamente, pequenas matrizes podem codificar em linha. Além da versão da máquina virtual e - vamos lá, essa estrutura pode ser restaurada na memória.
- Uma ferramenta útil para procurar objetos no gráfico de objetos de acordo com os critérios especificados, levando em consideração os modificadores de acesso, pelo tipo de SQL simples. Esta tarefa é bastante simplificada usando os parágrafos 1 ... 9. Essa ferramenta pode não apenas simplificar a hierarquia de objetos, mas também organizar vários testes e controle de valores permitidos e tentar alcançar o Prolog.