Day02Java基础-变量&标识符&数据类型&运算符&二进制（原反补码）

1.变量

注：

1. 变量名不允许重复定义

2. 一条语句，可以定义出多个变量，中间需要使用逗号进行分隔

3. 变量在使用之前，必须完成复制

4. 变量的作用域范围

2.标识符

就是给类，方法，变量等起名字的符号

命名规则

• 由数字、字母、下划线(_)和($)组成

• 不能以数字开头

• 不能是关键字

• 区分大小写

命名规范（便于区分变量名和类名）

• 小驼峰命名法：变量名

规范1：标识符为一个单词时，所有单词小写

范例1：name

规范2：标识符由多个单词组成时，从第二个单词开始，首字母大写

范例2：firstName

• 大驼峰命名法：类名

规范1：标识符为一个单词时，首字母大写

范例1：student

规范2：标识符由多个单词组成时，每个单词的首字母大写

范例2：GoodStudent

3.数据类型

基本数据类型

使用思路：

        1. 整数类型 ：首选int，如果发现int装不下了，将类型换成long，定义long类型变量需要加入L的标识

        2. 小数类型 ： 首选double，非要用float类型，需要加入F标识。

引用数据类型

第五节讲

4.编码表

5.Scanner键盘录入

步骤：

import java.util.Scanner;

public class ScannerDemo {
    /*
        Scanner键盘录入的三个步骤

        1.找符咒
                    代码：import java.util.Scanner
                    位置：class的上面
                    含义：能够让自己的类ScannerDemo，从代码仓库中，找到Scanner符咒
        2.召唤精灵
                    代码：Scanner sc = new Scanner(System.in);
                    位置：main方法里面
                    含义：从符咒中召唤精灵，给精灵其名字叫做sc
        3. 指挥精灵干活

     */
    public static void main(String[] args) {
        //召唤精灵 ：给精灵起名字叫做二狗
        Scanner 二狗 = new Scanner(System.in);

        //指挥精灵干活
        int age = 二狗.nextInt();

        System.out.println(age);
    }
}

import java.util.Scanner;

public class ScannerTest {
    public static void main(String[] args) {
        // 1. 召唤精灵
        Scanner sc = new Scanner(System.in);

        // 2. 键盘录入姓名
        System.out.println("请输入您的姓名：");
        String name = sc.next();

        // 3. 键盘录入年龄
        System.out.println("请输入您的你年龄：");
        int age = sc.nextInt();

        // 4. 键盘录入性别
        System.out.println("请输入您的性别：");
        String gender = sc.next();

        // 5. 键盘录入身高
        System.out.println("请输入您的身高：");
        double height = sc.nextDouble();

        // 6. 键盘录入婚姻状况
        System.out.println("请输入您的婚姻状况");
        boolean flag = sc.nextBoolean();

        System.out.println("注册成功！");
        System.out.println(name);
        System.out.println(age);
        System.out.println(height);
        System.out.println(gender);
        System.out.println(flag);

    }
}

6.运算符

对字面量或变量进行操作的符号

算术运算符

• + 、-、*、/、%

注：

1. / ：整数相除，结果只能得到整数，想要得到带有小数的结果，需要有小数（浮点数）参与运算

2. %：取模，作用是用来取余数的

import java.util.Scanner;

public class OperatorTest1 {
    /*
        需求：键盘录入一个三位数，将数值拆分出个位、十位、百位，随后打印在控制台

                数值拆分的公式：

                    个位：数值 % 10
                    十位：数值 / 10 % 10
                    百位：数值 / 10 / 10 % 10
                    千位：数值 / 10 / 10 / 10 % 10
                    ......

                    对于数值的最高位，简化处理

                        123 : 百位        123 / 100--->1
                        1234 : 千位       1234 / 1000--->1
                        12345 : 万位      12345 / 10000--->1
     */
    public static void main(String[] args) {

        // 1. 召唤Scanner精灵
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个三位数：");
        // 2. 指挥精灵，从键盘录入一个整数
        int num = sc.nextInt();
        // 3. 数值拆分
        int ge = num % 10;
        int shi = num / 10 % 10;
        int bai = num / 100;
        // 4. 将拆分后的数据，打印在控制台
        System.out.println(ge);
        System.out.println(shi);
        System.out.println(bai);
    }
}

