Java基础学习（三）

/*
java中的八种基本数据类型：
 
    整数：
        byte 、 short 、 int 、 long
 
    小数：
        float double
 
    字符：
        char
 
    布尔：
        boolean 
 
字符串的类型： String(引用数据类型)
 
声明变量的方式：
 
    方式1： 数据类型  变量名 = 数据;
 
    方式2：数据类型  变量名1 ， 变量名2 ......；
 
*/
class Demo1 {
 
    public static void main(String[] args) {
        String str = ""; //字符串还是字符呢？  ""字符串没有内容是属于一个空字符串。
        System.out.println(str);
    }
}

/*
数据类型转换： 
 
    小数据类型-------->大数据类型     自动类型转换
 
    大数据类型--------->小数据类型    强制类型转换
 
    强制类型转换的格式：
 
            小数据类型  变量名 = (小数据类型)大数据类型
 
数据类型转换要注意的细节：
    1. 凡是byte、short 、 char数据类型数据在运算的时候都会自动转换成int类型的数据再运算。
    2. 两个不同数据类型的数据在运算的时候，结果取决于大的数据类型。
 
*/
class Demo2
{
    public static void main(String[] args)
    {
        /*
        byte  b=  11;   // 一个字节   一两碗
        short s = b; // 把b变量存储的值赋予给s变量。 2字节 二两的碗
        int i = s;   // i是4字节
        long l = i;  // l 是8个字节。
        System.out.println(l);
 
        int i = 128;  //4个字节
        byte b =(byte) i;  // 1个字节
        System.out.println(b);  // -128
 
        //如果是负数，那么最高位肯定是1， 正数的二进制位的最高位是0。
        System.out.println(Integer.toBinaryString(-7));  //sun给我们提供一个功能 Integer.tobinaryString()  查看一个数据的二进制数据形式的。
        //   11111001（补码）
 
        凡是byte、short 、 char数据类型数据在运算的时候都会自动转换成int类型的数据再运算。
 
        byte b1 =1;
        byte b2 = 2;
        byte b3 = (byte)(b1+b2);
        System.out.println(b3); //3  
 
        System.out.println('a'+1); //98 
 
        两个不同数据类型的数据在运算的时候，结果取决于大的数据类型
 
        int i =10;
        long l = 20;
        i = (int)(i+l);
        System.out.println(i);
 
        */
 
        int i = 10;  //
        byte b = i;  // 一个整数没有加上任何标识的时候，默认是int类型的数据。
        //10 是一个常量， 编译器在编译的时候就能够确认常量的值了，byte b = 10,在编译到的时候
        //java编译器就会检查到10并没有超出byte的表示范围，所以允许赋值。
        //java编译器在编译 的时候并不能确认变量所存储的值，变量存储的值是在运行的时候才在内存中分配空间 的。
        System.out.println(b);
 
    }
}

/*
算术运算符:
    + (正数、加法、连接符)
    连接符的作用： 让任何的数据都可以与字符串进行拼接。
    如果+号用于字符串的时候，那么+号就是一个连接符，并不是 做加法功能了。
 
    连接符要注意：任何类型的数据与字符串使用连接符连接，那么结果都是字符串类型的数据。
    -
    *
    / (除法)
    %(取模、取余数)
 
*/
class Demo3 {
 
    public static void main(String[] args){
/*
        int i1 = 1; //
        int i2 = 2;
        //System.out.println(i1 +" world");  // "hello wolrd" ，    1 world
 
        // 计算机每次运算的时候只能取两个数据运算。
        System.out.println(1+2+3 +" world"+1+2+3); // 123world123   33world15
 
        1+2+3 +" world"+1+2+3
          3+3 +" world"+1+2+3
          6+" world"+1+2+3
           "6world"+1+2+3
 
        double a= 12.0;
        int b = 3;
        System.out.println(a/b); //3  4.0
 
        在java中做取模 运算的时，结果的正负号是取决于被除数。
*/
        System.out.println("结果:"+(10%3));
        System.out.println("结果:"+(10%-3)); // 1      1
        System.out.println("结果:"+(-10%3)); // -1    -1
        System.out.println("结果:"+(-10%-3)); //  -1  -1
 
    }
}

