编程基础---不同编程语言学习---不同编程语言的区别

面向对象技术简介

• 类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。
• 类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
• 数据成员：类变量或者实例变量, 用于处理类及其实例对象的相关的数据。
• 方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。
• 实例变量：定义在方法中的变量，只作用于当前实例的类。
• 继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。
• 实例化：创建一个类的实例，类的具体对象。
• 方法：类中定义的函数。
• 对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

不同编程语言的区别

来源

类定义方式的区别

python

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

python定义类不需要public关键字，一个源文件可以有多个类。

java

public class ClassName{
  <statement-1>;
    .
    .
    .
    <statement-N>;
  public void function(){
  }
}

java定义类一般会加上public，但也可以省去，默认就是public性质的。java类文件的名称要与类名一致；但python和scala中没有此要求。

scala

来源：

class Point(xc: Int, yc: Int) {
   var x: Int = xc
   var y: Int = yc

   def move(dx: Int, dy: Int) {
      x = x + dx
      y = y + dy
      println ("x 的坐标点: " + x);
      println ("y 的坐标点: " + y);
   }
}

Scala中的类不声明为public，一个Scala源文件中可以有多个类。
Scala 的类定义可以有参数，称为类参数，如上面的 xc, yc，类参数在整个类中都可以访问。在python和java中有构造函数，而构造函数是主要功能就是在实例化类的时候会自动执行，可以在实例化时传递参数，并完成类实例默认属性的赋值。而这里scala中，可以直接在类名后跟着参数，在实例化时传递参数值，这些参数在整个类中可访问，因而这里就相当于完成了python和java中构造函数的功能。

Scala 单例对象

http://www.runoob.com/scala/scala-classes-objects.html
在 Scala 中，是没有 static 这个东西的，但是它也为我们提供了单例模式的实现方法，那就是使用关键字 object。

Scala 中使用单例模式时，除了定义的类之外，还要定义一个同名的 object 对象，它和类的区别是，object对象不能带参数。

当单例对象与某个类共享同一个名称时，他被称作是这个类的伴生对象：companion object。你必须在同一个源文件里定义类和它的伴生对象。类被称为是这个单例对象的伴生类：companion class。类和它的伴生对象可以互相访问其私有成员。

访问修饰符的区别

python

python中@修饰符用法

java

http://www.runoob.com/java/java-modifier-types.html

scala

Scala 访问修饰符基本和Java的一样，分别有：private，protected，public。
如果没有指定访问修饰符符，默认情况下，Scala 对象的访问级别都是 public。
Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。
http://www.runoob.com/scala/scala-access-modifiers.html

类的属性(变量)的区别

python

python定义变量不需要声明变量类型，在使用时直接赋值即可，解释器会自己判断。
一般情况下变量都是可以全局访问的，只要记住特殊变量。
单下划线、双下划线、头尾双下划线说明：

• _foo: 以单下划线开头的表示的是 protected类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于from module import *。这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

• __foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

• __foo__: 定义的是特殊方法或变量，一般是系统定义名字 ，类似__init__()之类的。可以直接访问的，不是private变量。一般不会用__name__、__score__这样的变量名来命名普通变量。

Python内置类属性

• __dict__: 类的属性（包含一个字典，由类的数据属性组成,类成员，方法，数据属性）。Python __dict__属性详解
• __doc__:类的文档字符串
• __name__: 类名
• __module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.module 等于 mymod）
• __bases__: 类的所有父类构成元素（包含了一个由所有父类组成的元组）

class Employee:
    #'所有员工的基类'
    empCount = 0
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
        Employee.empCount += 1
    def displayCount(self):
        print("Total Employee %d" % Employee.empCount)
    def displayEmployee(self):
        print("Name : ", self.name, ", Salary: ", self.salary)

print("Employee.__doc__:", Employee.__doc__)
print("Employee.__name__:", Employee.__name__)
print("Employee.__module__:", Employee.__module__)
print("Employee.__bases__:", Employee.__bases__)
print("Employee.__dict__:", Employee.__dict__)
# Employee.__doc__: None
# Employee.__name__: Employee
# Employee.__module__: __main__
# Employee.__bases__: (<class 'object'>,)
# Employee.__dict__: {'__module__': '__main__', 'empCount': 0, '__init__': <function Employee.__init__ at 0x000001AC4CB26268>, 'displayCount': <function Employee.displayCount at 0x000001AC4CB262F0>, 'displayEmployee': <function Employee.displayEmployee at 0x000001AC4CB26378>, '__dict__': <attribute '__dict__' of 'Employee' objects>, '__weakref__': <attribute '__weakref__' of 'Employee' objects>, '__doc__': None}

类的私有属性实例如下：

#实例(Python 3.0+)
#!/usr/bin/python3
 
class JustCounter:
    __secretCount = 0  # 私有变量
    publicCount = 0    # 公开变量

    def count(self):
        self.__secretCount += 1
        self.publicCount += 1
        print (self.__secretCount)
        print(self.publicCount)

if __name__=='__main__':
    counter = JustCounter()
    counter.count()
    counter.count()
    print (counter.publicCount)
    # 结果如下：
    # 1
    # 1
    # 2
    # 2
    # 2
    print(counter.__secretCount)  # 报错，实例不能访问私有变量

java

来源：
定义变量时先声明变量类型，一般形式public 变量类型 变量名或private 变量类型 变量名，public也可以去掉，默认即为public性质即下面讲的成员变量;例如String name,private String address
java中一个类可以包含以下类型变量：

• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
• 类变量：类变量（静态变量）也声明在类中，方法体之外，但必须声明为static类型。Java语言中没有全局变量的概念。被static修饰的成员变量和成员方法独立于该类的任何对象。用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象时，不生成static变量的副本，而是类的所有实例共享同一个static变量。
  静态变量除了被声明为常量外很少使用，如public static final String DEPARTMENT = "开发人员";

