Índice
Lista simples e clara, tipo de mapa
Tudo no mundo groovy é um objeto
A manipulação de atributos ficou mais fácil
verificação de tipo obrigatória
Por que aprender Groovy
Como um programador baseado em Java, o Groovy tem uma vantagem única em compatibilidade como linguagem de script (linguagem dinâmica) na plataforma Java. Os alunos que tiveram contato com o desenvolvimento do Aandroid já tiveram contato com o projeto de construção Gradle (a construção Gradle também suporta a construção de projetos Java) Gradle é um framework para construção de projetos implementados usando Groovy. Além disso, a nova versão do idea recomenda o uso do Gradle para desenvolvimento de plug-ins. Obviamente, o que foi dito acima é apenas uma explicação objetiva da tendência de desenvolvimento da tecnologia Groovy (incluindo, mas não se limitando a esses aspectos) para ilustrar que precisamos aprender, de nosso próprio nível, aprender mais e se beneficiar mais, ou alunos que tenham habilidades técnicas perseguições ou ideais técnicos, saiba mais A tecnologia de portas também é uma melhoria para si mesmo. Em seguida, vamos entrar juntos no mundo do Groovy.
Introdução ao Groovy
Apache Groovy é uma linguagem poderosa, opcionalmente tipada e dinâmica com tipagem estática e compilação estática para a plataforma Java, projetada para aumentar a produtividade do desenvolvedor por meio de uma sintaxe concisa, familiar e fácil de aprender. Ele se integra perfeitamente a qualquer programa Java e fornece imediatamente ao seu aplicativo recursos poderosos, incluindo recursos de script, autoria de linguagem específica de domínio, metaprogramação em tempo de execução e tempo de compilação e programação funcional.
- site oficial do Groovy
A descrição acima é a introdução do site oficial. Meu entendimento popular pessoal é o seguinte: Groovy é uma linguagem ágil e dinâmica para a máquina virtual Java, uma linguagem de programação madura orientada a objetos e uma linguagem de script pura. O Groovy é executado no ambiente JVM e possui as características da linguagem java e da linguagem de script na sintaxe, o que simplifica bastante a sintaxe. Ao mesmo tempo, possui fechamentos e outras funcionalidades em linguagens dinâmicas, que compensam o dinamismo que o código Java puro não possui.Podemos modificar a lógica do código arbitrariamente enquanto o programa está rodando sem precisar reeditar.
Groovy 1.0 foi lançado em 2 de janeiro de 2007. Groovy é lançado sob a Apache License v 2.0. O site oficial do Groovy é a linguagem de programação Apache Groovy
Recursos interessantes
O Groovy tem os seguintes recursos (documentação da API do site oficial: A linguagem de programação Apache Groovy - Groovy Development Kit ):
- Groovy é uma linguagem de script orientada a objetos baseada na máquina virtual Java e suporta tipagem estática e dinâmica.
- Groovy é fácil para desenvolvedores Java porque a sintaxe de Java e Groovy é muito semelhante e as bibliotecas Java existentes podem ser usadas.
- A sobrecarga do operador é suportada.
- Listas de sintaxe nativa e matrizes associativas.
- Suporte nativo para expressões regulares.
- Várias linguagens de marcação, como XML e HTML, são suportadas nativamente.
- Groovy estende java.lang.Object.
Groovy em ação
tipo dinâmico
O primeiro recurso do groovy é o recurso dinâmico. Depois de definir uma variável, você pode atribuir qualquer tipo de valor à variável; o groovy fornece esse método de suporte, mas para bons hábitos de codificação, devemos encerrar esse método de desenvolvimento.
def v = 0;//定义了数值类型的变量v
v = new Date();//然后又给它赋与Date类型的值.
println(v);Lista simples e clara, tipo de mapa
Podemos usar groovy para definir estruturas de dados de lista e mapa de forma simples e clara. Ao contrário do Java China, onde temos que definir um tipo antes de atribuir um valor, o Groovy pode usar diretamente o açúcar sintático para atribuir um valor rapidamente. Consulte os exemplos de código a seguir para obter detalhes. Somente APIs típicas são listadas para ilustração de conceito. Se você estiver interessado nas APIs restantes, pode tentar praticar por conta própria.
- Use "[]" para definir a lista de lista e operar diretamente nela
// list 可以看到的是编译器帮我们作何类型识别
def list = [1, 2]
// 这个是groovy的list的API从左边插入一个记录
list.leftShift(3)
// push是从插入到列表前面
list.push(0)
// add和我们java的List一样是追加到最后
list.add("abc")
// groovy中的<<可以对list数据类型的作用添加值，也是追加到最后面，需要注意的是在数字类型时是位运算操作
list << "<<号";
// "+"在groovy的语法中也是追加元素到集合中，并且是追加到最后
list += "加上+="
// 查看打印结果可以看到我在每个API的功能描述上的说明
// [0, 1, 2, 3, abc, <<号, 加上+=]
println(list)
// 也可以采用 lambda 表达式遍历集合
list.forEach({ println(it)})- Use ":" para separar a chave e o valor para definir os dados do mapa, a chave não precisa ser colocada entre aspas e a chave pode ser usada para ler e gravar diretamente no mapa
def map = [a: 2, b: new Date()];
// 写入 直接追加到map集合中
map.put("aaaa","bbb")
println(map)
// 写入 直接采用Map的key进行操作
map.a = "a value change"
println(map)
// 结果如下 可以看到 key 为 "a" 的value被改变
[a:2, b:Sun May 28 11:19:56 CST 2023, aaaa:bbb]
[a:a value change, b:Sun May 28 11:19:56 CST 2023, aaaa:bbb]Tudo no mundo groovy é um objeto
Como entender os conceitos acima Comparado com a linguagem Java, todos nós sabemos que na linguagem Java, tipos básicos e tipos de referência são tratados de forma diferente. Tipos primitivos não têm chamadas de método porque tipos primitivos são acessados por valor, e Groovy é mais uma linguagem orientada a objetos do que Java nesse aspecto.
// 在groovy中，一切都是对象。一切都可以当成对象来使用；
// 即使在Java中的基本类型也更像是一个对象
100.times {println("hello world")}A manipulação de atributos ficou mais fácil
Ao contrário do Java, para operar as propriedades de um objeto, você deve usar os métodos get e set, mesmo que as propriedades sejam definidas como privadas. No groovy, para definir um javabean, não é mais necessário escrever métodos getter e setter. Você pode usar diretamente o "." para operar os atributos de leitura e gravação.
class JavaBeans {
String a
// 即使是定义成private 也可以直接访问
// private String a
}
def beans = new JavaBeans();
beans.a = "object set property value"
println(beans.a)GString
GString é uma ferramenta fornecida pelo Groovy para processamento rápido de strings. A string entre aspas duplas "" pode embutir variáveis diretamente de forma simples e clara através de $var ou ${var}. E GStrng chamará o encerramento que o contém, e GString sem parâmetros chamará o encerramento e imprimirá o resultado que esperamos para o Writer.
// case1
def a = "a"
def b = "b"
// a=a,b=b 快速替换字符串变量
println("a=${a},b=$b")
// case2
def name = 'lly'
def hello = "hello $name !"
// 结果：hello lly ! 快速替换字符串变量
println hello
// 注意这一行
name = '阳仔'
// 结果：hello lly !
println hello
// case3 ：GStrng会调用包含的闭包 无参GString会调用闭包并打印我们期待的结果到Writer
def quote = "${-> name} , welcome"
// 结果：阳仔 , welcome
println quote
// 注意这一行
name = 'lisi'
// 结果：lisi , welcome
println quoteFecho
Um encerramento em groovy pode ser visto como um bloco de código, que pode não ter parâmetros e valores de retorno; é como a sintaxe lambda acima de java8 ou como uma classe interna java com um método (aqui é semelhante à definição de especificação de programação funcional). Variáveis incorporadas implícitas em encerramentos groovy, por meio das quais variáveis podemos fazer coisas para obter operações de elementos individuais. Tais como iteração, julgamento e outros negócios.
it: Quando nenhum parâmetro é definido no método de fechamento, a variável it também pode ser usada diretamente;
this: Igual a isso em java;
owner: basicamente o mesmo que este, exceto que em um caso, se o encerramento estiver definido em outro encerramento, o proprietário aponta para o objeto encerramento que o define.
// 闭包中内置了很多迭代方法，如find、findAll、collect等等。这里需要注意的是内置对象 it 的使用
def list = ['foo', 'bar']
def newList = []
list.collect(newList) {
it.toUpperCase()
}
// 结果：[FOO, BAR]
println newList
//或者
list = ['foo', 'bar']
newList = []
list.collect(newList, {
it.toUpperCase()
});
// 结果：[FOO, BAR]
println newList
// 在groovy闭包中的隐含内置变量
def a = {
println "a this:" + this
println "a owner:" + owner // ower指向b
def b = {
println "b this:" + this
println "b owner:" + owner // ower指向b
}
b.call()
}
a.call()
// 结果：这里可以看到 this 和 owner 异同
a this:script.GroovyDemo1@78b236a0
a owner:script.GroovyDemo1@78b236a0
b this:script.GroovyDemo1@78b236a0
b owner:script.GroovyDemo1$_run_closure3@304b9f1aDelegação: delegado
O delegado no Groovy é basicamente o mesmo que o proprietário, exceto que ele delega para o novo objeto por meio de Closure.setDelegate().
def scriptClosure = {
println "scriptClosure this:" + this
println "scriptClosure owner:" + owner
println "scriptClosure delegate:" + delegate
}
println "before setDelegate()"
scriptClosure.call()
scriptClosure.setDelegate("lly")
println "after setDelegate()"
scriptClosure.call()
// 结果：
scriptClosure this:script.GroovyDemo1@5c371e13
scriptClosure owner:script.GroovyDemo1@5c371e13
scriptClosure delegate:script.GroovyDemo1@5c371e13
after setDelegate()
scriptClosure this:script.GroovyDemo1@5c371e13
scriptClosure owner:script.GroovyDemo1@5c371e13
scriptClosure delegate:llyMudar ficou mais simples
A opção no Groovy pode permitir que expressões como listas, objetos, intervalos, etc. sejam usadas como base de caso
def x = 20;
switch (x) {
case [1, 2, 3, 4, 5]:
println("aaaaaa")
break;
case "foo":
println("bbbbb")
case 10..1000:
println("ccccc")
break;
case Date:
println("dddddd")
break;
}
// 结果： 因为 20 在 10到1000 的范围内
cccccmetaprogramação
No Groovy, você pode usar a classe metaClass para adicionar propriedades e métodos a objetos meta. A razão é que no Groovy, se o seu objeto usar um método que não foi definido por ele, ele não reportará um erro, pelo menos não reportará um erro ao compilar, devido ao mecanismo especial de tempo de execução do Groovy. Quando você chama um método de um objeto, ele primeiro verificará se a propriedade e o método estão definidos na classe. Caso contrário, você irá para MeteClass para encontrá-lo.Em Java, todas as classes irão integrar Object, enquanto em Groovy, todas as classes herdarão GroovyObject, e esta classe possui um método para obter MeteClass. Dessa forma, você pode adicionar dinamicamente propriedades e métodos a objetos durante a operação, até mesmo métodos estáticos. Se este método não estiver definido em MeteClass, é necessário descobrir se os métodos methodMissing e invokeMethod são implementados na classe de entidade por sua vez, e um processamento especial pode ser feito nesses dois métodos.
// 基本元编程
// 对String类，添加一个uppers方法
String.metaClass.uppers = { -> toUpperCase() };
println "aaa".uppers()
//结果：AAA
// 对Interger类，添加一个say方法
Integer.metaClass.say = { -> "I am Interger" }
def i = new Integer(100);
println i.say()
// 结果：I am Interger
// 给对象添加属性、方法、静态方法
class Person {
String name;
Integer age;
String eat() {
println(name + "like eat")
}
}
def p = new Person(name: "阳仔", age: 18)
p.eat()
// 给对象添加属性
p.metaClass.sex = '男'
// 给对象添加方法
p.metaClass.drink = {
-> println "喜欢喝饮料"
}
// 给对象添加静态方法
p.metaClass.static.play = {
-> println "喜欢玩游戏"
}
println "${p.name}，今年${p.age}岁了，性別是${p.sex}"
p.drink()
p.play()
// 结果
阳仔like eat
阳仔，今年18岁了，性別是男
喜欢喝饮料
喜欢玩游戏verificação de tipo obrigatória
Em nosso aprendizado anterior, descobrimos que Groovy é uma verificação de tipo fraca. Seja uma variável ou uma coleção, ela pode receber qualquer tipo de dado. Se quisermos restringir um determinado tipo em alguns cenários, devemos usar o @ Anotação TypeChecked Divirta-se reforçando a verificação de tipo. No encerramento, se você precisar de verificação de tipo forte, poderá definir o tipo de parâmetro como a sintaxe java.
class Foos{
int i = 42.0; //编译通过
}
@TypeChecked
class Foo{
int i = 42.0; //编译不通过
}
//在闭包中，如果需要强类型检查，可以像java语法一样定义参数类型
def list = ["a","b","c"]
// 编译不通过
//def list = ["a","b","c", 1]
list.collect {
String it -> it.toUpperCase()
}
println(list)Operador Elvis
Groovy adota a operação Elvis Operator para simplificar ainda mais o operador ternário.
def a = null;
// 在定义b变量时，先判断a是否有值，如果有，就取a的值作为b的值，否则就取值"b"
def b = a ?: "b";
println(b)acesso seguro
É o mesmo que o julgamento vazio em nosso Java, mas é mais conciso.
def person;
//先判断person是否为不为null,然后，再调用getName方法
String name = person?.getName();
println(name)