1 // 将取值范围小的数据类型自动提升为取值范围大的类型
 2
 3 // 定义byte类型数据
 4 byte b = 10;
 5
 6 // 定义short类型数据
 7 short s = 20;
 8
 9 // short a = b + s;　　　　// 两个变量在相加的时候会自动转换成两个int类型相加,将int赋值给byte报错
10
11 //修改方法将会在强制转换给出12 // 自动转换顺序
13 byte -> short -> int -> long -> float -> double

// 将取值范围大的数据类型强制转换成取值范围小的类型// 定义byte类型数据
byte b = 10;// 定义short类型数据
short s = 20;// short a = b + s;　　　　// 两个变量在相加的时候会自动转换成两个int类型相加,将int赋值给byte报错//修改方法1

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

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

　　/*

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

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

　　*/

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

　　 　　/*　　 =    等号+=    加等于-=    减等于*=    乘等于/=    除等于%=    取模等于*/    // += 扩展:byte a = 10;byte c = a + 1;        // 报错,1为int类型,自动提升为intbyte c += 1;   　　　　 // java自动强转,等同于 byte c =(byte)(c + 1);

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

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

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

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

 1 // 方法在定义完成之后,自己不会运行,只有被调用再能执行,我们在主方法中调用方法
 2         // 举个栗子:
 3
 4         public class Method{
 5             // 主方法
 6             public static main(String[] args){
 7                 // 调用方法
 8                 method();
 9             }
10
11             // 定义的方法
12             public static void method(){
13                 System.out.println("我是一个被调用的方法");
14             }
15         }
16
17         // 注意:
18             // 方法必须定义在类中main方法外,不能定义在另一个方法中

  1 //    问题一：
  2         int a = 100;
  3         byte b = 50;
  4         //        int + int  所以计算结果是int
  5         short c = a + b;
  6         //改一
  7         short c = (short)(a + b);
  8         //改二
  9         int c = a + b;
 10
 11 //问题二：
 12     int x = 100;
 13     //200是int类型,赋值给long类型.自动类型提升.
 14     long  y = 200;
 15     //      int  long  计算结果 long
 16     int z = x + y;
 17     //改一
 18     int z = (int)(x + y);
 19     //改二
 20     long z = x + y;
 21
 22 //问题三：
 23     long  t = 100;//类型提升
 24     int  s = 50;
 25         //    long + int 计算结果是long .赋值给float类型的变量f,这里是自动类型转换
 26     float f = t + s;
 27
 28 //问题四：
 29     byte a = 10;
 30     byte b = 20;
 31     //计算结果应该是int类型的
 32     byte c = a + b;
 33
 34 //问题五：
 35     char c = 'a';//97
 36     System.out.println(c + 10);    //        107
 37
 38     int i = 97;
 39     //强转的时候.会拿着97去编码表中查他对应的字符.然后把这个字符赋值给变量c
 40     char c = (char)i;
 41     System.out.println(c);//a
 42
 43     char c = 'a';
 44     //        int + int 计算结果是int
 45     char cc = c + 1;
 46     //改一
 47     int cc = c + 1;
 48     System.out.println(cc); //98
 49     //改二
 50     //先进行加法运算. 97 + 1 = 98
 51     //然后强制类型转换. 就是拿着98去编码表中去查他对应的字符, 'b'
 52     char cc = (char)(c + 1);
 53     System.out.println(cc);//b
 54
 55
 56  //16-编译器的两点优化
 57
 58
 59
 60
 61     byte a = 10;
 62     byte b = 20;
 63     //       int + int所以运算结果是int
 64     byte c = a + b;//编译出错
 65     byte cc = 10 + 20;//等号右边全部都是常量,编译器给我们计算出结果,然后去判断30是在byte取值范围之内,所以直接赋值.
 66
 67
 68     char c = 'a';
 69     System.out.println(c);//a
 70     char c = 97;//赋值的过程,就是拿着97这个编号去编码表中查他对应的字符,然后给变量c赋值
 71     System.out.println(c);//a
 72
 73     //问题：
 74         //    int + int 计算结果是int类型.
 75         //这个int类型的计算结果再char的范围之内,可以直接赋值给变量c
 76     char c = 'a' + 1;
 77     System.out.println(c);//b
 78
 79     byte b = 3 + 4; //相当于 byte b = 7;
 80     System.out.println(b);
 81
 82     byte b = 100 + 100; //1. 200,2 200超出了byte范围,所以编译出错.
 83     System.out.println(b);
 84
 85
 86
 87
 88 //变量跟变量之间：
 89     int a = 10;
 90     int b = 20;
 91     int c = a + b;
 92
 93 //变量跟常量之间
 94     int a = 10;
 95     int b = a + 10;
 96
 97 //常量跟常量之间：
 98
 99     byte b1 = 3;
100     byte b2 = 4;
101     byte b = b1 + b2;    //报错,byte相加会升级成int,然后相加
102     //修改1
103     byte b = (byte) (b1 + b2)
104     //修改2
105     int b = b1 + b2
106
107     byte bb = 3 + 4 ;
108     System.out.println(bb);
109
110     byte bbb = 100 + 100;    //报错,超出范围
111
112     System.out.println(bbb);
113
114
115
116     int a = 1;
117     int b = a-- + a--;
118     System.out.println(a);    // -1
119     System.out.println(b);    // 1
120
121
122     int a = 1;
123     int b = ++a + a--;
124     System.out.println(a);     // 1
125     System.out.println(b);    // 4
126
127
128     int a = 1;
129     int b = --a + ++a;
130     System.out.println(a);    // 1
131     System.out.println(b);    // 1
132
133
134
135     int a = 1;
136     int b = 2;
137     int c = (a++ > b++) && (a++ >= b++) ? a : b;
138     System.out.println(c);    //3
139
140
141     int c = (a++ > b++) & (a++ >= b++) ? a : b;
142     System.out.println(c);    //4
143
144
145     int c = (a++ < b++) & (a++ >= b++) ? a : b;
146     System.out.println(c);    //4
147
148
149     int a = 1;
150     int b = 2;
151     int c = (++a >= b++) && (a++ >= b++) ? a : b;
152     System.out.println(c);    //4