scala

来源：
在 Scala 中，使用关键词 “var” 声明变量，使用关键词 “val” 声明常量。变量 可以修改它,如果修改常量值，程序将会在编译时报错。
变量的类型在变量名之后等号之前声明。定义变量的类型的语法格式如下：

var VariableName : DataType [=  Initial Value]
或
val VariableName : DataType [=  Initial Value]
如
var myVar : String = "Too"
val myVal : String = "Foo"

变量声明一定需要初始值，否则会报错。

在 Scala 中声明变量和常量不一定要指明数据类型，在没有指明数据类型的情况下，其数据类型是通过变量或常量的初始值推断出来的。
所以，如果在没有指明数据类型的情况下声明变量或常量必须要给出其初始值，否则将会报错。

var myVar = 10;
val myVal = "Hello, Scala!";

Scala 多个变量声明
Scala 支持多个变量的声明：

val xmax, ymax = 100  // xmax, ymax都声明为100

如果方法返回值是元组，我们可以使用 val 来声明一个元组：

scala> val pa = (40,"Foo")
pa: (Int, String) = (40,Foo)

类方法的区别

python

http://www.runoob.com/python3/python3-function.html
在类的内部，使用 def 关键字来定义一个方法，与一般函数定义不同，类方法必须包含参数 self, 且为第一个参数，self 代表的是类的实例。本质上是因为python变量默认是全局的，为了限定范围才要加self。如

python中self和cls的区别：self表示一个具体的实例本身，cls表示这个类本身。

def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))

不定长参数
加了星号 * 的参数会以元组(tuple)的形式导入，存放所有未命名的变量参数。
加了两个星号 ** 的参数会以字典的形式导入。

java

http://www.runoob.com/java/java-methods.html
定义类中的方法形式如下
public(或其他修饰符) 返回值类型（或void） 函数名(传入参数类型 变量名){

}
返回值类型如String，void表示无返回值，也可去掉返回类型，默认就是无返回值。
可变参数

typeName... parameterName

一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

scala

scala中方法一定要定义在class中或object中；而python中方法到处都可以定义
Scala 也是一种函数式语言，所以函数是 Scala 语言的核心。
Scala方法和函数还有一个很特殊的地方，它可以不需要用return来指明返回值，默认最后一行为返回值（python如果没有return就没有返回值）
除了主函数，其他方法和函数都要={}，这个是其他编程语不同的
http://www.runoob.com/scala/scala-functions.html
Scala 有方法与函数，二者在语义上的区别很小。Scala 方法是类的一部分，**而函数是一个对象可以赋值给一个变量。**换句话来说在类中定义的函数即是方法。Scala 中的函数其实就是继承了 Trait 的类的对象。
方法声明
方法定义
标准形式

def functionName ([参数列表]) : [return type] = {
   function body
   return [expr]
}

参考后面函数的用法可以看到，也不一定要写明返回值类类型，也不一定要用return.
方法调用
关于函数的用法
Scala 函数传名调用(call-by-name)
http://www.runoob.com/scala/functions-call-by-name.html
使用 => 符号来设置传名调用,要注意=>前面就有空格。如f: Int => String，其他符号前是传入函数入口参数类型，符号后面是函数返回值的类型。如果函数没有入口参数，则前面可以不写

object helloWorld {
  def main(args:Array[String]){
    delayed(time())
  }
  def time()={
    println("获取时间，单位为纳秒")
    System.nanoTime()
  }
  def delayed(t: => Long ) = {
    println("在delayed方法内")
    println("参数："+t)//在打印返回值时需要先执行time函数,执行的过程会打印"获取时间，单位为纳秒",返回的时间接着被delayed中的println使用
    t//再次执行time()，因而还会打印"获取时间，单位为纳秒"，也有返回值，但这里没有操作返回值。
  }
}
//在delayed方法内
//获取时间，单位为纳秒
//参数：781568704453798
//获取时间，单位为纳秒

Scala 指定函数参数名
http://www.runoob.com/scala/functions-named-arguments.html
这个就和其他编程语言是差不多的。
Scala 函数 - 可变参数
http://www.runoob.com/scala/functions-variable-arguments.html
python,java中也有可变参数的概念，具体只是表达形式的细微差别

object helloWorld {
  def main(args:Array[String]){
    printStrings("Java","Scala","Python")
  }
  def printStrings(args:String*)={
    var i:Int=0
    for (arg <- args){
      println("Arg value["+i+"]="+arg)
      i=i+1
    }
  }
}

//Arg value[0]=Java
//Arg value[1]=Scala
//Arg value[2]=Python

Scala 函数 - 默认参数值
http://www.runoob.com/scala/functions-default-parameter-values.html
Scala 递归函数
http://www.runoob.com/scala/recursion-functions.html
Scala 高阶函数
http://www.runoob.com/scala/higher-order-functions.html
Scala 函数嵌套
http://www.runoob.com/scala/nested-functions.html
Scala 匿名函数
http://www.runoob.com/scala/anonymous-functions.html
如var mul = (x: Int, y: Int) => x*y，调用时println(mul(3, 4));
匿名函数使得scala中在一些简单功能的实现上便得很简洁。
Scala 偏应用函数
http://www.runoob.com/scala/partially-applied-functions.html
Scala 函数柯里化(Currying)
http://www.runoob.com/scala/currying-functions.html
Scala 闭包
http://www.runoob.com/scala/scala-closures.html

构造方法的区别

python

python中很多类都倾向于将对象创建为有初始状态的。因此类可能会(在python中构造方法不是必须的)定义一个名为 init() 的特殊方法（构造方法）。像下面这样：

def __init__(self):
    self.data = []

类定义了 init() 方法的话，类的实例化操作会自动调用 init() 方法。
当然， init() 方法可以有参数，参数通过 init() 传递到类的实例化操作上。例如:

