在论坛中出现的比较难的sql问题：24(生成时间段)

package com.itheima;
/**
 * 第1题：
 * 从键盘接受一个数字，打印该数字表示的时间，最大单位到天
例如：
键盘输入6，打印6秒
键盘输入60，打印1分
键盘输入66，打印1分6秒
键盘输入666，打印11分6秒
键盘输入3601，打印1小时1秒
键盘输入86440，打印1天40秒
 * @author AbuGe
 *
 */
import java.util.Scanner;
public class Test1
{
	public static Scanner sc; 
	public static void main(String[] args)
	{
		sc = new Scanner(System.in);
		while(true)
		{
			System.out.println("您输入的数字是：");
			int num = sc.nextInt();
			printTime(num);
		}

	}
	//将输入数字转换成对应的时间
	public static void printTime(int num)
	{
		int[] arr = new int[4];
		int pos = arr.length;
		while(num > 0)
		{
			int tmp = num % 60;
			arr[--pos] = tmp;
			num = num / 60;		
			//对小时进行处理(分秒是60进制，小时是24进制)
			if(24 <= arr[1] )
			{
				arr[0] = arr[1] / 24;
				arr[1] = arr[1] % 24;
			}
		}

			
		//遍历数组后，按格式输出
		for(int i = 0; i < arr.length; ++i)
		{
			if(arr[i] != 0)
			{
				switch(i)
				{
					case 0:System.out.print(arr[i] + " 天 "); break;
					case 1:System.out.print(arr[i] + " 时 "); break;
					case 2:System.out.print(arr[i] + " 分 "); break;
					case 3:System.out.print(arr[i] + " 秒 "); break;
					default:break;
				}
			}
		}

		System.out.println();
	}
}

/**
 * 第2题：为什么需要配置path，什么时候需要classpath？
 * @author AbuGe
 */

 *1.在我们使用cmd来使用JDK时，需要使用java,javac等，对于操作系统而言，当它要使用某个*.exe
 *时，会先从当前目录查找这个命令，若查不到OS就会到PATH所设定的路径去查找该命令，然后执行。这个path
 *也就是系统变量，它会告诉OS可执行文件（*.exe,*.bat）所在的路径。
 *当我我们使用JDK时，可以切换到JDK的bin目录下然后再编译，这样可以不设置path，但是比较麻烦，所以
 *我们将bin的路径添加到path中，这样我们就可以在任何 目录下使用javac和java的命令了
 *2.claasspath是专门针对java的，它就相当于OS的path，path针对整个OS，classpath告诉java虚拟机
 *（JVM）要使用或执行的*.class文件放在什么地方。所谓的JVM就像在当前OS下再激活另一个OS，对JVM来说classpath就是它的path
 *，所以JVM要运行程序需要设定classpath，即JVM需要像OS一样需要一个默认的查找class文件的路径。默认路径为英文的点，即“.”，表示
 *当前路径。在打包成jar或者调用其他包或者jar的时候classpath就显示出它的重要性了。默认情况下当前路径就可以了。
 *注：当前目录不是*.java和*.class文件所在文件夹时，javac时可以加上路径来编译，但是要在classpath中加入*.class的路径，否则JVM不能找到
 *这样才能直接运行，否则必须切换到*.class的目录才能执行。
 *

package com.itheima;
/**
 * 第3题：
 * 编程计算3乘8等于几，什么方法效率更高？
 * @author AbuGe
 *
 */
public class Test3 {
		public static void main(String[] args)
		{
			int result = getResult(3, 8);
			System.out.println("3 * 8 = " + result);
			int result_2 = getResult(8, 3);
			System.out.println("8 * 3 = " + result_2);
			//位运算效率最高
			int result_3 = getResult_2(3, 8);
			System.out.println("3 * 8 = " + result_3);

		}
		//运用累加
		public static int getResult(int base, int offset)
		{
			int result = 0;
			for(int i = 0; i < offset; i++)
			{
				result += base;
			}
			return result;
		}
		//位运算：3 * 8 = 3 * 2 * 2 * 2，因为乘以2就相当于左移一位，所以3 * 8即可由左移3位得到
		//位运算是CPU直接支持的，效率最高
		public static int getResult_2(int base, int offset)
		{
			int pos = 0;
			while(offset != 1)
			{
				offset = offset >> 1;
				pos++;
			}
			base = base << pos;
			return base;
		}
}

package com.itheima;
/**
 * 第4题： 以下代码哪个是正确的？为什么？
	a. byte b = 1 + 1;   正确  
	b. byte b = 1; b = b + 1; 错误
	c. byte b = 1; b = b += 1; 正确   
	d. byte b = 1; b = ++b;正确
 * @author AbuGe
 */
类型转换：（java是强类型的语言）
 *byte：整型数据类型的一种，占8位从-128-127；
 *整型默认是int型占32位，即4个字节
 *a:
 *1 + 1 先运算得到2， 是常量int型并在byte范围内，然后默认进行强制类型转换int为byte赋值给byte型的b，故可以
 *b：
 *byte = 1;是正确地，是常量int型并在byte范围内,默认直接将int型的1强制转换为byte型的，
 *但是b = b + 1;
 *将byte型的1与int型的1进行运算，自动进行类型提升，即byte的1提升为int型的，运算后
 *得到的结果是个int型的占4个字节，不能将一个占四个字节的int型直接赋值给占一个字节的byte型
 *可以更正为b = (byte)(b + 2);
 *c:
 *+=默认进行了强转b先+1然后再赋值给 b
 *d:
 *自增是可以的，默认会进行类型强制转换

