Java_Foundation（一）-阿里云开发者社区

1.基础概述

1. 什么是跨平台？

由Java编写的程序可以在不同的操作系统上运行：一次编写，多处运行

2. 原理

编译之后的字节码文件和平台无关，需要在不同的操作系统上安装一个对应版本的虚拟机(JVM)

1.计算机基础知识

1. 二进制

计算机中的数据不同于人们生活中的数据，人们生活采用十进制数，而计算机中全部采用二进制数表示，它只包含0、1两个数，逢二进一，1+1=10.每一个0或者每一个1，叫做一个bit（比特，位）

十进制数据转成二进制数据：使用除以2获取余数的方式

二进制数据转成十进制数据

2. 字节

位（bit）：一个数字0或者一个数字1，代表一位，我们又称之为 “比特位”，通常用小写的字母b表示

字节 ( Byte）: 每逢8位是一个字节,这是数据存储的最小单位，通常用大些字母 “B” 表示

1Byte=8bit
  1KB=1024Byte
  1MB=1024KB
  1GB=1024MB
  1TB=1024GB

3. 命令提示符

d: 回车盘符切换

dir(directory):列出当前目录下的文件以及文件夹

cd (change directory)改变指定目录(进入指定目录)

cd 文件夹\文件夹2\文件夹3

cls : (clear screen)清屏

exit : 退出dos命令行

这里面的了解即可，上面的要
 md (make directory) : 创建目录
 rd (remove directory): 删除目录

4 . 什么是JDK，JRE

JDK是提供给Java开发人员使用的，其中包含了java的开发工具，也包括了JRE。所以安装了JDK，就不用在单独安装JRE了。其中的开发工具：编译工具(javac.exe) 打包工具(jar.exe)等

JRE(Java Runtime Environment Java运行环境)
包括Java虚拟机(JVM Java Virtual Machine)和Java程序所需的核心类库等，如果想要运行一个开发好的Java程序，计算机中只需要安装JRE即可。

5.第一个HelloWorld

步骤：

将 Java 代码编写到扩展名为 .java 的文件中。

通过 javac 命令对该 java 文件进行编译。

通过 java 命令对生成的 class 文件 [字节码文件] 进行运行。

6. 注释

单行注释 //注释文字

多行注释 /* 注释文字 */

文档注释（java特有）

格式：/**
      * @author  指定java程序的作者
    *@version  指定源文件的版本
             *@param   方法的参数说明信息
             */

2.基本语法

1. 关键字和标识符

关键字：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

所谓保留字,即它们在Java现有版本中没有特殊含义,以后版本可能会作为有特殊含义的词

①.完全小写的纯字母

②.在增强版的记事本中有特殊颜色

标识符：给类、变量、方法、接口等起名字用的符号[掌握]

→ 命名的规则：（一定要遵守，不遵守就会报编译的错误）

①.由26个英文字母大小写，0-9 ，_或 $ 组成

②.数字不可以开头

③.不可以使用关键字和保留字，但能包含关键字和保留字

④.Java中严格区分大小写，长度无限制

⑤.标识符不能包含空格

2.Java中的名称命名规范 [掌握]

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

3. 常量

1.常量的定义

在程序运行期间，固定不定的量

2. 常量的分类：

分为自定义常量和字面值常量 [ 以下的6种属于这种类型 ]：

①.字符串常量：凡是用双引号引起来的部分，叫做字符串常量。例如：“abc”、“hello”、“123”

②.整数常量：直接写上的数字，没有小数点，例如 100、200、0

③.浮点数常量：直接写上的数字，有小数点，例如：2.5，-3.14

④.字符常量：凡是用单引号引起来的单个字符，只能单个字母、数字、中文=，就做字符常量。例如：‘A’、‘b’ 、'中’

⑤.布尔常量：只有两种取值: true 和 false

⑥.空常量：null。代表没有任何数据,不能直接输出

null值不能直接输出，在引用类型中，被赋值了null表示引用类型不存在了

@Test
  public void fun5(){
    //字符串常量
  System.out.println("ABC");
  System.out.println("");//字符串两个双引号中间的内容为空
  System.out.println("XYZ");
  //整数常量
  System.out.println(30);
  System.out.println(-500);
  //浮点数常量(小数)
  System.out.println(3.14);
  System.out.println(-2.5);
  //字符常量
  System.out.println('A');
  System.out.println('6');
  //System.out.println('');两个单引号中间必须有且仅有一个字符，没有不行
  //System.out.println('AB');有两个不行
  //布尔常量
  System.out.println(true);
  System.out.println(false);
  //空常量。空常量不能直接用来打印输出
  //System.out.println(null);
  }

4 . 变量

1. 变量的定义

在一定的范围内可以发生改变的量

2. 变量的定义

定义变量的格式：数据类型变量名 = 初始化值

3. 变量的分类 → 按数据类型

整数类型默认是 int

浮点类型默认是 double

布尔类型默认是 false

整数类型：byte、short、int、long
→ java的整型常量默认为 int 型，声明long型常量须后加‘l’或‘L’

浮点类型：float、double

计算机是无法运算小数的，只能无限接近这个小数

→Java 的浮点型常量默认为double型，声明float型常量，须后加‘f’或‘F’

字符串：char 只能表示一个字符=2个字节

boolean类型数据只允许取值true和false，无null [ 内存占用1字节 ]

4. 变量的注意事项

①. 名字不能重复

②. 变量未赋值，不能使用

③. long类型的变量定义的时候，为了防止整数过大，后面要加L或l

long l=10000000000 （×）

④. floa类型的变量定义的时候，为了防止不兼容的类型，后面要加F或f

float f=13.14 （×）

int a;//不报错
int a;
System.out.println(a);//报错

5. 变量的自动类型转换和强制类型转换

1. 自动类型转换

自动类型转换：容量小的类型自动转换为容量大的数据类型。数据类型按容量大小排序为：

@Test
  public void fun1(){
  int i1=12;
  short s2=2;
  int i2=i1+s2;
  System.out.println(i2);//14
  float f1=12.3F;
  float f2=f1=i2;
  System.out.println(f2);
  long l=12;//不加f默认12是int；int型赋值给long可以转换
  }

2. 强制数据类型

强制类型转换: 容量大转换为容量小的,要使用强制类型转换符
强制类型转换的问题：导致精度的损失

通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类则可以实现把字符串转换成基本类型

格式：范围小的类型范围小的变量名=（范围小的类型）原本范围大的数据

如： String a = “43”; int i = Integer.parseInt(a);

boolean类型不可以转换为其它的数据类型。

int num=(int) 100L;
    System.out.println(num);

3.数据类型转换 [ 注意事项 ]

①. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出

②. byte、short、char这三个类型都可以发生数学运算，例如加法 "+"

③. byte、short、char这三个类型在运算的时候，都会被首先提升为int类型，然后再进行计算

④. boolean类型不能发生数据类型转换

char c1='A';//这是一个字符型变量，里面是大写字母A
    System.out.println(c1+1);//66，也就是大写字母A被当成65进行处理
    //计算机的底层会用一个数字（二进制） 来代表字符A，就是65
    //一旦char类型进行了数据运算，那么字符就会按照一定的规则翻译成一个数字
    byte b1=40;//注意！右侧的数值大小不能超过左侧的类型范围
    byte b2=50;
    //byte + byte---> int + int =int
    int result1=b1+b2;
    System.out.println(result1);
    short s1=60;
    //byte + short -->int + int 
    int result2=b1+s1;
    //int 强制转换为short: 注意必须保证逻辑上真实大小
    //本来就没有超过short范围，否则会发生数据溢出
    //short result3=(short)(b1+s1);

6. ASCII编码表和 unicode

ASCII：美国信息交换标准代码

Unicode码表：万国表，也是数字和字符的对照关系，开头0-127部分和ASCII 完全一样，但是从128开始包含有更多字符

ASCII：记住如下
48 代表0
65 代表A
97 代表小写a

7. 运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。

1. 算术运算符：+ - * / % ++ – +

/ 和 %的区别：两个数据做除法，/ 取结果的商，%取结果的余数

整数除以整数，要想得到小数，必须有浮点数参与运算

double d=3.4;
System.out.println(3.6/5);//0.72
System.out.println(3.0/2);//1.5

i++或++i ①.单独使用的时候，++或-- 无论是在变量的前边还是后边，结果都是一样的

②. 参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++或–；参与操作的时候，如果放在变量的前边，先拿变量做++或–，后拿变量参与操作；

int i=1,a=0;
     i++ 先赋值再运算,例如 a=i++,先运算a=i,后运算i=i+1,所以结果是a==1
     ++i 先运算再赋值,例如 a=++i,先运算i=i+1,后运算a=i,所以结果是a==2
     int a=5;
     System.out.println(++a);//6
     System.out.println(a++);//6
     /   除法运算
     %   取模运算，两个数字相除取余数

//% : 符号左边的数字如果大于右边，那么先进行除法运算，求余数
        System.out.println(7%6); //1
        System.out.println(8%6); //2
        //% :符号左边的数字如果是右边的倍数的时候，余数是0
        System.out.println(12%6); //0
        System.out.println(24%6); //0
        // % 符号左边的数字如果＜右边，那么余数就是左边
        System.out.println(4%6); // 4
        System.out.println(5%6); // 5
        System.out.println(3%6); // 3

四则运算当中的加号 " + " 有常见的三种用法

①. 对于数值来说，那就是加法

②. 对于字符char类型来说，在计算之前，char会被提升为int，然后再计算 [ 重点 ]

③. 对于字符串String(首字母大写，并不是关键字)，加号代表字符串链接串。任何数据类型和字符串进行连接的时候，结果都会变成字符串 [ 重点 ]

④. 一旦运算当中有不同的类型的数据，那么结果将会使数据类型范围大的那种 [ 重点 ]

//小的会提升为大的，在进行运算
          int a=10;
          double  b=10.0;
          double result=a+b;
          //字符首先会被提升为int，在进行加法运算
          System.out.println('你'+0);//20320
          System.out.println('最'+0);//26368
          System.out.println('近'+0);//36817
          System.out.println('还'+0);//36824
          System.out.println('好'+0);//22909
          System.out.println('吗'+0);//21527

当 " + " 操作中出现字符串时，这个 " + "是字符串连接符，而不是算术运算

在 " + " 操作中，如果出现了字符串，就是连接运算符，否则就是算术运算。当连续进行 " + " 操作时，从左到右逐个执行

System.out.println(1 + 99 + "年黑马"); // 输出：100年黑马
System.out.println(1 + 2 + "itheima" + 3 + 4); // 输出：3itheima34
// 可以使用小括号改变运算的优先级 
System.out.println(1 + 2 + "itheima" + (3 + 4)); // 输出：3itheima7

int x=10;
int y=20;
//  11+20
int result=++x + y --; 
System.out.println(result);//31
System.out.println(x);//11
System.out.println(y);//19

2.赋值运算符

基本赋值运算符：就是一个等号 ‘=’, 代表将右侧的数据交给左侧的变量

复合赋值运算符

+=： a+=1 相当于 a=a+1;

-= *= /= %=

注意事项：

①.只有变量才能使用赋值运算符，常量不能进行赋值

②. 复合赋值运算符其中隐含了一个强制类型的转换

int i= 12；
i  = i * 5;
i *= 5;//与上一行代码同样的意思
【特别地】
short s = 10;
s = s + 5;//报编译的异常
s = (short)(s + 5);
s += 5;//s = s + 5，但是结果不会改变s的数据类型。

3. 比较 [ 关系 ]运算符：[ == > < >= <= ]

①.比较运算符的结果一定是一个 boolean 值，成立就是true，不成立就是false

②.如果进行多次判断，不能连着写

数学当中的写法，例如：3<x<6, 程序当中不允许这种写法

4. 逻辑运算符

1. &、|、！、^

&: 有：false则false

|：有true则true

^ 相同为false，不同为true

 int a=10;
 int b=20;
 int c=30;
 System.out.println((a>b)^(a>c));// false ^ false =false
 System.out.println((a<b)^(a>c));// ture ^ false = true
 System.out.println((a>b)^(a<c));// false ^ true =true
 System.out.println((a<b)^(a<c));// true ^ true =false

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6

2. 短路逻辑运算符 [ 重点 ]

“&”和“&&”的区别：

单&时，左边无论真假，右边都进行运算；

双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算

“ | ”和“|| ”的区别同理，||表示：当左边为真，右边不参与运算。

异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。

5. 三元运算符：(条件表达式)？表达式1 ：表达式2；

①. 既然是运算符，一定会返回一个结果，并且结果的数据类型与表达式1，2 的类型一致

②. 表达式 1 与表达式 2 的数据类型一致。

③. 使用三元运算符的，一定可以转换为if-else。反之不一定成立。

注意：

①.必须同时满足表达式A和表达式B都符合左侧数据类型的要求

②.三元运算符的结果必须使用

int a=10;
  int b=20;
  //判断a>b是否成立，如果成立将a的值赋值给max;
  //如果成立将a的值赋值给max;如果不成立将b的值赋值给max
  int max=a>b?a:b;
  System.out.println(max);
  System.out.println(a>b?a:b);//正确写法
  //3>4?3:4;错误写法

程序流程控制

8.程序流程控制

顺序结构：程序从上到下逐行地执行，中间没有任何判断和跳转

分支结构：根据条件，选择性地执行某段代码,有if…else和switch两种分支语句

循环结构

根据循环条件，重复性的执行某段代码

有while、do…while、for三种循环语句

注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素

1. 顺序结构

Java中定义成员变量时采用合法的前向引用。如：

public class Test{
        int num1 = 12;
        int num2 = num1 + 2;
}
错误形式：
public class Test{
       int num2 = num1 + 2；
       int num1 = 12;
}

2. 分支结构

1. 条件判断 : if

①if(条件表达式){   }
②if(条件表达式){
  //执行的语句1；
  }else{
  //执行的语句2；
  }
③if(条件表达式1){
  //执行的语句1；
  }else if(条件表达式2){
  //执行的语句2；
  }else if( 条件表达式3){
  //执行的语句3；
  }...
  }else{
  //执行的语句；
  }

