分类 - 编程之路

2020-09-19 18:13:58    3    0    0

使用go mod来管理项目,完全忽略掉GOPATH的存在,测试版本go1.15

一. 启用GO111MODULE并设置代理

  1. $ go env -w GO111MODULE=on
  2. $ go env -w GOPROXY=https://goproxy.cn,direct
  3. # 设置完成以后查看
  4. $ go env
2020-03-14 12:18:57    31    0    0

一. 导入通配符

*号在Java中是导入通配符,但是在Scala中是合法的方法名,所以导入包时要使用_代替。

import java.util._


二. 类成员默认值

Java中类成员可以不赋初始值,编译器会自动帮你设置一个合适的初始值,而在Scala中必须要显式指定,可以用 _ 让编译器自动帮你设置初始值,注意: 该语法只适用于类成员,而不适用于局部变量。

class Fo
2020-03-12 18:56:36    55    0    0

函数内定义函数

和Python一样,也可以在函数内部定义新的函数,新函数的作用域只在当前函数有效

def calcSalary() = {
    def getSalary() = {
        10000
    }
    getSalary * 1.1
}

println(calcSalary)

函数作为参数

val n = List(-11, -10, -5, 0, 5, 10)

// 返回大于 0 的数据
n.filter((x: Int) => x > 0)

// 返回大于 0 的数据
n.filter((x) => x > 0)

// 返回大于 0 的数据:效果同上,简写版本
n.filter(_ > 0)

// 简版的函数定义,这里的待填空下划线必须给定类型,否则报错。
val f=(_: Int) + (_: Int)
f(3,4)
res4: Int = 7

部分应用函数

部分应用函数,简单的来说,其实就是先给函数提前确定一些参数的值,这样一来就形成了新的函数,新函数里面会去调用原来的函数,传入原来格式的参数。

// 当你这样使用下画线时,实际上是在编写一个部分应用的函数(partially applied function)。在Scala中,当你调用某个函数,传入任何需要的参数时,你实际上是应用那个函数到这些参数上
val n = List(-11, -10, -5, 0, 5, 10)
n.foreach(println _)

// 部分应用的函数是一个表达式,在这个表达式中,并不给出函数需要的所有参数,而是给出部分,或完全不给。举例来说,要基于 sum创建一个部分应用的函数,假如你不想给出三个参数中的任何一个,可以在"sum"之后放一个下画线。这将返回一个函数,可以被存放到变量中。
def sum(a: Int, b: Int, c: Int) = a + b + c
val a = sum _
a(1, 2, 3)
res1: Int = 6

// 背后发生的事情是:名为a的变量指向一个函数值对象。这个函数值是一个从Scala编译器自动从sum _ 这个部分应用函数表达式生成的类的实例。由编译器生成的这个类有一个接收三个参数的apply方法。生成的类的apply方法之所以接收三个参数,是因为表达式sum _缺失的参数个数为3
2020-02-20 23:54:44    35    0    0

赋值语句返回值

在Java中,赋值语句的结果是被赋上的值(在本例中就是从标准输入读取的一行文本),而在Scala中赋值语句的结果永远是单元值()。因此,赋值语句"line=readLine()"将永远返回(),而不是""。这样一来,while循环的条件检查永远都不会为false,循环将无法终止。

while ((line=readLine()) != "")
    println("go
2020-02-19 13:37:23    32    0    0

Rational类的规格定义

有理数(rational number)是可以用比例表示的数,比如 1/2 4/5等等,其中包含了分子(numerator)分母(denominator)。跟浮点数相比,有理数的优势是小数是精确展现的,而不会舍入或取近似值。本章节会设计一个有理数的对象,它包括了一些常用的功能。

 

Rational对象是不可变的,每一个有理数都会有一个Rational对象

2020-02-18 00:06:17    39    0    0

Scala基础类型 

Scala中以 0x 或者 0X开头的是十六进制,可以包含0到9以及大写或小写的A到F表示的数字,注意:Scala的shell总是以十进制打印整数。

 

Scala的3引号和Python的类似,但是Scala可以去除开始的空格,用法如下:

scala> """
     | where are you
     | hahahaha
     | 
2020-02-17 00:11:44    47    0    0

 类、字段、方法

在类中,通过 val 或者 var 定义的字段是指向对象的变量,def 定义的方法包含可执行代码。标记私有防止外部直接访问字段:private var sum = 0  。在 Scala 中 默认就是public的,比如ChecksumAccumulator.scala

class ChecksumAccumulator {
    private var sum = 0
2020-02-16 19:23:24    42    0    0


Scala的解释器执行结果被存在了类似 res0 的val值里面,可以再次调用 res0。

 

定义函数

def max(x: Int, y:Int): Int = {
    if (x > y) x
    else y
}

 Scala方法参数的一个重要特征是它们都是 val 而不是 var。

 

Scala脚本

在Scala 脚本中,args是一个字符串类型的

2020-01-30 22:37:44    148    0    0

Java从8开始,不但引入了Lambda表达式,还引入了一个全新的流式API:Stream API。它位于java.util.stream包中。这个Stream不同于java.io的InputStream和OutputStream,它代表的是任意Java对象的序列,它类似Python中的迭代器。

一. 创建Stream

1.1 Stream.of()

创建Stream最简单的方式是直接用Stream.of()静态方法,传入可变参数即创建了一个能输出确定元素的Stream,虽然这种方式基本上没啥实质性用途,但测试的时候很方便。

  1. import java.util.stream.Stream;
  2. public class Main {
  3. public static void main(String[] args) {
  4. Stream<String> stream = Stream.of("A", "B", "C", "D");
  5. stream.forEach(System.out::println);
  6. }
  7. }


2020-01-29 19:37:04    47    0    0

反射就是Reflection,Java的反射是指程序在运行期可以拿到一个对象的所有信息。


一. 类的加载

1.1 加载的流程

class是由JVM在执行过程中动态加载的。JVM在第一次读取到一种class类型时,将其加载进内存。Java的所有类都是一个叫做Class的类的一个实例,Class类大概如下所示。每加载一种classJVM就为其创建一个Class类型的实例,并关联起来。注意:这里的Class类型是一个名叫Classclass

  1. public final class Class {
  2. private Class() {}
  3. }

注意JVM在执行Java程序的时候,并不是一次性把所有用到的class全部加载到内存,而是第一次需要用到class时才加载。