今天我们学习了数据类型转换、运算符、方法
请将下面问题用自己理解的话表述出来：

今日需要掌握的有：

1、++和--单独使用和在运算中使用有什么区别？
2、什么是强转？什么是自动类型转换？
3、&&和||的区别？
4、什么是方法？定义和调用的时候有什么要注意的地方？
5、s+=1和s=s+1有什么区别？

1、++和--单独使用和在运算中使用有什么区别？自增自减运算符在单独使用的时候没有区别,混合使用的时候,前++为先加后用,后++为先用后+,后++先把当前的变量的值拿来使用,使用过后才在当前值的基础上+,自减同理.

2、什么是强转？什么是自动类型转换？
强制转换是将数据类型由小转大,发生运算的时候,数据类型会变成默认值,在表达式里面加上(数据类型),将会把当前数据的默认类型强制转换成自己设置的数据类型,不推荐使用因为可能会导致数据溢出或精度损失.
自动类型转换是将数据由小转大,也是发生运算的时候会将小的数据类型自动转换成默认值.



3、&&和||的区别？
&&为并且的关系,设置条件都需要为true才是true.
||为或者的关系,设置条件其中一个为true,就是true.

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法是将程序运行的步骤抽取出来并且单独定义一个方法,可以提高程序的可维护性及可读性,优化代码.
定义的时候要写在main方法外,类里面,命名用小驼峰式,方法不可以方法间嵌套.如果要执行方法需要调用,单独调用格式为: 方法名();

5、s+=1和s=s+1有什么区别？


s += 1 为 s = s + 1
s = s+1 为将 s + 1 的值赋给s

======迷人的反派角色林传伟=====
1、单独使用：没区别，都自增自减1；
运算中使用：前++，变量先+1，用结果进行运算，先加后用；后++，先用原本变量运算，然后变量+1，先用后加；
2、自动类型（隐式）转换：特点：代码不需要特殊处理，规则：数据范围从小到大；
强制类型（显式）转换：格式：范围小的类型 范围小的变量名=（范围小的类型） 原本范围大的数据；
3、&&：and的关系，两者都true才为true；||：or的关系，两者中有一为true就为true；
4、方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能，格式：public static void 方法名(){}
方法名用小驼峰方式命名，方法体：大括号当中可以包含任意条语句，方法的定义不能嵌套即不能放在另一个方法内；调用：方法名（）;；
5、在程序执行上前者只运算一次，后者两次，且S+=有强制转换特点。

吴佳更
1.单独使用的时候没有任何影响。在运算中使用。如果是先++或先--，就先执行+1或者减1再加入运算，如果是后++或者后--，则运算完再++或--。
2.强转就是范围大的数据类型转换成范围小的数据类型。自动则是范围小的转成范围大的，比如byte，short，char在运算时候会被转换成范围更大的int类型加入运算。
3.&&只有在两个都为true的时候才会为true，否则为false，只要第一个为false，则不执行后面判断，已经为false。||在只有两个都为false的时候才会为false，否则都为true，只要第一个为true，则不执行后面判断，已经为true。
4.方法就是一段具有功能的代码。定义在类中方法外，命名为小驼峰式。调用直接用方法名（);
5.s+=1有隐含一个强制转换的公式。而s=s+1没有。

黄希

1、++和--单独使用和在运算中使用有什么区别？
        单独使用：++在前或在后，没有区别；
        在运算中使用：++在前，先自增再使用；++在后，先使用再自增。
       
2、什么是强转？什么是自动类型转换？
        强制转换：取值范围大的数据类型，转换为取值范围小的数据类型，例如int i=100;byte b=(byte)i;
        自动类型转换：将取值范围小的数据类型的数据，赋值给取值范围大的数据类型的变量，例如float f=100L;

3、&&和||的区别？
        &&且，两边的条件必须都为true，返回结果才为true；只要有一边条件为false，返回结果就为false；
        ||或，两边的条件只要有一边为true，返回结果就为true；两边都为false，返回结果为false。
       
        &&和||都具有短路效果，只要左边的表达式能确认最终的返回结果，那么右边的表达式就不会执行。

4、什么是方法？定义和调用的时候有什么要注意的地方？
        把代码单独定义在一个大括号内，形成一个独立的功能，实现代码复用，体现了面向对象中封装的特性。

