python vs java，从java转python一键简简单单入门，轻轻松松上手，抓紧收藏起来吧

Java资料网推荐python vs java，从java转python一键简简单单入门，轻轻松松上手，抓紧收藏起来吧这篇文章给大家，欢迎收藏Java资料网享受知识的乐趣

好文推荐：
netty搭建websocket集群（高性能.,高并发）
springboot 实现延时队列（超级实用）
2.5万字讲解DDD领域驱动设计（史上最全DDD）
史上最全从0到1搭建最新版本jenkins可持续集成

前言：

现在人工智能，数据分析，机器学习，爬虫，越来越火，而python正是最合适的编程语言，物联网+大数据+机器学习将会是以后的趋势，跟随潮流学习python，技多不压身！java转python是非常容易的，小编以java为基础点来一起入门python！从各个角度学习python，包括开发环境，hello world，方法，类，命名规范，if语句，for语句，while语句，switch语句，接口，封装，继承，多态，常量，反射，枚举，数据类型，数组，集合，处理集合，泛型，lambda，多线程，线程安全，定时任务，IO，异常等角度入门python，简简单单入门，轻轻松松上手。

区别：

1. 语法：
   Java：静态类型语言，要求在编译时声明变量类型，语法较为严格。
   Python：动态类型语言，变量类型在运行时确定，语法简洁，易于阅读。
2. 编译与解释：
   Java：编译成字节码，通过 Java 虚拟机（JVM）运行，具有跨平台能力。
   Python：通常是解释执行，直接运行源代码，速度相对较慢。
   性能：
   Java：通常性能较高，适合大型应用和高性能需求。
   Python：性能较低，但开发速度快，适合快速原型开发。
3. 库和框架：
   Java：有丰富的企业级框架（如 Spring），适合构建大型应用。
   Python：有大量的库（如 NumPy、Pandas、Django），适合数据科学、机器学习和Web开发。
   社区和生态：
   Java：有成熟的社区和生态，广泛应用于企业级开发。
   Python：社区活跃，特别是在数据科学和人工智能领域。
4. 多线程：
   Java：支持多线程，使用线程池和同步机制。
   Python：由于全局解释器锁（GIL），多线程性能受限，通常使用多进程或异步编程。
   用途：
   Java：广泛用于企业应用、Android开发和大规模系统。
   Python：常用于数据分析、机器学习、Web开发和自动化脚本。
   这两种语言各有优缺点，选择哪种语言取决于具体的项目需求和开发者的熟悉程度。

开发环境：

1. java
   安装jdk，配置开发环境，开发工具使用idea，java具体步骤不再赘述
2. python
   ①安装python解释器，点击下载，一路安装即可，
   ②下载开发工具使用VS Code或者PyCharm
   ③打开VScode，您要在VS Code IDE的“Extensions”中安装插件Python
   

③使用快捷键：Ctrl+Shift+P弹出命令面板，在命令面板中输入>Python: select Interpreter

根据需要选择相应的Python解释器

④打开开发工具新建hello.py文件即可开发
⑤运行py程序，右键->运行python->在终端中运行python文件

hello world:

java:

//Main.java
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Java!");
    }
}

python

# main.py
print("Hello, Python!")

说明：
python的hello world比java要简单的多！

方法：

java：

public class Demo {
    // 定义一个方法，返回两个数的和
    public static int add(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = add(5, 3);
        System.out.println("Java: 5 + 3 = " + result);
    }
}

python：
第一种：

def add(a, b):
    # 定义一个方法，返回两个数的和
    return a + b

result = add(5, 3)
print(f"Python: 5 + 3 = {result}")

第二种：

def add(a: int, b: int) -> int:  # 方法，参数类型，返回值
    return a + b  # 返回值

result = add(5, 3)  # 方法参数
print("Result:", result)

解释
Java：使用 public static 关键字定义方法，方法需要在类中，并通过 main 方法调用，如果方法需要多个返回值，使用数组或自定义类来返回多个值。
Python：直接使用 def 关键字定义方法，调用时不需要类的结构。如果方法需要多个返回值，可以直接返回多个值，使用元组解包。