#实例(Python 3.0+)
#!/usr/bin/python3
 
class Complex:
    def __init__(self, realpart, imagpart):
        self.r = realpart
        self.i = imagpart
x = Complex(3.0, -4.5)
print(x.r, x.i)   # 输出结果：3.0 -4.5

self代表类的实例，而非类

java

每个类都有构造方法。如果没有显式地为类定义构造方法，Java编译器将会为该类提供一个默认构造方法。
在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。
下面是一个构造方法示例：

public class Puppy{
    public Puppy(){
    }
 
    public Puppy(String name){
        // 这个构造器仅有一个参数：name
    }
}

scala

scala中，可以直接在类名后跟着参数，在实例化时传递参数值，这些参数在整个类中可访问，因而这里就相当于完成了python和java中构造函数的功能。

类的私有方法的区别

python

__private_method：两个下划线开头，声明该方法为私有方法，只能在类的内部调用 ，不能在类地外部调用。self.__private_methods。
类的私有方法实例如下：
实例(Python 3.0+)

#!/usr/bin/python3
 
class Site:
    def __init__(self, name, url):
        self.name = name       # public
        self.__url = url   # private
 
    def who(self):
        print('name  : ', self.name)
        print('url : ', self.__url)
 
    def __foo(self):          # 私有方法
        print('这是私有方法')
 
    def foo(self):            # 公共方法
        print('这是公共方法')
        self.__foo()
 
x = Site('菜鸟教程', 'www.runoob.com')
x.who()        # 正常输出
x.foo()        # 正常输出
x.__foo()      # 报错

java

java中无此概念，一般都是成员方法;如过加static就相当于全局方法了

scala

类的专有方法的区别：

在python中方法名如果是__xxxx__()的，那么就有特殊的功能，因此叫做“魔法”方法

python

__init__: 构造函数，在生成对象时调用
__new__:python–__new__方法（二十七）
__call__：python __call__函数
__del__: 析构函数，释放对象时使用。Python对象中__del__方法起作用的条件
__str__：当使用print输出对象的时候，只要自己定义了__str__(self)方法，那么就会打印从在这个方法中return的数据。Python __str__()方法
__del__:

__repr__: 打印，转换
__setitem__: 按照索引赋值
__getitem__: 按照索引获取值
__len__: 获得长度
__cmp__: 比较运算
__call__: 函数调用
__add__: 加运算
__sub__: 减运算
__mul__: 乘运算
__div__: 除运算
__mod__: 求余运算
__pow__: 乘方

java

无此概念

scala

类的继承格式的区别：

python

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。
需要注意的地方：
**继承语法 **

class 派生类名（基类名）：//... 基类名写在括号里，基本类是在类定义的时候，在元组之中指明的。

class DerivedClassName(BaseClassName1):
    <statement-1>
    .
    .
    .
    <statement-N>

无相应关键字，直接在子类后用小括号跟父类。所有类都继承自object类。
若是基类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找基类中是否包含方法。
BaseClassName（示例中的基类名）必须与派生类定义在一个作用域内。除了类，还可以用表达式，基类定义在另一个模块中时这一点非常有用:class DerivedClassName(modname.BaseClassName):
实例(Python 3.0+)

#!/usr/bin/python3
 
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
 
 
s = student('ken',10,60,3)
s.speak()

执行以上程序输出结果为：

ken 说: 我 10 岁了，我在读 3 年级

在python中继承中的一些特点：

• 1：在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。
• 2：在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别在于类中调用普通函数时并不需要带上self参数
• 3：Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" ，关于多重继承可参考。
语法：
派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后。

class Parent:  # 定义父类
    parentAttr = 100
    def __init__(self):
        print("调用父类构造函数")
    def parentMethod(self):
        print('调用父类方法')
    def setAttr(self, attr):
        Parent.parentAttr = attr
    def getAttr(self):
        print("父类属性 :", Parent.parentAttr)

class Child(Parent):  # 定义子类
    def __init__(self):
        print("调用子类构造方法")
    def childMethod(self):
        print('调用子类方法')

c = Child()  # 实例化子类
c.childMethod()  # 调用子类的方法
c.parentMethod()  # 调用父类方法
c.setAttr(200)  # 再次调用父类的方法 - 设置属性值
c.getAttr()  # 再次调用父类的方法 - 获取属性值
# 调用子类构造方法
# 调用子类方法
# 调用父类方法
# 父类属性 : 200

可以使用issubclass()或者isinstance()方法来检测。

• issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法：issubclass(sub,sup)
• isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

Python super() 函数

java

class 子类 extends 父类 {
}
class 子类implements 父类 {
}

extend或implements,而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。
继承的特性

• 子类拥有父类非private的属性，方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。

scala

http://www.runoob.com/scala/scala-classes-objects.html
Scala继承一个基类跟Java很相似, 但我们需要注意以下几点：

• 1、重写一个非抽象方法必须使用override修饰符。
• 2、只有主构造函数才可以往基类的构造函数里写参数。
• 3、在子类中重写超类的抽象方法时，你不需要使用override关键字。

多继承的区别

Python同样有限的支持多继承形式。多继承的类定义形如下例:

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

需要注意圆括号中父类的顺序，若是父类中有相同的方法名，而在子类使用时未指定，python从左至右搜索 即方法在子类中未找到时，从左到右查找父类中是否包含方法。
实例(Python 3.0+)

#!/usr/bin/python3
 
#类定义
class people:
    #定义基本属性
    name = ''
    age = 0
    #定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0
    #定义构造方法
    def __init__(self,n,a,w):
        self.name = n
        self.age = a
        self.__weight = w
    def speak(self):
        print("%s 说: 我 %d 岁。" %(self.name,self.age))
 