5、s+=1和s=s+1有什么区别？
        计算结果没有区别。
        s如果是byte、short或char类型，在运算时，会先转换为int类型，再加上1，最后强制转换回byte、short或char类型。

王宇晨
1、++和--单独使用和在运算中使用有什么区别？
        单独使用时：前++（--）和后++（--）没有什么区别
        在运算中使用时：前++（--）数据先进行自增（减），然后再进行运算；
                                   后++（--）数据先参与运算，然后再进行自增（减）
2、什么是强转？什么是自动类型转换？
   强转（显式转换）：就是取值范围大的数据向取值范围小的数据转换，不能自动完成；
   自动类型转换（隐式转换）：就是运算时取值范围小的数据自动转换为取值范围大的数据。
3、&&和||的区别？  
   &&与：前后只要有一个为false，结果为false，只有两个都为true结果才为true
   ||或：前后只要有一个为true，结果为true，只有两个都为false结果才为false
4、什么是方法？定义和调用的时候有什么要注意的地方？
    方法就是把一个功能抽取出来，放在一个大括号内，方便我们调用。
    定义方法时：要定义在类内main方法外。
    调用方法：方法定义完成后不会自动运行，要通过调用才能运行；要在main方法中调用。
5、s+=1和s=s+1有什么区别？
    s+=1属于复合赋值，中间不存在隐式转换；
    s=s+1就是将s+1赋值给左边，因为1是int类型，运算过程中存在隐式转换，左右两边都为int类型

1、++和--单独使用和在运算中使用有什么区别？
自增和自减的表现形式分别是写在变量之前或者之后，例如i++和++i，i--和--i；
分别表示变量进行加一运算或者减一运算；
在单独使用时，前++与后++没有区别，同理，前--与后--；
在运算中使用时，前++表示变量值先进行自加一然后再参与外部运算，后++表示先参与外部运算，再将变量自身值进行自加一运算，同理可以知道自减运算。

2、什么是强转？什么是自动类型转换？
强制类型转换是指在运算过程当中参与运算的数据类型中将范围大的数据类型强制转换成范围小的变量，
基本格式是 范围小的数据类型 a = （范围小的数据类型）b；
自动类型转换则是在运算过程当中，范围小的变量自动转换成范围大的数据类型然后参与运算，例如：byte、short、char在参与运算的时候都是转换成int类型然后再进行计算。

3、&&和||的区别？
&&表示逻辑运算中的与，当判断全是TRUE的时候才输出TRUE
||表示逻辑运算的中的或，当判断只要有一个TRUE就输出TRUE，全是false的时候输出false
&&和||都具有短路效应，当&&的左边为false的时候就停止运行右边的内容，直接输出false;
                                      当||的左边为true的时候就停止运行右边的内容，直接输出ture。

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法是我们定义出来的具有特定意义的程序段，定义格式为public static void 方法名(){方法体}
定义方法的时候要注意：1、方法名首字母小写，后面每一个单词的首字母大写；
                                     2、方法名不能够嵌套使用；
调用方法的格式：方法名();（需要使用方法的时候执行调用命令）。

5、s+=1和s=s+1有什么区别？
二者在一般情况下没有什么区别，即s+=1和s=s+1表示的意思是一样的
主要区别是“+=”运用的是复合赋值运算符，‘=’和“+”运用的的是基本赋值运算符
而在符合赋值运算符中包含了一个强制类型转换。

杨银万
1、++和--在单独使用的时候没有区别,都为自增或自减。在运算使用的时候,前++为先加后用,后++为先用后+,后++先把当前的变量的值拿来使用,使用过后才在当前值的基础上自增或自减.
2、
强制转换是将取值范围大的数据类型转换成取值范围小的数据类型，不推荐使用因为可能会导致数据丢失或精度损失.
自动类型转换是将取值范围小的数据类型转换成取值范围大的数据类型，在程序运行的时候会将小的数据类型自动转换成大的数据类型.
3、
&&为并且的关系,设置条件都需要为true最后结果才是true.
||为或者的关系,设置条件其中一个为true,最后结果就是true.
4、
方法是将程序运行的部分代码抽取出来模块化并且单独定义，可以优化代码，提高程序的可维护性及可读性。方法定义的时候要写在类里面，方法外，命名规范为小驼峰式，方法不可以嵌套定义。如果要执行方法需要在main方法中调用,调用格式为: 方法名();
5、
s += 1 等同于 s = s + 1
但是s+=1在运算时会自动进行数据类型的强制转换，而s=s+1不会进行数据类型转换；

