JAVAEE学习day02

1.数据类型的转换

　　1>自动转换(隐式)　　

// 将取值范围小的数据类型自动提升为取值范围大的类型

// 定义byte类型数据
byte b = 10;

// 定义short类型数据
short s = 20;

// short a = b + s;　　　　// 两个变量在相加的时候会自动转换成两个int类型相加,将int赋值给byte报错

//修改方法将会在强制转换给出

// 自动转换顺序
byte -> short -> int -> long -> float -> double

　　2>强制转换(显式)　　　

// 将取值范围大的数据类型强制转换成取值范围小的类型

// 定义byte类型数据
byte b = 10;

// 定义short类型数据
short s = 20;

// short a = b + s;　　　　// 两个变量在相加的时候会自动转换成两个int类型相加,将int赋值给byte报错

//修改方法1

short a = (short) (b + s);

//修改方法2
int a = b + s;

　　/*

　　转换格式:
　　　　目标类型 变量名 = (目标数据类型) 数据值;

　　注意:
　　　　1)浮点数转换成整数,直接取消小数部分,可能造成精度损失
　　　　2)取值范围大的数据类型强制转换成取值范围小的数据类型,
　　　　将砍掉前边多余的字节,可能损失精度.

　　*/

　　

2.ASCII码表

　　0　　　　  48
　　9　　　　  57
　　A　　　　  65
　　Z 　　　　 90
　　a 　　　　 97
　　z 　　　　 122

 

3.算数运算符

　　 +    加法
    -    减法
    *    乘法
    /    除法
    %    取模/取余
    ++    自增
    --    自减
    以上运算符计算整数的时候不会产生小数
    
    自增和自减
        两种表现形式
            前++,前--
            ++后,--后
            
        在独立运算的时候两者没有区别
        在混合运算时候的区别
            前++,先拿自身做运算,然后再自加
            ++后,先自加,然后再做运算
        
    加号
        + 在遇到字符串的时候表示链接和拼接的含义

4.赋值运算符

　　 
　　/*
　　 =    等号
    +=    加等于
    -=    减等于
    *=    乘等于
    /=    除等于
    %=    取模等于
　　 */    

    // += 扩展:
        byte a = 10;
        byte c = a + 1;        // 报错,1为int类型,自动提升为int
        byte c += 1;   　　　　 // java自动强转,等同于 byte c =(byte)(c + 1);

5.比较运算符

    ==        比较两边是否相等,相等结果为true
    <        比较左边是否小于右边,如果是,为true
    >        比较左边是否大于右边,如果是,为true
    <=        比较左边是否小于等于右边,如果是,为true
    >=        比较左边是否大于等于右边,如果是,为true
    !=        比较两边是不是不相等,如果不等则为true    

6.逻辑运算符

    &&        短路与
        两边为true为true
        短路的特性:左边是false,右边不再运算
        
    ||        短路或
        一边为true则为true
        短路特性:左边是true,右边不再运算
        
    !        取反
        !true == false
        !false == true

7.三元运算符

// 格式:
        // 数据类型 变量名 = 布尔类型表达式 ? 结果1 : 结果2;
        
        // 布尔表达式结果为true,结果1赋值给变量
        // 布尔表达式结果为false,结果2赋值给变量

8.定义方法入门

    将一个功能提取出来,把代码单独定义在一个大括号内,形成一个单独的功能
    
    方法的定义格式:
        修饰符 返回值类型 方法名(参数){
            return ;
        }
    public static void demo(){
        System.out.println("我是一个方法");
    }

9.方法的调用

// 方法在定义完成之后,自己不会运行,只有被调用再能执行,我们在主方法中调用方法
        // 举个栗子:
        
        public class Method{
            // 主方法
            public static main(String[] args){
                // 调用方法
                method();
            }
            
            // 定义的方法
            public static void method(){
                System.out.println("我是一个被调用的方法");
            }
        }
        
        // 注意:
            // 方法必须定义在类中main方法外,不能定义在另一个方法中