注意：

①. 一旦满足某个条件表达式，则进入其执行语句块执行，执行完毕，跳出当前的条件判断结构，不会执行其以下的条件结构语句。

②. 如果诸多个条件表达式之间为“互斥”关系，多个结构可以上下调换顺序

③. 如果诸多个条件表达式之间为“包含”关系，要求条件表达式范围小的写在范围大的上面。

2. 选择结构

执行的流程 [ 掌握 ]：首先会先计算出switch表达式中的值，然后和第一个case进行匹配。如果匹配成功，就执行语句体，接着就遇到break，这个时候整个switch 全部结束！！如果所有的case都不匹配的情况下，才会执行 default
switch(变量){
  case 值1:
  //break;
  case 值2:
  //break;
  ...
  default:
  break;
}

注意：

①. 变量可以为如下的数据类型：byte short int char 枚举 String [ 掌握 ]

②. 多个case后面的数值不可以重复，最后一个break可以省略，但是通常不要省略

③. switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略。"匹配哪一个case就从哪一个位置向下执行，直到遇到了break或整体结束为止"

int num=1;
     switch(num){
     case 1:
      System.out.println("今天是星期一");
      break;
     case 2:
      System.out.println("今天是星期二");
      break;
      default:
       System.out.println("随时");
       break;
     }