名：刘思聪


1、++和--单独使用和在运算中使用有什么区别？单独使用时候，放在变量的前后没有区别
在运算中混合使用时候，先++/--则先增/减后用（即用自增/减结果参与其他运算）、后++/--则先用后增/减（先参与其他运算然后在自增/减）

2、什么是强转？什么是自动类型转换？
强转，即强制类型转换，显式转换，当数据类型从范围较大的转向范围较小的数的时候需要使用强制类型转换。要手动在代码里完成。
自动类型转换，隐式转换，在当范围较大的数据类型的变量接受来自取值范围较小的数据类型时候，自动完成的数据类型转换，能够自动完成，不需要特定的代码处理。
3、&&和||的区别？
与逻辑计算&&为必须前后都为true，最后返回值才为true
或逻辑计算||只要有一个为true就会返回true

4、什么是方法？定义和调用的时候有什么要注意的地方？
将实现特定功能的代码提取出来放在一个大括号内，并且在需要时调用。
注意事项：方法不能嵌套。方法定义的先后顺序无所谓。方法只会在调用的时候才会执行。

5、s+=1和s=s+1有什么区别？


s为byte、char、short类的时候，s+=1包括了一个强制类型转换。将因为参与计算自动提升为int的值强转回原有类型。

林焕
1、单独使用时没有区别，都是自增或者自减1。
运算中使用：如果是前++或者前--，变量直接取加1或者减1的结果使用。
            如果是后++或者后--，变量就是先取原来数值使用，然后再加1或者减1。
2、强转：强制类型转换（显式），也就是范围大的数据类型进行特殊的格式处理转换为范围小的数据类型，其格式为 范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
  自动类型转换：隐式，代码不需特殊处理，自动把范围小的数据类型转换成范围大的数据类型。
3、&&：与，两侧条件都要为true，结果才为true，否则为false。
   ||：或，两侧条件至少有一个为true，结果为true，两侧都为false，结果才为false。
二者的共同点是都具有短路效果。
4、方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
方法定义时必须定义在一类方法外，不能定义在另一类的方法里面。
调用时可以直接在主方法里调用已经定义好的方法，只要写出调用的方法名即可。
5、s+=1相当于s=s+1,只运算了一次，计算结果被提升到int类型，带有强制转换的特点。
s=s+1进行运算了2次。

吴香斌

1、++和--单独使用和在运算中使用有什么区别？
   单独使用没有区别
   在运算中使用：++a和--a（前++）是变量自加1后，以加完的数值进行使用
                          a++和a--（后++）是使用完后，变量再自加1.

2、什么是强转？什么是自动类型转换？
   在运算过程中，转换发生在数据类型不一样的时候。
   自动类型转换：格式：无，Java编译器自行转换。
                          适用条件：大的取值范围转换为小的。
   强制类型转换：格式：范围小的数据类型 变量名称 = （范围小的数据类型） 数据值；
                 适用条件：小的取值范围转换为大的
                 注意事项：容易产生数据丢失及精度缺失问题，不建议使用
                                   针对byte/short/char类型，在进行运算时，会被Java编译器强制转换为int类型然后进行计算
   各数据类型取值范围比较
   byte、short、char <  int < long < float < double
   
3、&&和||的区别？
   &&是 与 即符号两侧的布尔值都为true，才是true;否则是false
   ||是 或 即符号两侧的布尔值有一个为true，就是true;全部false,才是false.
   
4、什么是方法？定义和调用的时候有什么要注意的地方？
   方法就是用来简化代码，使代码模块化，增加可读性，使代码更加的优秀。
   方法的定义格式：public static void 方法名称(){方法体}
   调用的格式：方法名称();

5、s+=1和s=s+1有什么区别？
   s+=1 使用了复合赋值运算符 += ,s+=1 当数据类型是比int小的数据类型，这个等式存在一个强制转换，因此这个等式可以实现
   s=s+1当数据类型是比int小的数据类型，这个等式中的1是int类型，这时候会有int类型往小的数据类型转换，会报错。