# Python 示例：直接返回多个值
def get_values():
    return 1, 2, 3

value1, value2, value3 = get_values()
print("Value 1:", value1)
print("Value 2:", value2)
print("Value 3:", value3)

类：

java：

// 文件名: Demo.java
public class Demo {
    private String name;

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

    public void greet() {
        System.out.println("Hello, " + name + "!");
    }

    public static void main(String[] args) {
        Demo demo = new Demo("World");
        demo.greet();
    }
}

python：

# 文件名: demo.py
class Demo:
    def __init__(self, name):
        self.name = name

    def greet(self):
        print(f"Hello, {self.name}!")

if __name__ == "__main__":
    demo = Demo("World")
    demo.greet()

解释
Java：使用 class 关键字定义类，构造函数通过 public 关键字定义，方法使用 void 表示无返回值。
Python：使用 class 关键字定义类，构造函数为 init 方法，使用 self 关键字引用实例属性。

命名规范：

java：

1. 类名：使用大驼峰命名法（PascalCase）。
2. 方法名：使用小驼峰命名法（camelCase）。
3. 变量名：使用小驼峰命名法（camelCase）。
4. 常量名：使用全大写字母，单词之间用下划线分隔。

// Java 示例
public class MyDemoClass {
    private static final int MAX_VALUE = 100; // 常量

    public void myMethod() { // 方法
        int myVariable = 10; // 变量
        System.out.println("Hello, World!");
    }
}

python：
类名：使用大驼峰命名法（PascalCase）。
2. 函数名：使用小写字母，单词之间用下划线分隔（snake_case）。
变量名：使用小写字母，单词之间用下划线分隔（snake_case）。
常量名：使用全大写字母，单词之间用下划线分隔。

# Python 示例
class MyDemoClass:
    MAX_VALUE = 100  # 常量

    def my_method(self):  # 函数
        my_variable = 10  # 变量
        print("Hello, World!")

总结
Java：类名和方法名使用驼峰命名法，常量使用全大写。
Python：类名使用驼峰命名法，函数和变量使用下划线分隔，常量使用全大写。

if 语句：

java：

public class IfDemo {
    public static void main(String[] args) {
        int number = 10;

        if (number > 0) {
            System.out.println("数字是正数");
        } else if (number < 0) {
            System.out.println("数字是负数");
        } else {
            System.out.println("数字是零");
        }
    }
}

python：

number = 10

if number > 0:
    print("数字是正数")
elif number < 0:
    print("数字是负数")
else:
    print("数字是零")

解释
Java：使用大括号 {} 来定义代码块，条件语句以 if 开头，后面可以跟 else if 和 else。
Python：使用缩进来定义代码块，条件语句以 if 开头，后面可以跟 elif 和 else。

for语句：

java:

public class ForLoopDemo {
    public static void main(String[] args) {
        // Java 中的 for 循环
        for (int i = 0; i < 5; i++) {
            System.out.println("当前值: " + i);
        }
    }
}

python:

# Python 中的 for 循环
for i in range(5):
    print("当前值:", i)

解释
Java：使用 for 关键字，定义循环变量 i，并设置循环条件和增量。
Python：使用 for 关键字和 range() 函数，直接遍历指定范围的数字。

while语句：

Java

public class WhileDemo {
    public static void main(String[] args) {
        int count = 0;
        while (count < 5) {
            System.out.println("Count is: " + count);
            count++;
        }
    }
}

python

count = 0
while count < 5:
    print("Count is:", count)
    count += 1

解释
Java：使用 while 语句循环，直到 count 小于 5，每次循环打印当前计数并递增 count。
Python：逻辑相同，语法更简洁，使用 print 函数输出。

switch语句：

java