练习题

//    问题一：
        int a = 100;
        byte b = 50;
        //        int + int  所以计算结果是int
        short c = a + b;
        //改一
        short c = (short)(a + b);
        //改二
        int c = a + b;

//问题二：
    int x = 100;
    //200是int类型,赋值给long类型.自动类型提升.
    long  y = 200;
    //      int  long  计算结果 long
    int z = x + y;
    //改一
    int z = (int)(x + y);
    //改二
    long z = x + y;

//问题三：
    long  t = 100;//类型提升
    int  s = 50;
        //    long + int 计算结果是long .赋值给float类型的变量f,这里是自动类型转换
    float f = t + s; 

//问题四：
    byte a = 10;
    byte b = 20;
    //计算结果应该是int类型的
    byte c = a + b;

//问题五：
    char c = 'a';//97
    System.out.println(c + 10);    //        107

    int i = 97;
    //强转的时候.会拿着97去编码表中查他对应的字符.然后把这个字符赋值给变量c
    char c = (char)i;
    System.out.println(c);//a

    char c = 'a';    
    //        int + int 计算结果是int
    char cc = c + 1; 
    //改一
    int cc = c + 1; 
    System.out.println(cc); //98
    //改二
    //先进行加法运算. 97 + 1 = 98
    //然后强制类型转换. 就是拿着98去编码表中去查他对应的字符, 'b'
    char cc = (char)(c + 1);
    System.out.println(cc);//b


 //16-编译器的两点优化




    byte a = 10;
    byte b = 20;
    //       int + int所以运算结果是int
    byte c = a + b;//编译出错
    byte cc = 10 + 20;//等号右边全部都是常量,编译器给我们计算出结果,然后去判断30是在byte取值范围之内,所以直接赋值.


    char c = 'a';
    System.out.println(c);//a
    char c = 97;//赋值的过程,就是拿着97这个编号去编码表中查他对应的字符,然后给变量c赋值
    System.out.println(c);//a

    //问题：
        //    int + int 计算结果是int类型.
        //这个int类型的计算结果再char的范围之内,可以直接赋值给变量c
    char c = 'a' + 1; 
    System.out.println(c);//b

    byte b = 3 + 4; //相当于 byte b = 7;
    System.out.println(b);

    byte b = 100 + 100; //1. 200,2 200超出了byte范围,所以编译出错.
    System.out.println(b);




//变量跟变量之间：
    int a = 10;
    int b = 20;
    int c = a + b;

//变量跟常量之间
    int a = 10;
    int b = a + 10;

//常量跟常量之间：
    
    byte b1 = 3;
    byte b2 = 4;
    byte b = b1 + b2;    //报错,byte相加会升级成int,然后相加
    //修改1
    byte b = (byte) (b1 + b2)
    //修改2
    int b = b1 + b2

    byte bb = 3 + 4 ;
    System.out.println(bb);

    byte bbb = 100 + 100;    //报错,超出范围
    
    System.out.println(bbb);



    int a = 1;
    int b = a-- + a--;
    System.out.println(a);    // -1
    System.out.println(b);    // 1


    int a = 1;
    int b = ++a + a--;
    System.out.println(a);     // 1
    System.out.println(b);    // 4


    int a = 1;
    int b = --a + ++a;
    System.out.println(a);    // 1
    System.out.println(b);    // 1
    
    

    int a = 1;
    int b = 2;
    int c = (a++ > b++) && (a++ >= b++) ? a : b;
    System.out.println(c);    //3


    int c = (a++ > b++) & (a++ >= b++) ? a : b;
    System.out.println(c);    //4


    int c = (a++ < b++) & (a++ >= b++) ? a : b;
    System.out.println(c);    //4


    int a = 1;
    int b = 2;
    int c = (++a >= b++) && (a++ >= b++) ? a : b;
    System.out.println(c);    //4