1、++和--单独使用和在运算中使用有什么区别？
//++和--在单独使用的时候，没有区别，在参与运算中，前++a,先加后用，后a++,先用后加 --同前面一样


2、什么是强转？什么是自动类型转换？
//范围小的类型，范围小的变量名 = 原本范围大的数据 ，数据会丢失， 就叫做强行转换
//数据范围从小到大叫做自动类型转换

3、&&和||的区别？
//(与并且) && 全是true,才是true,否则为false
//（或或者）|| 至少有一个是true,才是true,否则为false


4、什么是方法？定义和调用的时候有什么要注意的地方？
//方法名称和命名变量名称一致，使用小驼峰
//不分先后顺序，不能嵌套包含关系，如果想要执行，必须先要方法调用


5、s+=1和s=s+1有什么区别？
//+号代表字符串连接操作

1.++和--单独使用是没有任何的区别，如果是在混合使用的时候是重大的区别，如前++是先计算在赋值，后++是先赋值在计算。

2.强转：当右边的数据类型比左边的数据类型大时就需要强转，自动类型转换：就是当右边的数据类型比左边的数据类型小时就会自动转换。（整数默认的数据类型是int，浮点默认的数据类型是double）。

3.&&：表示中文且的意思就是判断有一方为false 结果就为false，全部为true时结果才true。||：表示中文或的意思就是判断有一方为true结果就为true,全部为false时结果才为false。（短路运用：只要左边的判断体为true右边的判断体不做任何的运算）。

4.就是将程序的某些功能拿出来定义在main方法外边单独定义的方法，优化了代码提高了代码的阅读性。定义的方法的顺序无所谓，方法内不能再嵌套另外一个方法。

5.s+=1相当于s=s+1。但s+=1在byte，short，char中会存在强制转换。

1、++和--单独使用和在运算中使用有什么区别？
2、什么是强转？什么是自动类型转换？
3、&&和||的区别？
4、什么是方法？定义和调用的时候有什么要注意的地方？
5、s+=1和s=s+1有什么区别？

卢林觉

1、++在单独使用时，前++与后++没有区别，都代表给变量本身+1；当++混合使用时，前++表示先将变量本身+1后，在放到表达式中使用，后++表示先将变量本身进行使用，用完之后再变量本身+1。
前--后--使用方法与前++后++一样。

2、强制转换：取值范围大的赋值给取值范围小的需进行数据类型的转换。格式：范围小的数据类型 变量名 = （范围小的数据类型） 范围大的数据。

3、&&表示逻辑运算符与的关系，只有当&&左右两边的条件都为true时才为true，否则就是false。
||表示逻辑运算符或的关系，当||两边条件都为false时即为false，否则为true。

4、方法就是将能实现一定功能的语句定义在一个模块化语句中，当要实现此功能时，可调用该模块。
定义方法时要将方法定义在类和main方法中间。
方法中不可再嵌套方法。
在main方法前后无差别。
命名要使用小驼峰。

5、两者等同。

1.++和--单独使用时，在前后没有任何区别。
在运算中使用，在前就先加后用，在后就先用后加。
2.强转就是将原本范围大的数据类型值强制转换为范围小的数据类型值，是显式的。自动类型转换就是将范围小的数据转换为范围大的数据，无需操作，自动完成，是隐式的。
3.&&并 只要一个是false就是false，都是true才是true。||或  只要一个有true就是true，都是false才是false。
4.public static void 方法名（）{}  方法名（）；   
方法名首单词要小写后单词首字母大写，方法定义不能嵌套，方法定义后要调用才能使用。
5.没有区别。两者一样。

1，在单独使用中，两者都是自加或者自减1，在运算中使用，前++或者前--会先把变量加减完再使用，后++或者后--会先使用当前值然后再加减变量。
2，数据类型转换分为1，强制类型转换，即数据类型范围大向小的转换，右侧值前加上（数据类型范围小的类型）。2自动类型转换：数据类型范围小的向大的转换，自动进行。
3，&&是两者都为真的时候值为真，不满足的话为假，||是两者至少其中一方为真的时候值为真，两者都为假的时候值为假，两者具有短路效果。
4，方法可以使代码逻辑更清晰更整洁，更具可维护性，定义方法要在类里面，方法外面（即方法定义不能互相嵌套），方法名软规范为小驼峰式。调用为方法名（）;。
5，s=s+1和s+=1都是使s的加上1，s+=1具有隐藏的强制类型转换。s=s+1如果s的数据类型比int的范围小，那么程序会报错。

