2.3 数据类型和运算符经典例题

一：
package day02;
//数据类型的演示
public class DataTypeDemo {
    public static void main(String[] args) {
        /*
         * 基本类型间转换的练习:
         * 1)声明整型变量a并赋值为5
         *   声明长整型变量b并赋值为a
         *   声明整型变量c并赋值为b
         * 2)声明长整型变量d并赋值为100亿
         *     声明整型变量e并赋值为d，输出e
         *   声明浮点型变量f并赋值为36.987
         *     声明整型变量g并赋值为f，输出g
         * 3)声明short型变量s1并赋值为6
         *   声明short型变量s2并赋值为8
         *   声明short型变量s3并赋值为s1+s2
         * 4)输出0+0的值，输出'0'+'0'的值
         * 
         */
        
        //基本数据类型间的转换:
        int a = 5;
        long b = a; //自动类型转换
        int c = (int)b; //强制类型转换
        
        long d = 5; //自动类型转换
        double e = 5; //自动类型转换
        System.out.println(e); //5.0
        
        long f = 10000000000L;
        int g = (int)f; //强制类型转换
        System.out.println(g); //强转有可能会溢出
        double h = 25.987;
        int i = (int)h;
        System.out.println(i); //25，强转有可能会丢失精度
        
        byte b1 = 5;
        byte b2 = 6;
        byte b3 = (byte)(b1+b2);
        
        System.out.println(2+2);     //4
        System.out.println(2+'2');   //52
        System.out.println('2'+'2'); //100，'2'的码50，加上'2'的码50
        
        
        
        
        /*
         * boolean、char的练习:
         * 1)声明布尔型变量b1并赋值为true
         *   声明布尔型变量b2并赋值为false 
         *   声明布尔型变量b3并赋值为36.5-----???
         * 2)声明字符型变量c1并赋值为字符男
         *   声明字符型变量c2并赋值为字符m
         *   声明字符型变量c3并赋值为字符3
         *   声明字符型变量c4并赋值为空格符
         *   声明字符型变量c5并赋值为空字符-----???
         *   声明字符型变量c6并赋值为字符男性---???
         *   声明字符型变量c7并赋值为98，输出c7
         *   声明字符型变量c8并赋值为单引号(')，输出c8
         */
        
        /*
        //4.boolean:布尔型，1个字节
        boolean b1 = true;  //true为布尔型直接量
        boolean b2 = false; //false为布尔型直接量
        //boolean b3 = 250; //编译错误，布尔型只能取值为true或false
        
        //5.char:字符型，2个字节
        char c1 = '女'; //字符女
        char c2 = 'f'; //字符f
        char c3 = '6'; //字符6
        char c4 = ' '; //空格符
        //char c5 =  女; //编译错误，字符必须放在单引号中
        //char c6 = ''; //编译错误，不能是空字符
        //char c7 = '女性'; //编译错误，只能装一个字符    
        char c8 = 65; //0到65535
        System.out.println(c8); //A
        char c9 = '\\';
        System.out.println(c9); //\
        */
        
        
        /*
         * int、long、double类型的练习:
         * 1)声明整型变量a并赋值为36
         *   声明整型变量b并赋值为100亿---------???
         *   输出5/3的值，输出3/5的值，输出3.0/5的值
         *   声明整型变量c并赋值为2147483647(int的最大值)
         *     在c本身基础之上增1，输出c的值
         * 2)声明长整型变量d并赋值为100亿
         *   声明长整型变量e并赋值为10亿*2*10L，输出e
         *   声明长整型变量f并赋值为10亿*3*10L，输出f
         *   声明长整型变量g并赋值为10亿L*3*10，输出g
         *   声明长整型变量h并赋值为
         *     System.currentTimeMillis()，输出h
         * 3)声明浮点型变量i并赋值为3.14
         *   声明浮点型变量j和k，并分别赋为6.0和4.9
         *     输出j-k
         */
        
        /*
        //1.int:整型，4个字节，-21个多亿到21个多亿
        int a = 250; //250为整数直接量，默认为int型
        //int b = 10000000000; //编译错误，100亿默认为int型，但超出范围了
        System.out.println(5/2); //2
        System.out.println(2/5); //0
        System.out.println(5/2.0); //2.5
        int c = 2147483647; //int的最大值
        c = c+1;
        System.out.println(c); //溢出了-2147483648
        
        //2.long:长整型，8个字节，很大很大很大
        //long d = 10000000000; //编译错误，100亿默认为int型，但超出范围了
        long e = 10000000000L; //100亿L为long型直接量
        long f = 1000000000*2*10L;
        System.out.println(f); //200亿
        long g = 1000000000*3*10L;
        System.out.println(g); //溢出了(不是300亿)
        long h = 1000000000L*3*10;
        System.out.println(h); //300亿
        long i = System.currentTimeMillis();
        System.out.println(i);
        
        //3.double:浮点型，8个字节，很大很大很大
        double pi = 3.14159; //3.14159为浮点型直接量，默认为double型
        double j=6.0,k=3.9;
        System.out.println(j-k); //0.10000000000000009，有可能会发生舍入误差
        */
    }
}

二：
package day02;
//变量的演示
public class VarDemo {
    public static void main(String[] args) {
        /*
         * 要求: 1.题目不用抄  2.注释不用写  3.有错必须改/注释
         * 1)声明一个整型的变量，名为a
         *   声明两个整型的变量，名为b和c
         * 2)声明整型变量d并直接赋值为250
         *   声明整型变量e，
         *     给变量e赋值为250
         * 3)声明整型变量f并赋值为10
         *     声明整型变量g并赋值为f+100，输出g的值
         *     在f本身基础之上增100，输出f的值
         *   声明整型变量h并赋值为36.789---------???
         *   输出变量i的值----------------------???
         *   声明整型变量i，输出i的值------------???
         * 4)声明几个正确的和几个错误的变量
         * 
         */
        
        
        
        
        
        
        
        
        
        
        
        
        //1.变量的声明:
        int a; //声明一个整型的变量，名为a
        int b,c,d; //声明三个整型的变量，名为b,c,d
        
        //2.变量的初始化:第一次赋值
        int e = 250; //声明整型变量e并赋值为250
        int f;   //声明整型变量f
        f = 250; //给变量f赋值为250
        
        //3.变量的使用:
        int g = 5; //声明整型变量g并赋值为5
        int h = g+10; //取出g的值5，加10后，再赋值给整型变量h
        System.out.println(h);   //输出变量h的值15
        System.out.println("h"); //输出h，双引号中的原样输出
        g = g+10; //在g本身基础之上增10
        System.out.println(g); //15
        //int i = 3.14; //编译错误，数据类型不匹配
        //System.out.println(m); //编译错误，m未声明
        int m;
        //System.out.println(m); //编译错误，m未初始化
        
        //4.变量的命名:
        int a1,a_5$,_6b,$_;
        //int a*b; //编译错误，不能包含*号等特殊字符
        //int 1a; //编译错误，不能以数字开头
        int am = 5;
        //System.out.println(Am); //编译错误，严格区分大小写
        //int class; //编译错误，不能使用关键字
        int 年龄; //正确，但不建议
        int age; //建议"英文的见名知意"
        int score,myScore,myJavaScore; //驼峰命名法
    }
}

三：

package day02;
import java.util.Scanner; //1.
//Scanner的演示
public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in); //2.
        System.out.println("请输入年龄:");
        int age = scan.nextInt(); //3.
        System.out.println("请输入价格:");
        double price = scan.nextDouble();
        
        System.out.println(age);
        System.out.println(price);
    }
}