public class MyThread2 implements Runnable{
	int count = 1, number;

	public MyThread2(int i){
		number = i;
		System.out.println("创建线程"+number);
	}

	public void run(){
		while(true){
			System.out.println("线程"+number+":计数"+count);
			if(++count == 6)
				return；
		}
	}

	public static void main(String[] args) {
		for(int i=0; i<5; i++){
			new Thread(new MyThread2(i+1)).start();
		}
	}
}

结果

创建线程1
创建线程2
创建线程3
线程1:计数1
线程1:计数2
线程2:计数1
线程2:计数2
线程2:计数3
线程3:计数1
线程1:计数3
线程3:计数2
线程3:计数3

 

--> 前提            通过实现接口创建线程的方法通过生成实现java.lang.Runnable接口的类创建多线程。该接口只定义了一个方法run(),所以必须在新类中实现它。但是Runnable接口并没有任何对线程的支持,还必须创建Thread类的实例，这一:点可以通过Thread类的构造方法public Thread( Runnable target)来实现。通过这种方式实现多线程还...

     

前提

主要通过继承java.lang.Thread类，并覆盖Thread类的run()方法完成线程的创建

Thread类是一个具体的类，即不是抽象类，该类封装了线程的行为。要创建线程，需先创建一个Thread类的子类，Thread类中有两个最重要的方法run()和start()

run()方法必须重写，把线程所要的代码加入到这个方法中，也就是线程体

虽然run()方法是线程体，但不能直接调用，而是通过调用start()方法来启动线程。在调用start()的时候，start()方法会首先进行与多线程相关的初始化，然后调用run()方法

start和run方法

start: 用start方法来启动线程，真正实现了多线程运行，这时无需等待run方法体代码执行完毕而直接继续执行下面的代码。通过调用Thread类的start()方法来启动一个线程，这时此线程处于就绪（可运行）状态，并没有运行，一旦得到cpu时间片，就开始执行run()方法，这里方法run称为线程体，它包含了要执行的这个线程的内容，run方法运行结束，此线程随机终止。

run：run()方法只是类的一个普通方法而已，如果直接调用Run方法，程序中依然只有主线程这一个线程，其程序执行路径还是只有一条，还是要顺序执行，还是要等待run方法体执行完毕后才可继续执行下面的代码，这样就没有达到写线程的目的

代码

public class MyThread extends Thread{
	//count变量用于统计打印次数并共享变量
	private static int count = 0;
	public MyThread(String name)
	{
		//super 关键字可以在子类的构造方法中显式地调用父类的构造方法
		//访问父类的成员方法和变量
		super(name);
	}
	public static void main(String[] args) {
		//main方法开始
		//实例化线程
		MyThread p = new MyThread("t1");
		p.start();
		//主线程main方法执行一个循环
		for(int i=1; i<4; i++){
			count++;
			//主线程中打印count+"main"变量的值，并换行
			System.out.println("主线程 "+ count +" main");
		}
	}

	public void run(){
		//线程类必须有run()方法
		for(int i=1; i<4; i++){
			count++;
			System.out.println("run方法 "+count+": "+this.getName());
		}
	}
}

运行结果

主线程 1 main
run方法 2: t1
主线程 3 main
run方法 4: t1
主线程 5 main
run方法 6: t1

这段程序用Java虚拟机启动程序后，main方法生成新线程t1，并通过for循环输出变量count的值和线程名称

-->      前提主要通过继承java.lang.Thread类，并覆盖Thread类的run()方法完成线程的创建Thread类是一个具体的类，即不是抽象类，该类封装了线程的行为。要创建线程，需先创建一个Thread类的子类，Thread类中有两个最重要的方法run()和start()run()方法必须重写，把线程所要的代码加入到这个方法中，也就是线程体虽然run...

//package oop123;              //包
import java.io.*;              //引入键盘输入所需要的类所在的包
interface getProperty{         //接口定义，方法声明
	double Pi = 3.1415926;
	double getArea();          //面积
	double getCircum();        //周长
	String getName();          //名称
}

class mpoint{                  //定义点
	static int i = 0;
	double x,y;
	mpoint(double a,double b){
		this.x = a;
		this.y = b;
	}
	double getX(){
		return x;
	}
	double getY(){
		return y;
	}

}

class disp{                  //定义屏幕输出所需要的类
	double area;             //面积
	double circum;           //周长
	String drawingName;      //名称
	disp(double a,double b,String ss){
		this.area = a;
		this.circum = b;
		this.drawingName = ss;
	}
	public void display(){
		System.out.println("图像 是 "+ drawingName);
		System.out.println("面积 = "+area+'\n'+"周长 = "+circum);
	}
}