package com.itheima;
import java.util.Scanner;
/**
 *第5题： 声明一个类Person，包括两个成员变量：name,age。定义函数sayHello(),
 *调用时输出：我叫***，今年***岁了。声明类Chinese继承Person。
 * @author AbuGe
 */
class Person
{
	public String name;
	public int age;
	public void sayHello(String n, int a)
	{
		this.name = n;
		this.age = a;
		System.out.println("我叫" + name + ",今年" + age + "岁了。");
	}
}
class Chinese extends Person
{
	
}
public class Test5 
{
	private static Scanner sc;
	public static void main(String[] args)
	{
		Person p = new Person();
		sc = new Scanner(System.in);
		System.out.println("请输入您的姓名：");
		String name = sc.nextLine();
		System.out.println("请输入您的年龄：");
		int age = sc.nextInt();
		p.sayHello(name, age);
	}
}

package com.itheima;
/**
 * 第6题：用控制台倒着输出九九乘法表，输出结果如下图所示：
 *   1*9=9    2*9=18    3*9=27    4*9=36    5*9=45    6*9=54    7*9=63    8*9=72    9*9=81
      ……
     1*3=3   2*3=6   3*3=9
     1*2=2   2*2=4
     1*1=1
 *变成打印所有的3位质数，质数特点：只能被和其本身整除
 * @author AbuGe
 */
public class Test6 {
	public static void print99(int num)
	{
		for(int x = 9; num <= x; --x)
		{
			for(int y = 1; y <= x; ++y)
			{
				System.out.print(y + " * " + x + " = " + (y * x) + "\t");
			}
			System.out.println();
		}	
	}
	public static void main(String[] args)
		{
			print99(1);
		}
}

package com.itheima;
/**
 * 第7题：编程打印所有的3位质数
 * 质数特点：只能被1和其本身整除
 * @author AbuGe
 */
public class Test7 {
	public static void main(String[] args) {
		//遍历了所有数
		printNum(100);
		//效率较高，只考虑奇数的情况即可
		System.out.println("--------------------------------------------------------");
		printNum_2(101);
	}
	public static void printNum(int num)
	{
		int i,j;
		for(i = num; i < 1000; ++i)
		{
			for(j = 2; j < i; ++j)
			{
				if(i % j == 0)
					break;
			}
			if(j ==i)
			System.out.println("i = " + i + " ");
		}
	}
	public static void printNum_2(int num)
	{
		boolean b;
		//除了2以外的所有偶数都不是质数，所以外循环只考虑奇数即可,而对于内循环最大只需考虑到其平方根即可用Math.sqrt(num)这个函数
		//求num的平方根，因为非质数的奇数只能分解为两个奇数相乘
		for(int i = num; i < 1000; i += 2)
		{
			b = true;
			for(int j = 3; j <= Math.sqrt(i); j += 2)
			{
				if(i % j == 0)
				{
					b = false;
					
					break;
				}
			}
			if(b)
			{
				System.out.println("i = " + i + " ");
			}
		}
	}
}

package com.itheima;
/**
 * 第8题：定义一个包含私有成员变量和函数的类，再定义一个内部类，在内部类函数中访问外部成员变量，
 * 并调用外部函数。在外部函数中创建内部类对象，调用内部类函数。
 * @author AbuGe
 */
public class Test8 
{
	private int num;
	private void func()
	{
		System.out.println("The num is: " + num);
	}
	public void VisitInner()
	{
		Inner innerobject = new Inner();
		innerobject.InnerFunc();
	}
	class Inner
	{	
		public void VisitOutter(int tmp)
		{
			num = tmp;
			func();
		}
		public void InnerFunc()
		{
			System.out.println("This is InnerFunc()!");
		}
	}
	//测试用例：
	public static void main(String[] args)
	{
		Test8 TestObject = new Test8();
		TestObject.new Inner().VisitOutter(20);
		TestObject.VisitInner();
	}
}

package com.itheima;
/**
 * 第9题：小明的妈妈每天会给他20元零花钱。平日里，小明先花掉一半，再把一半存起来。每到周日，小明拿到钱后会把所有零花钱花掉一半。
 * 请编程计算，从周一开始，小明需要多少天才能存够100元？
 * @author AbuGe
 *
 */
public class Test9 {
		public static void main(String[] args)
		{
			//定义两个变量：days用来统计天数
			//因为前六天每天可以存10元是固定的，故六天可以存60元，第七天拿到钱用掉一半;
			double sum = 0;
			int days = 0;
			while(sum < 100)
			{
				++days;
				if(days % 7 != 0)
				{
					sum += 10;
				}else if(days % 7 == 0)
				{
					sum = (sum + 20 ) / 2;
				}
			}
			System.out.println("小明需要" + days + "天，才能存够100元");
		}
}