Java基础

一.常用运算符

1.1赋值运算符

+=  -+  *=  /=  %=这些是常用的赋值运算符，他们把等号后面的值或者变量赋值给等号前面的变量

如：  a+=b  相当于a = a + b
   -+:   如：  a-=b  相当于a = a - b
   *=:   如：  a*=b  相当于a = a * b
   /+:   如：  a/=b  相当于a = a / b
   %=:   如：  a%=b  相当于a = a % b

package com.basic.day03.symbol; //


public class AssignSymbol01 {
    public static void main(String[] args) {
       int a = 10;
       int b = 20;
       a+=b;  //  相当于a = a + b
       System.out.println(a); //30
        System.out.println(b);//20
        a-=b; //  相当于a = a - b
        System.out.println(a); //10

        int c = 3;
        int d = 6;
        c *= d;
        System.out.println(c); //18

        c = 15;
        c /= d; //注意：；两个整数做除法运算，取整操作
        System.out.println(c); //2

        int x = 15;
        int y = 6;
        x %= y;
        System.out.println(x); //3
    }
}

在上述代码中，我们可以很清楚的发现a+=b相当于a=a+b,  a-=b相当于a=a-b,所以第一次a的值是30，第二次的值是10，

第二组中c*=d相当于c=c*d,结果就是18      第三组除法也是相同的，c/+d相当于c=c/d,最后的结果是2（18/6之后保留整数部分）   第四组是x%=y，相当于x=x%y,最后的结果是3（取模运算看余数），最后的结果如下：

1.2 关系运算符

关系运算符包括：  >,  >= ,  < ,  <= ,  == ,   !=

他们的作用是用于判断两边的大小关系，最后的返回值的类型是：  boolean类型

我们通过一个案例可以更好的理解，对变量x和y分别赋值，根据关系运算符我们观察返回结果：

        

package com.basic.day03.symbol;

public class RelationSymbol {
    public static void main(String[] args) {
        int x = 10;
        int y = 20;
        System.out.println(x>y); //false
        System.out.println(x>=y); //false
        System.out.println(x<y); //true
        System.out.println(x<=y); //true
        System.out.println(x==y); //false
        System.out.println(x!=y); //true
    }
}

我们通过返回的结果可以看出来，如果判断语句是正确的，结果就是true，反之则是false，结果都是boolean类型。

1.3逻辑运算符

在Java语言中，我们常用的逻辑运算符有四种：

&与： 两真即为真，反之则是假

|或： 两假即为假，其中有任一为真则为真

!非：非真即假，非假即真

^异或：两个相同为假，两者不同为真

在Java语言中，我们更常用的是短路操作，

特点：第一个条件若是已经可以确定结果，则不需要执行第二个条件，节省时间

&&短路与： 一假全假，全真为真，

true&&true ==> true

true&&false ==> false 

false&&false ==> false

 false&&true ==> false 

对于短路与来讲，如果第一个是假，则不需要执行第二个条件，即可判断是假

||短路或：一真即为真，全假则假，

true||true ==> true

 true||false ==> true

false||false ==> false

false||true ==> true 

对于短路或来讲，如果第一个是true，则不需要执行第二个条件，即可判断是真

案例如下：

public class LogicSymbolDemo1 {
    public static void main(String[] args) {
       // 验证短路&&
         int a = 1, b = 2, c = 3, d = 4; //每个变量使用逗号隔开
        boolean f = a < b && c <d;
        System.out.println("f的值："+f);//true
        f = a < b && c > d;
        System.out.println("f的值："+f);  //false
        f = a >b && c++ < d;
        System.out.println("f的值："+f);  //false
        System.out.println("c的值"+c); //如果c是3，表示第二个条件未执行
        f = a > b && c > d++;
        System.out.println("f的值："+f); //false
        System.out.println("d的值"+d); //如果d是4，表示第二个条件未执行


        //验证短路或
        int m = 1, n = 2, x = 3, y = 4;
         f = m < n ||  x++<y;
        System.out.println("f的值："+f);//true 
        System.out.println("x的值："+x)// x的值为3，第一个条件是true，因此没进行自增运算
         f = m > n ||  x<y;
        System.out.println("f的值："+f);  //true
        f = m < n ||  x>y++;
        System.out.println("f的值："+f);  //true  y的值为4，第一个条件是true，因此没有进行自增运算，可以证明短路
        f = m > n ||  x>y++;
        System.out.println("f的值："+f); //false
        System.out.println("y的值"+y); //

        //  !   非真即假，非假即真
        f = !(1>2);
        System.out.println("f的值："+f);//true
        f = !f;
        System.out.println("f的值："+f);//false
    }
}

运行结果如下：

我们通过第二组短路或||来判断，m<n已经成立，可以跳过第二个条件，我们设置了自增的条件来验证，发现结果成立，上一组也是同样的方法验证，需要注意的是，在我们验证的过程中，需要先设置第一个条件不成立，然后通过设置第二个条件变量的自增来判断结果

