Java与Python语法对比 （二）面向对象

（一）静态方法 VS 函数

1.定义一个函数

Java

public class Funtion {
    public static void fn() {
        System.out.println("这是我的第一个函数！");
        System.out.println("hello！");
        System.out.println("今天天气真不错！！");
    }
}

Python

def fn() :
    print('这是我的第一个函数！')
    print('hello')
    print('今天天气真不错！')

2.定义函数时指定形参

Java

public class Funtion {
    // 定义函数时指定形参
    public static void fn2(int a, int b) {
        System.out.println("a =" + a);
        System.out.println("b =" + b);
        System.out.println(a + "+" + b + "=" + (a + b));
    }

    // 调用函数时，来传递实参
    public static void main(String[] args) {
        fn2(10, 20);
    }
}

Python

# 定义函数时指定形参
def fn2(a , b) :
    print('a =',a)
    print('b =',b)
    print(a,"+",b,"=",a + b)

# 调用函数时，来传递实参
fn2(10,20)

（二）面向对象

1. 创建数据类型的实例

Java

Integer a = new Integer(10); // 创建一个int类的实例
String str = new String("hello"); //创建一个str类的实例

Python

a = int(10) # 创建一个int类的实例
b = str('hello') # 创建一个str类的实例

2. 创建类和对象

Java

// 定义一个简单的类
class MyClass{
}

//使用MyClass创建一个对象
MyClass mc = new MyClass();

// 检查一个对象是否是一个类的实例
boolean result = mc instanceof MyClass;

// 不能添加属性，只能在类中定义
static class MyClass {
    String name = "孙悟空";
    int age = 18;
}

Python

# 定义一个简单的类
class MyClass():
    pass

# 使用MyClass创建一个对象
mc = MyClass()

# isinstance()检查一个对象是否是一个类的实例
result = isinstance(mc,MyClass)

# 可以向对象中添加变量，对象中的变量称为属性
# 语法：对象.属性名 = 属性值
mc.name = '孙悟空'
mc.age = 18

3. 方法和属性的调用

Java

    class Person {
        public String name = "swk"; // 公共属性，所有实例都可以访问

        public void say_hello() {
            System.out.println("你好！我是" + this.name);
        }
    }

    public static void main(String[] args) {
// 创建Person的实例
        Person p1 = new Person();
        Person p2 = new Person();

// 修改p1的name属性
        p1.name = "猪八戒";
        p2.name = "沙和尚";

        p1.say_hello(); // 你好！我是猪八戒
        p2.say_hello(); // 你好！我是沙和尚
    }

Python

class Person :
    name = 'swk' # 公共属性，所有实例都可以访问
    
    def say_hello(self) :
        print('你好！我是 %s' %self.name)

# 创建Person的实例
p1 = Person()
p2 = Person()

# 修改p1的name属性
p1.name = '猪八戒'
p2.name = '沙和尚'

p1.say_hello() # '你好！我是 猪八戒'
p2.say_hello() # '你好！我是 沙和尚'

4. 构造器 VS init函数

Java

    static class Person {
        public String name;

        public Person(String name) {
            // 通过self向新建的对象中初始化属性
            this.name = name;
        }

        public void say_hello() {
            System.out.println("大家好，我是" + this.name);
        }
    }

    public static void main(String[] args) {
        Person p1 = new Person("孙悟空");
        Person p2 = new Person("猪八戒");
        Person p3 = new Person("沙和尚");
        Person p4 = new Person("唐僧");
        
        p4.say_hello(); // 你好！我是唐僧
    }

Python

class Person :

    def __init__(self,name):
        # print(self)# 通过self向新建的对象中初始化属性
        self.name = name

    def say_hello(self):
        print('大家好，我是%s'%self.name)

p1 = Person('孙悟空')
p2 = Person('猪八戒')
p3 = Person('沙和尚')
p4 = Person('唐僧')

p4.say_hello() # 大家好，我是唐僧

 5. 封装性：private VS 隐藏属性

Java

   // 可以为对象的属性使用private修饰字
// private开头的属性，是对象的私有属性，私有属性只能在类的内部访问，无法通过其他类访问
public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
public static void main(String[] args) {
        Person p = new Person("孙悟空");

       // System.out.println(p.name); 私有属性，无法通过对象访问
    }

Python

# 可以为对象的属性使用双下划线开头，__xxx
# 双下划线开头的属性，是对象的隐藏属性，隐藏属性只能在类的内部访问，无法通过对象访问
class Person:
    def __init__(self,name):
        self.__name = name

    def get_name(self):
        return self.__name

    def set_name(self , name):
        self.__name = name

p = Person('孙悟空')

# print(p.__name) __开头的属性是隐藏属性，无法通过对象访问