Java中实现多线程有以下几种方法：

继承Thread类

创建一个新的类，继承Thread类，然后重写run()方法。在该类的对象上调用start()方法来启动线程。例如：

class MyThread extends Thread {
    @Override
    public void run() {
        // 任务代码
    }
}

public class Main {
    public static void main(String[] args) {
        MyThread thread = new MyThread();
        thread.start();
    }
}

实现Runnable接口

创建一个新的类，实现Runnable接口，并实现run()方法。然后将该类的实例传递给Thread类的构造函数，创建Thread对象。调用Thread对象的start()方法来启动线程。例如：

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 任务代码
    }
}

public class Main {
    public static void main(String[] args) {
        MyRunnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

使用Callable和FutureTask

创建一个新的类，实现Callable接口，并实现call()方法。然后将该类的实例传递给FutureTask类的构造函数，创建FutureTask对象。将FutureTask对象传递给Thread类的构造函数，创建Thread对象。调用Thread对象的start()方法来启动线程。例如：

import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;

class MyCallable implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        // 任务代码
        return 0;
    }
}

public class Main {
    public static void main(String[] args) {
        MyCallable callable = new MyCallable();
        FutureTask<Integer> futureTask = new FutureTask<>(callable);
        Thread thread = new Thread(futureTask);
        thread.start();
    }
}

使用Executor框架

Java提供了一个Executor框架，它可以用于更高级的线程管理。可以使用ExecutorService来创建和管理线程。例如：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 任务代码
    }
}

public class Main {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        MyRunnable runnable = new MyRunnable();
        executorService.submit(runnable);
        executorService.shutdown();
    }
}

这些方法中，使用Executor框架是最为推荐的，因为它提供了更多的灵活性和控制。不过，在了解Java多线程的基本概念时，从实现Runnable接口或者继承Thread类开始是一个很好的选择。