case穿透 [ 掌握 ]：在switch语句中，如果case控制的语句体后不写break，将出现穿透现象，在不判断下一个case值的情况下，向下运行，直到遇到break，或者整体switch语句结束
        //如果这个时候输入一个月份是1，会运行 冬季
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入月份");
        int month=sc.nextInt();
        switch (month){
            case 1:
            case 2:
            case 12:
                System.out.println("冬季");
                break;
            case 3:
            case 4:
            case 5:
                System.out.println("春季");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("夏季");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("秋季");
                break;
            default:
                    System.out.println("你输入的月份有误！");
                    break;
        }

///

@Test
    public void fun2() {
        int x = 3;
        int y = 2;
        /*
        ①. x=3 会在case中查找有没有为3的，这里没有，则运行default中的语句
        ②. y++ 后 y的值变成3，这时 default 中没有 break 语句，所以会发生穿透现象
        ③. 在case 2 中 y=4 ;
        ④. 之后遇到了 break ，循环结束 y=4
        * */
        switch (x) {
            case 1:
                y++;
            default:
                y++;
            case 2:
                y++;
                break;
            case 5:
                y++;
                break;
        }
        System.out.println(y);//4
    }
    @Test
    public void fun1() {
        int x = 3;
        int y = 2;
        /*
        ①. x=3 会在case中查找有没有为3的，这里没有，则运行default中的语句
        ②. y++ 后 y的值变成3，这时 default 中没有 break 语句，所以会发生穿透现象
        ③. 在case 1 中 y=4 ; 在 case 2 中 y=5
        ④. 之后遇到了 switch 中结束的 括号，循环结束 y=5
        * */
        switch (x) {
            default:
                y++;
            case 1:
                y++;
            case 2:
                y++;
        }
        System.out.println(y);//5
    }

