在论坛中出现的比较难的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元");
		}
}


郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。