/*
    ++ （自增） :  自增就是相当于操作数+1.
 
    前自增：++位于操作数的前面。  比如： ++a；
 
    前自增：先自增，后使用。    
 
    后自增： 先使用，后自增。
 
*/
class Demo4
{
    public static void main(String[] args)
    {
        /*
        int a = 0;
        //int sum = ++a; //前自增。 a = a+1  ， sum = a
        int sum = a++; //后自增  sum = 0 , a = a+1
        System.out.println("sum= "+ sum+ " a = "+ a); //1 
 
后自增在jvm的运行原理：
 
    因为后自增要使用 到没有+1之前的值，那么jvm会先声明一个变量用于保存没有+1之前的值。
 
    原理：
        1. int temp = i; // 声明了一个临时变量用于记录了i没有加1之前的值。
        2. 自增。  i = i+1;
        3. temp把用作了表达式 的结果。
 
*/
        int i = 0;
        i = i++; // 后自增...  后自增要使用到没有+1之前的值。
        System.out.println("sum ="+ sum+ "i= "+i);
    }
}

/*
自减： 操作数-1.
 
前自减: --位于操作数的前面。  --操作数
 
前自减： 先自减，后使用。
 
----------------------------------------------
 
后自减：--位于操作数的后面。 操作数--；
 
后自减： 先使用，后自减。
 
*/
class Demo5
{
    public static void main(String[] args)
    {
        /*
        int i = 1;
        int sum = --i;  //前自减   i = i-1 , sum = i;
        int sum = i--; // 后自减   sum = i ; i = i-1;
        System.out.println("sum = "+ sum);  // 0  1
        */
 
        int num = 10;
        //int sum = 10* num++; //后自增
        int sum = 10* ++num; //前自增
        System.out.println("sum = "+ sum);
 
    }
}

/*
赋值运算符：
    =  (赋值运算符)
    +=
    -=
    *=
    /=
    %=
*/
class Demo6
{
    public static void main(String[] args)
    {
 
        int i = 10; // 把10赋予给i变量。
        i+=2;  // i = i+2;
        System.out.println("i = "+i);
 
        byte b1 = 1;
        byte b2 = 2;
        //b2 = (byte)(b2+b1); //报错。， 需要强制类型转换
        b2+=b1;  //b2 = b2+ b1;     b2+=b1 在编译的时候，java编译器会进行强制类型转换，不需要我们手动转换了。
        System.out.println("b2 : "+ b2);
    }
}

/*
比较运算符： 比较运算符的结果都是返回一个布尔值的。
 
    == (判断是否等于)
    ==用于比较两个基本数据类型数据的时候，比较的是两个变量所存储的值是否一致.
    ==用于比较两个引用类型变量的数据时候，比较的是两个引用类型变量所记录的内存地址是否一致. 
 
    != (不等于)
    > (大于)
    < (小于)
    >= (大于等于)
    <= (小于等于)
*/
class Demo7
{
    public static void main(String[] args)
    {
        /*
        int a = 10;
        int b =10;
        System.out.println("10等于10吗？"+ (a==b));
        System.out.println("10不等于1吗？"+ (10!=1) ); //true
        */
 
        byte b  = 10;
        long l = 30;
        System.out.println(l>b); //两个不同类型的数据是否可以比较呢.,可以的，但是两个不同类型的数据必须是兼用的数据。
        //这个比较的过程会先把b转换了long类型的数据，然后再进行比较 。
 
        System.out.println('a'>50);
 
    }
}

/*
逻辑运算符 ：逻辑运算符的作用是用于连接布尔表达式的。 
 
    & （与,并且）
规律： 只有左右变量同时 为true，那么结果才是true，否则就为false。
 
    |  (或,或者)
 
规律： 只要两边的布尔表达式有一边为true，那么结果就为true，只有两边同时为false 的时候，结果才是false.
 
    ^  (异或)
 
规律： 只要两边的布尔表达式 结果不一致，那么结果就为true，如果左右两边 的布尔表达式一致，那么就为false.
 
    ！ (非)
 
--------------------
    && (短路与\双与)
 
短路与和单与符号的相同与不同点：
 
    相同点： 短路与和单与运算 的结果是一样的。
 
    不同点： 使用短路与的时候，如果左边的布尔表达式为false，则不会在运算右边的布尔表达式，从而提高了
    效率。使用单与的时候，即使发现左边的布尔表达式为false，还是会运算右边的布尔表达式的。
 
只有左边的布尔表达式为false时，双与的效率才要高于单与的.
 
    || (短路或\双或)
 
短路或与单或的相同点与不同点：
 
    相同点：运算的结果是一致的。
 
    不同点：使用短路或的时候，当发现左边的布尔表达式为true时，则不会运算右边的布尔表达式。
    使用单或的时候 发现左边的布尔表达式为true，还是会运算右边布尔表达式。
 
需求：要求两年或两年以上的工作经验，年龄大于18岁。
 
*/
class Demo8
{
    public static void main(String[] args)
    {
        /*
        int workAge = 2;
        int age = 24;
        System.out.println(workAge>=2|age++>18);
        System.out.println("age:"+ age);
 
        System.out.println(true&true);  //true
        System.out.println(true&false); // false
        System.out.println(false&true); // false
        System.out.println(false&false); // false
 
        System.out.println(true|true);  // true
        System.out.println(true|false); // true
        System.out.println(false|true); // true
        System.out.println(false|false); // false
 
        System.out.println(true^true);  //  false
        System.out.println(true^false); //  true
        System.out.println(false^true); //  true
        System.out.println(false^false); //  false
 
        System.out.println(!true); // 
 
        System.out.println(true&&true);  //true
        System.out.println(true&&false); // false
        System.out.println(false&&true); // false
        System.out.println(false&&false); // false
 
    */
 
        System.out.println(true||true);  // true
        System.out.println(true||false); // true
        System.out.println(false||true); // true
        System.out.println(false||false); // false
    }
}