#单继承示例
class student(people):
    grade = ''
    def __init__(self,n,a,w,g):
        #调用父类的构函
        people.__init__(self,n,a,w)
        self.grade = g
    #覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁了，我在读 %d 年级"%(self.name,self.age,self.grade))
 
#另一个类，多重继承之前的准备
class speaker():
    topic = ''
    name = ''
    def __init__(self,n,t):
        self.name = n
        self.topic = t
    def speak(self):
        print("我叫 %s，我是一个演说家，我演讲的主题是 %s"%(self.name,self.topic))
 
#多重继承
class sample(speaker,student):
    a =''
    def __init__(self,n,a,w,g,t):
        student.__init__(self,n,a,w,g)
        speaker.__init__(self,n,t)
 
test = sample("Tim",25,80,4,"Python")
test.speak()   #方法名同，默认调用的是在括号中排前地父类的方法

执行以上程序输出结果为：

我叫 Tim，我是一个演说家，我演讲的主题是 Python

java

extends关键字
在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。
implements关键字
使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

scala

声明方法不能被继承的差别

python

无

java

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

    声明类：

    final class 类名 {//类体}

    声明方法：

    修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

scala

构造器继承的差别

python

python中构造器是为了类属性的声明，也就没有继承的概念，如果在子类中要继承父类中所有的属性，直接在子类构造器中调用父类构造器即可，同时还可以加入新的属性。

java

子类不能继承父类的构造器（构造方法或者构造函数），如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。
如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。
实例

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){
    super(300);
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    SubClass sc = new SubClass();
    SubClass sc2 = new SubClass(200); 
  }
}

输出结果为：

SuperClass(int n)
SubClass
SuperClass()
SubClass(int n):200

scala

方法重写与重载的差别

python

方法重写
子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！
如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法：

class Parent:  # 定义父类
    def myMethod(self):
        print('调用父类方法')
class Child(Parent):  # 定义子类
    def myMethod(self):
        print('调用子类方法')

c = Child()  # 子类实例
c.myMethod()  # 子类调用重写方法
#结果：调用子类方法

除了上面方法重写的方式，也可以用方法覆盖
下面是一个样例：

class Dog:
    def bark(self):
        print "Woof"

def new_bark(self):
    print "Woof Woof"

foo = Dog()

funcType = type(Dog.bark)

# "Woof"
foo.bark()

# replace bark with new_bark for this object only
foo.bark = funcType(new_bark, foo, Dog)

foo.bark()
# "Woof Woof"

Python同样支持运算符重载，我们可以对类的专有方法进行重载，实例如下：
实例(Python 3.0+)
基础重载方法
下表列出了一些通用的功能，你可以在自己的类重写：

序号	方法, 描述 & 简单的调用
1	init ( self [,args…] ) 构造函数 简单的调用方法: obj = className(args)
2	del( self ) 析构方法, 删除一个对象 简单的调用方法 : del obj
3	repr( self ) 转化为供解释器读取的形式 简单的调用方法 : repr(obj)
4	str( self ) 用于将值转化为适于人阅读的形式 简单的调用方法 : str(obj)
5	cmp ( self, x ) 对象比较 简单的调用方法 : cmp(obj, x)

运算符重载

class Vector:
    def __init__(self, a, b):
        self.a = a
        self.b = b
    def __str__(self):
        return 'Vector (%d, %d)' % (self.a, self.b)
    def __add__(self, other):
        return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2, 10)
v2 = Vector(5, -2)
print(v1)
print(v2)
print(v1 + v2)
# Vector (2, 10)
# Vector (5, -2)
# Vector (7, 8)

java

重新在子类中定义一遍方法
重写(Override)

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：
TestDog.java 文件代码：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

以上实例编译运行结果如下：

动物可以移动
狗可以跑和走

在上面的例子中可以看到，尽管b属于Animal类型，但是它运行的是Dog类的move方法。

这是由于在编译阶段，只是检查参数的引用类型。

然而在运行时，Java虚拟机(JVM)指定对象的类型并且运行该对象的方法。

因此在上面的例子中，之所以能编译成功，是因为Animal类中存在move方法，然而运行时，运行的是特定对象的方法。

思考以下例子：
TestDog.java 文件代码：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      b.bark();
   }
}

以上实例编译运行结果如下：

TestDog.java:30: cannot find symbol
symbol  : method bark()
location: class Animal
                b.bark();
                 ^

该程序将抛出一个编译错误，因为b的引用类型Animal没有bark方法。
方法的重写规则

• 参数列表必须完全与被重写方法的相同；
• 返回类型必须完全与被重写方法的返回类型相同；
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
• 父类的成员方法只能被它的子类重写。
• 声明为final的方法不能被重写。
• 声明为static的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
• 构造方法不能被重写。
• 如果不能继承一个方法，则不能重写这个方法。

Super关键字的使用
Python中super的用法

当需要在子类中调用父类的被重写方法时，要使用super关键字。
TestDog.java 文件代码：

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
 
      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法
 
   }
}

以上实例编译运行结果如下：

动物可以移动
狗可以跑和走

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

实例
Overloading.java 文件代码：

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

重写与重载之间的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

总结

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