public class SwitchDemo {
    public static void main(String[] args) {
        int day = 3;
        String dayName;

        switch (day) {
            case 1:
                dayName = "星期一";
                break;
            case 2:
                dayName = "星期二";
                break;
            case 3:
                dayName = "星期三";
                break;
            case 4:
                dayName = "星期四";
                break;
            case 5:
                dayName = "星期五";
                break;
            case 6:
                dayName = "星期六";
                break;
            case 7:
                dayName = "星期日";
                break;
            default:
                dayName = "无效的天数";
                break;
        }

        System.out.println(dayName);
    }
}

python

def switch_demo(day):
    switcher = {
        1: "星期一",
        2: "星期二",
        3: "星期三",
        4: "星期四",
        5: "星期五",
        6: "星期六",
        7: "星期日"
    }
    return switcher.get(day, "无效的天数")

day = 3
print(switch_demo(day))

Python 3.10 及以上版本可以使用 match 语句，类似于 switch：

day = 3

match day:
    case 1:
        day_name = "星期一"
    case 2:
        day_name = "星期二"
    case 3:
        day_name = "星期三"
    case 4:
        day_name = "星期四"
    case 5:
        day_name = "星期五"
    case 6:
        day_name = "星期六"
    case 7:
        day_name = "星期日"
    case _:
        day_name = "无效的天数"

print(day_name)

接口：

Java 示例：

// 定义接口
interface Animal {
    void makeSound();
}

// 实现接口的类
class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound(); // 输出: Woof!
    }
}

python示例：

from abc import ABC, abstractmethod

# 定义接口
class Animal(ABC):
    @abstractmethod
    def make_sound(self):
        pass

# 实现接口的类
class Dog(Animal):
    def make_sound(self):
        print("Woof!")

# 主程序
if __name__ == "__main__":
    my_dog = Dog()
    my_dog.make_sound()  # 输出: Woof!

解释
Java：使用 interface 关键字定义接口，类通过 implements 关键字实现接口。
Python：使用 ABC 模块和 abstractmethod 装饰器定义抽象基类，子类实现接口中的方法。

封装：

java示例：

// Java: 封装示例
public class Person {
    // 私有属性
    private String name;
    private int age;

    // 构造函数
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 公共方法：获取姓名
    public String getName() {
        return name;
    }

    // 公共方法：设置姓名
    public void setName(String name) {
        this.name = name;
    }

    // 公共方法：获取年龄
    public int getAge() {
        return age;
    }

    // 公共方法：设置年龄
    public void setAge(int age) {
        this.age = age;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Person person = new Person("Alice", 30);
        System.out.println(person.getName() + " is " + person.getAge() + " years old.");
    }
}

python示例：

# Python: 封装示例
class Person:
    def __init__(self, name, age):
        self.__name = name  # 私有属性
        self.__age = age    # 私有属性

    # 公共方法：获取姓名
    def get_name(self):
        return self.__name

    # 公共方法：设置姓名
    def set_name(self, name):
        self.__name = name

    # 公共方法：获取年龄
    def get_age(self):
        return self.__age

    # 公共方法：设置年龄
    def set_age(self, age):
        self.__age = age

# 使用示例
person = Person("Alice", 30)
print(f"{person.get_name()} is {person.get_age()} years old.")

封装：在这两个示例中，name 和 age 属性被定义为私有，外部无法直接访问。通过公共方法（getter 和 setter），可以安全地访问和修改这些属性。

继承：

java示例

// 父类
class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类
class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
}

// 主类
public class Demo {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.sound(); // 输出: Dog barks
    }
}

python示例：

# 父类
class Animal:
    def sound(self):
        print("Animal makes a sound")

# 子类
class Dog(Animal):
    def sound(self):
        print("Dog barks")

# 主程序
if __name__ == "__main__":
    my_dog = Dog()
    my_dog.sound()  # 输出: Dog barks

python多继承

# Python: src/main.py
class Animal:
    def speak(self):
        print("Animal speaks")

class Pet:
    def play(self):
        print("Pet plays")

class Dog(Animal, Pet):
    def bark(self):
        print("Dog barks")