3. 循环结构

1. 循环结构的分类

1. for循环
表达式：for（初始化；布尔表达式；更新）{
  　程序代码.......
}　
2. do--while
   do{
       }while（）
3. while（）{  }
4.死循环：永远停不下来的循环，叫做死循环
for( ; ; ){}
while(ture){
循环体；
}
do{
}while(true)

int i=0;
       for(;i<5;){
           System.out.println("了解这里就可以了");
           i++;
       }
       int j=0;
       while(j<5){
           System.out.println("了解这里就可以了");
           j++;
       }

2. 获取任意数字位的数字

个位：i %10; 十位: i / 10 % 10 ； 百位：i /10/10%10
        //获取3这个数字
        int x=1234567/10000%10;
        System.out.println(x);
        水仙花：个位的 ³ +十位的 ³ +百位的 ³ =这个数字 称为水仙花数
        @Test
        public void fun6() {
            int count = 0;
            for (int i = 100; i < 1000; i++) {
            //在计算之前获取三位数中每个位上的值
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 10 / 10 % 10;
            //判断条件水仙花数的过程中，满足条件不再输出，更改为修改count的值，使count+1
            if (ge * ge * ge + shi * shi * shi + bai * bai * bai == i) {
                count++;
            }
        }
        System.out.println("水仙花数是:" + count + "个");
    }