• (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
• (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
• (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

scala

封装的区别

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。
封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。
要访问该类的代码和数据，必须通过严格的接口控制。
封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。
封装的优点

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员变量进行更精确的控制。
• 隐藏信息，实现细节。

python

和普通函数相比，在类中定义函数只有一点不同，就是第一参数永远是类的本身实例变量self，并且调用时，不用传递该参数。除此之外，类的方法(函数）和普通函数没啥区别，你既可以用默认参数、可变参数或者关键字参数（*args是可变参数，args接收的是一个tuple，**kw是关键字参数，kw接收的是一个dict）。
既然Student类实例本身就拥有这些数据，那么要访问这些数据，就没必要从外面的函数去访问，而可以直接在Student类的内部定义访问数据的函数（方法），这样，就可以把”数据”封装起来。这些封装数据的函数是和Student类本身是关联起来的，称之为类的方法：

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print("%s: %s" %(self.name, self.score))

student = Student("Hugh", 99)
student.print_score()
#结果：Hugh: 99

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线，在Python中，实例的变量名如果以__开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把Student类改一改：

class Student(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print("%s: %s" %(self.__name,self.__score))

student = Student("Hugh",99)
student.print_score()
student.__name

改完后，对于外部代码来说，没什么变动，照样可以打印出结果；但是已经无法从外部访问实例变量.__name和实例变量.__score了：

Hugh: 99
  File "F:/huanghe/study/Demo/helloWorld.py", line 22, in <module>
    student.__name
AttributeError: 'Student' object has no attribute '__name'

这样就确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮。
但是如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_score这样的方法：

class Student(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print("%s: %s" %(self.__name,self.__score))
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score

student = Student("Hugh",99)
student.print_score()
name=student.get_name()
print(name)
#Hugh: 99
#Hugh

如果又要允许外部代码修改score怎么办？可以给Student类增加set_score方法：

class Student(object):
    def __init__(self, name, score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print("%s: %s" %(self.__name,self.__score))
    def get_name(self):
        return self.__name
    def get_score(self):
        return self.__score
    def set_score(self, score):
        self.__score = score

student = Student("Hugh",99)
student.print_score()
student.set_score(90)
score=student.get_score()
print(score)
#Hugh: 99
#90

封装的另一个好处是可以随时给Student类增加新的方法，比如：get_grade:

    def get_grade(self):
        if self.__score >= 90:
            return 'A'
        elif self.__score >= 60:
            return 'B'
        else:
            return 'C'

student = Student("Hugh",99)
grade=student.get_grade()
print(grade)
#A

get_grade方法可以直接在实例变量上调用，不需要知道内部实现细节。

java

实现Java封装的步骤

• 修改属性的可见性来限制对属性的访问（一般限制为private），例如：

public class Person {
    private String name;
    private int age;
}

这段代码中，将 name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

• 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如：

public class Person{
    private String name;
    private int age;
​
    public int getAge(){
      return age;
    }
​
    public String getName(){
      return name;
    }
​
    public void setAge(int age){
      this.age = age;
    }
​
    public void setName(String name){
      this.name = name;
    }
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。
实例

让我们来看一个java封装类的例子：
EncapTest.java 文件代码：

/* 文件名: EncapTest.java */
public class EncapTest{
 
   private String name;
   private String idNum;
   private int age;
 
   public int getAge(){
      return age;
   }
 
   public String getName(){
      return name;
   }
 
   public String getIdNum(){
      return idNum;
   }
 
   public void setAge( int newAge){
      age = newAge;
   }
 
   public void setName(String newName){
      name = newName;
   }
 
   public void setIdNum( String newId){
      idNum = newId;
   }
}

以上实例中public方法是外部类访问该类成员变量的入口。
通常情况下，这些方法被称为getter和setter方法。
因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。
通过如下的例子说明EncapTest类的变量怎样被访问：
RunEncap.java 文件代码：

/* F文件名 : RunEncap.java */
public class RunEncap{
   public static void main(String args[]){
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");
 
      System.out.print("Name : " + encap.getName()+ 
                             " Age : "+ encap.getAge());
    }
}

以上代码编译运行结果如下:

Name : James Age : 20

scala

接口的区别

python

python中是没有接口的概念吧

java

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。
接口与类相似点：

• 一个接口可以有多个方法。
• 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
• 接口的字节码文件保存在 .class 结尾的文件中。
• 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

• 接口不能用于实例化对象。
• 接口没有构造方法。
• 接口中所有的方法必须是抽象方法。
• 接口不能包含成员变量，除了 static 和 final 变量。
• 接口不是被类继承了，而是要被类实现。
• 接口支持多继承。

接口特性

• 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

• 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
• 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

接口的声明
接口的声明语法格式如下：

[可见度] interface 接口名称 [extends 其他的类名] {
        // 声明变量
        // 抽象方法
}

Interface关键字用来声明一个接口。下面是接口声明的一个简单例子。
NameOfInterface.java 文件代码：

/* 文件名 : NameOfInterface.java */
import java.lang.*;
//引入包
 
public interface NameOfInterface
{
   //任何类型 final, static 字段
   //抽象方法
}

接口有以下特性：

• 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
• 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
• 接口中的方法都是公有的。

实例
Animal.java 文件代码：

/* 文件名 : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

接口的实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。
实现一个接口的语法，可以使用这个公式：
Animal.java 文件代码：

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

实例
MammalInt.java 文件代码：

/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{
 
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

以上实例编译运行结果如下:

Mammal eats
Mammal travels

重写接口中声明的方法时，需要注意以下规则：

• 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
• 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
• 如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

在实现接口的时候，也要注意一些规则：

• 一个类可以同时实现多个接口。
• 一个类只能继承一个类，但是能实现多个接口。
• 一个接口能继承另一个接口，这和类之间的继承比较相似。

接口的继承

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。
下面的Sports接口被Hockey和Football接口继承：

// 文件名: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
 
// 文件名: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}
 
// 文件名: Hockey.java
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

Hockey接口自己声明了四个方法，从Sports接口继承了两个方法，这样，实现Hockey接口的类需要实现六个方法。
相似的，实现Football接口的类需要实现五个方法，其中两个来自于Sports接口。

接口的多继承

在Java中，类的多继承是不合法，但接口允许多继承。
在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。 如下所示：

public interface Hockey extends Sports, Event

以上的程序片段是合法定义的子接口，与类不同的是，接口允许多继承，而 Sports及 Event 可能定义或是继承相同的方法
标记接口

最常用的继承接口是没有包含任何方法的接口。
标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
标记接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。

例如：java.awt.event 包中的 MouseListener 接口继承的 java.util.EventListener 接口定义如下：

package java.util;
public interface EventListener
{}

没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的：

• 建立一个公共的父接口：
  正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。
• 向一个类添加数据类型：
  这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

scala

Scala Trait(特征)
http://www.runoob.com/scala/scala-traits.html

模块的区别

python

可理解为对应于一个文件。在创建了一个脚本文件后，定义了某些函数和变量。你在其他需要这些功能的文件中，导入这模块，就可重用这些函数和变量。一般用module_name.fun_name，和module_name.var_name进行使用。这样的语义用法使模块看起来很像类或者名字空间，可将module_name 理解为名字限定符。模块名就是文件名去掉.py后缀。
模块属性__name__，它的值由Python解释器设定。如果脚本文件是作为主程序调用，其值就设为__main__，如果是作为模块被其他文件导入，它的值就是其文件名。
每个模块都有自己的私有符号表，所有定义在模块里面的函数把它当做全局符号表使用。
模块可以导入其他的模块。通常将import语句放在模块的开头，被导入的模块名字放在导入它的模块的符号表中。
from module import names可以直接从模块中导入名字到符号表，但模块名字不会被导入。
from module import *可以把模块中的所有名字全部导入，除了那些以下划线开头的名字符号。不建议使用，不清楚导入了什么符号，有可能覆盖自己定义的东西
内建函数dir()可以查看模块定义了什么名字（包括变量名，模块名，函数名等）：dir(模块名)，没有参数时返回所有当前定义的名字
模块搜索路径
当导入一个模块时，解释器先在当前包中查找模块，若找不到，然后在内置的built-in模块中查找，找不到则按sys.path给定的路径找对应的模块文件(模块名.py)
sys.path的初始值来自于以下地方：

• 包含脚本当前的路径，当前路径
• PYTHONPATH
• 默认安装路径

sys.path初始化完成之后可以更改
这些搜索目录可在运行时动态改变，比如将module1.py不放在当前目录，而放在一个冷僻的角落里。这里你就需要通过某种途径，如sys.path，来告知Python了。sys.path返回的是模块搜索列表，通过前后的输出对比和代码，应能理悟到如何增加新路径的方法了吧。非常简单，就是使用list的append()或insert()增加新的目录。

import sys
import os

print(sys.path)
print(sys.argv)
print(os.path.abspath(sys.argv[0]))
workpath = os.path.dirname(os.path.abspath(sys.argv[0]))
print(workpath)
sys.path.insert(0, os.path.join(workpath, 'modules'))
print(sys.path)

# ['F:\\hh\\study\\Demo', 'F:\\hh\\study\\Demo', 'C:\\WINDOWS\\SYSTEM32\\python27.zip', 'F:\\hh\\study\\Demo\\venv\\DLLs', 'F:\\hh\\study\\Demo\\venv\\lib', 'F:\\hh\\study\\Demo\\venv\\lib\\plat-win', 'F:\\hh\\study\\Demo\\venv\\lib\\lib-tk', 'F:\\hh\\study\\Demo\\venv\\Scripts', 'C:\\Python27\\Lib', 'C:\\Python27\\DLLs', 'C:\\Python27\\Lib\\lib-tk', 'F:\\hh\\study\\Demo\\venv', 'F:\\hh\\study\\Demo\\venv\\lib\\site-packages']
# ['F:/hh/study/Demo/helloWorld.py']
# F:\hh\study\Demo\helloWorld.py
# F:\hh\study\Demo
# ['F:\\hh\\study\\Demo\\modules', 'F:\\hh\\study\\Demo', 'F:\\hh\\study\\Demo', 'C:\\WINDOWS\\SYSTEM32\\python27.zip', 'F:\\hh\\study\\Demo\\venv\\DLLs', 'F:\\hh\\study\\Demo\\venv\\lib', 'F:\\hh\\study\\Demo\\venv\\lib\\plat-win', 'F:\\hh\\study\\Demo\\venv\\lib\\lib-tk', 'F:\\hh\\study\\Demo\\venv\\Scripts', 'C:\\Python27\\Lib', 'C:\\Python27\\DLLs', 'C:\\Python27\\Lib\\lib-tk', 'F:\\hh\\study\\Demo\\venv', 'F:\\hh\\study\\Demo\\venv\\lib\\site-packages']

其他的要点
模块能像包含函数定义一样，可包含一些可执行语句。这些可执行语句通常用来进行模块的初始化工作。这些语句只在模块第一次被导入时被执行。这非常重要，有些人以为这些语句会多次导入多次执行，其实不然。
模块在被导入执行时，python解释器为加快程序的启动速度，会在与模块文件同一目录下生成.pyc文件。我们知道python是解释性的脚本语言，而.pyc是经过编译后的字节码，这一工作会自动完成，而无需程序员手动执行。

java

没有模块的概念

包的区别

python

通常包总是一个目录，可以使用import导入包，或者from + import来导入包中的部分模块。包目录下为首的一个文件便是__init__.py。然后是一些模块文件和子目录，假如子目录中也有__init__.py那么它就是这个包的子包了。
在创建许许多多模块后，我们可能希望将某些功能相近的文件组织在同一文件夹下，这里就需要运用包的概念了。包对应于文件夹，使用包的方式跟模块也类似，唯一需要注意的是，当文件夹当作包使用时，文件夹需要包含__init__.py文件，主要是为了避免将文件夹名当作普通的字符串。__init__.py的内容可以为空，一般用来进行包的某些初始化工作或者设置__all__值，__all__是在from package-name import *这语句使用的，全部导出定义过的模块。
如下所示：

__all__ = ['file1','file2'] #package1下有file1.py,file2.py

Python中import机制
可以从包中导入单独的模块
1).import PackageA.SubPackageA.ModuleA,使用时必须用全路径名
2). 变种:from PackageA.SubPackageA import ModuleA, 可以直接使用模块名而不用加上包前缀。
3). 也可以直接导入模块中的函数或变量：from PackageA.SubPackageA.ModuleA import functionA
import语句语法：

1. 当使用from package import item时，item可以是package的子模块或子包，或是其他的定义在包中的名字（比如一个函数、类或变量）
   首先检查item是否定义在包中，不过没找到，就认为item是一个模块并尝试加载它，失败时会抛出一个ImportError异常。
2. 当使用import item.subitem.subsubitem语法时，最后一个item之前的item必须是包，最后一个item可以是一个模块或包，但不能是类、函数和变量
3. from pacakge import *
   如果包的__init__.py定义了一个名为__all__的列表变量，它包含的模块名字的列表将作为被导入的模块列表。
   如果没有定义__all__， 这条语句不会导入所有的package的子模块，它只保证包package被导入，然后导入定义在包中的所有名字。

可以被import语句导入的对象是以下类型：

• 模块文件（.py文件）
• C或C++扩展（已编译为共享库或DLL文件）
• 包（包含多个模块）
• 内建模块（使用C编写并已链接到Python解释器中）

可以作为模块的文件类型有.py、.pyo、.pyc、.pyd、.so、.dll
关于import的过程和原理，可参考该文

python在执行import语句时，到底进行了什么操作，按照python的文档，它执行了如下操作：
第1步，创建一个新的，空的module对象（它可能包含多个module）；
第2步，把这个module对象插入sys.module中
第3步，装载module的代码（如果需要，首先必须编译）
第4步，执行新的module中对应的代码。

在执行第3步时，首先要找到module程序所在的位置，其原理为：
如 果需要导入的module的名字是m1，则解释器必须找到m1.py，它首先在当前目录查找，然后是在环境变量PYTHONPATH中查找。 PYTHONPATH可以视为系统的PATH变量一类的东西，其中包含若干个目录。如果PYTHONPATH没有设定，或者找不到m1.py，则继续搜索 与python的安装设置相关的默认路径，在Unix下，通常是/usr/local/lib/python。
事实上，搜索的顺序是：当前路径 （以及从当前目录指定的sys.path），然后是PYTHONPATH，然后是python的安装设置相关的默认路径。正因为存在这样的顺序，如果当前 路径或PYTHONPATH中存在与标准module同样的module，则会覆盖标准module。也就是说，如果当前目录下存在xml.py，那么执 行import xml时，导入的是当前目录下的module，而不是系统标准的xml。

了解了这些，我们就可以先构建一个package，以普通module的方式导入，就可以直接访问此package中的各个module了。

Python中的package定义很简单，其层次结构与程序所在目录的层次结构相同，这一点与Java类似，唯一不同的地方在于，python中的package必须包含一个__init__.py的文件。
例如，我们可以这样组织一个package:

package1/
    __init__.py
    subPack1/
        __init__.py
        module_11.py
        module_12.py
        module_13.py
    subPack2/
        __init__.py
        module_21.py
        module_22.py
    ……

__init__.py可以为空，只要它存在，就表明此目录应被作为一个package处理。当然，__init__.py中也可以设置相应的内容，下文详细介绍。

好了，现在我们在module_11.py中定义一个函数：

def funA():
    print("funcA in module_11")
    return

在顶层目录（也就是package1所在的目录，当然也参考上面的介绍，将package1放在解释器能够搜索到的地方）运行python:

from package1.subPack1.module_11 import funcA
funcA()
#结果：funcA in module_11

这样，我们就按照package的层次关系，正确调用了module_11中的函数。

细心的用户会发现，有时在import语句中会出现通配符*，导入某个module中的所有元素，这是怎么实现的呢？
答案就在__init__.py中。我们在subPack1的__init__.py文件中写

__all__ = ['module_13', 'module_12']

然后进入python

>>>from package1.subPack1 import *
>>>module_11.funcA()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named module_11

也就是说，以*导入时，package内的module是受__init__.py限制的。

好了，最后来看看，如何在package内部互相调用。
如果希望调用同一个package中的module，则直接import即可。也就是说，在module_12.py中，可以直接使用

import module_11

如果不在同一个package中，例如我们希望在module_21.py中调用module_11.py中的FuncA，则应该这样：

from module_11包名.module_11 import funcA
注意：我们也可以使用编译过后的"同名.pyc"文件放在与"同名.py"文件相同的位置，这样可在一定程度上保护源码。但是要注意在与生产环境中进行编译，确保编译与运行时python版本和依赖一致。

常见问题：

• 引入某一特定路径下的模块
  使用sys.path.append(yourmodulepath)，然后在packagea中的__init__.py添加这句话，然后该包下得所有module都添加* import __init_即可。
• 将一个路径加入到python系统路径下，避免每次通过代码指定路径
  利用系统环境变量 export PYTHONPATH=$PYTHONPATH:yourmodulepath，
  直接将这个路径链接到类似/Library/Python/2.7/site-packages目录下
• 好的建议
  经常使用if __name__ == '__main__'，保证你写包既可以import又可以独立运行，用于test。
  多次import不会多次执行模块，只会执行一次。可以使用reload来强制运行模块，但不提倡。

java

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。
包的作用

• 把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
• 如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
• 包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

包语句的语法格式为：

package pkg1[．pkg2[．pkg3…]];

例如,一个Something.java 文件它的内容

package net.java.util;
public class Something{
   ...
}

那么它的路径应该是 net/java/util/Something.java这样保存的。 package(包) 的作用是把不同的 java 程序分类保存，更方便的被其他 java 程序调用。
一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。
以下是一些 Java 中的包：

• java.lang-打包基础的类
• java.io-包含输入输出功能的函数

开发者可以自己把一组类和接口等打包，并定义自己的包。而且在实际开发中这样做是值得提倡的，当你自己完成类的实现之后，将相关的类分组，可以让其他的编程者更容易地确定哪些类、接口、枚举和注释等是相关的。
由于包创建了新的命名空间（namespace），所以不会跟其他包中的任何名字产生命名冲突。使用包这种机制，更容易实现访问控制，并且让定位相关类更加简单。
创建包
创建包的时候，你需要为这个包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。
包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。
如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。
例子
让我们来看一个例子，这个例子创建了一个叫做animals的包。通常使用小写的字母来命名避免与类、接口名字的冲突。
在 animals 包中加入一个接口（interface）：
Animal.java 文件代码：

/* 文件名: Animal.java */
package animals;
 
interface Animal {
   public void eat();
   public void travel();
}

接下来，在同一个包中加入该接口的实现：
MammalInt.java 文件代码：

package animals;
 
/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{
 
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

然后，编译这两个文件，并把他们放在一个叫做animals的子目录中。 用下面的命令来运行：

$ mkdir animals
$ cp Animal.class  MammalInt.class animals
$ java animals/MammalInt
Mammal eats
Mammal travel

import 关键字

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 “import” 语句可完成此功能。
在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

import package1[.package2…].(classname|*);

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。
例子
下面的 payroll 包已经包含了 Employee 类，接下来向 payroll 包中添加一个 Boss 类。Boss 类引用 Employee 类的时候可以不用使用 payroll 前缀，Boss类的实例如下。
Boss.java 文件代码：

package payroll;
 
public class Boss
{
   public void payEmployee(Employee e)
   {
      e.mailCheck();
   }
}

如果 Boss 类不在 payroll 包中又会怎样？Boss 类必须使用下面几种方法之一来引用其他包中的类。
使用类全名描述，例如：

payroll.Employee

用 import 关键字引入，使用通配符 “*”

import payroll.*;

使用 import 关键字引入 Employee 类:

import payroll.Employee;

注意：
类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前。
package 的目录结构

类放在包中会有两种主要的结果：

• 包名成为类名的一部分，正如我们前面讨论的一样。
• 包名必须与相应的字节码所在的目录结构相吻合。

下面是管理你自己 java 中文件的一种简单方式：
将类、接口等类型的源码放在一个文本中，这个文件的名字就是这个类型的名字，并以.java作为扩展名。例如：

// 文件名 :  Car.java
 
package vehicle;
 
public class Car {
   // 类实现  
}

接下来，把源文件放在一个目录中，这个目录要对应类所在包的名字。

....\vehicle\Car.java

现在，正确的类名和路径将会是如下样子：

• 类名 -> vehicle.Car
• 路径名 -> vehicle\Car.java (在 windows 系统中)

通常，一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 runoob.com，所有的包名都以 com.runoob 开头。包名中的每一个部分对应一个子目录。

例如：有一个 com.runoob.test 的包，这个包包含一个叫做 Runoob.java 的源文件，那么相应的，应该有如下面的一连串子目录：

....\com\runoob\test\Runoob.java

编译的时候，编译器为包中定义的每个类、接口等类型各创建一个不同的输出文件，输出文件的名字就是这个类型的名字，并加上 .class 作为扩展后缀。 例如：

// 文件名: Runoob.java
 
package com.runoob.test;
public class Runoob {
      
}
class Google {
      
}

现在，我们用-d选项来编译这个文件，如下：

$javac -d . Runoob.java

这样会像下面这样放置编译了的文件：

.\com\runoob\test\Runoob.class
.\com\runoob\test\Google.class

你可以像下面这样来导入所有 \com\runoob\test\ 中定义的类、接口等：

import com.runoob.test.*;

编译之后的 .class 文件应该和 .java 源文件一样，它们放置的目录应该跟包的名字对应起来。但是，并不要求 .class 文件的路径跟相应的 .java 的路径一样。你可以分开来安排源码和类的目录。

<path-one>\sources\com\runoob\test\Runoob.java
<path-two>\classes\com\runoob\test\Google.class

这样，你可以将你的类目录分享给其他的编程人员，而不用透露自己的源码。用这种方法管理源码和类文件可以让编译器和java 虚拟机（JVM）可以找到你程序中使用的所有类型。
类目录的绝对路径叫做 class path。设置在系统变量 CLASSPATH 中。编译器和 java 虚拟机通过将 package 名字加到 class path 后来构造 .class 文件的路径。

<path- two>\classes是 class path，package 名字是com.runoob.test,而编译器和 JVM 会在<path-two>\classes\com\runoob\test中找 .class 文件。

一个 class path 可能会包含好几个路径，多路径应该用分隔符分开。默认情况下，编译器和 JVM 查找当前目录。JAR 文件按包含 Java 平台相关的类，所以他们的目录默认放在了 class path 中。
设置 CLASSPATH 系统变量

用下面的命令显示当前的CLASSPATH变量：

• Windows 平台（DOS 命令行下）：C:\> set CLASSPATH
• UNIX 平台（Bourne shell 下）：# echo $CLASSPATH

删除当前CLASSPATH变量内容：

• Windows 平台（DOS 命令行下）：C:\> set CLASSPATH=
• UNIX 平台（Bourne shell 下）：# unset CLASSPATH; export CLASSPATH

设置CLASSPATH变量:

• Windows 平台（DOS 命令行下）：C:\> set CLASSPATH=C:\users\jack\java\classes
• UNIX 平台（Bourne shell 下）：# CLASSPATH=/home/jack/java/classes; export CLASSPATH

scala

scala中包的用法可参考java，也是用package来声明。

杂集

Java装饰器

Java中@ 的作用
语法: @关键字(值)
用于把关键字和值传递给编译器，更精确低控制编译器的动作。
关键字都是随技术、框架、编译器的不同而不同，含义也不同、数量不定。可以由子技术或开发者扩充。
比如@override 说明会重写该方法

python装饰器

如何理解Python装饰器？
python【编程课堂】装饰器浅析