/*
位运算符：位运算符就是直接操作二进制位的。
    & (与)
    | (或)
    ^ (异或)
规律： 如果操作数A连续异或同一个操作数两次，那么结果还是操作数A。
 
应用： 对数据加密.
 
    ~  (取反)
 
*/
 
class Demo9{
 
    public static void main(String[] args){
        System.out.println(6&3); // 2
        System.out.println(6|3);
        System.out.println(6^3); 
 
        System.out.println(~7);  // -8
    }
}

/*
位运算符可能会出现的笔试题目：
    1. 交换两个变量的值,不准出现第三方变量。
 
    2. 取出一个二进制数据的指定位数。要求读取该二进制数据的低4位
            00000000-00000000-00010100-01001101
        &   00000000-00000000-00000000-00001111
        ------------------------------------------
            00000000-00000000-00000000-00001101
*/
class Demo10 {
 
    public static void main(String[] args)
    {
        int a = 3;
        int b = 5;
 
        /*
        第一种方式： 定义第三方变量。
        int temp = a;  //3
        a = b; //a = 5
        b = temp; 
 
        方式2：相加法， 缺点： 两个int类型的数据相加，有可能会出现超出int的表示范围。
 
        a = a+b;  // a =8
        b = a-b; //b = 8 - 5 = 3
        a = a-b; // a = 8 - 3 = 5
 
        方式3： 可以使用异或。 缺点： 逻辑不清晰。
        */
        a = a^b;  // a = 3^5
        b = a^b;  // b = (3^5)^5 = 3
        a = a^b; //  a = (5^3)^3 = 5
        System.out.println("a = "+ a+" b="+b);
    }
}

/*
移位运算符：
    <<(左移)
规律：一个操作数进行左移运算的时候，结果就是等于操作数乘以2的n次方，n就是左移的位数.
    3<<1 = 3 *2(1) = 6;
    3<<2 = 3*2(2) = 12
    3<<3 = 3*2(3) = 24
 
    >>(右移)
 
规律：一个操作数在做右移运算的时候，实际上就是等于该操作数除以2的n次方，n就是右移的位数。
 
    3>>1 = 3 / 2(1) = 1
    3>>2 = 3 / 2(2) = 0 。。
 
    >>>(无符号右移) ：
 
无符号右移与右移的区别：进行右移运算的时候，如果操作数是一个正数，那么左边的空缺位使用0补，
如果操作数是一个负数，那么左边的空缺位使用1补。而使用无符号右移的时候，不管是正数还是负数都
统一使用0补。
 
笔试题目：使用最高的效率算出2乘以8的结果。
        2<<3 = 2*2(3) = 16;
*/
class Demo11 {
 
    public static void main(String[] args){
        /*
        左移
        System.out.println(3<<1); // 6
        System.out.println(3<<2); // 12
        System.out.println(3<<3); // 24 
 
        右移：
        */
        System.out.println(3>>>1); // 1
        System.out.println(3>>>2);  //0 
 
    }
}