if __name__ == "__main__":
    dog = Dog()
    dog.speak()  # 输出: Animal speaks
    dog.play()   # 输出: Pet plays
    dog.bark()   # 输出: Dog barks

说明：
Java：使用 extends 关键字来实现继承，子类可以重写父类的方法。只支持单继承
Python：使用括号来指定父类，子类同样可以重写父类的方法。支持单继承和多继承，Dog 类可以同时继承 Animal 和 Pet 类。

多态：

java示例：

// Java 多态示例
class Animal {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog extends Animal {
    void sound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    void sound() {
        System.out.println("Cat meows");
    }
}

public class PolymorphismDemo {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        Animal myCat = new Cat();
        
        myDog.sound(); // 输出: Dog barks
        myCat.sound(); // 输出: Cat meows
    }
}

python示例：

# Python 多态示例
class Animal:
    def sound(self):
        print("Animal makes a sound")

class Dog(Animal):
    def sound(self):
        print("Dog barks")

class Cat(Animal):
    def sound(self):
        print("Cat meows")

def polymorphism_demo():
    my_dog = Dog()
    my_cat = Cat()
    
    my_dog.sound()  # 输出: Dog barks
    my_cat.sound()  # 输出: Cat meows

polymorphism_demo()

解释
Java：通过父类 Animal 和子类 Dog、Cat 实现多态，使用相同的方法 sound() 但不同的实现。
Python：同样通过继承实现多态，子类重写父类的方法，调用时根据对象类型执行相应的方法。

常量：

java示例：

public final class Constants {
    public static final String APP_NAME = "MyApp";
    public static final int MAX_USERS = 100;

    // 私有构造函数，防止实例化
    private Constants() {}
}

// 使用常量
public class Main {
    public static void main(String[] args) {
        System.out.println(Constants.APP_NAME);
        System.out.println(Constants.MAX_USERS);
    }
}

python示例：

class Constants:
    APP_NAME = "MyApp"
    MAX_USERS = 100

# 使用常量
if __name__ == "__main__":
    print(Constants.APP_NAME)
    print(Constants.MAX_USERS)

解释
Java：使用 final 关键字定义常量，并通过私有构造函数防止类被实例化。
Python：通过类属性定义常量，虽然没有强制性，但使用全大写的命名约定来表示常量。

反射：

java示例：

import java.lang.reflect.Method;

public class ReflectionDemo {
    public void sayHello() {
        System.out.println("Hello from Java!");
    }