自增自减运算符

1. ++：让变量自身的值+1

2. --：让变量自身的值-1

注：

• 单独使用：一句代码中，只做++，或是--（++或--在变量前面或后面，起结果没有区别）

• 参与运算使用：

  ++在前：先自增，再操作

  ++在后：先操作，再自增

public class OperatorTest2 {
    /*
        看程序说结果
     */
    public static void main(String[] args) {

        int x = 10;
        int y = x++;    // y = 10, x = 11
        int z = ++y;    // y = 11, z = 11

        System.out.println("x=" + x);
        System.out.println("y=" + y);
        System.out.println("z=" + z);

        System.out.println("--------------");

        int a = 3;
                // 4  +  4    +  5 *10
        int b = (++a) + (a++) + (a * 10);
        System.out.println("a=" + a);   // 5
        System.out.println("b=" + b);   // 58
    }
}

类型转换分类

• 隐式转换：把一个取值范围小的数值或变量，赋值给另一个取值范围大的变量

public class TypeConversionDemo1 {
    /*
        类型转换 - 隐式转换
            介绍：将取值范围小的数据或变量，给取值范围大的变量赋值，可以直接赋值
                    - 简单记：小的给大的，可以直接给

             取值范围从大到小

                    byte -> short -> int -> float ->double

                    问题：float占用4个字节，为什么放在long(8个字节)的后面
                    解释：虽然float占用4个字节，但是【取值范围】要比8个字节的long更大
                            - 小数的二进制存储形式，更加节省内存
     */
    public static void main(String[] args) {

        int a = 10;

        double b =a;

        System.out.println(a);  // 10
        System.out.println(b);  // 10.0

        System.out.println("---------------");

        long num1 = 123L;
        float num2 = num1;
        System.out.println(num2);   //123.0
    }
}

lic  class  Test{
    public static void main(String[] args){
        int a = 1;
        char b ='a';   // b = 97
        int c = a + b;
        System.out.println(c); // c = 98
    }
}

• 强制转换

介绍：

将取值范围大的数值或变量，给取值范围小的变量赋值，不允许直接复制，需要加入强转

注意：

强制转换（有可能）会出现精度损失

public class TypeConversionDemo2 {
    /*
        类型转换 - 强制转换
            介绍：将取值范围大的数值或变量，给取值范围小的变量赋值，不允许直接复制，需要加入强转
            注意：强制转换（有可能）会出现精度损失
     */
    public static void main(String[] args) {

        double a = 12.3;
        int b = (int)a;
        System.out.println(b);  // 12

        System.out.println("---------------");

        int c = 10;
        byte d = (byte)c;
        System.out.println(d);  // 10

        System.out.println("----------------");

        int num1 = 130;
        byte num2 = (byte)num1;
        System.out.println(num2);   // -126(补码)
    }
}

7.二进制原码反码补码

二进制的转换

二进制8421快速转换法

原码反码补码

规律：

正数的原反补相同。

强转中的精度损失

相关面试题

public class TypeConversionTest {
    /*
        类型转换面试题 : 下列代码是否存在错误，如果有，请指出说明，并改正.

            byte b1 = 3;
            byte b2 = 4;
            byte b3 = b1 + b2;

            错误原因:
                    b1和b2是两个byte类型，在运算的时候，会提升为int类型.
                    提升之后，就是两个int在运算了，运算的结果还是int.
                    将int类型的结果，赋值给byte类型的变量，属于大给小，不能直接给.

                    byte b1 = 3;
                    byte b2 = 4;
                    byte b3 = (byte)(b1 + b2);

                    System.out.println(b3);

         byte b = 3 + 4;

         【误解】这里的3和4是字面量，之前提到过，所有整数默认都是int类型，所以这里应该是两个int做运算
         运算后的结果还是int，int类型结果给byte类型变量赋值，大的给小的，不能直接给，编译错误.

         Java存在常量优化机制 : 在编译的时候（javac）就会将3和4这两个字面量进行运算.
                                产生的字节码文件 :  byte b = 7;
     */
    public static void main(String[] args) {
        byte b = 3 + 4;
        System.out.println(b);  // 7
    }
}