姓名：刘宵
1.单独使用的时候不用考虑先++还是后++，该行语句运行完后，变量都会+1。在运算中使用的时候要考虑先++还是后++，++在前那就变量先自增1然后在进行运算，++在后就先进行运算，然后运算完毕后在进行自增。
经典案例：int a=10;
                 System.out.println(a++); //输出10
                 System.out.println(a);//输出11
2.在对变量进行赋值的时候要考虑左右两个类型是否相同。不同的时候，右边类型的取值范围如果大于左边类型，那么就必须要进行强制转换。（记忆方法：将一个体积比较大的物体，装入一个小杯子里头，就必须要强行塞入。）反之，右边类型的取值范围小于左边类型时候，会自动进行转换,自动转换就是java编译器会自动的给右边的数据类型进行（左边类型）补全。
经典案例:float a=10L; //此时右边为long类型，long类型取值范围小于float，此时自动转换。
              int c=(int)10000000000L;//此时右边为long类型，long类型的取值范围大于int，此时需要强制转换。
3.&&和||的区别是 &&两边的布尔值都为真时，表达式结果才为真。||是两边布尔值只要有一个为真，那么表达式的结果就为真。&&和&的区别是：&&当左边的布尔值为false时，不对右边进行运算。||和|的区别是：||右边布尔值为true时，不对右边进行运算。
4.方法就是能解决某些特定问题的一个逻辑代码块。
**定义**方法时要注意五点：①方法的修饰符；②是否有返回值；③方法名是否符合命名规则；④是否需要形参；⑤定义方法的位置（类内，其他方法外）。
**调用**方法时要注意两点：①方法是否有返回值；②是否需要传参。
5.s+=1和s=s+1的区别在于 s+=1多了一个自动类型转换的过程。
案例：short s=20;
                s+=1;
                System.out.println(s);//这样编译时不报错。
而     short s=20;
                s=s+1;
                System.out.println(s);//编译报错，原因是short类型变量+int型数据时候，short会提升为int类型，相当于int+int所以接收的变量应该是int类型。

名:贾宗虎




1、++和 --在单独使用的时候,++和--用法是一样的,    前++和后++是一样的,都是给自己增加1.     但是如果和别人运算,前++例如: ++i;是先自增1,再参与运算.先加后用.  而后++例如: i++; 是先用本来的值参与运算,然后再自增1.先用后加.
2、强转是指强制类型转换.格式为数据类型 变量名 = (数据类型) 变量值;例如: byte b=(byte) 200;
     一般是指取值范围大的类型转向取值范围小的类型.但不建议用,因为会损失数据.变得不准确.
     自动类型转换是指,取值范围小的类型转向大的类型.不需要手动操作.
     有个ASCII码表要被3个值,  0为48,A为65,a为97.
3、&&是逻辑运算符:与
     ||是或
     与  是必须要同时满足前后两个条件都为真,结果才为真,有一个为假,结果就是假.
     或  要宽松一些,前后两个条件,满足一个为真,结果就为真,同时为假,结果才是假.
    有个短路原则要注意: 当&& 和 || 判断第一个条件是符合结果为真的时候,就不执行第二个条件了.
4、方法是把一些具有特定功能的代码,放到一个模块里面,以便于使代码更优秀,提高阅读性
     定义: 目前的固定格式 public static void 方法名(){方法体}
              定义的位置为类中,main方法外.
              定义多个方法,位置不分先后
     调用: 格式 方法名();   调用的时候要在main方法里面.
              调用多个方法的时候是区分先后顺序的.
5、1)s += 1是一次计算, s = s + 1;是两次计算.

     2)s +=1 可以自动类型转换,例如s是byte,short,char型的时候.而s=s+1不行.编译报错.

康春达

1、++和--单独使用和在运算中使用有什么区别？