/*
三元运算符(三目运算符)
 
格式;
    布尔表达式？值1:值2  ;
 
三元运算符要注意的细节：
    使用三元运算符的时候，一定要使用该表达式返回的结果，或者是定义一个变量接收该表达式返回的结果。
 
*/
class Demo12
{
    public static void main(String[] args) {
        /*
        int age = 26;
        String result = age>=18?"成年人":"未成年人";
        System.out.println(result);
        */
 
        int a = 1;
        int b = 2;
        int c = 3;
 
        int result = a*b+c/2+2*(a+b)/c;
        System.out.println("result="+result);
/*
 
a*b+c/2+2*(a+b)/c;
 
a*b+c/2+2*3/c
 
2+c/2+2*3/c
 
2+1+2*3/c
2+1+2  = 5
*/
 
    }
}

流程控制语句

/*
 
控制流程语句:
 
语句: 使用分号分隔的代码就是一个语句。
 
顺序语句: 按照代码顺序从上往下执行所有的代码就是顺序语句，，
 
*/
class Demo1 {
 
    public static void main(String[] args)
    {
        /*
        int i = 10;  //声明变量的语句
        ;//空语句
        System.out.println("Hello World!"); //输出语句
        */
        System.out.println("A");
        System.out.println("B");
        System.out.println("C");
        System.out.println("D");
    }
}

/*
控制流程语句之（if）判断语句
 
if判断语句的格式：
 
格式1：适用于一种情况使用。
 
    if(判断的条件){
        符合条件执行的代码;
    }
 
格式2 : 适用于两种情况下去使用的。
 
    if(判断条件){
        符合条件执行的代码
    }else{
        不符合条件执行的代码；
    }
 
三元运算符的格式：布尔表达式？值1：值2;
 
if-else 与三元运算符非常像：
 
    三元运算符的优点： 结构比较简洁。
 
    三元运算符的缺点： 符合条件必须要返回一个结果，不能执行语句。
 
格式三： 适用于多种情况下去使用的。
 
    if(判断条件1){
        符合条件1执行的代码
    }else if(判断条件2){
        符合条件2执行的代码
    }else if(判断条件3){
        符合条件3执行的代码
    }......else{
        都不符合上述 的条件执行的代码
    }
 
if语句要注意的细节：
    1. 如果符合条件后只有一个语句需要执行，那么可以省略大括号。但是建议不要省略，因为结构不清晰。
    2. if语句的判断条件后不能添加分号，否则会影响到执行的效果的，
 
需求1：工作经验要两年或者两年以上。
 
需求2：根据一个变量所记录的数字输出对应的星期。 0 ---星期天  1 星期一
 
*/
class Demo2
{
    public static void main(String[] args)
    {    
 
        int workAge = 2;
 
    /*
    格式1：
        if(workAge>=2){
            System.out.println("电话通知过来面试..");
        }
 
    格式2：
 
        if(workAge>=2){
            //符合条件执行的代码
            System.out.println("电话通知你面试");
        }else{
            //如果不符合上述的条件执行的代码
            System.out.println("电话通知不要再投简历了，不收你!!");
        }
    */
 
        int num = 31;
 
        if(num==0){
            System.out.println("星期天");
        }else if(num==1){
            System.out.println("星期一");
        }else if(num==2){
            System.out.println("星期二");
        }else if(num==3){
            System.out.println("星期三");
        }else if(num==4){
            System.out.println("星期四");
        }else if(num==5){
            System.out.println("星期五");
        }else if(num==6){
            System.out.println("星期六");
        }else{
            System.out.println("没有对应的星期");
        }
 
    }
}

/*
需求： 键盘录入一个分数，根据分数输出对应的等级。
 
比如： 100-90  A等级    89-80  B等级 ..... E等级
 
接受键盘录入数据的步骤：
    1. 创建一个扫描器对象。
    2. 调用扫描器对象的nextInt方法扫描数据。
    3. 导入包。
*/
import java.util.*;
class Demo3
{
    public static void main(String[] args)
    {
 
        //创建一个扫描器
        Scanner scanner = new Scanner(System.in);
        //调用扫描器扫描键盘录入的数据
 
        System.out.println("请输入一个分数：");
        int score = scanner.nextInt(); //定义了一个num变量接收扫描到内容。
 
        if(score>=90&&score<=100){
            System.out.println("A等级");
        }else if(score>=80&&score<=89){
 
            System.out.println("B等级");
        }else if(score>=70&&score<=79){
 
            System.out.println("C等级");
        }else if(score>=60&&score<=69){
 
            System.out.println("D等级");
        }else if(score>=0&&score<=59){
 
            System.out.println("E等级");
        }else{
            System.out.println("补考..");
        }
 
    }
}