02数据类型和运算符

数据类型和运算符


标识符
常作用    
常量、变量、方法、类和包等的名称
命名规则
必须以字母、_下划线、美元符$开头。
其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合
大小写敏感，长度无限制。
不可以是Java的关键字。
注意
Java不采用通常语言使用的ASCII字符集
Java采用unicode这样的标准的国际字符集。因此，这里的字母的含义：英文、汉字等等。(不建议大家使用汉字来定义标识符！
常量和变量
常量变量定义
在程序中存在大量的数据来代表程序的状态，其中有些数据在程序的运行过程中值会发生改变，有些数据在程序运行过程中值不能发生改变，这些数据在程序中分别被叫做变量和常量。
变量举例：
在2D游戏程序中，需要代表人物的位置，则需要2个变量，一个是x坐标，一个是y坐标，在程序运行过程中，这两个变量的值会发生改变
常量举例
代表常数，便于程序的修改（例如：圆周率的值）
增强程序的可读性（例如：常量UP、DOWN、LEFT和RIGHT分辨代表上下左右，其数值分别是1、2、3和4）

在实际的程序中，可以根据数据在程序运行中是否发生改变，来选择应该是使用变量代表还是常量代表
数据类型
整型  
整型变量：
整型常量默认为int型，声明long型常量可以后加‘ l ’或‘ L ‘(建议使用大写，小写容易误认为数字1)
浮点型
 浮点类型常量：
浮点型变量：
float类型：单精度类型，尾数可以精确到7位有效数字，在很多情况下，float类型的精度很难满足需求。
double类型：双精度类型  精度是float类型的两倍，尾数可以精确到16位有效数字，绝大部分应用程序都采用double类型。
注意
浮点常量默认为double。要变为float，需在后面增加F/f.  如： 3.14F
浮点数存在舍入误差，很多数字不能精确表示。如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

 字符型
  布尔型
boolean类型有两个值，true和false

boolean 类型用来判断逻辑条件，一般用于程序流程控制 

实践：
请不要这样写：if ( is == true && done == false ) ，只有新手才那么写。对于任何程序员 if ( whether && !done ) 都不难理解吧。所以去掉所有的==fasle 和 ==true。


运算符
算术运算符
+：字符串相加，只要有一个操作数是字符串，自动变为字符串相连

  关系运算符
关系运算符用来进行比较运算

关系运算的结果是布尔值：true/false


Scanner的用法
package scanner;

/**
 * lang包是java的核心包，系统会自动加载lang包的内容
 * 所以使用lang包中的内容不需要导入
 * 
 * 除了lang包以外，其他的内容使用之前都必须要先导入
 */
import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
//        创建Scanner的变量
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入第一个数字");
        int n1 = sc.nextInt();
        System.out.println("请输入第二个数字");
        int n2 = sc.nextInt();
        System.out.println("两个数字之和是："+(n1+n2));

    }
}


位运算符 
位运算符是对操作数以二进制比特位为单位进行操作和运算，操作数和结果都是整型数。
如果操作的对象是char、byte、short，位移动作发生前其值会自动晋升为int，运算结果也为int。
package bit;
/**
 * 位运算符
 * @author tang
 *
 */
public class Test {
    public static void main(String[] args) {
        int a = 11;
        int b = 8;
        //按位与
        /**
         * 首先将表达式两边的数组转换为2进制
         * 对应的位进行比较
         * 如果对应的位上都是1 则结果的这一位为1
         * 如果对应的位上有一个是0 则结果的这一位是0
         * 1011
         * 1010
         * 1010
         * 
         */
        System.out.println(a & b);
        
        /**
         * 按位或
         * 首先将表达式两边的数组转换为2进制
         * 对应的位进行比较
         * 如果对应的位上都是0 则结果的这一位为0
         * 如果对应的位上有一个是1 则结果的这一位是1
         * 1011
         * 1000
         * 1011
         */
        System.out.println(a | b);
        
        /**
         * 按位异或 ^
         * 首先将表达式两边的数组转换为2进制
         * 对应的位进行比较
         * 对应的位上的值相等 则结果这一位为0
         * 对应的位上的值不等，则结果这一位为1
         * 1011
         * 1000
         * 0011
         */
        System.out.println(a ^ b);
        
        /**
         * 位移运算符
         * a << n;
         * 运算规则   箭头向左   二进制后面多加几个0
         *             箭头向右   二进制后面少几位
         * 10
         */
        a = 8;
        System.out.println(a << 2);
        System.out.println(a / 2);
    }
}



 条件运算符
语法格式
x ? y : z 
唯一的三目运算符
执行过程
其中 x 为 boolean 类型表达式，先计算 x 的值，若为true，则整个三目运算的结果为表达式 y 的值，否则整个运算结果为表达式 z 的值。  
经常用来代替简单的if-else判断

优先顺序：  赋值<三目<逻辑<关系<算术<单目

