//银行卡类
创新互联网站建设公司一直秉承“诚信做人，踏实做事”的原则，不欺瞒客户，是我们最起码的底线！ 以服务为基础，以质量求生存，以技术求发展，成交一个客户多一个朋友！专注中小微企业官网定制，做网站、成都网站设计，塑造企业网络形象打造互联网企业效应。
public class BanCard {
private Double money = 5000d;
public synchronized void drawMoney(double howMoney,String threadName){
try {
System.out.println(threadName+"进入取钱操作!");
Thread.sleep(2000);//为了提前是一次只有一个线程进入此方法，进行了睡眠2秒
if(howMoneymoney){
System.out.println(threadName+"余额不足！");
return;
}
this.money-=howMoney;
System.out.println(threadName+"-原始余额:"+this.money+",取钱"+howMoney+"后，还剩余额"+this.money);
System.out.println(threadName+"结束取钱操作!");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
//线程类
public class ThreadDemo implements Runnable {
private BanCard banCard = new BanCard();
private double howMoney=0d;
public void run() {
banCard.drawMoney(this.howMoney,Thread.currentThread().getName());
}
public double getHowMoney() {
return howMoney;
}
public void setHowMoney(double howMoney) {
this.howMoney = howMoney;
}
}
//main所在类
public class Test1 {
public static void main(String[] args) {
ThreadDemo threadDemo = new ThreadDemo();
threadDemo.setHowMoney(3000d);//取款3000
Thread thread1 = new Thread(threadDemo);
thread1.start();
threadDemo.setHowMoney(4000d);//取款4000
Thread thread2 = new Thread(threadDemo);
thread2.start();
}
}
package threadgroup;
class ThreadDemo3 extends Thread {
private String name;
private int delay;
public ThreadDemo3(String sname, int i_delay) {
name = sname;
delay = i_delay;
}
public void run() {
try {
sleep(delay);
} catch (InterruptedException e) {
}
System.out.println("多线程测试！\n" + name + "\n" + delay);
}
}
public class testMyThread {
public static void main(String[] args) {
ThreadDemo3 th1,th2,th3;
th1 = new ThreadDemo3("线程1", (int) (Math.random() * 900));
th2 = new ThreadDemo3("线程2", (int) (Math.random() * 900));
th3 = new ThreadDemo3("线程3", (int) (Math.random() * 900));
th1.start();
th2.start();
th3.start();
}
}
package threadgroup;
public class threadDemo {
public static void main(String[] args) {
Thread t = Thread.currentThread();
t.setName("你好吗？");
System.out.println("正在进行的Thread是：" + t);
try {
for (int i = 0; i 5; i++) {
System.out.println("我不叫穆继超" + i);
Thread.sleep(3000);
}
} catch (Exception e) {
// TODO: handle exception
System.out.println("Thread has wrong" + e.getMessage());
}
}
}
package threadgroup;
public class threadDemo2 implements Runnable {
public threadDemo2() {
Thread t1 = Thread.currentThread();
t1.setName("第一个主进程");
System.out.println("正在运行" + t1);
Thread t2 = new Thread(this, "");
System.out.println("在创建一个进程");
t2.start();
try {
System.out.println("使他进入第一个睡眠状态");
Thread.sleep(2000);
} catch (InterruptedException e) {
System.out.println("Thread has wrong" + e.getMessage());
}
System.out.println("退出第一个进程");
}
public void run() {
try {
for (int i = 0; i 5; i++) {
System.out.println("进程" + i);
Thread.sleep(3000);
}
} catch (InterruptedException e) {
// TODO: handle exception
System.out.println("Thread has wrong" + e.getMessage());
}
System.out.println("退出第二个进程");
}
public static void main(String[] args) {
new threadDemo2();
}
}
public class Monkey
{
public static void main(String[] args)
{
int sum=0,remain=1;
//每天吃剩的桃子加一个正好是前一天桃子的一半，每天桃子的总数就是前一天剩下桃子的数量
for(int day=9;day=1;day--)
{
sum=(remain+1)*2;
remain=sum;
System.out.println("第"+day+"天还剩"+remain+"个桃子");
}
System.out.println(sum);
}
}
1. 插入排序：插入排序基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入排序的基本思想是：每步将一个待排序的纪录，按其关键码值的大小插入前面已经排序的文件中适当位置上，直到全部插入完为止。
2. 选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
3. 冒泡排序：冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端。
4. 快速排序：快速排序（Quicksort）是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
5. 归并排序：归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
6. 希尔排序：希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
你看这个链接，网页链接
希望可以帮到你，望采纳~
这是斐波那契数列的问题
可以用递归，也可以用循环
递归：
public class Demo3 {
// 使用递归方法
private static int getFibo(int i) {
if (i == 1 || i == 2)
return 1;
else
return getFibo(i - 1) + getFibo(i - 2);
}
public static void main(String[] args) {
System.out.println("斐波那契数列的前20项为：");
for (int j = 1; j = 20; j++) {
System.out.print(getFibo(j) + "\t");
if (j % 5 == 0)
System.out.println();
}
}
}
循环：
public class Demo2 {
// 定义数组方法
public static void main(String[] args) {
int arr[] = new int[20];
arr[0] = arr[1] = 1;
for (int i = 2; i arr.length; i++) {
arr[i] = arr[i - 1] + arr[i - 2];
}
System.out.println("斐波那契数列的前20项如下所示：");
for (int i = 0; i arr.length; i++) {
if (i % 5 == 0)
System.out.println();
System.out.print(arr[i] + "\t");
}
}
}
System.out.println("1--" + a1.show(b));
a1是A类引用指向A类对象，不存在多态，一定调用A类方法。A类方法有两个show(D)和show(A)，b是B类引用无法转换为D类引用，但可以转换为A类引用，因此调用show(A)，输出A and A。
System.out.println("2--" + a1.show(c));
输出A and A，原因同上。
System.out.println("3--" + a1.show(d));
调用show(D)，输出A and D。
System.out.println("4--" + a2.show(b));
a2是A类引用指向B类对象，可能存在多态。b是B类引用无法转换为D类引用，但可以转换为A类引用，因此调用show(A)，而B类重写了show(A)，因此调用的是重写后的show(A)，输出B and A。
System.out.println("5--" + a2.show(c));
同上，C类引用无法转换为D类引用，但可以转换为A类引用，因此调用show(A)，输出B and A。
System.out.println("6--" + a2.show(d));
调用show(D)，show(D)又调用父类即A类的show(D)，输出A and D
System.out.println("7--" + b.show(b));
b是B类引用指向B类对象，不存在多态，一定调用B类方法。B类一共有三个方法：重写自A类的show(A)和show(D)，以及新定义的show(B)。show(b)调用show(B)方法，输出B and B
System.out.println("8--" + b.show(c));
C类继承自B类，也调用show(B)方法，输出B and B
System.out.println("9--" + b.show(d));
调用show(D)，show(D)又调用父类即A类的show(D)，输出A and D