    public static void main(String[] args) {
        try {
            // 获取类的 Class 对象
            Class<?> clazz = Class.forName("ReflectionDemo");
            // 创建实例
            Object obj = clazz.getDeclaredConstructor().newInstance();
            // 获取方法
            Method method = clazz.getMethod("sayHello");
            // 调用方法
            method.invoke(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

python示例

class ReflectionDemo:
    def say_hello(self):
        print("Hello from Python!")

# 获取类的引用
clazz = ReflectionDemo
# 创建实例
obj = clazz()
# 获取方法
method = getattr(obj, 'say_hello')
# 调用方法
method()

解释
Java：使用 Class.forName() 获取类的 Class 对象，通过反射创建实例并调用方法。
Python：直接使用类名创建实例，使用 getattr() 获取方法并调用。

枚举：

java示例:

// Java 枚举示例
public class EnumDemo {
    public enum Day {
        SUNDAY, MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY
    }

    public static void main(String[] args) {
        Day today = Day.MONDAY;
        System.out.println("Today is: " + today);
    }
}

python示例：

# Python 枚举示例
from enum import Enum

class Day(Enum):
    SUNDAY = 1
    MONDAY = 2
    TUESDAY = 3
    WEDNESDAY = 4
    THURSDAY = 5
    FRIDAY = 6
    SATURDAY = 7

today = Day.MONDAY
print(f"Today is: {today.name}")

解释
Java：使用 enum 关键字定义枚举类型，枚举值是常量，通常用于表示固定的集合。
Python：使用 Enum 类定义枚举，枚举值可以是任何类型，通常用于表示一组相关的常量。

数据类型：

Java 有八种基本数据类型：
byte，short，int，long，float，double，char，boolean

public class DataTypesDemo {
    public static void main(String[] args) {
        // 基本数据类型
        int intValue = 10;
        float floatValue = 10.5f;
        double doubleValue = 20.99;
        char charValue = 'A';
        boolean booleanValue = true;
        byte byteValue = 100;
        short shortValue = 30000;
        long longValue = 100000L;

        // 输出基本数据类型
        System.out.println("int: " + intValue);
        System.out.println("float: " + floatValue);
        System.out.println("double: " + doubleValue);
        System.out.println("char: " + charValue);
        System.out.println("boolean: " + booleanValue);
        System.out.println("byte: " + byteValue);
        System.out.println("short: " + shortValue);
        System.out.println("long: " + longValue);
    }
}

Java 引用数据类型：
String，数组，类，接口

public class ReferenceTypesDemo {
    public static void main(String[] args) {
        // 引用数据类型
        String strValue = "Hello, Java!";
        int[] arrayValue = {1, 2, 3, 4, 5};

        // 输出引用数据类型
        System.out.println("String: " + strValue);
        System.out.print("Array: ");
        for (int num : arrayValue) {
            System.out.print(num + " ");
        }
    }
}

python：
Python 的数据类型不需要显式声明，常用的基本数据类型包括：
int，float，str，bool

# 基本数据类型
int_value = 10
float_value = 10.5
str_value = "Hello, Python!"
bool_value = True

# 输出基本数据类型
print("int:", int_value)
print("float:", float_value)
print("str:", str_value)
print("bool:", bool_value)

Python 的引用数据类型包括：
列表（List）
字典（Dictionary）
元组（Tuple）
集合（Set）

# 引用数据类型
list_value = [1, 2, 3, 4, 5]
dict_value = {"key": "value"}
tuple_value = (1, 2, 3)
set_value = {1, 2, 3}

# 输出引用数据类型
print("List:", list_value)
print("Dictionary:", dict_value)
print("Tuple:", tuple_value)
print("Set:", set_value)

总结
Java 有八种基本数据类型和多种引用数据类型，类型是静态的。基本数据类型（如 int, double, boolean）与其对应的包装类（如 Integer, Double, Boolean）是不同的类型。包装类提供了对象的功能。
Python 的数据类型更为灵活，类型是动态的。所有数据类型都是对象，没有单独的基本数据类型和包装类的区分。

数组：

java:

public class ArrayDemo {
    public static void main(String[] args) {
        // 一维数组
        int[] oneDimensionalArray = {1, 2, 3, 4, 5};
        System.out.println("一维数组:");
        for (int num : oneDimensionalArray) {
            System.out.print(num + " ");
        }
        System.out.println();

        // 二维数组
        int[][] twoDimensionalArray = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        System.out.println("二维数组:");
        for (int[] row : twoDimensionalArray) {
            for (int num : row) {
                System.out.print(num + " ");
            }
            System.out.println();
        }
    }
}

python

# 一维数组
one_dimensional_array = [1, 2, 3, 4, 5]
print("一维数组:")
for num in one_dimensional_array:
    print(num, end=" ")
print()

# 二维数组
two_dimensional_array = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]
print("二维数组:")
for row in two_dimensional_array:
    for num in row:
        print(num, end=" ")
    print()

解释
一维数组：在 Java 和 Python 中，分别使用 int[] 和列表来定义一维数组。
二维数组：在 Java 中使用数组的数组，而在 Python 中使用嵌套列表。

集合：

java：

import java.util.*;

public class Demo {
    public static void main(String[] args) {
        // List 示例
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        System.out.println("List: " + list);

        // Set 示例
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Apple"); // 重复元素不会被添加
        System.out.println("Set: " + set);

        // Map 示例
        Map<String, Integer> map = new HashMap<>();
        map.put("Apple", 1);
        map.put("Banana", 2);
        System.out.println("Map: " + map);
    }
}

python：

# List 示例
list_example = ["Apple", "Banana"]
print("List:", list_example)

# Set 示例
set_example = {"Apple", "Banana", "Apple"}  # 重复元素不会被添加
print("Set:", set_example)

# Map 示例 (使用字典)
map_example = {"Apple": 1, "Banana": 2}
print("Map:", map_example)

解释
List：有序集合，可以包含重复元素。
Set：无序集合，不允许重复元素。
Map：键值对集合，允许通过键快速访问值。Python 中使用字典（dict）来实现。

处理集合：

java:

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class StreamDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6);

        // 使用 Stream 过滤出偶数并平方
        List<Integer> squaredEvens = numbers.stream()
            .filter(n -> n % 2 == 0)
            .map(n -> n * n)
            .collect(Collectors.toList());

        System.out.println(squaredEvens); // 输出: [4, 16, 36]
    }
}