package bit;
/**
 * 三目运算符
 * @author tang
 *
 */
public class Test02 {
    public static void main(String[] args) {
        /**
         * 三目运算符的语法
         * 布尔值的表达式？值1:值2
         * 如果布尔值表达式返回true  则三目运算符返回值1
         * 如果布尔值表达式返回false 则三目运算符返回值2
         */
        
        int score = 69;
        System.out.println(score >= 60?"及格":"不及格");
        int b = 10;
        System.out.println("abc"+(score + b));
    }
}



命名规则(规范)  
所有变量、方法、类名：见名知意

变量、方法名：
首字母小写和驼峰原则
run(), runRun(),  age     ageNew   monthSalary
userName

常量：
大写字母和下划线：MAX_VALUE

类名：
首字母大写和驼峰原则:  Man, GoodMan

//代码的第一行非注释的内容一定是 标记包名
package com.gzsxt.test;
//创建一个java文件的时候，系统会同时生成一个跟文件同名的 java的class
//文件的命名必须遵守以下规则：
//1，首字母大写，以后每个单词的首字母也大写
//2，命名要见名知意
//public 是一个访问修饰符  代表公共的公开的，意思就是修饰的内容在整个项目中都可以被调用
// class 是java的关键字  用来标记一个java的类

/*
 * 多行注释
 * 凡是在  /*和 * /之间的内容都是注释的内容 
 * 
 */

/**
 * 文档注释  
 * @author tang
 *
 */
public class HelloWorld { //开始的大括号   可以独自占一行也可以跟在代码后面
    //static 修饰符，表示静态的     所有静态的内容都是可以通过类名直接调用
    // void 代表没有返回值，如果这里有返回值，则void会变成返回值的类型
//    main   方法名   
//    main 方法是程序的入口，执行一个程序的系统会首先去寻找main方法，来执行main方法中的代码
    
    public static void main(String[]args){
//        输出一句话在控制台
//        双引号来标记java中的字符串
        System.out.println("我的第一是的发顺丰个java程序");
    }//结束的大括号一定要独自占一行
}


final 常量  
package day02;
/**
 * 使用final来修饰一个变量，则该变量就变为常量
 * 在常量的整个声明周期中只能被赋值一次
 * 常量的命名规则   全部是大写字母  如果有多个单词  则通过下划线来链接多个单词
 * @author tang
 *
 */
public class FinalDemo {
    public static void main(String[] args) {
        int age = 10;
        System.out.println(age);
        final int USER_AGE;
        USER_AGE = 20;
        
        String studentName;
        
        
    }
    
    public static void setUserName(){
        
    }
}



package day02;
/**
 * 变量的三要素
 * 1,变量类型 
 * 2,变量名 
 * 3,作用域    从声明的位置开始   到   第一个结束的大括号
 * @author tang
 *
 */
