Python与Java对比笔记

命名

方法、变量名称

• Java 是首单词小写后续单词首字母大写。如 myColor
• Python是单词小写，以 _ 连接。如 my_color

注释

• Java 单行注释使用 // ，多行注释使用 /**/
• Python 单行注释使用 # ，多行注释使用 """"""或 ''''''

//java单行注释

/*
java多行注释
哈哈
*/

# python 单行注释
"""
python 多行注释
哈哈
"""

'''
python 多行注释
哈哈
'''

数据类型

• Java 内置数据类型有：byte, short, int, long, float, double, boolean, char
• Python 内置数据类型有：int, long, float, complex, bool, str, tumple, set, list, dict

注：java内置没有字符串类型，而python有。但java提供了其他类来创造字符串，如String类、StringBuffer类、 StringBuilder类。

java 的String、StringBuffer、 StringBuilder类

• 这三个类均是不可被继承的，因为类采用了final进行修饰，用关键字final修饰的域为最终域。
  final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。
  

• String类对象的值是不可改变的，这就导致每次对String的操作都会生成新的String对象；StringBuffer 和StringBuilder类对象可以被修改且不产生新的对象。

• StringBuilder是可变类，单线程不安全；StringBuffer底层方法使用了synchronized关键字（同步锁），线程比较安全，但效率较StringBuilder慢；
  

• StringBuilder 和StringBuffer之间，由于速度问题，大多数情况下会使用StringBuilder。

声明与实例化

	Java	Python
类声明	public/private/protected class 类名	class 类名
方法声明	void 方法名	def 方法名
变量声明	数据类型 变量名	变量名

• Java 语句用 ; 分隔
• Python语句不要 ; ，若是加了会提示不符合规范。
• Java 代码段用 {} 包含
• Python 代码段无需 {} 包含，通过空格缩进来区分。
• Java 实例化是 类名 名称=new 类名(参数)，如 ``
• Python 实例化是 名称=类名(参数)

//Java 类声明
public class MyClass{
	// Java 方法声明
	void myFunction(){
		//Java 变量声明
		int i=0;
	}
}

# Python 类声明
class MyClass:
    # Python 方法声明
    def myFunction(self):
        # Python 变量声明
        i=0;

变量类型

Java：

• 局部变量：类的方法中的变量。
• 实例变量：独立于方法之外的变量，没有 static 修饰。
• 类变量：独立于方法之外的变量，用 static 修饰。

Python：

• 局部变量：类的方法中的变量。无 self.
• 成员变量（实例变量）：独立于方法之外的变量，用 self.
• 类变量：独立于方法之外的变量，无 self.

// Java
public class MyClass {
	int number;  // 实例变量
	static int number2;  // 类变量
	public void varDefine() {
		int number3;  // 局部变量
	}
}

# Python
class MyClass:
    number1=None  # 实例变量
    
    def __init__(self, number):
        self.number = number  # 构造函数里定义的成员变量

    def varDefine(self):
        self.number2=None  # 普通函数里定义的成员变量
        number3=None  # 局部变量

打印

• Java 打印使用 System.out.println();
• Python 打印使用 print()

条件控制

• Java 使用if, else if, else 和 swich, case。且判断语句需要用()包含，执行体需要用{}包含。
• Python 使用if, elif, else。

// java if
		int i=3;
		if(i<5){
			System.out.println(i+"小于5");
		}
		else if(i<10){
			System.out.println(i+"大于等于5小于10");
		}
		else {
			System.out.println(i+"大于等于10");
		}
// java switch
		switch(number) {
		case 1:
			System.out.println("number为1");
			break;
		
		case 3:
			System.out.println("number为3");
			break;
		default:
			System.out.println(number);
			break;
		}

# python
i = 3
if i < 5:
    print('{}小于5'.format(i))
elif i < 10:
    print('{}大于等于5且小于10'.format(i))
else:
    print('{}大于10'.format(i))

主方法

• Java 是 public static void main(String[] args){}
• Python是 if __name__=='__main__:'

//Java
package main;

public class MyClass {
	public static void main(String[] args) {
		int i=3;
		if(i<5){
			System.out.println(i+"小于5");
		}
		else if(i<10){
			System.out.println(i+"大于等于5小于10");
		}
		else {
			System.out.println(i+"大于等于10");
		}
	}
}

# Python
if __name__ == '__main__':
    i = 3
    if i < 5:
        print('{}小于5'.format(i))
    elif i < 10:
        print('{}大于等于5且小于10'.format(i))
    else:
        print('{}大于10'.format(i))

构造方法

• Java 是与类名同名，public 类名(){}
• Python 是 __init__()

// Java
package main;

public class MyClass {
	int number;
	public MyClass(int number) {
		this.number=number;
		
	}
	public void compareWith3And5() {
		if(number<5){
			System.out.println(number+"小于5");
		}
		else if(number<10){
			System.out.println(number+"大于等于5小于10");
		}
		else {
			System.out.println(number+"大于等于10");
		}
	}
	public static void main(String[] args) {
		MyClass myClass=new MyClass(3);
		myClass.compareWith3And5();
	}
}

# Python
class MyClass:
    def __init__(self, number):
        self.number = number

    def compare_5_10(self):
        if self.number < 5:
            print('{}小于5'.format(self.number))
        elif self.number < 10:
            print('{}大于等于5且小于10'.format(self.number))
        else:
            print('{}大于10'.format(self.number))


if __name__ == '__main__':
    my_class = MyClass(3)
    my_class.compare_5_10()

继承

• Java 没有多继承，但是可以通过接口来实现多继承。
• Python 有多继承。

// Java
// 歌手类
package main;

public class Singer {
	String name;
	public Singer(String name){
		this.name=name;
	}
	
	public void sing() {
		// 唱歌
        System.out.println(this.name + "会唱歌");
	}
}

// 接口类：作词类
package main;

public interface Lyric {
	public void write() ;
}

// 子类继承了歌手类，实现接口类
package main;

public class Songstress extends Singer implements Lyric{
	
	public Songstress(String name) {
		super(name);
	}
	
	//实现接口类中的方法
	public void write() {
		System.out.println(this.name + "写词");
	}
	
	//本类中的方法
    public void get_gender() {
        System.out.println(this.name + "是女性");
    }
    
    public static void main(String args[]) {
    	Songstress s=new Songstress("Selina");
    	s.get_gender();
        s.sing();
        s.write();
    }

}

# Python

#父类1：multiple_inheritance.singer
class Singer:
    """歌手类"""

    def __init__(self, name):
        self.name = name

    def sing(self):
        """唱歌"""
        print(self.name + "会唱歌")
        
# 父类2：multiple_inheritance.lyric
class Lyric:
    """作词类"""

    def __init__(self, name):
        self.name = name

    def write(self):
        """作词"""
        print(self.name + "写词")
        
# 子类
from multiple_inheritance.lyric import Lyric
from multiple_inheritance.singer import Singer


class SongstressWriter(Singer, Lyric):
    """作词女歌手"""

    def get_gender(self):
        print(self.name + '是女性')


class Songstress(Singer):
    """女歌手"""

    def get_gender(self):
        print(self.name + '是女性')


if __name__ == "__main__":
    s = SongstressWriter('Selina')
    s.get_gender()
    s.sing()
    s.write()

以上两个的输出结果是：

Selina是女性
Selina会唱歌
Selina写词

// Java

# Python