3. 三种循环的区别

①. 如果条件判断从来没有满足过，那么for循环和while循环将会执行0次，但是do-wh ile循环会执行至少一次

②. for循环的变量在小括号当中定义，只有循环内部才可以使用。while循环和do-whi le循环初始化语句本来就在外面，所以出来循环之后还可以继续使用

4. break 和 continue

①.break

使用switch-case结构或者循环结构中

在循环结构中，一旦执行到break，就跳出当前循环。

②.continue

使用在循环结构中
 一旦执行到continue，就跳出当次循环
//break:用在循环中，基于条件控制，终止循环内容的执行，也就是说结束当前整个循环
//continue：用在循环中，基于条件控制的，跳过某次循环体内容的执行，继续下一次的执行
for(int i = 1;i <= 10;i++){
  if(i % 4 == 0){
  //break; //123
  continue;  //123567910
  }
  System.out.print(i);
}

5.循环嵌套

外循环执行一次，内循环控制分钟的范围
       //外循环执行一次，内循环控制分钟的范围
        for (int hour = 0; hour < 24; hour++) {
            for(int minute=0;minute<60;minute++){
                System.out.println(hour+"时"+minute+"分");
            }
        }

API

9. API

应用程序编程接口 [ 产品说说明 ]

1>. Scanner 类

1. Scanner类的功能：

可以实现键盘输入数据，到程序当中

2. 引用类型的一般使用步骤：

①. 导包

import 包路径.类名称；如果需要使用的目标类，和当前类位于同一个包下，则可以省略导包语句不写。只有java.lang包下的内容不需要导包，其他的包都需要使用import语句

②. 创建

类名称对象名=new 类名称（）；

③ .使用

对象名.成员方法名（）；

获取键盘输入的一个int数字：sc.nextInt();

获取键盘输入的一个字符串：sc.next();[ 是以空格结束的 ]

sc.nextLine（）：是以/r/n结束的

import java.util.Scanner;//1.导包
public class Demo1Scanner {
    public static void main(String[] args) {
        //2.创建
        //备注：System.in ：从键盘进行输入
        Scanner sc=new Scanner(System.in);
        System.out.println("请从键盘输入一个数字");
        int num1=sc.nextInt();
        System.out.println("请从键盘输入一个数字："+num1);
       //快捷键 ctrl+alt+v
        String str=sc.next();
        System.out.println("输入的字符串是"+str);
   }
}

//求出键盘输入的最大值
import java.util.Scanner;//1.导包
public class Demo1Scanner {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入第一个数字: ");
        int num1=sc.nextInt();
        System.out.println("请输入第二个数字: ");
        int num2=sc.nextInt();
        System.out.println("请输入第三个数字: ");
        int num3=sc.nextInt();
        //首先得到前两个数字当中的最大值
        int temp=num1>num2?num1:num2;
        int max=temp>num3? temp:num3;
        System.out.println("最大值是:"+max);
   }
}

2>. Random 类

①. 导包：import java.util.Random;

②. 创建：Random random=new Random();

③. 使用：