python

numbers = [1, 2, 3, 4, 5, 6]

# 过滤出偶数并平方
squared_evens = [n * n for n in numbers if n % 2 == 0]

print(squared_evens)  # 输出: [4, 16, 36]

解释
Java：使用 stream() 方法创建流，filter() 进行过滤，map() 进行映射，最后使用 collect() 收集结果。
Python：使用列表推导式直接在一行中实现过滤和映射。

泛型：

import java.util.ArrayList;
import java.util.List;

public class GenericDemo {
    public static void main(String[] args) {
        // 创建一个泛型列表
        List<String> stringList = new ArrayList<>();
        stringList.add("Hello");
        stringList.add("World");

        // 遍历并打印列表
        for (String str : stringList) {
            System.out.println(str);
        }
    }
}

python
在 Python 中，泛型通常通过类型提示实现，使用 typing 模块。

from typing import List

def print_list(items: List[str]) -> None:
    for item in items:
        print(item)

# 使用泛型函数
string_list = ["Hello", "World"]
print_list(string_list)

解释
Java：使用 List 定义一个字符串类型的列表，确保列表中只能存储字符串。
Python：使用 List[str] 作为类型提示，表示该函数接受一个字符串列表，虽然 Python 本身不强制类型检查，但提供了类型提示以增强可读性和工具支持。

lambda：

java

import java.util.Arrays;
import java.util.List;

public class LambdaDemo {
    public static void main(String[] args) {
        List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

        // 使用 Lambda 表达式打印每个名字
        names.forEach(name -> System.out.println(name));
    }
}

python

# 使用 Lambda 表达式定义一个简单的函数
square = lambda x: x ** 2

# 打印 1 到 5 的平方
for i in range(1, 6):
    print(square(i))

总结
Java：使用 Lambda 表达式简化函数式接口的实现，通常与集合操作结合使用。
Python：使用 Lambda 表达式创建匿名函数，适用于简单的函数定义。

线程:

// Java 线程示例
class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("线程正在运行: " + Thread.currentThread().getName());
    }
}

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread();
        MyThread thread2 = new MyThread();
        
        thread1.start(); // 启动线程1
        thread2.start(); // 启动线程2
    }
}

python

import threading

# Python 线程示例
class MyThread(threading.Thread):
    def run(self):
        print("线程正在运行:", threading.current_thread().name)

if __name__ == "__main__":
    thread1 = MyThread()
    thread2 = MyThread()
    
    thread1.start()  # 启动线程1
    thread2.start()  # 启动线程2

    thread1.join()   # 等待线程1完成
    thread2.join()   # 等待线程2完成

解释
Java：使用 Thread 类创建线程，重写 run 方法并调用 start() 启动线程。
Python：使用 threading.Thread 类，重写 run 方法并调用 start() 启动线程，使用 join() 等待线程完成。

线程安全：

Java

public class Counter {
    private int count = 0;

    // 使用 synchronized 确保线程安全
    public synchronized void increment() {
        count++;
    }

