每周总结12

每周总结12

1.char类型的输入

没有nextChar()这一说。

虽然有nextInt() nextDouble之类。但

Scanner类中没有提供nextChar()方法。

可以用

char a = in.next().charAt(n);

利用charAt(n)这个方法，可以返回输入的第n个字符。注意是从0开始计数的。（凡是信息学一类，一般从0开始计数，要有习惯和意识。）

代码示例

import java.util.*;


public class Test{
    public static final int INT = 0;
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        //char a = in.nextLine();//错了，类型不符合
        System.out.println("请输入一个字符，ps:即使你输入多个我也只取第一个，因为参数设定是0");
        char a = in.next().charAt(INT);
        System.out.println("你输入的字符是" + a);
    }
}
//输出结果
请输入一个字符，ps:即使你输入多个我也只取第一个，因为参数设定是0
gdhjkjtkyj43562456453gfjhjkkhjf
你输入的字符是g

2.java中常量的定义

（1）在interface中

public interface a{
    int ABC = 1;
}

接口中可以直接定义常量，接口中只能定义常量和抽象方法。接口的定义包括接口的声明和接口体

接口体由常量定义和方法定义组成

(2)在类中

public class a{
    public static final int INT = 1;
}

用static final int(datatype)来定义常量。要用public来修饰（或者其他）表示访问范围权限。

public static final int ABC = 1;

3.switch语句的格式

switch(表达式)

case 值1:

代码1;

code2;

code3…

可以写break;一般会写break,不然会case穿透，当然也可以利用穿透设计做事。

case 值2:

…

default:

codes…

表达式子的值类型只能为byte,short,char和int这4种之一。

case后的值1、2只能为常数或者常量，不能为变量。

多用才记得住。

4.Java程序运行时间的计算

（1）System.currentTimeMillis(),返回的时间单位为毫秒

current 现在的；当前的；

---

current
英 [ˈkʌrənt] 美 [ˈkɜːrənt]
adj.
现在的;当前的;现时发生的;通用的;流通的;流行的
n.
电流;(海洋或江河的)水流;气流;思潮;潮流;趋向

---

milli
英 [ˈmɪlɪ] 美 [ˈmɪli]
毫，千分之一

---

current Time Millis 现在的 时间 毫（秒）（为单位）

应该是静态方法，直接用类名System调用

学好英语确实对这个专业重要，方便看源码和理解，代码本身就是英语表示的，正统，感觉上也确实方便与计算机

形成照应，26个字母就可以组成所有的词汇，确实方便。

不像中文汉字，最初是象形文字语言，既形声又像形。

是艺术品和文化造物。

而

System.currentTimeMillis();

这个方法的返回值是 程序运行到这里 花费了多少时间

（2）

System.nanoTime();返回时间的单位为纳秒

---

nano
英 [ˈnænəʊ] 美 [ˈnɑnoʊ]
n.
毫微；纤（10的负九次方）

---

package com.XGX.Test;

import java.lang.*;

public class Test{
    public static void main(String[] args){
        int a = 0;
        //System.out.println(currentTimeMillis()+"ms");//这个好像不行啊
        long startTime = System.currentTimeMillis();
        int sum = 0;
        for(int i =0;i<=99;i++) {
            //sum + = i;//报错过不了，+=号要写在一起才能识别
            sum += i;
        }
        long endTime = System.currentTimeMillis();
        long time = endTime-startTime;
        System.out.println("计算花费时间：" + time);
        System.out.println("计算结果是："+ sum);

        System.out.println("上面是currentTimeMillis()方法返回的是毫秒，下面是nanoTime()返回纳秒");
        long startTime1 = System.nanoTime();
        int sum1 = 0;
        for(int i =0;i<=99;i++) {
            //sum + = i;//报错过不了，+=号要写在一起才能识别
            sum1 += i;
        }
        long endTime1 = System.nanoTime();
        double time1 = endTime1-startTime1;//double也是可以的
        System.out.println("计算花费时间：" + time1);
        System.out.println("计算结果是："+ sum1);
    }
}
//运行结果
计算花费时间：0
计算结果是：4950
上面是currentTimeMillis()方法返回的是毫秒，下面是nanoTime()返回纳秒
计算花费时间：1800.0
计算结果是：4950
//
每次计算所用的时间可能不同，计算机也是这样的。每次不一样。
    这里可以看到毫秒都显示不出来，因为在很短的时间内就计算完了。
    显示毫秒只能是0秒，要用纳秒才能显示出来。同时也可以看到double的级别高于long，可以实现自动类型转换。
    

总结

long/double startTime,endTime,Time;//等等，用于计算各个时间点程序运行了多久。

此方法可以计算

package com.XGX.Test;
import static com.XGX.Test.myException.T1.*;//6，导包还有静态导包
//静态导包后调用这个包中的静态方法就不需要加类名or对象名，直接用方法名就可以。
//路径写到方法所在的类，然后*按需导包or直接写方法名字。

public class Test{
    public static void main(String[] args){
        System.out.println(currentTimeMilis() + "ms");
        //毫秒时间
        System.out.println(nanoTime() + "ns");
        //纳秒时间
        //是两次计算，虽然计算的东西一致，但是耗时可能不一样。
    }
}
//这里是事先定义了方法（函数）才实现了这种效果。

//静态导包了。
package com.XGX.Test.myException;

import java.util.concurrent.Callable;

public class T1 extends Thread {//第一种构造，普通构造，
    public void run(){
        System.out.println("T1 start running.");
        for(int i = 0;i<=999;i++)
            System.out.println((i+1));
    }
    public static long currentTimeMilis(){
        long startTime = System.currentTimeMillis();//获取开始时间
        int sum = 0;
        for(int i = 0;i<10000000;i++){
            sum += i;
        }
        long endTime = System.currentTimeMillis();//获取结束时间。
        return endTime - startTime;
    }
    public static long nanoTime(){
        long startTime = System.nanoTime();//获取开始时间
        int sum = 0;//用于计算拖时间吧。
        for(int i =0;i<10000000;i++){
            sum += i;
        }

        long endTime = System.nanoTime();
        return endTime - startTime;
    }
    //这里是重写了

总结

所以直接用System这个类名去调用 这两个静态方法就可以了。

currentTimeMillis(); return 毫秒时间（千分之一秒）

nanoTime(); return 纳秒时间（十亿分之一秒）

返回值都是（程序运行到这里用了多少时间 ) , long类型的

所以要用减法得知中间大致花的时间。

用变量来储存返回值。

or直接显示

//格式
long startTime1 = System.currentTimeMillis();
long startTime2 = System.nanoTime();//or 这种。
这里写要计算时间的代码正文

long endTime1 = System.currentTimeMillis();
long endTime2 = System.nanoTime();

System.out.println("程序执行用时：" + endTime1 - startTime1);
    System.out.println("程序执行用时：" + endTime2 - startTime2);