python调用java接口
主要有以下四点区别:
1.python虚拟机没有java强，java虚拟机是java的核心，python的核心是可以很方便地使用c语言函数或c++库。
2.python是全动态性的，可以在运行时自己修改自己的代码，java只能通过变通方法实现。python的变量是动态的，而java的变量是静态的，需要事先声明，所以java ide的代码提示功能优于python ide。
3.python的产生几十年了，几十年前面向过程是主流，所以用python有好多程序用的是面向过程设计方法，很多概念从c语言过来的，class在python中是后加入的，而java是为了实现没有指针的c++（当年com组件用的引用记数，java用的虚拟机），主要采用面向对象的设计方法，很多概念是oop的概念。面向过程，相对简洁直观，但容易设计出面条程序，面向对象，相对抽象优雅，但容易过度抽象。
4.在实际使用的python入门简单，pyhton的强大在于库，为什么python的库强大，原因是python的库可以用python，c语言,c++等设计，再提供给python使用，所以无论gpu运行，神经网络，智能算法，数据分析，图像处理，科学计算，各式各样的库在等着你用。 而java没有python那么多的开源库，很多库是商业公司内部使用，或发布出来只是一个jar包，看不到原始代码。python虚拟机因为编译性没有java的支持的好（或者说故意这么设计的），一般直接使用源码（linux），或源码简单打个包（如pyexe）。
‘贰’ 建立java与python的接口，让java能调用python脚本。请问可以用什么方式
不建议研究jython。比较简单的思路是把python脚本完全当做一个外部程序，用shell方式调用它。
首先设计好python脚本的接口，把参数用命令行方式传入，然后输出打印出来。示例：
$ python func.py arg1 arg2
result
然后在java里就可以用Runtime来执行shell命令，解析输出字符串然后得到结果。
‘叁’ Python请求java中文编码问题
首先 全部使用 “utf-8”颤梁编码
然后 分别在 java 和 python 中使用 json.mps() 和 json.loads() 来处肢洞胡理 json数据。这样肯定不会出错的。
java中使用：import net.sf.json.JSONArray; import net.sf.json.JSONObject;
python中使用：历拦import json
‘肆’ java和python的区别，是不是学会python，java也会啊
随着人工智能的火爆，Python和Java一直在各种流行编程语言中名列前茅。其实Java和Python有些相似，因为很多编程语言之间是互通的。Java现在还是第一，不知道Python未来会不会超越Java，但是现在有些人不明白Python和Java的区别。今天就来教大家三分钟看懂Python和Java的区别。
对象
就面向的对象而言，Java语言的设计集中于对象及其接口，提供了类机制以及动态的接口模型。对象中封装了它的状态变量以及相应的方法，实现了模块化和信息隐藏;而类则提供了一类对象的原型，并且通过继承机制，子类可以使用父类所提供的方法，实现了代码的复用。
而Python既支持面向过程的函数编程也支持面向对象的抽象编程。在面向过程的语言中，程序是由过程或仅仅是可重用代码的函数构建起来的。在面向对象的语言中，程序是由数据和功能组合而成的对象构建起来的。
2. 开源
Java和Python都是开源语言，就是可以自由阅读源代码、做改动等。在这一点上，Java和Python差不多。但也有一个差别：Java代码的中文版本很多，而Python主要是英文版，所以想学Python的话，英语能力不可或缺。
3. 可读性
Java和Python都有很好的可读性。而它们的不同之处在于，Java的简单是因为略去了运算符重载、多重继承等模糊的概念，并且通过实现自动垃圾收集大大简化了程序设计者的内存管理工作。
而Python编程思维几乎完全和生活中的思维习惯一致，更适合人们阅读。虽然Python是用C语言写的，但它简化了语法，所以不论是在阅读上还是在学习上，都非常简单容易。
4. 跨平台性
Java和Python都是跨平台语言，但它们的跨平台也有区别，Java可以跨平台是因为Java的类库非常多，提供各个平台的接口;而Python程序基本不做任何改变即可在主流计算机平台上运行，但并不是所有平台都可以。
5. 可扩展性
Python和Java都有良好的可扩展性，但Java的设计使它适合于一个不断发展的环境，在类库中加入新的方法和实例变量，不会影响用户程序的执行，且Java通过接口来支持多重继承。
而Python的可扩展性，体现在如果需要一段关键代码运行得更快或者希望某些算法不公开，可以把部分程序用C或C++编写，然后在Python程序中使用它们。
6. 类库
Java之所以强大，主要就是因为它有大量的类库。其中中大量的规范，大量的库，只需要用基础的语法调用就能解决问题，所以项目上只要使用的都是基础语法。
其实Python也有自己的库，而且标准库很庞大。此外，python有可定义的第三方库可使用，能处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、密码系统、GUI、Tk和其他与系统有关的操作。
‘伍’ Python与Java如何构建通信请给出一个学习方向。
1、python提供restful接口，java直接调用restful api即可；
2、rpc通信，现成框架例如grpc。 java 和python都支持。
3、消息队列，python计算结果存到消息队列，java端订阅处理即可。相当于引入一个中间代理角色。
思路大概就上面的方式，根据实际场景进行技术选型。
‘陆’ python和java那个比较好呀
如果有人跟你说Java比Python好或Python比Java好，奉劝你一句不要相信！用Python并且薪资待遇比较好的人，一定会告诉你Python好。用Java的人也一定会告诉你Java好。
一、Java VS Python 定位不同
Java源自C和C++的技术体系，于1995年推出，定位于给专门的程序员设计大型的复杂分布式应用而设计。
Python是1991年推出（比Java还早）主要面向于系统管理、科研、教育和非程序员群体等。
如果从时间来看，Python比掘运山Java早4年出身。在国内由于大数据的盛行、互联网的快速发展，Python逐渐进入大众眼中，相关企业开始加大了对Python人才的招聘力度。而Python的火爆直接导致相关人才真正的技术能力并没有那么好，但也能拿到高薪！随后便流传了“人生苦短，我用Python”。
但当Python进入大众眼中的同时，Java也并未受到任何影响。薪资待遇及市场需求一直在稳步前进。
二、难易程度不同
1、Python
Python是一种解释型脚本语言。而提到Python，大部人会想到简单易学。其在设计上也坚持了清晰划一的风格，这使得Python成为易读、易维护的语言。
Python的设计目标之一是让代码具备高度的可阅读性。它设计时尽量使用其它语言经常使用的标点符号和英文单字，让代码看起来整洁美观。它不像其他的静态语言如C、Pascal那样需要重复书写声明语句，也不像它们的语法那样经常有特殊情况和意外。
Python开发者有意让违反了缩进规则的程序不能通过编译，以此来强制程序员养成良好的编程习惯。并且Python语言利用缩进表示语句块的开始和退出（Off-side规则），而非使用花括号或者某种关键字。增加缩进表示语句块的开始，而减少缩进则表示语句块的退出。缩进成为了语法的一部分。
简而言之：Python可直接调用别人的代码接口。
2、Java
Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。
Java看起来设计得很像C++，但是为了使语言小和容易熟悉，设计者们把C++语言中悄前许多可用的特征去掉了，例如Java不支持go to语句。Java还剔除了C++的操作符过载（overload）和多继承特征，并且不使用主文件。因为Java没有结构，数组和串都是对象，所以不需要指针。Java能够自判中动处理对象的引用和间接引用，实现自动的无用单元收集，使用户不必为存储管理问题烦恼。
简而言之：Java的很多处理相对要原生一点，代码要多一些。
三、Java VS Python 应用领域不同
1、Python
· Web 和 Internet开发
· 科学计算和统计
· 人工智能
· 教育
· 桌面界面开发
· 软件开发
· 后端开发
2、Java
· Android应用
· 金融业应用的服务器程序
· 网站
· 嵌入式领域
· 大数据技术
· 高频交易的空间
· 科学应用
以上就是整理的Python和Java之间的区别。Python和Java哪个好？主要是结合个人想要发展的领域进行学习。两个编程语言在市场的地位均不可撼动，但只有喜好才能让你更容易付出百分之二百的努力！
最后，想说无论你选择何种语言，都去好好享受编码吧！至于不知道对哪个编程语言更感兴趣？这需要自己去亲身体验过才知道。
‘柒’ 如何在Python中使用static，class，abstract方法
方法在Python中是塌侍如何悉胡工作的
方法就是一个函数，它作为一个类属性而存在，你可以用如下方式来声明、访问一个函数：
Python
>>> class Pizza(object):
... def __init__(self, size):
... self.size = size
... def get_size(self):
... return self.size
...
>>> Pizza.get_size
<unbound method Pizza.get_size>
Python在告诉你，属性_get_size是类Pizza的一个未绑定方法。这是什么意思呢？很快我们就会知道答案：
Python
>>> Pizza.get_size()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: unbound method get_size() must be called with Pizza instance as first argument (got nothing instead)
我们不能这么调用，因为它还没有绑定到Pizza类的任何实例上，它需要一个实例作为第一个参数传递进去（Python2必须是该类的实例，Python3中可以是任何东西），尝试一下：
Python
>>> Pizza.get_size(Pizza(42))
42
>>> Pizza.get_size(Pizza(42))
42
太棒了，现在用一个实例作为它的的第一个参数来调用，整个世界都清静了，如果我说这种调用方式还不是最方便的，你也会这么认为的；没错，现在每次调用这个方法的时候我们都不得不引用这个类，如果不知道哪个类是我们的对象，长期看来这种方式是行不通的。
那么Python为我们做了什么呢，它绑定了所有来自类_Pizza的方法以及该类的任何一个实例的方法。也就意味着现在属性get_size是Pizza的一个实例对象的绑定方法，这个方法的第一个参数就是该实例本身。
Python
>>> Pizza(42).get_size
<bound method Pizza.get_size of <__main__.Pizza object at 0x7f3138827910>>
>>> Pizza(42).get_size()
42
和我们预期的一样，现在不再需要提供任何参数给_get_size，因为它已经是绑定的，它的self参数会自动地设置给Pizza实例，下面代码是最好的证明：
Python
>>> m = Pizza(42).get_size
>>> m()
42
更有甚者，你都没必要使用持有Pizza对象的引用了，因为该方法已经绑定到了这个对象，所以这个方法对它自己来说是已经足够了。
也许，如果你想知道这个绑定的睁衫拦方法是绑定在哪个对象上，下面这种手段就能得知：
Python
>>> m = Pizza(42).get_size
>>> m.__self__
<__main__.Pizza object at 0x7f3138827910>
>>> # You could guess, look at this:
...
>>> m == m.__self__.get_size
True
显然，该对象仍然有一个引用存在，只要你愿意你还是可以把它找回来。
在Python3中，依附在类上的函数不再当作是未绑定的方法，而是把它当作一个简单地函数，如果有必要它会绑定到一个对象身上去，原则依然和Python2保持一致，但是模块更简洁：
Python
>>> class Pizza(object):
... def __init__(self, size):
... self.size = size
... def get_size(self):
... return self.size
...
>>> Pizza.get_size
<function Pizza.get_size at 0x7f307f984dd0>
静态方法
静态方法是一类特殊的方法，有时你可能需要写一个属于这个类的方法，但是这些代码完全不会使用到实例对象本身，例如：
Python
class Pizza(object):
@staticmethod
def mix_ingredients(x, y):
return x + y
def cook(self):
return self.mix_ingredients(self.cheese, self.vegetables)
这个例子中，如果把_mix_ingredients作为非静态方法同样可以运行，但是它要提供self参数，而这个参数在方法中根本不会被使用到。这里的@staticmethod装饰器可以给我们带来一些好处：
Python不再需要为Pizza对象实例初始化一个绑定方法，绑定方法同样是对象，但是创建他们需要成本，而静态方法就可以避免这些。
Python
>>> Pizza().cook is Pizza().cook
False
>>> Pizza().mix_ingredients is Pizza.mix_ingredients
True
>>> Pizza().mix_ingredients is Pizza().mix_ingredients
True
可读性更好的代码，看到@staticmethod我们就知道这个方法并不需要依赖对象本身的状态。
可以在子类中被覆盖，如果是把mix_ingredients作为模块的顶层函数，那么继承自Pizza的子类就没法改变pizza的mix_ingredients了如果不覆盖cook的话。
类方法
话虽如此，什么是类方法呢？类方法不是绑定到对象上，而是绑定在类上的方法。
Python
>>> class Pizza(object):
... radius = 42
... @classmethod
... def get_radius(cls):
... return cls.radius
...
>>>
>>> Pizza.get_radius
<bound method type.get_radius of <class '__main__.Pizza'>>
>>> Pizza().get_radius
<bound method type.get_radius of <class '__main__.Pizza'>>
>>> Pizza.get_radius is Pizza().get_radius
True
>>> Pizza.get_radius()
42
无论你用哪种方式访问这个方法，它总是绑定到了这个类身上，它的第一个参数是这个类本身（记住：类也是对象）。
什么时候使用这种方法呢？类方法通常在以下两种场景是非常有用的：
工厂方法：它用于创建类的实例，例如一些预处理。如果使用@staticmethod代替，那我们不得不硬编码Pizza类名在函数中，这使得任何继承Pizza的类都不能使用我们这个工厂方法给它自己用。
Python
class Pizza(object):
def __init__(self, ingredients):
self.ingredients = ingredients
@classmethod
def from_fridge(cls, fridge):
return cls(fridge.get_cheese() + fridge.get_vegetables())
调用静态类：如果你把一个静态方法拆分成多个静态方法，除非你使用类方法，否则你还是得硬编码类名。使用这种方式声明方法，Pizza类名明永远都不会在被直接引用，继承和方法覆盖都可以完美的工作。
Python
class Pizza(object):
def __init__(self, radius, height):
self.radius = radius
self.height = height
@staticmethod
def compute_area(radius):
return math.pi * (radius ** 2)
@classmethod
def compute_volume(cls, height, radius):
return height * cls.compute_area(radius)
def get_volume(self):
return self.compute_volume(self.height, self.radius)
抽象方法
抽象方法是定义在基类中的一种方法，它没有提供任何实现，类似于Java中接口(Interface)里面的方法。
在Python中实现抽象方法最简单地方式是：
Python
class Pizza(object):
def get_radius(self):
raise NotImplementedError
任何继承自_Pizza的类必须覆盖实现方法get_radius，否则会抛出异常。
这种抽象方法的实现有它的弊端，如果你写一个类继承Pizza，但是忘记实现get_radius，异常只有在你真正使用的时候才会抛出来。
Python
>>> Pizza()
<__main__.Pizza object at 0x7fb747353d90>
>>> Pizza().get_radius()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
File "<stdin>", line 3, in get_radius
NotImplementedError
还有一种方式可以让错误更早的触发，使用Python提供的abc模块，对象被初始化之后就可以抛出异常：
Python
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_radius(self):
"""Method that should do something."""
使用abc后，当你尝试初始化BasePizza或者任何子类的时候立马就会得到一个TypeError，而无需等到真正调用get_radius的时候才发现异常。
Python
>>> BasePizza()
Traceback (most recent call last):
File "<stdin>", line 1, in <mole>
TypeError: Can't instantiate abstract class BasePizza with abstract methods get_radius
混合静态方法、类方法、抽象方法
当你开始构建类和继承结构时，混合使用这些装饰器的时候到了，所以这里列出了一些技巧。
记住，声明一个抽象的方法，不会固定方法的原型，这就意味着虽然你必须实现它，但是我可以用任何参数列表来实现：
Python
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""
class Calzone(BasePizza):
def get_ingredients(self, with_egg=False):
egg = Egg() if with_egg else None
return self.ingredients + egg
这样是允许的，因为Calzone满足BasePizza对象所定义的接口需求。同样我们也可以用一个类方法或静态方法来实现：
Python
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
@abc.abstractmethod
def get_ingredients(self):
"""Returns the ingredient list."""
class DietPizza(BasePizza):
@staticmethod
def get_ingredients():
return None
这同样是正确的,因为它遵循抽象类BasePizza设定的契约。事实上get_ingredients方法并不需要知道返回结果是什么，结果是实现细节，不是契约条件。
因此，你不能强制抽象方法的实现是一个常规方法、或者是类方法还是静态方法，也没什么可争论的。从Python3开始（在Python2中不能如你期待的运行，见issue5867），在abstractmethod方法上面使用@staticmethod和@classmethod装饰器成为可能。
Python
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
ingredient = ['cheese']
@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.ingredients
别误会了，如果你认为它会强制子类作为一个类方法来实现get_ingredients那你就错了，它仅仅表示你实现的get_ingredients在BasePizza中是一个类方法。
可以在抽象方法中做代码的实现？没错，Python与Java接口中的方法相反，你可以在抽象方法编写实现代码通过super()来调用它。（译注：在Java8中，接口也提供的默认方法，允许在接口中写方法的实现）
Python
import abc
class BasePizza(object):
__metaclass__ = abc.ABCMeta
default_ingredients = ['cheese']
@classmethod
@abc.abstractmethod
def get_ingredients(cls):
"""Returns the ingredient list."""
return cls.default_ingredients
class DietPizza(BasePizza):
def get_ingredients(self):
return ['egg'] + super(DietPizza, self).get_ingredients()
这个例子中，你构建的每个pizza都通过继承BasePizza的方式，你不得不覆盖get_ingredients方法，但是能够使用默认机制通过super()来获取ingredient列表。