class triangle implements getProperty{    //定义三角形
	mpoint p1,p2,p3;                      //三点
	double s1,s2,s3;                      //三边 
	String drawingName = "triangle";
	triangle(mpoint p1,mpoint p2, mpoint p3){ //构造方法
		this.p1 = p1;
		this.p2 = p2;
		this.p3 = p3;
		this.s1 = Math.sqrt((p1.x - p2.x)*(p1.x - p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
		this.s2 = Math.sqrt((p3.x - p2.x)*(p3.x - p2.x)+(p3.y-p2.y)*(p3.y-p2.y));
		this.s3 = Math.sqrt((p1.x - p3.x)*(p1.x - p3.x)+(p1.y-p3.y)*(p1.y-p3.y));
	}
	 //方法实现
	public double getArea(){      
		double ss,ssa;
		ss = (s1+s2+s3)*Pi/2.0/Pi;
		ssa = Math.sqrt(ss*(ss-s1)*(ss-s2)*(ss-s3));
		return ssa;
	}
	public double getCircum(){
		return s1+s2+s3;
	}
	public String getName(){
        return drawingName;
	}
	public boolean tline(){
		return true;
	}
}

class circle implements getProperty{     //定义圆形
	mpoint p1;                           //圆心
	double radius;                       //半径
	String drawingName = "Circle";
	circle(mpoint p1,double radius){    //构造方法
		this.p1 = p1;
		this.radius = radius;
	}
	public double getArea(){
		double ssa;
		ssa = Math.PI*radius*radius;
		return ssa;
	}
	public double getCircum(){
		return Math.PI*2.0*radius;
	}
	public String getName(){
		return drawingName;
	}
	public boolean tcircle(){
		return true;
	}
}

class rectangle implements getProperty{   //定义长方形
	mpoint p1,p2;
	double s1,s2;
	String drawingName = "Rectangle";
	rectangle(mpoint p1,mpoint p2){
		this.p1 = p1;
		this.p2 = p2;
		this.s1 = Math.sqrt((p1.x-p2.x)*(p1.x-p2.x));
		this.s2 = Math.sqrt((p1.y-p2.y)*(p1.y-p2.y));
	}
	public double getArea(){
		return s1*s2;	
	}
	public double getCircum(){
		return s1+s2+s1+s2;
	}
	public String getName(){
		return drawingName;
	}
	public boolean rline(){
		return true;
	}
}
public class drawing extends disp{      //定义 main() 所在的类
	drawing (double a, double b, String ss){
		super(a,b,ss);
//由于子类不能继承父类的构造方法，因此，如果要调用父类的构造方法，
//可以使用 super 关键字。super 可以用来访问父类的构造方法、普通方法和属性。
	}
	public static void main(String[] args) throws IOException {
         BufferedReader keyin = new BufferedReader(new InputStreamReader(System.in));
//new BufferedReader 将字符流放到字符流缓冲区之中
//new InputStreamReader 将字节流变为字符流
//System.in 字节输入流
         String strxx;
         for(;true;){
         	System.out.println("输入字符串如 Triangle,Rectangle,Circle:");
         	strxx = keyin.readLine();  //读取输入
         	if(strxx.length() == 0) continue;
         	char charxx;
         	charxx = strxx.toUpperCase().charAt(0);  //大小写转换
         	switch(charxx)
         	{
             	case'T':         //三角形
             	System.out.println("请输入(三角形) 第一个点 x(enter) y(enter)");
             	mpoint p1 = new mpoint(aVar(keyin),aVar(keyin));
             	System.out.println("请输入(三角形) 第二个点 x(enter) y(enter)");
             	mpoint p2 = new mpoint(aVar(keyin),aVar(keyin));
             	System.out.println("请输入(三角形) 第三个点 x(enter) y(enter)");
             	mpoint p3 = new mpoint(aVar(keyin),aVar(keyin));
             	triangle t1 = new triangle(p1,p2,p3);  //构造三角形
             	disp tdisp = new drawing(t1.getArea(),t1.getCircum(),t1.getName());
             	tdisp.display();
             	break;
             	
             	case'C':        //圆形
             	System.out.println("请输入(圆形) 圆心 x(enter) y(enter)");
             	mpoint p4 = new mpoint(aVar(keyin),aVar(keyin));
             	System.out.println("请输入半径 x(enter)");
             	double radius = aVar(keyin);
             	circle t2 = new circle(p4,radius);   //构造圆形
             	disp cdisp = new drawing(t2.getArea(),t2.getCircum(),t2.getName());
             	cdisp.display();
             	break;
             	
             	case'R':        //长方形
                System.out.println("请输入(长方形)第一个点 x(enter) y(enter)");
                mpoint p6 = new mpoint(aVar(keyin),aVar(keyin));
                System.out.println("请输入(长方形)第一个点 x(enter) y(enter)");
                mpoint p7 = new mpoint(aVar(keyin),aVar(keyin));
                rectangle t3 = new rectangle(p6,p7);   //构造长方形
                disp rdisp = new drawing(t3.getArea(),t3.getCircum(),t3.getName());
                rdisp.display();
                break;
                
                default:System.out.println("错误，请输入 t(T),c(C),r(R)");
         	}//switch
         }//for循环
	}//main 方法
	static double aVar(BufferedReader keyin) throws IOException
	{//得到一个双变量
		String xx;
		xx = keyin.readLine();
		return Double.parseDouble(xx);

	}
}

--> 运用继承，接口，包等技术，编写求解几何图形(包括三角形，矩形，圆)的周长，面积//package oop123; //包 import java.io.*; //引入键盘输入所需要的类所在的包 interface getProperty{ //接口定义，方法声明 double Pi = 3.1415926; double...