<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[ALAN的专栏]]></title><description><![CDATA[梦想需要一步一步的去实现]]></description><link>https://blog.youkuaiyun.com/ymingw</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; ymingw]]></copyright><item><title><![CDATA[Java远程对象调用 RMI]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48626537</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48626537</guid><author>ymingw</author><pubDate>Mon, 21 Sep 2015 14:58:38 +0800</pubDate><description><![CDATA[对RMI的学习已经过去了3天时间，概念很简单，但是在使用过程中总是遇到这样那样的问题，也再次从一个侧面证明了，技术的学习一定要通过真实环境的测试，否则知其然不知其所以然也是没有办法在生产环境中来使用的，下面对rmi的原理与问题进行分析。
 
下面的描述部分内容收集来自互联网.


黑体部分是我加注并需要注意的
 
RMI（即Remote Method Invoke 远程方法调用）。在]]></description><category></category></item><item><title><![CDATA[scala学习笔记（十七） Actor]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48626517</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48626517</guid><author>ymingw</author><pubDate>Mon, 21 Sep 2015 14:57:19 +0800</pubDate><description><![CDATA[Actor模型框架是我最早学习scala的主要目标，通过actor消息驱动式编程可以更加方便的实行各种多线程与异步处理。
 
package demo
 
importjava.awt.image.BufferedImage
importscala.collection.mutable.ArrayBuffer
importscala.util.Random
importcom.typ]]></description><category></category></item><item><title><![CDATA[scala学习笔记（十六） 类型参数与隐式转换]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48626479</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48626479</guid><author>ymingw</author><pubDate>Mon, 21 Sep 2015 14:56:15 +0800</pubDate><description><![CDATA[Scala中的类型参数晦涩难懂，不过有几个基本要点可以记录
 
T

上界，通俗理解T是UpperBound的子类
T >: LowerBound
下界，通俗理解为T为LowerBound的超类
T <% Comparable[T]
视图界定，简单理解为，T可以通过隐式转换为后者
T : Ordering
上下文界定，必须存在一个类型为Ordering[T]的隐式值，这里还没有]]></description><category></category></item><item><title><![CDATA[scala学习笔记（十五） 高等类型]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48626455</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48626455</guid><author>ymingw</author><pubDate>Mon, 21 Sep 2015 14:54:03 +0800</pubDate><description><![CDATA[类或特质可以定义一个在子类中被具体化的抽象类型，如下：
 trait Reader {
    type Contents //这里定义一个抽象类型，子类中必须指定这个类型
    def read(fileName: String): Contents
  }
 
  class StringReader extends Reader {
    type Contents = S]]></description><category></category></item><item><title><![CDATA[scala学习笔记（十四） 注解]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48523339</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48523339</guid><author>ymingw</author><pubDate>Thu, 17 Sep 2015 16:18:12 +0800</pubDate><description><![CDATA[Scala中移除了一些关键字改用注解来表示
@volatile,@transient ,@strictfp ,@native
Scala中没有首检异常，使用@throws来与java兼容
例如：
class Book{

@throws(classOf[IOException]) defread(fileName : String){ … 
}

}

 
Scala中有很]]></description><category></category></item><item><title><![CDATA[scala学习笔记（十三） 模式匹配与样例类]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48523271</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48523271</guid><author>ymingw</author><pubDate>Thu, 17 Sep 2015 16:14:25 +0800</pubDate><description><![CDATA[如果要问scala的核心类容是什么，以我接触的情况来看，模式匹配与样例
绝对是核心中的核心
 
因为scala是运行与JVM的，所以我们很多时候不自觉的会将他与java来进行比较，但是在这章之前它除了提供了一些让代码看起来更加简洁的语法糖外（语法糖大部分情况下可以被高级IDE弥补），似乎只有函数参数比较吸引人，而函数参数使用上面其实和C++的函数指针也是比较类似的，所以结论是，前面的都是sc]]></description><category></category></item><item><title><![CDATA[scala学习笔记（十二） 集合]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48523189</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48523189</guid><author>ymingw</author><pubDate>Thu, 17 Sep 2015 16:09:24 +0800</pubDate><description><![CDATA[Scala
的集合分为三大分支
序列 
集 
映射
 
1、所有集合都扩展自Iterable
特质
2、几乎所有的集合都分为可变与不可变版本
3、集（Set）
不保证插入顺序的
4、使用 +
来添加元素， -
来移除元素
，+:
添加到头部，:+
添加到尾部， ++
用来将两个集合拼接， --
移除后面集合的所有元素
5、scala
的集合中已经包含了很多内]]></description><category></category></item><item><title><![CDATA[scala学习笔记（十一） 高阶函数]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48494523</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48494523</guid><author>ymingw</author><pubDate>Wed, 16 Sep 2015 15:14:21 +0800</pubDate><description><![CDATA[Scala作为函数式语言，函数自然是头等公民…
 
一个接收函数作为参数的函数称为高阶函数
比如定义如下：
defvalueAtOneQuarter(f: (Double) => Double) = f(0.25)
这个函数接收一个参数为Double返回值为Double的函数作为参数。
 
高阶函数还可以是返回一个函数作为参数的函数，如下
defmulBy(factor : Dou]]></description><category></category></item><item><title><![CDATA[scala学习笔记（十） 操作符]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48494465</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48494465</guid><author>ymingw</author><pubDate>Wed, 16 Sep 2015 15:13:06 +0800</pubDate><description><![CDATA[操作符的规则大体和其他语言差不多，有几个需要说明的：
1、由于scala中允许运算符重载，所以当你看到一起奇怪的运算符的时候不要奇怪，这些都是方法调用而已
2、方法调用的.操作符很多时候可以不写，而是用空格的方式，另外对于无参方法你也可以不写()，但是有一个比较通用的规则是，对于没有返回值的方法还是写上()
3、scala中的几个特殊方法apply,update,unapply,unappl]]></description><category></category></item><item><title><![CDATA[scala学习笔记（九） 特质]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48494385</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48494385</guid><author>ymingw</author><pubDate>Wed, 16 Sep 2015 15:06:50 +0800</pubDate><description><![CDATA[要点：
类可以实现任意数量的特质
特质可以提供实现
当一个类实现多个特质的时候，顺序很重要 ——其方法需要被先执行的特质应该放在越后面
 
注意1：
因为scala中一个类可以实现多个特质，然而特质中的又可以提供实现，所以就存在了c++中多继承的问题，究竟是调用哪一个的问题。Scala中的解决办法是如果一个类扩展多个特质，并且有冲突的方法实现，那么扩展类必须重写该方法，你可以在扩展类中]]></description><category></category></item><item><title><![CDATA[scala学习笔记（八） 文件与正则表达式]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48464877</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48464877</guid><author>ymingw</author><pubDate>Tue, 15 Sep 2015 11:10:58 +0800</pubDate><description><![CDATA[Scala中只提供字符流读取方式，其他读取需要使用java中的类。
如果是字符文件读取，可使用下面的方式
 
valsource = Source.fromFile("file.txt","UTF-8")
val lines= source.getLines
 
如果需要将文件读成一个字符串，则可以使用
source.mkString
 
正则表达式
""" """
在sca]]></description><category></category></item><item><title><![CDATA[scala学习笔记（七） 继承]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48464831</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48464831</guid><author>ymingw</author><pubDate>Tue, 15 Sep 2015 11:08:56 +0800</pubDate><description><![CDATA[Scala在继承上面与java的一些差别：
1、scala重写一个非抽象方法必须加
 override关键字
2、只有主构造器可以调用父类的主构造器
 
类型检查与使用上，不再是使用java的
 instanceOf来判断了，而是使用
isInstanceOf来进行判断对象，使用asInstanceOf来转换对象，例如：
If(p.isInstanceOf[A]){

val ]]></description><category></category></item><item><title><![CDATA[scala学习笔记（六）包与引入]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48464781</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48464781</guid><author>ymingw</author><pubDate>Tue, 15 Sep 2015 11:06:59 +0800</pubDate><description><![CDATA[1、Scala中包可以嵌套
包的引入可以使用相对路径，但是这里会造成一些问题，就是在包嵌套中，如果出现了和默认包scala包（默认被引入）中同名包的时候，就会造成一些混乱
 
如果要使用绝对路径引入包，需要以_root_开始，例如
val sub =new _root_.scala.collection.mutable.ArrayBuffer[String]
 
Scala
包在引入]]></description><category></category></item><item><title><![CDATA[scala学习笔记（五） 类]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48464751</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48464751</guid><author>ymingw</author><pubDate>Tue, 15 Sep 2015 11:05:38 +0800</pubDate><description><![CDATA[要点包括：
类中的字段都自动带有getter
和
setter方法
每个类都有一个主要的构造器，这构造器和类的定义写在一起，这个构造器的参数会直接成为类的字段，如下

class Point(x:Int,y:Int){

}
这样默认Point类就具备了x，y两个字段了，并且默认是val(不可修改)

 
调用类中的无参方法，可以写上后面的圆括号，也可以不写，一般来说入sc]]></description><category></category></item><item><title><![CDATA[scala学习笔记（四） 映射与元组]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48464575</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48464575</guid><author>ymingw</author><pubDate>Tue, 15 Sep 2015 10:52:52 +0800</pubDate><description><![CDATA[scala中的map可以使用mapValues.map(推导式)
来批量修改值
 
 
scala中有自带的可变集合与不可变集合，java集合在scala中也可以使用
 
不可变集合在
immutable
包中
可变集合在mutable包中

 
元组(tuple)
是不同类型的值的聚集，包括但不限于对偶（键值对）

 
使用拉链操作(zip)
可以将几个独立的集]]></description><category></category></item><item><title><![CDATA[scala学习笔记（三）数组]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48464373</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48464373</guid><author>ymingw</author><pubDate>Tue, 15 Sep 2015 10:42:18 +0800</pubDate><description><![CDATA[要点：
1、若长度固定则使用Array，若长度可能有变化则使用ArrayBuffer
2、如果提供了初值则不使用new
3、用()来访问元素
4、用 for(elem
 来遍历元素
5、用 for(elem
  …) … yield …来产生新数组
6、与java的互操作使用scala.collection.JavaConversions中的转换函数
 


如果要从数组的]]></description><category></category></item><item><title><![CDATA[scala学习笔记（二） 控制语句]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48464247</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48464247</guid><author>ymingw</author><pubDate>Tue, 15 Sep 2015 10:41:02 +0800</pubDate><description><![CDATA[Scala的大部分表达式都有返回值，所以可以将表达式负值给其他变量或者作为参数传递
 
如果一个表达式或者函数没有输出值则由系统默认返回一个Unit作为占位，表示为()，你可以在print中打印出来看。
 
传统其他语句的赋值如

x=y=1
 
这样的语句在scala里面得到的结果不是你想要的，这个语句的结果是y=1，但是x=()，也就是Unit。
 
Scala的高级for]]></description><category></category></item><item><title><![CDATA[Scala学习笔记（一） 基础类型]]></title><link>https://blog.youkuaiyun.com/ymingw/article/details/48464189</link><guid>https://blog.youkuaiyun.com/ymingw/article/details/48464189</guid><author>ymingw</author><pubDate>Tue, 15 Sep 2015 10:34:07 +0800</pubDate><description><![CDATA[今天开始准备学习scala。

 

 
一、Scala中类与伴生类的关系:

 

类与java中类似，伴生类者更加类似于java静态类

 
伴生类中的apply方法默认是可以不用写出的,如：
 
System("1")
等于调用 System.apply("1"),这里是语言提供的语法糖，可以省略一些方法名，使程序看上去更加自然，方便理解。
 
Scala中]]></description><category></category></item></channel></rss>