int num=r.nextInt（）：获取一个随机的int 数字 [ 范围是int所有的范围，有正负两种 ]
 int num2=r.nextInt（10）:获取一个随机的int数字 [ 参数代表了范围，左闭右开区间 ]，实际上代表的含义是[0,10) ,也就是0-9；
 public static void main(String[] args) {
        Random r=new Random();
        int num=r.nextInt();
        System.out.println("随机数是："+num);
        int num2=r.nextInt(3);
        System.out.println("随机数0-3之间的是："+num2);
   }

//根据int变量n的值，来获取随机数字，范围是：[1,n] 
        Scanner sc=new Scanner(System.in);
        System.out.println("请输入一个随机数：");
        int n=sc.nextInt();
        Random r=new Random();
        int num=r.nextInt(n)+1;// n-1+1  后面的1就是前面的取值[1
        System.out.println("生成的随机数1-n是:"+num);

//猜数字小游戏
  /*
   1.首先需要产生一个随机数字，并且一旦产生不再变化，用Random的nextInt()方法
   2.需要键盘输入，所以用到了Scanner
   3.获取键盘输入的数字，用Scanner当中的nextInt()方法
   4.已经得到了两个数字，判断(if)一下:
   如果太大了，提示太大，并且重试
   如果太小了，提示太小，并且重试
   如果猜中了，游戏结束
   5.重试就是再来一次，循环次数不确定，用while(true)
    * */
    public static void main(String[] args) {
        Random r=new Random();
        int randomNum=r.nextInt(100)+1;//[1-100]
        System.out.println("随机生成的这个数字是:"+randomNum);
        Scanner sc=new Scanner(System.in);
        System.out.println("请猜下这个数是");
       while(true){
           int gussNum=sc.nextInt();//键盘输入猜测的数字
           if(gussNum>randomNum){
               System.out.println("太大了，请重试");
           }else  if(gussNum<randomNum){
               System.out.println("太小了，请重试");
           }else{
               System.out.println("恭喜你，猜中啦！");
                break;
           }
       }
   }

3>. Arrays [ static ]

java.util.Arrays:是一个与数组相关的工具类，里面提供了大量的静态方法，用来实现数组常见的操作，构造方法用private修饰

public static String toString（数组）：将参数数组变成字符串（按默认格式：[ 元素1 ，元素2 ，元素3 ]）

public static void sort（数组）：按照默认升序（从小到大）对数组的元素进行排序

备注：①.如果是数值，sort默认按照升序从小到大

②. 如果是字符串，sort默认按照字母升序

③. 如果是自定义类型，那么这个自定义的类需要有Comparable或 Comparator 接口的支持

int []intArray={10,20,30};
        String instr= Arrays.toString(intArray);
        System.out.println(instr);//[10, 20, 30]
        int [] array1={1,2,66,99,77,55,21};
        Arrays.sort(array1);
        System.out.println(Arrays.toString(array1));//[1, 2, 21, 55, 66, 77, 99]

//需求：将一个随机字符串中得到所有字符升序排序，并倒序打印
        //自定义随机的字符串
        String line="adxcvewgjgn";
        //转换成字符数组
        char[]ch=line.toCharArray();
        //升序排序
        Arrays.sort(ch);
        //倒序打印
        System.out.print("升序后倒序打印如下:");
        for(int i=ch.length-1;i>=0;i--){
            System.out.print(ch[i]+"\t");
        }

4>. Math [ 静态 ]

注意：Math 类有构造方法，构造方法被私有化了

public static double abs(double num):获取绝对值,有多种取整

public static double ceil(double num):向上取整

public static double floor(double num):向下取整

public static long round(double num): 四舍五入，不带小数点 [ 常用 ]

Math.PI: 代表近似的圆周率常量

public static void main(String[] args) {
        //获取绝对值
        double dou=Math.abs(-3.14);
        System.out.println(dou);//3.14
        //向上取整
        System.out.println(Math.ceil(3.8));//4.0
        //向下取整
        System.out.println(Math.floor(3.9));//3.0
        //四舍五入
        System.out.println(Math.round(3.8));//4
    }

5>. System

1. System类的概述

System 类包含了一些有用的字段和方法，它不能被实例化

2. 方法

public static void exit （int status）:终止当前运行的Java虚拟机，该参数作为状态代码，按照惯例，非零状态码标识异常终止。

public static long currentTimeMillis（）：返回的是当前时间，以毫秒为单位：从1970年到现在的毫秒值