    public int getCount() {
        return count;
    }

    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread[] threads = new Thread[10];

        for (int i = 0; i < 10; i++) {
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    counter.increment();
                }
            });
            threads[i].start();
        }

        for (Thread thread : threads) {
            thread.join();
        }

        System.out.println("Final count: " + counter.getCount());
    }
}

python：

import threading

class Counter:
    def __init__(self):
        self.count = 0
        self.lock = threading.Lock()

    def increment(self):
        with self.lock:  # 使用锁确保线程安全
            self.count += 1

    def get_count(self):
        return self.count

def worker(counter):
    for _ in range(1000):
        counter.increment()

if __name__ == "__main__":
    counter = Counter()
    threads = []

    for _ in range(10):
        thread = threading.Thread(target=worker, args=(counter,))
        threads.append(thread)
        thread.start()

    for thread in threads:
        thread.join()

    print("Final count:", counter.get_count())

解释
Java 示例：使用 synchronized 关键字来确保 increment 方法在同一时间只能被一个线程访问。
Python 示例：使用 threading.Lock 来确保在对 count 进行修改时，只有一个线程可以访问该部分代码。

定时任务：

java

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class ScheduledTaskDemo {
    public static void main(String[] args) {
        ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

        Runnable task = () -> {
            System.out.println("定时任务执行: " + System.currentTimeMillis());
        };

        // 每隔 5 秒执行一次
        scheduler.scheduleAtFixedRate(task, 0, 5, TimeUnit.SECONDS);
    }
}

python

import time

def my_task():
    print("定时任务执行中...")

while True:
    my_task()
    time.sleep(5)  # 休眠1秒

IO：

java:

import java.io.*;

public class FileIOExample {
    public static void main(String[] args) {
        String content = "Hello, World!";
        String filePath = "example.txt";

        // 写入文件
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
            writer.write(content);
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 读取文件
        try (BufferedReader reader = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

python

# 写入文件
content = "Hello, World!"
file_path = "example.txt"

with open(file_path, 'w') as file:
    file.write(content)

# 读取文件
with open(file_path, 'r') as file:
    for line in file:
        print(line.strip())

解释
Java：使用 BufferedWriter 和 BufferedReader 进行文件的写入和读取。
Python：使用 open 函数和上下文管理器 (with) 来处理文件的写入和读取，代码更简洁。

异常：

java

public class ExceptionDemo {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0); // 可能抛出异常
            System.out.println("Result: " + result);
        } catch (ArithmeticException e) {
            System.out.println("捕获到异常: " + e.getMessage());
        } finally {
            System.out.println("执行 finally 块");
        }
    }

    public static int divide(int a, int b) {
        return a / b; // 可能抛出 ArithmeticException
    }
}

python

def divide(a, b):
    return a / b  # 可能抛出 ZeroDivisionError

try:
    result = divide(10, 0)  # 可能抛出异常
    print("Result:", result)
except ZeroDivisionError as e:
    print("捕获到异常:", e)
finally:
    print("执行 finally 块")

解释
Java：使用 try-catch-finally 结构来捕获和处理异常。ArithmeticException 用于处理除以零的情况。
Python：同样使用 try-except-finally 结构，ZeroDivisionError 用于处理除以零的情况。

总结：

没有最好的编程语言，只有最合适的编程语言！大家一起学起来吧！

如果看到这里，说明你喜欢这篇文章，请关注和点赞小编。关注【微信公众号微信】搜索【老板再来一杯时光】回复【进群】即可进入无广告交流群！

好文推荐：
netty搭建websocket集群（高性能.,高并发）
springboot 实现延时队列（超级实用）
2.5万字讲解DDD领域驱动设计（史上最全DDD）
史上最全从0到1搭建最新版本jenkins可持续集成

文章来源:https://blog.csdn.net/qq_41889508/article/details/142585050
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系邮箱：jacktools123@163.com进行投诉反馈，一经查实，立即删除！