a = b++; ++写在后面，说明前面那个东西前用了，也就是b先赋值给a了，然后b再+1。a = ++b; ++写在前面，说明++先有效，即b要+1，然后赋值给a。//最终效果上是a的值不同，而b的值都做了+1操作，只是先赋值还是先+1的问题。
单独使用 自加减一

2、什么是强转？什么是自动类型转换？

自动类型转换，也称隐式类型转换，是指不需要书写代码，由系统自动完成的类型转换。由于实际开发中这样的类型转换很多，所以Java语言在设计时，没有为该操作设计语法，而是由JVM自动完成。
byte b1 = 100;
int n = b1;
强制类型转换，也称显式类型转换，是指必须书写代码才能完成的类型转换。该类类型转换很可能存在精度的损失，所以必须书写相应的代码，并且能够忍受该种损失时才进行该类型的转换。
double d = 3.10;
int n = (int)d;

3、&&和||的区别？
a && b
a和b同时为true 才返回 true， 否则返回false

a || b
a或b任意一个为true 就返回true ， 否则返回false

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法其实就是一个{},给该{}起名字,来去执行{}中的内容   方法:调用独立的代码块
1方法定义的先后顺序无所谓。
2.方法的定义不能产生嵌套包含关系。
3.方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的调用的啦。

5、s+=1和s=s+1有什么区别？

1.     必须进行显示类型转换而s+=1的意思与s =s+1不同，s=s+1

这句先执行s+1然后把结果赋给s，由于1为int类型，所以s+1的返回值是

int，编译器自动进行了隐式类型转换。

2.     将一个int类型赋给short就会出错，而s+=1不同由于是+=操

作符，在解析时候s+=1就等价于s = (short)(s+1),翻过来讲就是  

s+=1 <=> s = (s的类型)(s+1)

王博


1：
++和--单独使用时，写在变量前面和后面一样，没有区别。如果在运算中使用前++、--，会先让变量加1或者减1，然后再来运算，如果是后++、--， 那么会先直接拿变量本身来运算，然后变量再来加1或减1

2：
自动类型转换：代码不需要特殊处理，会自动进行转换（由取值范围小的数据类型转换成范围大的类型）
强制类型转换：代码需要进行特殊的处理（由取值范围大的数据类型转换为范围小的类型）
强制类型转换格式：范围小的数据类型 变量名 = （范围小的数据类型）取值范围大的数值；

3：
&&：两个条件都为true时结果才为true，若有一个为false结果就为false，如果第一个条件为false，那么结果就为false且第二条件代码不会执行
||：两个条件有一个为true结果就为true，全都为false结果才为false，如果第一个条件为true，那么结果就为true且第二个条件代码不会执行

4：
方法就是定义的一种方法，可以让代码模块化，更易读
定义方法的格式：public static void 方法名（）{      方法体       }
方法要定义在类当中，其他方法外
方法必须调用才能使用
调用方法格式： 方法名();

5:
s += 1; 相当于 s = s + 1;

1.这个前++和后++的这种自增自减运算符的话，前++和后++在单独使用的时候是没有任何区别的，都是可以让数字自动增加或减少一个数字。如果说在运算当中的话，前++是让数字先加或者先减再拿来用，后++是先把原来的数字拿来用，然后在增加或减少一个数。总结一下就是前++就是先加再用！后++就是先用再加！
2.强制转换就是把大的数据范围转换为小的数据范围，比如说int强转为short类型，short转换为byte类型，但是这种极度不推荐使用，会发生数据的精度损失、溢出。
自动类型转换的话就是数据类型的范围从小变到大，比如byte转换成short，short转换为int，int转换成long类型这样子的，这种的话，不需要我们做任何特殊处理，编译会自动完成。
3.&&这种就是“短路与”条件缺一不可，只要其中一个条件不满足就会判定false，一定要满足两个条件才会判定true！
||这种就是“短路或”条件只要满足其中一个是正确的，那么就会判定true，除非两个条件都不满足才会判定false！
在我们写代码的时候是极度推荐使用这种格式，会提高我们代码运行的性能！
4.方法就是我们程序运行的起点，像我们写public static void main（String【】 args）{}中的main方法就是我们程序运行的起点！定义方法的话格式是 修饰符 void 方法名称（）{}   也就是public static void 方法名称（）{}即可
注意事项的话就是我们这行代码是没有分号“；”的，还有就是我们的方法是定义在类的里面，main方法的外面即可！
调用的话是在main方法里面调用即可，格式就是 方法名称（）； 调用方法的话在语句的结尾是有分号“；”的！
5.s += 1 翻译过来的话就是 s = s + 1 所以和 s = s + 1 是没有区别的。区别就是s += 1这种使我们的复合赋值运算符的用法。也是极度推荐使用这种格式。