1.4三目运算符

三目运算的语法格式如下：

boolean类型的变量或者表达式  ?  值1  :  值2

当？前面的返回值是true时，选择第一个变量 值1；

当？前面的返回值时false时，选择第二个变量 值2；

需要注意：

1.该运算也遵循混合数据类型运算时转换成数值范围最大的类型

2.值1 和 值2可以是变量，也可以是表达式

3.值1 和 值2 的类型，需要能自动转换

4.通常三目运算的结果需要一个变量来接受，该变量的类型应该是值1 或 值2 其中的一个

我们通过一个小案例来理解一下三目运算符：

package com.basic.day03.symbol;


public class ThreeEyeSymbolDemo01 {
    public static void main(String[] args) {
        int a = 100;
        int b = 200;
       String str= a > b ? "是a大于b" : "a不大于b";
        System.out.println(str); //返回不大于

        int m = 10;
        long n = 15;
        long  result = n%m==1?n:m; //注意：需要考虑m与n在三目运算里，long类型的范围更大
        System.out.println("result的值："+result);

    }
}

返回的结果如下：

由上述的返回结果和代码内容我们可以发现，第一组我们设置了字符类str a>b,结果是false，带入到三目运算中，我们可以发现应该选择值1，也就是：左边的值，a不大于b

第二组中定义了long类型的变量result去判断n%m==1,结果是false，还是选择值2，所以是n的值，10

二.两个常用的类

2.1 Scanner

Scanner类的使用方法主要分为四步：

1.第一步是导包：使用如下命令：

 import java.util.Scanner;（需要注意代码写在类的上面，package下面）

2.第二步是创建扫描器变量并用扫描器的变量引用该对象；使用如下命令：

 Scanner  sc（自己书写变量名） =  new Scanner(System.in);

3.第三步是调用类里提供好的方法，需要注意在调用前输出一个友好提示

System.out.println("请在控制台上输入一个年龄：");    
int age = sc.nextInt();

4.在操作结束，需要关闭选择器

sc.close()

下面我们可以看一个具体案例：

package com.basic.day03.scanner;
import java.util.Scanner;
public class ScannerDemo01 {
    public static void main(String[] args) {
       //步骤2：  创建对象并引用
       Scanner sc = new Scanner(System.in);
       //步骤3：   友好提示
       System.out.println("请输入几个单词，用空格隔开，这几个单词被扫描到一个变量里");
       // 调用类里提供的方法
        String words = sc.nextLine();//该方法可以扫描到空格，但是尽量不要和其他扫描功能一起使用，可能出现bug，不能输入，直接出错
        System.out.println("words:"+words);
        // 关闭操作器
        sc.close();
    }
}

运行结果如下：

通过上述的代码和运行结果我们可以发现，我们创建了Scanner类型的对象 sc ，并在之后输出了友好提示，在我们调用类的方法是，我们选择了sc.nextline(),使用这种方法可以扫描到空格，但是不要和其他的扫描方法在一起使用，可能会出现bug，我们继续看下一个案例：

package com.basic.day03.scanner;
import java.util.Scanner;
public class ScannerDemo01 {
    public static void main(String[] args) {
       //步骤2：  创建对象并引用
       Scanner sc = new Scanner(System.in);
        //步骤3：  扫描一个姓名
        System.out.println("请输入一个姓名：");
        String name = sc.next();
        System.out.println("姓名："+name);

        System.out.println("请输入5个数字：");
        int a = sc.nextInt();
        int b = sc.nextInt();
        int c = sc.nextInt();
        int d = sc.nextInt();
        int e = sc.nextInt();
        System.out.println(a+","+b+","+c+","+d+","+e); 
        sc.close();
    }
}

通过这一部分代码我们可以发现，在调用Scanner类的方法的时候，需要定义一个需要的类，比如第一组就是定义了String类型的变量name，第二组定义了int类型的变量a ，b ， c

2.2random

第二个类是random，他的作用是产生随机数。使用方式与Scanner类似：

1.第一步是导包，使用命令：

import  java.util.Random;

2.创建类的对象 Random r = new  Random();

3.最后一步是调用类里的方法：

       r.nextInt(number);     创建一个[0,number)的随机数，

      r.nextDouble();      创建一个[0,1)的随机小数

我们可以参考一个案例：

package com.basic.day03.random;
import java.util.Random;
public class RandomDemo01 {
    public static void main(String[] args) {
        Random r = new Random();
        //产生一个[0，10）区间的一个整数  生成等号前的变量快捷键  alt+enter
       int i = r.nextInt(10);
        System.out.println("i="+i);

        //产生一个[0,11]区间内的一个整数
        int i1 = r.nextInt(12);
        System.out.println("i1="+i1);

        //产生一个[-5,5]区间内的一个整数
        int i2 = r.nextInt(11)-5;
        System.out.println("i2="+i2);


        //产生一个[0,1)内的小数
        double v = r.nextDouble();
        System.out.println("v="+v);


    }
}