System.exit(0);//非0状态是异常终止，退出了Jvm，后面那句话不执行
          System.out.println("1111111");
          long start=System.currentTimeMillis();
           for (int i = 0; i < 1000; i++) {
               System.out.println("*");
           }
           long end=System.currentTimeMillis();//获取当前时间的毫秒值
           System.out.println("程序所产生的时间是"+end);

6>. Object

1.toString( )方法

①. 当我们打印一个对象的引用时，实际上默认调用的就是这个对象的toString（）方法

②. 当我们打印的对象所在类没有重写Object中的toString（）方法时，那么调用的就是Object中定义的toString（）方法。返回此对象所在的类及对应的堆空间对象实体的首地址值

③. 当我们打印的对象所在的类重写了toString（）方法时，调用的就是我们自己重写的toString（）方法,建议所有子类重写此方法：toString()

注意：像String类、包装类、File类、Date类等，已经实现了Object类中toString()方法

//重点是看Object中toString() 方法的源码
public class ObjectDemo {
    public static void main(String[] args) {
        Student s = new Student();
        s.setName("林青霞");
        s.setAge(30);
        //输出语句直接打印对象名，在源码的底层会调用该类的toString()
        //因此,我们曾经看到的都是对象的地址
        System.out.println(s); //com.itheima_01.Student@3f3afe78
        System.out.println(s.toString()); //com.itheima_01.Student@3f3afe78
        /*
        public void println(Object x) { //x = s;
            String s = String.valueOf(x);
            synchronized (this) {
                print(s);
                newLine();
            }
        }
        public static String valueOf(Object obj) { //obj = x;
            return (obj == null) ? "null" : obj.toString();
        }
        public String toString() {
            return getClass().getName() + "@" + Integer.toHexString(hashCode());
        }
         */
    }
}

2.Object类中的equals()方法

2.1. ==

①. 基本数据类型:根据基本数据类型的值判断是否相等。相等返回true，反之返回false

注：两端数据类型可以不同，在不同的情况下，也可以返回true

②. 引用数据类型：比较引用类型变量的地址值是否相等

2.2. equals()

①. 只能处理引用类型的变量

②. 比较对象是否相等。默认比较地址，重写后比较的是内容

// ==
int x = 10;
int y = 10;
String str1 = new String("abc");
String str2 = new String("abc");
System.out.println(x == y); // 输出true
 // 输出false，str1和str2是两个不同的引用类型变量，指向两个不同的地址。
System.out.println(str1 == str2);

//equals
        person person1=new person();
  person person2=new person();
  //没有重写前是比较的是地址值
  System.out.println(person1.equals(person2));//false
Object obj1 = new Object();
  Object obj2 = new Object();
  没有重写前是比较的是地址值
  System.out.println(obj1.equals(obj2));//false
  //String类是重写了equals的，所以比较的是内容
  String str1=new String("123");
  String str2=new String("123");
  System.out.println(str1.equals(str2));//true重写了equal方法

2.3 equals 重点理解

7>. Date类

1.Date类的概述

Date 类的概述是util 包下的，不能导入sql包下的

类Date 表示特定的瞬间，精确到毫秒。

2.构造方法

public Date()：空参构造，是当前时间

public Date(long l)：有参构造，从1970开始指定的毫秒数

//如果没有传递参数表示的是当前时间
      Date date1=new Date();
      System.out.println("date1 = " + date1);//date1 = Tue Jul 02 16:21:31 CST 2019
      //如果构造方法中传递的参数是0，代表的1970年1月1日
      Date date2=new Date(0);
      System.out.println("date2 = " + date2);//date2 = Thu Jan 01 08:00:00 CST 1970

3.成员方法

public long getTime（）：获得的是日期对象从1970年1月1日00：00：00到现在的毫秒值

public void setTime（）：设置时间，给的是毫秒值

Date date1=new Date();
        long time = date1.getTime();
        long systemTime = System.currentTimeMillis();
        //大多数情况下time  和 systemTime 是一样的，相差的时间间隙太小了
        System.out.println("通过时间对象获取毫秒值"+time);//1562763852244
        System.out.println("通过系统方法获取毫秒值"+systemTime);//1562763852245
        System.out.println("--------");
        Date dat2=new Date();
        dat2.setTime(1000);//设置豪秒值，改变时间对象
        System.out.println(dat2);// Thu Jan 01 08:00:01 CST 1970