1：
++和--单独使用时，写在变量前面和后面一样，没有区别。如果在运算中使用前++、--，会先让变量加1或者减1，然后再来运算，如果是后++、--， 那么会先直接拿变量本身来运算，然后变量再来加1或减1

2：
自动类型转换：代码不需要特殊处理，会自动进行转换（由取值范围小的数据类型转换成范围大的类型）
强制类型转换：代码需要进行特殊的处理（由取值范围大的数据类型转换为范围小的类型）
强制类型转换格式：范围小的数据类型 变量名 = （范围小的数据类型）取值范围大的数值；

3：
&&：两个条件都为true时结果才为true，若有一个为false结果就为false，如果第一个条件为false，那么结果就为false且第二条件代码不会执行
||：两个条件有一个为true结果就为true，全都为false结果才为false，如果第一个条件为true，那么结果就为true且第二个条件代码不会执行

4：
方法就是定义的一种方法，可以让代码模块化，更易读
定义方法的格式：public static void 方法名（）{      方法体       }
方法要定义在类当中，其他方法外
方法必须调用才能使用
调用方法格式： 方法名();

5:
s += 1; 相当于 s = s + 1;

刘慧梅
1、++和--单独使用和运算中使用有什么区别？
在单独使用时是一个独立的步骤，前++/--和后++/--并没有区别，都是增一或减一。
在运算中前++/--是使用变量进行运算，后++/--是使用变量前原来的值进行运算。

2、什么是强转？什么是自动类型转换？
强制类型转换（显式）是数据取值范围从大到小进行转换，代码需要进行特殊处理，不能自动完成。
自动类型转换（隐式）是数据取值范围从小到大进行转换，代码不需要进行特殊处理，能够自动完成。

3、&&和||的区别？
&&：与（并且）——前后必须全都是true，运行结果才是true;如果其中有一个为false，则运行结果为false。
||：或（或者）——前后至少一个是true，运行结果则为true；前后全是false，运行结果才为false。

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法是将程序中的步骤单独放在一个大括号中
注意事项：定义在类中方法外;不能产生嵌套包含关系;如果要运行，那就要调用方法

5、s+=1和s=s+1有什么区别？
s+=1相当于s=s+1
s=s+1是将s+1赋值于左边的s

1: ++和 -- 在单独使用是没有什么区别，各自增加或者减少一个1；
在参与运算中，如果++或者--在前边，则先增加或者减少一个1再用；
如果++或者--在后边，则先用然后再增加或者减少一个1。
2：强转：代码需要进行特殊处理，不能自动完成，是数据范围大的转换为数类型范围小的       
自动类型转换：代码不需要进行特殊处理，可以自动完成，范围是小到大转。
3：&& 全部是true才为true，|| 只要有一个为true就为true；具有短路效果，左边可以判断右边不会执行；
可以连续。
4：方法：指定一个可以使用的功能
public static void 方法名称（）{
        方法体
}
方法名使用小驼峰式命名，首单词小写
调用：方法名（）；
5：s+=1 逻辑上看作是s=s+1 计算结果被提升为int类型，
但是， s=s+1进行两次运算 ， += 只运算一次，是强制转换的，

1.++和--单独使用作用类似，运算中自增和自减分为先后，区别是先计算还是先自增或自减。
2.强制转换时范围大的类型赋值给范围小的类型需要转换类型，自动类型转换为范围小的类型转换为范围大的，可自动转换。
3.&&真为真，且前面为假后面无需判断，||有真为真，短路与&&类似。
4.方法封装功能，方法格式 修饰符 方法名(){}
方法不可嵌套  方法调用 方法名()；
5.s+=1 隐藏类型转换

最后一题，s+=1有个强制类型转换。s=s+1的话没有，在类型转换的时候会出错，例如  byte s =1，byte s=s+1.