public class Test {
    public static void main (String [] args){
        //在java中所有用到的东西都必须要先声明 （有些是系统声明好的，就可以直接使用）
        //声明变量的语法     数据类型  变量名 = 值
        //           数据类型  变量名;
        //           变量名 = 值;
        
        int x;  
        x = 180;
        int y = 200;
        
        float w = 100.2f;
        
        //不建议使用这种方式声明
        int a , b ;
        
        // byte 字节 类型    取值范围  -128 ~ 127
        byte b1 = 100;
        byte age = 127;
        
        //short 短整型  占用两个字节   -2^15 ~ 2^15-1  
        short s = 30000;
        
        //int  整型   占用4个字节       -2^31 ~2^31-1 
        int sal = 2100000000;
        
        //long  长整型    占用8个字节   -2^63 ~ 2^63-1
        //java 中所有的整数类型都默认是int类型  如果需要long类型则要在数字后面加一个l L
        long money = 88888888888888L;
        
        //在java中 整数类型默认使用int 如果长度不够，使用long类型
        
        
        //带小数的类型     所有带小数的数字 默认都是double类型   
        //float类型 占用4个字节    小数点后面最多保留7位有效数字
        float f  = 3.1234567890F;
        //double 类型   占用8个字节  小数点后面最多保留16位有效数字
        double d = 1.123456789012;
        System.out.println(d);
        
        
        //在java中  双引号标记一个字符串
        //单引号标记一个字符   char
        //java使用的是unicode字符集   所以java中一个字符可以是一个汉字
        char c = 'a';
        char r = '\'';
        System.out.println("abc"+r+"def");
        
        
        //布尔值类型
        //取值只能是true 或者false  
        //如果值为true 则在内存中保存的是1  如果是false 在内存中保存的是0
        //布尔值只占用一个二进制的位      就是八分之一个字节
        //多用于条件判断
        boolean b2 = true;
        System.out.println(59 > 60);
        

  
 赋值运算符：
package flg;

public class Test {
    public static void main(String[] args) {
        int a = 10;
        String  str01 = "abc";
        /**
         * 1,当加号两边出现的都是数字类型，则作为数学运算
         * 2,当加号两边出现了字符串类型 ，则作为连接符来使用，将加号两边的内容链接在一起形成一个新的字符串
         */
//        System.out.println(a+10+str01);
//        System.out.println(str01+a+ 10);
//        System.out.println(a/6);
        
        //% 求模   求余数
        //System.out.println(10%6);
        
        // ++ 自增运算
        //a ++;  //等同于  a = a + 1;   等同于 a += 1;
        // -- 自减运算
        //a --;  //等同于 a = a - 1;
        
        
        //扩展运算符
        // += 
//        a += 10;//等同于  a = a + 10;
//        a -= 10;//等同于  a = a - 10;
//        a /= 10;//等同于 a = a / 10;
//        a *= 10;//等同于 a = a * 10;
//        a %= 10;//等同于 a = a % 10;
        

逻辑运算符 ：
逻辑运算符与布尔操作数一起使用，组成逻辑表达式
逻辑表达式的结果是布尔值
&和&&的区别
“&”:无论任何情况，“&”两边的表达式都会参与计算。
“&&”: 当“&&”的左边为false，则将不会计算其右边的表达式。即左false则false
“|”和“||”的区别与“&”和“&&”的区别类似。

package flg;
/**
 * 逻辑运算符
 * 运算符两边出现的都是返回布尔值的表达式
 * 运算结果也是布尔值表达式
 * @author tang
 *
 */
public class Test02 {
    public static void main(String[] args) {
 
//        
        /**
         *短路与   && 
         * 表达式两边的布尔值都返回true 则结果为true
         * 如果表达式两边的布尔值有一个为false 则结果为false
         * 如果第一个表达式就能确定返回结果  就不在去执行第二个表达式
         * 
         * 逻辑与  &
         * 表达式两边的布尔值都返回true 则结果为true
         * 如果表达式两边的布尔值有一个为false 则结果为false
         * 如果第一个表达式就能确定返回结果  仍然要去执行第二个表达式
         */
        int a = 10;
        int b = 20;
        
        boolean bl = a<1 && b>1/0;
        System.out.println(bl);
        
        
        /**
         * 短路或 ||
         * 当表达式两边的布尔值有一个返回true 则结果就为true
         * 当表达式两边的布尔值都返回false  则结果为false 
         * 当第一个表达式就已经可以确定返回结果了  就不再执行第二个表达式
         * 
         * 
         * 逻辑或 |
         * 当表达式两边的布尔值有一个返回true 则结果就为true
         * 当表达式两边的布尔值都返回false  则结果为false 
         * 当第一个表达式就已经可以确定返回结果了  仍然会继续执行第二个表达式
         * 
         */
        
//        System.out.println(a > 1 || b/0 > 100);
        
        
        //逻辑非
        //取反  
        //System.out.println(!(a>10));
        
        //逻辑异或  ^
        //表达式两边的布尔值相同   则返回false 
        //表达式两边的布尔值不相同  则返回true
        System.out.println(false ^ true);
        
    }

基本数据类型的类型转换
在赋值运算或算术运算时，要求数据类型相同，否则要进行类型转换

转换方式：
自动转换
强制转换

除boolean类型外，所有的基本数据类型因为各自的精度不同，赋值时都要考虑这个问题
除boolean类型外，所有的基本数据类型包括：整型，浮点型，字符型。
package 类型转换;
/**
 * 基本数据类型的类型转换
 * @author tang
 *
 *    类型转换分为两种情况
 *    一，自动类型转换
 *        1，低精度 向高精度转换
 *        2，低位向高位转换
 *    二，强制类型转换
 *        1，高精度向低精度转换
 *            可能会损失精度
 *        2，高位向低位转换
 *            可能会损失大小
 *        
 */
public class Test {
    public static void main(String[] args) {
        int  a = 10;
        float f = 1.23f;
        f = a;
        long lo = 123L;
        
        
        //__________________________
        
        int b = 270;
        byte bt = (byte)b;
        System.out.println(bt);
        //00000001 00001110
        
        
        f = 3.14f;
        int c =  (int)f;
        System.out.println(c);
    }
}



package test;

import java.util.Scanner;

/**
 * 练习3:商场推出幸运抽奖活动 根据抽奖规则计算会员卡号各位数字之和为16,则为幸运会员
 * @author tang
 *
 */
public class Test03 {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入四位数的会员卡卡号");
        //接收到用户输入的卡号
        int cardNo = input.nextInt();
        //求出卡号千位上的数字
        int k  = cardNo/1000;
        //求出卡号百位上的数字
        int b = (cardNo%1000)/100;
        //求出卡号十位上的数字
        int s = (cardNo%100)/10;
        //求出卡号个位上的数字
        int g = cardNo%10;
//        求和
        int sum = k + b + s + g;
        String message = (sum == 16)?"恭喜你，中奖了！":"很遗憾，本次没有中奖";
        System.out.println(message);