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元");
}
}
苹果开发者证书下载／安装