8>. SimpleDateFormat类实现日期和字符串的相互转换

1.DateFormat 类的概述

DateFormat: 是一个抽象类，不能被被实例化。是SimpleDateFormat的父类

2. SimpleDateFormat

构造函数：①. SimpleDateFormat() ②. SimpleDateFormat(String pattern)

方法：public final String format(String pattern): 将日期对象转成字符串

public Date parse(String source): 将字符串转成日期对象
        //获取当前时间对象
        Date d1=new Date();
        //创建日期格式化类对象
        SimpleDateFormat sdf=new SimpleDateFormat();
        String format = sdf.format(d1);
        System.out.println(format);//2019/7/10 下午9:14

//将日期对象转换成字符串
        //获取当前时间对象
        Date d1=new Date();
        //创建日期格式化类对象
        //SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd HH:mm:ss");//2019年07月10 21:18:48
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");//2019/07/10 21:19:28
        System.out.println(sdf.format(d1));

//将时间字符串转成日期对象
        String str="2000年08月08日08:08:08";
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        //将字符串转成日期对象
        Date d1=sdf.parse(str);
        System.out.println(d1);//Tue Aug 08 08:08:08 CST 2000

//计算出你活了多少天
        //1.将生日字符串和今天字符串存在String类型的变量中
        String strBir="1996年02月11日08:08:08";
        String strNow="2019年07月10日08:08:08";
        //2.定义日期格式化对象
        SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
        //3.将日期字符串转成日期对象
        Date dBir=sdf.parse(strBir);
        Date dNow=sdf.parse(strNow);
        //4.通过日期对象获取毫秒值
        long time=dNow.getTime()-dBir.getTime();
        System.out.println("你再世界上活了"+time/(1000*60*60*24));

3>. 关于工具类

工具类: ①.构造方法私有 ②.成员方法静态

public class DateUtils {
    private DateUtils(){}
    //将日期转化为指定格式的字符串
    public static String dateToString(Date date,String format){
        SimpleDateFormat sdf=new SimpleDateFormat(format);
        String s=sdf.format(date);
        return s;
    }
    //把字符串解析为指定格式的日期
    public static Date stringToDate(String str,String format) throws ParseException {
    SimpleDateFormat sdf=new SimpleDateFormat(format);
    Date date=sdf.parse(str);
    return date;
    }
}

public class DateDemo {
    public static void main(String[] args)throws Exception {
        //1.测试将日期转成字符串
        Date d=new Date();
        String format="yyyy年MM月dd日 HH:mm:ss";
        String string=DateUtils.dateToString(d,format);
        System.out.println(string);//2019年07月16日 15:07:05
        //2.测试将字符串转成日期
        String str="2019-7-16 08-08-08";
        String format2="yyyy-MM-dd HH-mm-ss";
        Date date=DateUtils.stringToDate(str,format2);
        System.out.println(date);//Tue Jul 16 08:08:08 CST 2019
    }
}

9>. Calendar类

public static Calendar getInstance（）：创建Calendar对象

public int get（int field）：获取年、月、日等

public abstract void add（int field，int amount）：根据日历的规则，将制定的时间量添加或减去给定的日历字段

public final void set（int year，int month，int date） ：设置当前日历的年月日
        //获取对象
        Calendar c=Calendar.getInstance();//多态的方式
        //System.out.println(c);
        //public int get(int field);
        int year=c.get(Calendar.YEAR);
        //月份是从0开始的
        int month=c.get(Calendar.MONTH)+1;
        int day=c.get(Calendar.DATE);
        System.out.println(year+"年"+month+"月"+day+"日"); 
/*
    需求：
        获取任意一年的二月有多少天
    思路：
        1:键盘录入任意的年份
        2:设置日历对象的年、月、日
            年：来自于键盘录入
            月：设置为3月，月份是从0开始的，所以设置的值是2
            日：设置为1日
        3:3月1日往前推一天，就是2月的最后一天
        4:获取这一天输出即可
 */
public class CalendarTest {
    public static void main(String[] args) {
        //键盘录入任意的年份
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年：");
        int year = sc.nextInt();
        //设置日历对象的年、月、日
        Calendar c = Calendar.getInstance();
        c.set(year, 2, 1);
        //3月1日往前推一天，就是2月的最后一天
        c.add(Calendar.DATE, -1);
        //获取这一天输出即可
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年的2月份有" + date + "天");
    }
}

Java_Foundation（一）