由上述代码我们可以发现，第一步操作就是导包，import java.util.Random

之后我们定义了Random的对象r，然后使用类里的方法，定义了一个int类型的变量i

int i = r.nextInt(10);     表示产生了[0,10) 之间的随机整数

下一组i1需要注意的是：在我们所需要的长度是[0,11]时，我们需要把r.nextInt()的值设置成12，因为初始值时开区间，我们需要多+1，后面也会遇到这种情况，

第三组需要的长度是10，我们就需要把长度赋值为11，然后初始值是-5，再把变量-5

第四组是产生小数，可以直接使用  double v = r.nextDouble();

如果数据类型不一致，我们还需要进行强转换。

下一部分我们直接上一个案例，来解释这一部分知识：

package com.basic.day03.random;

import java.util.Random;

/**
 * 练习Random的nextdouble方法
 */
public class RandomDemo02 {
    public static void main(String[] args) {
        Random rd = new Random();
        //随机[0,10)以内的任意小数
        double  num = rd.nextDouble()*10;
        //随机[0,10)以内的任意整数
       int n1 = (int) (rd.nextDouble()*10);
        System.out.println(n1);
        //随机[-6,6]以内的任意整数
        int n2 =(int)(rd.nextDouble()*13-6);
        System.out.println(n2);
        //随机[5,15]以内的任意的整数
        int n3 =(int)(rd.nextDouble()*11+5);


        /**
         * 通过上述练习可以总结一个公式：
         * 闭区间公式：[n,m]     r.nextDouble()*(m+1-n)+n
         * 开区间公式：[n,m)     r.nextDouble()*(m-n)+n
         */
        //[98,155]随机整数
        int n4 = (int)(rd.nextDouble()*58+98);
    }
}

在这里我们用的方法都是  r.nextDouble();方法，在一些情况下需要进行强转换，第一组代码十分简单，我们就不过多赘述，第二段代码因为要生成整数，但是方法生成的是浮点数，多以需要强转换，并且需要把方法的所有内容打上（），

第三段代码生成长度要求是12，所以我们需要把方法的原有量*（12+1），然后对整个方法-6来设置偏移量，下一段也是同样的道理，长度要求是10，所以*11，然后偏移量是5，对整个方法+5，感兴趣可以看一下公式，更方便理解，需要注意：开区间就不必+1了，而闭区间需要。

2.3数学工具类：

这之中包括了许多的数学工具，可以帮助我们开发，使用方式比较简单，直接使用类名后面加上具体方法名调用即可。工具的种类有很多，比如：

1.静态常量：　　E（自然对数）　　PI（圆周率）　　

2.常用函数：ｍａｘ（）　　　ｍｉｎ（）　　　ｒａｎｄｏｍ（）取随机数　　

ａｂｓ（）取绝对值

取整函数：　ｃｅｉｌ（）向上取整　　ｆｌｏｏｒ（）向下取整

ｒｉｎｔ（）返回距离该数最近的整数　　　ｒｏｕｎｄ（）四舍五入

指数函数：　ｐｏｗ（）　幂函数　　ｓｑｒｔ（）平方根　　ｃｂｒｔ（）立方根

三角函数：　ｓｉｎ（）　ｃｏｓ（）　ｔａｎ（）

具体的使用方法我们通过实例来了解：

package com.basic.day03.random;
public class MathDemo01 {
    public static void main(String[] args) {
        System.out.println("自然对数："+Math.E); //double类型
        System.out.println("圆周率"+Math.PI);

        System.out.println("3和5比较，其中最大值："+Math.max(3,5));
        System.out.println("3和5比较，其中最小值："+Math.min(3,5));
        System.out.println("-3的绝对值："+Math.abs(-3));



        //使用Math.random()产生一个随机数，默认是[0,1)区间的小数
        //[5,10]
        int i = (int)(Math.random()*6+5);
        System.out.println("产生的随机数："+i);



        System.out.println("3.4向上取整："+Math.ceil(3.4));
        System.out.println("3.4向下取整："+Math.floor(3.4));
        System.out.println("3.4最近取整："+Math.rint(3.4));
        System.out.println("3.4四舍五入："+Math.round(3.4));

        System.out.println("3的四次方："+Math.pow(3,4));
        System.out.println("8的平方根："+Math.sqrt(8));
        System.out.println("8的立方根："+Math.cbrt(8));
    }
}

返回的结果：

一般来讲，他们的使用方法都是Mａｔｈ．＋函数名称，需要注意的是：产生随机数时，依旧是像Rａｎｄｏｍ类一样，初始值都是［０，１），需要自己找范围。