黑马程序员技术交流社区

标题: 【厦门校区JavaEE基础6期-每日总结】数据类型转换、运算符、方法入门 [打印本页]

作者: 厦门校区 时间: 2019-2-27 18:35
标题: 【厦门校区JavaEE基础6期-每日总结】数据类型转换、运算符、方法入门
请根据自己的理解，对当天内容进行总结
1、++和--单独使用和在运算中使用有什么区别？
2、什么是强转？什么是自动类型转换？
3、&&和||的区别？
4、什么是方法？定义和调用的时候有什么要注意的地方？
5、s+=1和s=s+1有什么区别？

作者: 陈伟彬 时间: 2019-2-27 21:30
1、++和--单独使用和在运算中使用有什么区别？
答
单独使用：，前++（--）和后++（--）没有区别，都是让一个变量涨（降）一个数字1；
混合使用：前++（--）是先加（减）再用；而后++（--）是先用在加（减）；
2、什么是强转？什么是自动类型转换？
答：
强转：代码需要进行特殊的格式处理，不能自动完成；格式为：范围小的类型  变量名  =（范围小的类型）原本类型范围大的数据；
自动转换：代码不需要特殊处理，自动完成类型转换；但需服从数据范围从小到大的要求
3、&&和||的区别？
答：
&&：与（并且）；一错全错，全对才对；
||：或（或者；）一对全对，全错才错。
4、什么是方法？定义和调用的时候有什么要注意的地方？
答：
概念：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
注意：方法定义的先后顺序无所谓，但不能产生嵌套包含关系；
         方法定义好之后，不会执行；想要执行，必须进行调用；
         main方法不能调用，只用由JVM来调用；
5、s+=1和s=s+1有什么区别？
答：如果s的数据类型比int大，则两者没有区别；
   如果s的数据类型比int小，则s+=1，隐含了一个强制类型转换，在编译时，右侧数据会被javac强转成左侧的数据类型；而s=s+1，会直接报错，需要进行s=s+（s的数据类型）1的强转。

作者: 龚荣章 时间: 2019-2-27 21:30
1、++和--单独使用和在运算中使用有什么区别？
前++和前--，先加/减后运算
后++和后--，先运算后加/减
2、什么是强转？什么是自动类型转换？
强转就是强制类型转换
强制类型转换：不是由程序自动完成的，需要手动进行转换
自动类型转换：自动类型转换是程序自动完成的，由小转大
3、&&和||的区别？
&&：全都是true才是true，有一个false就是false。
||：只要有一个是true就是true，全都是false才是false。
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。

（1）、方法的执行顺序和调用顺序有关
（2）、main方法不能调用
（3）、不能嵌套定义，方法中不能定义方法
（4）、方法的定义顺序和执行顺序无关
（5）、s+=1和s=s+1有什么区别？
s+=1 相当于 s=s+1

作者: 吴越 时间: 2019-2-27 21:30
1、++和--单独使用和在运算中使用有什么区别？
单独使用的时候++或--放在操作对象的前面或后面都无所谓，在运算中使用的时候运算符在前就先加（减）后用，操作对象在前的时候就先用后加（减）。特别注意，在打印输出的时候，也算做一种“运算”，需要注意操作对象的位置。
2、什么是强转？什么是自动类型转换？
强转：大范围数据类型-->小范围数据类型；
自动类型转换：小范围数据类型 -->大范围数据类型
3、&&和||的区别？
&&：两个我都要
||：给一个就行
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法是对抽象行为的提炼，形成一个单独的功能。定义时需要注意不能产生嵌套，调用时需注意方法的参数和返回值情况。
5、s+=1和s=s+1有什么区别？
s+=1 <==> s=(s的数据类型)(s+1)
s=s+1 有可能无法保持s原始的数据类型，无法通过编译

作者: 王冠琦 时间: 2019-2-27 21:31
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别

。混合使用：

++在前，先加后运算

++在后，先运算后加

2、什么是强转？什么是自动类型转换？
自动类型转换是程序自动完成的，由小转大。
不是由程序自动完成的，需要手动进行转换

小的数据类型变量名 = （小的数据类型）大的数据范围;

3、&&和||的区别？
&&两边都是true结果才会是true
||两边都是false结果才会是false

4、什么是方法？定义和调用的时候有什么要注意的地方？
就是讲一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能
方法在定义完毕后，不会自己运行，必须被调用才能执行。在主方法中，直接写要调用的方法名就行了

5、s+=1和s=s+1有什么区别？
a+=1隐含了一个强制类型转换

作者: 梦翼_李宗贤 时间: 2019-2-27 21:32

1、单独使用没区别；混合使用，前++，先加后用；后++，先用后加，带入运算后马上加
2、在运算的时候右边的数据范围比左边的大就要强制转换，根据我们的意愿进行转换，可能会出现精度丢失或数据溢出；
在运算的时候左右两边的数据类型不一样就会转换，自动类型转换（隐式）数据范围只能是从小到大
3、&&：全都是true才是true，从左到右只要有一个false时得到的值就是false，后面的就不会再判断，直接是false；||：只要有一个是true就是true，全都是false才是false
4、封装功能、减少代码重复率；无所谓方法定义的先后顺序，不能在main方法中定义，不能嵌套定义方法，
调用时需要方法名加上小括号然后分号，如果方法定义时定义有参数那么调用的时候还要在小括号中传入相应类型的参数
5、s+=1隐含有一个强制类型转换，而s=s+1会报错

作者: 魏政 时间: 2019-2-27 21:32
  （1）单独使用时，前++和后++没有任何区别
  （2）在混合使用的时候，有重大区别
      A.如果是前++，那么变量立刻马上+1，然后拿着结果进行使用。【现加后用】


      B.如果是后++，那么首先使用变量本来的数值，然后再让变量+1. 【先用后加】

2、什么是强转？什么是自动类型转换？
强制类型转换：代码需要进行特殊的格式处理，不能自动完成。
自动类型转换: 不与要我们干预，自动完成.
3、&&和||的区别？
&&(并且）：两边为true，结果才是true，否则为false
||(或者）：两边只要有一个true，结果就是true，两边都是false，结果为false。

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
A.方法定义的先后顺序无所谓。

B.方法的定义不能产生嵌套包含关系。

C.方法定义好了之后，不会执行的。如果想要执行，一定要进行方法的【调用】。

5、s+=1和s=s+1有什么区别？
s += 1隐含了一个强制类型转换;
s = s + 1没有强制类型转换。

作者: 叶彬彬 时间: 2019-2-27 21:32
1、++和--单独使用和在运算中使用有什么区别？
单独使用：++和--放在变量前后的作用一样，没有区别
在运算中使用：++变量：变量先加一，再进行运算；变量++：先进行运算，再使变量加一
--变量：变量先减一，再进行运算；变量--：先进行运算，再使变量减一。
2、什么是强转？什么是自动类型转换？
强转：需要手动转换，系统不能自动转换
自动类型转换：数据类型由取值范围小的转换成取值范围大的可以自动转换，无需手动转

换。
3、&&和||的区别？
&&：当有一个判断条件为false时，结果为false；全为true时，结果才是true。
||：当有一个判断条件为true时，结果为true。全为false时，结果才是false。
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：能够完成一个特定的功能的集合
注意事项：定义的方法不能有嵌套关系；方法定义的先后顺序无关
5、s+=1和s=s+1有什么区别？
s+=1：s=(s的数据类型)（s+1）；
s=s+1:s=（s的数据类型）s+（int）1；

作者: 魏政 时间: 2019-2-27 21:34
1、++和--单独使用和在运算中使用有什么区别？
（1）单独使用时，前++和后++没有任何区别
  （2）在混合使用的时候，有重大区别
      A.如果是前++，那么变量立刻马上+1，然后拿着结果进行使用。【现加后用】

      B.如果是后++，那么首先使用变量本来的数值，然后再让变量+1. 【先用后加】
2、什么是强转？什么是自动类型转换？
   强制类型转换：代码需要进行特殊的格式处理，不能自动完成。
   自动类型转换: 不与要我们干预，自动完成.
3、&&和||的区别？
   &&(并且）：两边为true，结果才是true，否则为false
   ||(或者）：两边只要有一个true，结果就是true，两边都是false，结果为false。
4、什么是方法？定义和调用的时候有什么要注意的地方？
   方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
   A.方法定义的先后顺序无所谓。

   B.方法的定义不能产生嵌套包含关系。

C.方法定义好了之后，不会执行的。如果想要执行，一定要进行方法的【调用】。
5、s+=1和s=s+1有什么区别？
   s += 1隐含了一个强制类型转换;
   s = s + 1没有强制类型转换。

作者: 余建强 时间: 2019-2-27 21:35
1、++和--单独使用和在运算中使用有什么区别？
++a和--a单独使用会先加1再运算,a++和--a在运算中是先运算再加1
2、什么是强转？什么是自动类型转换？
程序员自己手动将原本的类型改成另一种类型,叫做强转;自动类型转换时程序自动将原本小的范围的数据转成范围大的数据类型
3、&&和||的区别？
&&是两个为真则为真,有一个或者一个以上为假则为假,||是两个为假则为假,一个或一个以上为真则为真.
4、什么是方法？定义和调用的时候有什么要注意的地方？
程序员通过固定的修饰符修饰的方法名叫做方法,定义使用小驼峰命名法,调用要与定义名称一样
5、s+=1和s=s+1有什么区别？
s+=1是具有隐式的强转,当遇到需要强转的时候会强转成相应的类型,s=s+1不具有隐式强转

作者: 陈弘帅 时间: 2019-2-27 21:35
1、++和--单独使用和在运算中使用有什么区别？
++和--单独使用没有什么限制，在运算中使用时，++（--）变量要先自加（自减），然后显示变量值，变量++（--）是先应用变量的值，再将变量+（-）1.
2、什么是强转？什么是自动类型转换？
自动类型转换：取值范围小的数据类型提升成取值范围大的会自动转换。强制转换：取值范围大的数据类型转换成取值范围小的，需要我们手动进行转换。
3、&&和||的区别？
&&即与、并且的意思，在比较运算时，&&两边都为true时，结果为true，有一个不为true即为false。||即或者的意思，||两边有一个为true结果即为true，两边全为false即为false。
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。方法不能嵌套使用，方法中不能定义方法。
5、s+=1和s=s+1有什么区别？
s+=1就是s = (short)(s + 1)，隐藏了一个强制类型转换，而s=s+1中1是int类型，short+int-->int+int,会发生数据溢出。

作者: 黄振明 时间: 2019-2-27 21:35
1、++和--单独使用和在运算中使用有什么区别？
单独使用：没有区别
混合使用：
++在前，先加后运算
++在后，先运算后加

2、什么是强转？什么是自动类型转换？
不是由程序自动完成的，需要手动进行转换
自动类型转换是程序自动完成的，有小转大

3、&&和||的区别？
与（并且） && 全都是true，才是true；否者就是false
或（或者） || 至少一个是true，就是true；全都是false，才是false

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
（1）不能嵌套定义，方法中不能定义方法。
（2）方法的定义顺序和执行顺序无关
（3）main方法不能调用
（4）方法的执行顺序和调用顺序有关

5、s+=1和s=s+1有什么区别？
s += 1隐含了一个强制类型转换

作者: 李智梁 时间: 2019-2-27 21:36

1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别
混合使用(--和++同理)：++在前，先加后运算
++在后，先运算后加
2、什么是强转？什么是自动类型转换？
（1）强制转换是需要手动进行的，将范围大的数据类型转为数据类型小的。
格式是：小的数据类型数据名称 = （小的数据类型）大的数据类型
精度损失：当一个浮点数转为整数的时候，会发生精度损失，精度损失是直接舍弃小数部分.
数据溢出：当一个范围大的数据强转为范围小的数据，这个时候，表示不开，会发生数据溢出.
（2）自动类型转换是数据类型小的转为数据类型大的，会自动完成。

3、&&和||的区别？
&&是并且关系，两个都是true才是true，否则就是false；
||是或者关系，至少有一个true就是true，两个都是false才是false。

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
定义方法是注意不要在一个方法内嵌套另外一个方法，方法的定义顺序和执行顺序无关。
方法调用要注意方法的执行顺序和调用顺序有关，main方法不能调用。

5、s+=1和s=s+1有什么区别？
s += 1 隐含了一个强制转换。
s = s + 1，没有数据类型转换，会报错。

作者: 廖艺铭 时间: 2019-2-27 21:36
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别

混合使用时
++在前，先加后运算，--在前，先减后运算；
++在后，先运算后加，--在后，先运算后减

2、什么是强转？什么是自动类型转换？
强转不是由程序自动完成，需要手动进行转换
数据范围小的类型变量名 = (数据范围小的类型) 数据范围大的类型

自动类型转换是程序自动完成，由数据范围小的类型转数据范围大的类型

3、&&和||的区别？
&&

1)两边都是true，结果是true
2)一边是false，结果是false
短路特点：符号左边是false，右边不再运算

||
1)两边都是false，结果是false
2)一边是true，结果是true
短路特点：符号左边是true，右边不再运算

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能

方法定义定义不能嵌套
定义顺序和执行顺序无关

方法调用执行顺序和调用顺序有关
main方法不能调用，由jvm调起

5、s+=1和s=s+1有什么区别？
s+=1隐含了一个强制类型转换

作者: 刘曾铭 时间: 2019-2-27 21:37
1.答：单独使用++，--，相当于自身增加或者减小1（前++，-- ；后++，-- 都一样）
运算中使用时候++，--，那么变量立马＋或者-1再拿着结果使用（前++，--）
运算中使用时候++，--，那么变量首先使用本身的数值然后变量再＋或者-1（后++，--）

2.答：自动类型转换（隐式）
1：代码不需要特殊格式处理自动转换
2：规则；数据范围从小到大

强制类型转换（显式）
1：代码需要特殊格式处理不能自动完成
2：范围小的数据类型  范围小的变量名 = （范围大的数据类型）范围大的变量名

3.答：&&是与，并且。  全是true才是 true  否则是false
||  是或，或者。  至少有一个true就是true，全是false才是false。

4.答：1.就是将一个功能抽取出来，把代码单独定义再一个大括号内部，形成一个单独的功能。
2.方法定义的先后顺序无所谓
  方法的定义不能产生嵌套包含关系
  方法定义好了不会执行，如果想执行必须进行调用

  调用方法格式为
  方法名称( );

5.答：s = s+ 1 与s +=1是不等价的，s += 1是等价于 s = (s的数据类型)(s + 1),而不是等价于 s = s + 1，当中存在隐含了一个强制类型转换的过程。

作者: tanSir 时间: 2019-2-27 21:39
1、++和--单独使用和在运算中使用有什么区别？
答：单独使用的时候没有区别，在运算中++是自增，++在前先自增在用，++在后先用在自增。--是自减，--在前先自减在用，--在后先用在自减。
2、什么是强转？什么是自动类型转换？
答：强转是程序开发人员手动转换如 byte a = 1; byte b = (byte)(10+a);强转有可能会数据溢出，或者损失精度。
自动类型转换。表示范围小的变量或者常量赋值给表示范围大的一方的时候就会发生隐式的自动转换。
3、&&和||的区别？
答：&&两边条件都成立才为true,否则为false。||是两边条件任意一边条件成立就为true，都不成立为false。
4、什么是方法？定义和调用的时候有什么要注意的地方？
答:方法是程序中一段具有特定功能的一段代码，提升代码的复用性和可维护性。定义的时候使用小驼峰命名，方法中不能定义方法。调用的时候不能调用main方法，要注意是否有形参，是否为静态成员方法，如果为非静态就需要new一个对象。
5、s+=1和s=s+1有什么区别？
答：s+=1具有隐式的强制转换功能，s=s+1没有隐式的强制转换功能。

作者: LPY 时间: 2019-2-27 21:39
1、++和--单独使用和在运算中使用有什么区别？
答；在单独使用的时候没有任何区别;在混合运算的时候如果是[先用后加][前++]那么变量立马+1然后拿着结果进行使用;如果是[先用后加][后++]那么首先使用变量原本的数值,然后再让变量+1。
2、什么是强转？什么是自动类型转换？
答；强转也叫显式转换,是指=左边的数据类型跟右边的数据类型不一样且在右边的取值范围内的时候需要用到强转,否则会数据溢出或丢失数据精度;自动类型转换也叫隐式转换,不需要我们手动转换,会自动将小的数据类型提升为大的数据类型再进行运算。
3、&&和||的区别？
答；区别在于:&&(与)是两边必须为True才为True,否则为False;||(或)只要两边有一个为True那么结果就是True;&&和||有阻断效果,当&&前面不满足和||前面满足的时候,就不会进行后续的运行了。
4、什么是方法？定义和调用的时候有什么要注意的地方？
答；创建方法是为了将不同的功能写在不同方法里,需要用的时候直接通过方法名调用;在定义的时候需要定义在类里面和main方法外;调用的时候需要在main方法中通过方法名();调用
5、s+=1和s=s+1有什么区别？
答；s+=1相当于s=s+1,但是s的数据类型要和1(int)的数据类型相同,否则需要进行强转

作者: 黄杰南 时间: 2019-2-27 21:40
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别；混合使用：前++ 先加后用后++ 先用后加

2、什么是强转？什么是自动类型转换？
强制类型转换：取值范围大的数据类型转换为取值范围小的数据类型，需要手动操作。
自动类型转换：取值范围小的数据类型转换为取值范围大的数据类型，自动转换。

3、&&和||的区别？
&& ：两个都为true时才是true，不然为false
|| ：有一个为true时都是true，不然为false

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能
定义时需注意方法不能定义在方法中，方法名要采用小驼峰式。方法定义的顺序与方法执行的顺序无关
调用时需注意不能调用main方法，方法执行的顺序与调用方法的顺序有关

5、s+=1和s=s+1有什么区别？
s+=1中隐含了一个强制类型转换

作者: 刘曾铭 时间: 2019-2-27 21:41
1、++和--单独使用和在运算中使用有什么区别？

答：单独使用++，--，相当于自身增加或者减小1（前++，-- ；后++，-- 都一样）
运算中使用时候++，--，那么变量立马＋或者-1再拿着结果使用（前++，--）
运算中使用时候++，--，那么变量首先使用本身的数值然后变量再＋或者-1（后++，--）

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

答：自动类型转换（隐式）
1：代码不需要特殊格式处理自动转换
2：规则；数据范围从小到大

强制类型转换（显式）
1：代码需要特殊格式处理不能自动完成
2：范围小的数据类型  范围小的变量名 = （范围大的数据类型）范围大的变量名

3、&&和||的区别？

答：&&是与，并且。  全是true才是 true  否则是false
||  是或，或者。  至少有一个true就是true，全是false才是false。

4.么是方法？定义和调用的时候有什么要注意的地方？

答：1.就是将一个功能抽取出来，把代码单独定义再一个大括号内部，形成一个单独的功能。
2.方法定义的先后顺序无所谓
  方法的定义不能产生嵌套包含关系
  方法定义好了不会执行，如果想执行必须进行调用

  调用方法格式为
  方法名称( );

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

  答：s = s+ 1 与s +=1是不等价的，s += 1是等价于 s = (s的数据类型)(s + 1),而不是等价于 s = s + 1，当中存在隐含了一个强制类型转换的过程。

作者: 陈驰煜 时间: 2019-2-27 21:41
1.单独使用时: i++和++i或i--和--i没有区别;
运算中使用: ++i、--i运算后直接使用其值,i++、i--先使用其原先的值，再进行运算。

2.强转：强制类型转换，形如short a = (int) 20,由数据范围大的类型转换成数据范围小的类型时使用；
自动类型转换：如long a = 30,30本身是一个int类型，赋值时等号右边值在等号左边的类型的数据范围内时，编译器自动将等号右边的数据转换成等号左边的数据类型；

3.&&表示且，表达式：条件1 && 条件2中，1与2同时为真时表达式的值才为True，否则表达式的值为False；
||表示或，表达式：条件1 || 条件2中，1与2只要有一个为真，表达式的值就为True，否则表达式的值为False；
Ps：表达式是从左往右计算的，当表达式：条件1 && 条件2中，1的值为False，2的值将不会被计算（类似于短路）; ||同理；

4.方法就是类中定义的函数，注意事项：a.方法定义时先后顺序无所谓，b.不能在方法中定义方法，c.方法定义后要运行需要main函数中调用方法；

5.s += 1包含一个强制类型转换，如byte s = s+1等价于byte s =(byte) (s + 1),而byte s = s + 1是错误的。

陈驰煜.txt

920 Bytes, 下载次数: 2

售价: 10 黑马币 [记录] [购买]

作者: 李伟艺 时间: 2019-2-27 21:42

请根据自己的理解，对当天内容进行总结
1、++和--单独使用和在运算中使用有什么区别？
++和--再单独使用的时候都是给变量的值+1，再运算中，++和--符合在变量前时（例如：++a或者--a）,时先给变量的值+1或者-1再进行运算，当++和--符号在变量后时（例如a--或者a++）是先用变量原来的值进行运算，等运算结束后再给变量的值+1或者-1。
2、什么是强转？什么是自动类型转换？
自动转换是：进行赋值运算的时候，当右边的数据类型的取值范围小于左边的取值范围时，系统会自动的将右边的数据类型转换成左边的数据类型。
强制转换时：进行赋值运算的时候，当右边的数据类型的取值范围大于左边的取值范围时，程序员通过再代码强行将范围比较大的数据类型降至转换成为范围比较小的数据类型，例如（int a =(int)100L）
3、&&和||的区别？
“&&”是与运算，“||”是或运算。或运算和与运算两边的返回值都必须是布尔类型（boolean），只有当两边的代码的返回值都为true的时候，与运算的返回值才会是true，否则都为false，而或运算，只要两边代码有一个返回值为true的话，那么或运算的返回值就为ture。
4、什么是方法？定义和调用的时候有什么要注意的地方？
修饰符返回值类型方法名（方法参数）{
return；
}；
不能嵌套定义，方法中不能定义方法
方法的定义顺序和执行顺序无关，和调用顺序有关
方法调用格式是
mian方法不能调用
5、s+=1和s=s+1有什么区别？
a+=1隐藏了一个强制转换

作者: 林志鹏 时间: 2019-2-27 21:44
1、++和--单独使用和在运算中使用有什么区别？
++自增变量符让一个变量涨一个数字1
--自减变量符让一个变量减一个数字1
区别：1.单独使用的时候，前++--和后++--没有任何区别
2.在混合使用的时候区别 A.先加后用B.先用后加

2、什么是强转？什么是自动类型转换？
强转：强行转换数据类型
自动类型转换：将取值范围小的类型自动提升为取值范围大的类型

3、&&和||的区别？
&&含义是与（AND）当两个操作数皆为真的时候运算结果才为真。
||含义是或（OR）两个操作数只要一个为真，运算结果就为真。

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
定义的时候注意：1. 修饰符：固定写法 public static;返回值：固定写法 void; 方法名称的命名规则和

变量一样（小驼峰）2. 定义的先后顺序无所谓。 3.方法的定义不能产生嵌套包含关系。
调用的时候注意：格式：方法名称（）;

5、s+=1和s=s+1有什么区别？
s+=1和s=s+1区别：
s+=1是表示s+1的值存放在s中等价于s=（s的数据类型）（s+1）当中存在一个隐藏的类型转换
s=s+1是先执行s+1然后再把结果赋值给s

作者: 开心的小孩 时间: 2019-2-27 21:44
1、++和--单独使用和在运算中使用有什么区别？
  单独使用没有区别
混合使用时1：前++先参与表达式运算，后本身值增加一//运算玩本身后立刻变
            2：后++表示后参与表达式的运行，本身先加一。
            3：注意只有变量常能自增自减运算符。
2、什么是强转？什么是自动类型转换？
1：自动类型转换：数据范围从小到大，（代码不需要特殊处理，自动完成）。
2：强制类型转换：格式：范围小的类型范围小的变量名=（范围小的类型）范围大的类型（必须进行特殊处理手动完成）
3、&&和||的区别？
   1： &&和||具有短路效果；如果根据左边已经可以判断得到最终结果。
4、什么是方法？定义和调用的时候有什么要注意的地方？
   编译器在有些情况下会进行有些优化操作。
   不能嵌套定义，方法中不能定义方法
   方法的定义顺序和执行顺序无关
5、s+=1和s=s+1有什么区别？
s+=1包含强制转换，
s=s+1没有强制转换

作者: LIUXIAOMING 时间: 2019-2-27 21:44

请根据自己的理解，对当天内容进行总结
1、++和--单独使用和在运算中使用有什么区别
如果是前++(--)，那么变量立刻马上（-）+1，然后拿着结果进行使用。【先加后用】
如果是后++(--)，那么首先使用变量本来的数值，然乎再让变量(-)+1【先用后加】

2、什么是强转？什么是自动类型转换？
强转：特点代码需要特殊的格式处理，不能自动完成。自动类型转换：2. 自动完成，当运算的数据类型不一致，会发生自动类型转换。
3、&&和||的区别？
与（并且）&&,或者||
4、什么是方法？定义和调用的时候有什么要注意的地方？
可复用性可读性
方法定义的先后顺序无所谓
方法的定义不能产生嵌套包含关系。
方法定义好了之后，不会执行的。如果想要执行，一定要进行方法的调用。

5、s+=1和s=s+1有什么区别？
两者之间不相等，s += 1是等价于 s = (s的数据类型)(s + 1),而不是等价于 s = s + 1，当中存在隐含了一个强制类型转换的过程。

作者: 李煜霖 时间: 2019-2-27 21:44
1.
单独使用没有区别;
混合使用：
++在前，先加后运算;
++在后，先运算后加;
--在前，先加后运算;
--在后，先运算后加;

2.自动类型转换：不是由程序自动完成的，需要手动进行转换强转：小的数据类型变量名 = （小的数据类型）大的数据范围；

3.
&&：是与，所有条件要同时满足才是true；
||：是或，只要有一个条件满足就是true；

4.
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。

注意：

（1）不能嵌套定义，方法中不能定义方法

（2）方法的定义顺序和执行顺序无关

5.a+=1隐含了一个强制类型转换

作者: 黄成龙 时间: 2019-2-27 21:45
1、单独使用时没有区别
混合使用时：
++在前，先加后运算
++在后，先运算后加
2、强转不是由程序自动完成的，需要手动进行转换；自动类型转换时程序自动完成的，由小转大
3、 &&(并且）：两边为true，结果才是true，否则为false
||(或者）：两边只要有一个true，结果就是true，两边都是false，结果为false。
4、方法就是用大括号单独定义代码，形成一个单独的功能
（1）不能嵌套定义，方法中不能定义方法。
（2）方法的定义顺序和执行顺序无关
（3）main方法不能调用
（4）方法的执行顺序和调用顺序有关
5、s += 1隐含了一个强制类型转换

作者: 陈志铖 时间: 2019-2-27 21:46
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别

混合使用：

++在前，先加后运算

++在后，先运算后加

2、什么是强转？什么是自动类型转换？
不是由程序自动完成的，需要手动进行转换

小的数据类型变量名 = （小的数据类型）大的数据范围；

自动类型转换是程序自动完成的，由小转大
3、&&和||的区别？
&&:全都是true才是true,有一个false就是false。
||:只要有一个是true就是true，全都是false才是false。
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
（1）不能嵌套定义，方法中不能定义方法

（2）方法的定义顺序和执行顺序无关

5、s+=1和s=s+1有什么区别？
s+=1隐含了一个强制类型转换

作者: 沈松宏 时间: 2019-2-27 21:47
1、++和--单独使用和在运算中使用有什么区别？
单独使用前++与后++无关，可直接加一；
混合使用前++直接加1然后运算；后++先运算后加1
2、什么是强转？什么是自动类型转换？
强转由数据范围大的转换为范围小的，需人为操作；
自动转换指的是由数据范围小的转换为范围大的，
3、&&和||的区别？
&&是与，两者都是true才是true，其他都是false
||是或，只要其中一个true那就是true，两个false才是false
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法就是讲一个功能抽取出来，将代码单独定义在一个大括号内，形成一个单独的功能。
方法不能嵌套使用，与排列顺序无关，只与调用顺序有关，方法内不能再里面定义方法
5、s+=1和s=s+1有什么区别？
s+=1含有隐藏的强制转换

作者: zhaizhile 时间: 2019-2-27 21:48
1，自增/自减运算符
i++/i--
使用区别：1.单独使用没有区别
               2、混合使用，例如赋值混合、打印混合
前++，先加一，在使用
后++，先使用，后加一
2，自动类型转换
当运算的数据类型不一致，会发生自动类型转换
特点：不需要处理，自动完成
规则：数据范围从小到大，（和储存的空间大小无关，和数据的表示范围有关）
强制类型转换
必须我们手动完成，根据我们的意愿进行转换
特点：我们手动完成，代码需要进行特殊的格式处理，数据范围从大到小；
规则：表示范围小的数据类型    变量名=（小）表示范围大的数据类型
3，&&：只要有false，结果就是false
||：只要有true，结果就是true

4，就是把一个功能抽取出来，形成一个特定的功能
定义方法要在main方法外定义
方法定义完后需要被调用，不会自己运行

5，a+=1隐含了一个强制类型转换

作者: 林艺彬 时间: 2019-2-27 21:49

请根据自己的理解，对当天内容进行总结
1、++和--单独使用和在运算中使用有什么区别？
在单独使用的时候，前++和后++没有任何区别。也就是：++num；num++;是完全一样的。
在混合的时候，有重大区别。
A.前++马上加1，然后拿着结果使用。先加后用。
B.后++，先用变量本来的数值。然后在让变量加1.先用后加
2、什么是强转？什么是自动类型转换？
强制类型转换（显式）：必须我们手动完成，根据我们的意愿进行转换。
自动类型转化（隐式）：当运算的数据类型不一样时，将会发生自动数据类型转换。

3、&&和||的区别？
&& 全都是true，否则就是false;
|| 至少一个是true，就是true；全都是false才是false。
4、什么是方法？定义和调用的时候有什么要注意的地方？
什么是方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
注意的地方：
（1)方法定义的先后顺序无所谓。
(2)方法的定义不能产生嵌套包含关系。
(3)方法定义好了之后，不会执行的。如果想要齿形，一定要进行方法的【调用】
5、s+=1和s=s+1有什么区别？
s+=1隐含一个强制转换。
s=s+1没有强制转换。

作者: 6期江岳 时间: 2019-2-27 21:49
1、在单独使用的时候。前++和后++没有任何区别。也就是：++变量名;和变量名++;完全一样的。
在混合使用的时候，有重大区别：如果是前++,那么变量立马+1，然后那个结果进行使用（先加后用）；如果是后++,那么首先使用变量本来的数值，然后再让变量+1.（先用后加）
2、强制：代码需要进行手动数据类型转换，不能自动完成。小的数据类型变量名 = （小的数据类型）大的数据范围；
自动：代码不需要进行特殊处理，自动完成数据类型的转换，由小转大。
3、与（并且） && 全true才是true 否则false；或（或者） || 至少有一个是true结果就是true。
4、将一些功能语句单独定义在大括号呢，形成一个单独的功能。
（1、方法定义的先后顺序无所谓
（2、方法的定义不能产生嵌套包含关系
（3、方法定义好了之后，不会执行的。如果想要执行，需要进行调用。
5、s+=1 其中隐含了一个强制类型转换，运行时不会报错；而s=s+1没有强制类型转换运行时可能会报错。

作者: javawjs 时间: 2019-2-27 21:49
王佳盛

1、答：单独使用时，前++（--）和后++（--）并没有什么区别；
在运算中使用，前++（--）先自增（自减）后再参与运算；
后++（--）是先参与运算后再自增（自减）。

2、答：强制数据类型转换：
在运算中左边数据范围大于右边类型数据范围，需要特殊处理，
不能自动完成。
   自动类型转换：
当运算数据类型不一致时，会自动发生数据类型转换；要符合数据
范围从小到大的规则。

3、答：&&在运算时只要有一边结果确定为false，那么最终结果就为false；
只有两边都为true，结果才为true。
   ||在运算时只要有一边结果确定为true，那么最终结果就为true；
只有两边都为false，结果才为false。

4、答：将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能.
注意：1.方法的定义不分先后；
      2.方法的定义不能有嵌套包含关系
          3.方法定义好了之后，要在main方法中调用方法才能执行。
调用的格式：
      方法名称();

5、答：s+= 1编译的时候会自动加上一个强转；s = s+1 会先把变量s提升为int
类型然后再重新赋值给s，如果原先变量a的数据范围小于int。在编译的
时候就可能会报错

作者: 龙舟 时间: 2019-2-27 21:51
1、++和--单独使用和在运算中使用有什么区别？
单独使用：独立运算没有区别
运算中使用：‘前++’先加再用，‘后++’先用后加。‘’--‘’同理。
2、什么是强转？什么是自动类型转换？
强转：大转小
自动类型转换：小转大
3、&&和||的区别？
&&：两边都要达到要求。||：只要一边满足要求。
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
注意：不能嵌套定义，方法中不能定义方法。方法的定义顺序和执行顺序无关
5、s+=1和s=s+1有什么区别？
s+=1有隐藏自动转换
s=s+1没有

作者: 卢勇炜 时间: 2019-2-27 21:52
1、++和--单独使用和在运算中使用有什么区别？
答：单独使用的时候，前++和后++没有任何区别。如：++i；与i++；是完全一样的；
   混合使用的时候：如果是前++，变量立刻马上+1，拿结果进行使用；先加后用
          如果是后++，那么先用变量原本的数值，然后变量自己再加1；先用后加
注意事项：只有变量才能使用，常量不可发生改变，不能使用，如30++；
2、什么是强转？什么是自动类型转换？
答：代码需要进行特殊的格式处理，不能自动完成。格式：范围小的类型范围小的变量名=（范围小的类型）原本范围大的数据；自动类型转换：代码不需要特殊处理，自动完成，范围从小到大；
3、&&和||的区别？
答：“&&”是与运算，“||”是或运算；其中与运算，条件1 && 条件2中，1与2同时为真时表达式的值才为True，否则表达式的值为False；而或则是条件1 || 条件2中，1与2只要有一个为真，表达式的值就为True，否则表达式的值为False；
4、什么是方法？定义和调用的时候有什么要注意的地方？
答：方法就是类中定义的函数，方法名称的命名规则和变量一样，使用小驼峰；
         方法体大括号当中可以包含任意条语句。
注意事项：1.方法定义的先后顺序无所谓；2.方法的定义一定不能产生嵌套包含关系；
   3.方法定义好了之后，不会执行的，如果要想执行，一定要进行方法的【调用】。方法名和变量名要做到见名知意。
5、s+=1和s=s+1有什么区别？
答：s+=1有隐藏了一个强制转换。

作者: 罗加铭 时间: 2019-2-27 21:52
1、++和--单独使用和在运算中使用有什么区别？
答：单独使用没有区别

混合使用：

++在前，先加后运算

++在后，先运算后加
；--在前，先减后运算

--在后，先运算后减

2、什么是强转？什么是自动类型转换？
答：自动类型转换是程序自动完成的，由小转大；不是由程序自动完成的，需要手动进行转换
3、&&和||的区别？
答：&&一边是false，结果是false；||两边都是false，结果是false
4、什么是方法？定义和调用的时候有什么要注意的地方？
答：修饰符返回值类型方法名（）{

return

}；
(1)方法的执行顺序和调用顺序有关

(2)main方法不能调用

5、s+=1和s=s+1有什么区别？
答：s+=1隐含了一个强制类型转换

作者: 钟扬辉 时间: 2019-2-27 21:53
1、++和--单独使用和在运算中使用有什么区别？1.答：单独使用直接+1，前++后++ 没有区别，先+1；在运算中前++，用+1后用，后++，先用后+1.
2、什么是强转？什么是自动类型转换？2.范围小的类型转换范围大的需要进行强转；范围大的数据类型转换到范围小的数据类型，系统会自动转换。
3、&&和||的区别？3.&&：3.两个判断类型都要正确才是ture 否则是false；||：只要有一个是正确的就是ture。
4、什么是方法？定义和调用的时候有什么要注意的地方？4.在一个完整的代码中，提取出一段代码来调用；注意地方：不能嵌套使用。
5、s+=1和s=s+1有什么区别？5.s+=1 有一个隐藏强制转换，s=s+1没有。

作者: java基础6期刘伟 时间: 2019-2-27 21:54
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别

2、什么是强转？什么是自动类型转换？
不是由程序自动完成的，需要手动进行转换;自动类型转换是程序自动完成的，由小转大
3、&&和||的区别？
&&是并且的意思，||是或者的意思。
4、什么是方法？定义和调用的时候有什么要注意的地方？
将代码按照功能进行划分，提高代码的可读性

；提高代码的复用性。方法要注意不能嵌套定义，方法中不能定义方法；方法的定义顺序和执行顺序无关。
调用要注意方法的执行顺序和调用顺序有关main方法不能调用
5、s+=1和s=s+1有什么区别？
a+=1隐含了一个强制类型转换

作者: 徐代成 时间: 2019-2-27 21:58
1、++和--单独使用和在运算中使用有什么区别？
前++和前--，先加/减后参与运算
后++和后--，先参与运算后加/减
2、什么是强转？什么是自动类型转换？
不是由程序自动完成的，需要手动进行转换
小的数据类型变量名 = （小的数据类型）大的数据范围；
自动类型转换是程序自动完成的，由小转大。
3.&&和||的区别？
&&表示并，条件均需满足；
||表示或，条件满足一个就行
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
定义格式：修饰符返回值类型方法名（方法参数）{
return；
}；
（1）不能嵌套定义，方法中不能定义方法
（2）方法的定义顺序和执行顺序无关，和调用顺序有关
（3）mian方法不能调用
5、s+=1和s=s+1有什么区别？
a+=1隐含了一个强制类型转换，而s=s+1没有

作者: JavaEE06蒋才东 时间: 2019-2-27 22:01
1、++和--单独使用和在运算中使用有什么区别？
++和--在单独使用时，是无任何区别的，都是自增1或自减1
在混合使用中时，前++和前--是立刻马上自增1或自减1，再使用结果进行运算，后++和后--是先使用原先的数进行运算，再自增1或自减1
2、什么是强转？什么是自动类型转换？
强制转换是需要手动完成，不是由程序自动完成的
自动转换是由程序自动完成的，
3、&&和||的区别？
&&是与(并且)，判断结果两个都为true，结果才为true，否则结果为false
||是或，判断结果至少有一个为true，结果就为true，
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法是可以将不同的功能写在不同的方法，形成一个单独的功能
a.方法不能嵌套定义，方法中不能定义方法
b.方法的定义顺序和执行顺序无关
5、s+=1和s=s+1有什么区别？
s+=1隐含着一个强制转换
s=s+1会报错

作者: 黑马6期陈华 时间: 2019-2-27 22:07
1、++和--单独使用和在运算中使用有什么区别？
单独使用时没有区别；
混合使用时，++在前是先加后用；++在后是先用后加。
2、什么是强转？什么是自动类型转换？
在大范围数据类型赋值给小范围数据类型时，需要手动转换数据类型。自动转换发生在当运算的数据类型不一致且常量数值可以赋值时。
3、&&和||的区别？
&&是并且，当表达式两边都true时才为true；||是或，当表达式两边存在一个true时则为true。
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法是将一个功能单独提取出来放在一个大括号内，形成一个单独的功能。定义时应尽量使用小驼峰式命名，调用时需要在main方法中调用，否则不会自动执行。
5、s+=1和s=s+1有什么区别？
s+=1：复合赋值运算符会隐含一个强制类型转换，不会报错；
s=s+1：基本赋值运算符没有隐含强制类型转换，将报错。

作者: 陈前凌 时间: 2019-2-27 23:02
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别
混合使用：
++在前，先加后运算
++在后，先运算后加

2、什么是强转？什么是自动类型转换？
不是由程序自动完成的，需要手动进行转换
小的数据类型变量名 = （小的数据类型）大的数据范围；

3、&&和||的区别？
&&：全是true才输出true，一个false则输出false；
||：一个ture则输出ture，全false才输出false；

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
（1）方法的执行顺序和调用顺序有关
（2）main方法不能调用
（3）不能嵌套定义，方法中不能定义方法
（4）方法的定义顺序和执行顺序无关

5、s+=1和s=s+1有什么区别？
s+=1隐含了一个强制类型转换;

作者: 叶振鹏 时间: 2019-2-27 23:16

请根据自己的理解，对当天内容进行总结
1、++和--单独使用和在运算中使用有什么区别？
答：++和--单独使用是没有区别的
混合运用时用在前面先加（先减）在运算
用在后面先用后加（减）
2、什么是强转？什么是自动类型转换？
答，强制转换不是系统自动完成的，需要人为干涉强制进行转换
自动类型转换是系统自动完成
3、&&和||的区别？
答：&&也叫作与，在多个条件中，需要同时满足条件
||叫做且，在多个条件中只需要满足其中一项条件即可
4、什么是方法？定义和调用的时候有什么要注意的地方？
答：方法就是把一个功能抽取出来，把代码写在单独定义的大括号内，形成一个单独的功能，有需要时可以直接调用。
定义要注意方法不能嵌套，方法中不能在定义方法
方法的定义顺序和执行顺序无关
调用需要注意main方法不能调用
5、s+=1和s=s+1有什么区别？
答：s+=1其中隐含了一个强制类型转换

作者: 廖艺铭 时间: 2019-2-27 23:16
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别

混合使用时
++在前，先加后运算，--在前，先减后运算；
++在后，先运算后加，--在后，先运算后减

2、什么是强转？什么是自动类型转换？
强转不是由程序自动完成，需要手动进行转换
数据范围小的类型变量名 = (数据范围小的类型) 数据范围大的类型

自动类型转换是程序自动完成，由数据范围小的类型转数据范围大的类型

3、&&和||的区别？
&&

1)两边都是true，结果是true
2)一边是false，结果是false
短路特点：符号左边是false，右边不再运算

||
1)两边都是false，结果是false
2)一边是true，结果是true
短路特点：符号左边是true，右边不再运算

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能

方法定义定义不能嵌套
定义顺序和执行顺序无关

方法调用执行顺序和调用顺序有关
main方法不能调用，由jvm调起

5、s+=1和s=s+1有什么区别？
s+=1隐含了一个强制类型转换

作者: 廖艺铭 时间: 2019-2-27 23:17
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别

混合使用时
++在前，先加后运算，--在前，先减后运算；
++在后，先运算后加，--在后，先运算后减

2、什么是强转？什么是自动类型转换？
强转不是由程序自动完成，需要手动进行转换
数据范围小的类型变量名 = (数据范围小的类型) 数据范围大的类型

自动类型转换是程序自动完成，由数据范围小的类型转数据范围大的类型

3、&&和||的区别？
&&

1)两边都是true，结果是true
2)一边是false，结果是false
短路特点：符号左边是false，右边不再运算

||
1)两边都是false，结果是false
2)一边是true，结果是true
短路特点：符号左边是true，右边不再运算

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能

方法定义定义不能嵌套
定义顺序和执行顺序无关

方法调用执行顺序和调用顺序有关
main方法不能调用，由jvm调起

5、s+=1和s=s+1有什么区别？
s+=1隐含了一个强制类型转换

作者: 廖艺铭 时间: 2019-2-27 23:18
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别

混合使用时
++在前，先加后运算，--在前，先减后运算；
++在后，先运算后加，--在后，先运算后减

2、什么是强转？什么是自动类型转换？
强转不是由程序自动完成，需要手动进行转换
数据范围小的类型变量名 = (数据范围小的类型) 数据范围大的类型

自动类型转换是程序自动完成，由数据范围小的类型转数据范围大的类型

3、&&和||的区别？
&&

1)两边都是true，结果是true
2)一边是false，结果是false
短路特点：符号左边是false，右边不再运算

||
1)两边都是false，结果是false
2)一边是true，结果是true
短路特点：符号左边是true，右边不再运算

4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能

方法定义定义不能嵌套
定义顺序和执行顺序无关

方法调用执行顺序和调用顺序有关
main方法不能调用，由jvm调起

5、s+=1和s=s+1有什么区别？
s+=1隐含了一个强制类型转换

作者: 曾伟清 时间: 2019-2-27 23:32
1、++和--单独使用和在运算中使用有什么区别？
答：在单独使用时前++和后++没有区别，混合使用时，前++先加上1再拿结果去运算，后++是先拿原先的值去运算，然后再加上1；--跟++一样。
2、什么是强转？什么是自动类型转换？
答：右边的数据类型和左边的数据类型不一样就会发生数据类型转换，当右边的数据类型范围大于左边的数据类型范围就会发生强制类型转换，当右边的数据小于左边的数据类型范围就会发生自动类型转换。
3、&&和||的区别？
答:与&&和或||是逻辑运算符，是用来连接两个布尔类型结果的运算符，与&&左右两边都得是true结果才是true，或||左右两边至少有一个true结果就是true。
4、什么是方法？定义和调用的时候有什么要注意的地方？
答：方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
定义注意：方法定义的顺序与执行的顺序无关；不能嵌套定义，方法内不能再定义方法。
调用注意：方法的调用和执行有关；main方法不能调用。

5、s+=1和s=s+1有什么区别？
答：s+=1包含一个强制类型转换：s=(s的数据类型)(s+1)，而s=s+1没有。

作者: 曾伟清 时间: 2019-2-27 23:35
1、++和--单独使用和在运算中使用有什么区别？
答：在单独使用时前++和后++没有区别，混合使用时，前++先加上1再拿结果去运算，后++是先拿原先的值去运算，然后再加上1；--跟++一样。
2、什么是强转？什么是自动类型转换？
答：右边的数据类型和左边的数据类型不一样就会发生数据类型转换，当右边的数据类型范围大于左边的数据类型范围就会发生强制类型转换，当右边的数据小于左边的数据类型范围就会发生自动类型转换。
3、&&和||的区别？
答:与&&和或||是逻辑运算符，是用来连接两个布尔类型结果的运算符，与&&左右两边都得是true结果才是true，或||左右两边至少有一个true结果就是true。
4、什么是方法？定义和调用的时候有什么要注意的地方？
答：方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。定义注意：方法定义的顺序与执行的顺序无关；不能嵌套定义，方法内不能再定义方法。调用注意：方法的调用和执行有关；main方法不能调用。

5、s+=1和s=s+1有什么区别？
答：s+=1包含一个强制类型转换：s=(s的数据类型)(s+1)，而s=s+1没有。

作者: 唐彬桂 时间: 2019-2-28 11:24
1、++和--单独使用和在运算中使用有什么区别？
单独试用：不管++在前还是在后都是立刻加，--同理。
混合使用：++在前就先加后算 ++在后就是先运行原本的量在加，--同理。
2、什么是强转？什么是自动类型转换？
强转：就是需要手动进行转换的量不是程序自己转换的
自转：就是程序自动完成的由小转大
3、&&和||的区别？
&&：与有一个错是false，全对就是true。
||：或有一个是对的就是true，全错才是false。
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
方法定义的先后顺序没有要求无所谓，但不能包含方法嵌套方法。
方法定义完后不会执行，需要调用方法的方法名到main方法里才能执行。
5、s+=1和s=s+1有什么区别？
s+=1 里有一个强制类型的转换不会报错
s=s+1 里没有包含强制类型转换需要自己手动转换所以会报错。

作者: omasoo 时间: 2019-2-28 11:33
本帖最后由 omasoo 于 2019-2-28 12:03 编辑

李伟斌
1、++和--单独使用和在运算中使用有什么区别？
答:单独使用:++和--单独使用时两者没有区别,前++和后++结果一致,前--和后--结果一致;
  混合使用:混合使用运算时前++表示先加再运算,后++表示先运算再加,前--和表示先减再运算,后--表示先运算后减.  注意:后++和后--运算后将会立即对数字进行加或减.变量将会改变,一定注意.
2、什么是强转？什么是自动类型转换？
答:强转不是由程序自动完成的，需要手动进行转换,规则是数据范围由大转小.
  格式是:小的数据类型  变量名 = （小的数据类型）大的数据范围；
  自动转换是由程序自动完成的,无须手动操作.规则是数据范围由小转大.
3、&&和||的区别？
答:共同点:都有短路效果,如果已经得到结果，那么不会进行后面的操作.
  不同点:&&表示并且,需要两个表达式都满足条件才输出True,若一个表达式不满足条件将会输出False.
  ||表示或,只需要一个表达式满足条件就输出True,若两个表达式都不满足条件才输出False.
4、什么是方法？定义和调用的时候有什么要注意的地方？
答:方法是将代码按功能进行划分,从而提高代码的可读性和复用性.
注意: (1)不能嵌套定义,方法中不能定义方法;
(2)方法的定义顺序和执行顺序无关
(3)方法的执行顺序和调用顺序有关
(4)main方法不能调用
5、s+=1和s=s+1有什么区别？
答:s+=1隐含了一个强制类型转换,例如s的类型为byte时,s+=1相当于byte s=(byte)s+1;
  若只有s=s+1,s类型的数据范围比int小时,则会发生编译报错.

作者: 王旭艺 时间: 2019-2-28 11:35

1、++和--单独使用和在运算中使用有什么区别？
在单独使用时没区别
在混合使用时，如果前++（--），变量马上+1（-1），然后取结果使用，是先

加（减）后用；
如果是后++（——），首先使用变量原来的数值，用完后再让变量+（-）1，是

先用后加（减）。

2、什么是强转？什么是自动类型转换？
数据转换：当运算数据类型不一样时，就会发生数据类型的转换。
自动类型转换：当数据类型是由取值范围小转为大时，就会自动进行转换
强制类型转换：当数据类型有取值范围大转为小时，需要进行手动转换。格式：

小的数据类型  变量名 = （小的数据类型）大的数据范围

3、&&和||的区别？
&&，当两边都是true时，结果才是true;否则就是false。
||, 当两边至少有一个是true时，就是true.当两边全是false时，才是false.

4、什么是方法？定义和调用的时候有什么要注意的地方？
  方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个

单独的功能。当我们需要这个功能的时候，就可以去调用。这样即实现了代码的

复用性，也解决了代码冗余的现象。
  （1）不能嵌套定义，方法中不能定义方法

  （2）方法的定义顺序和执行顺序无关

(3) 方法定义好了之后，不会执行的。如果要想执行，一定要进行方法的调

用

5、s+=1和s=s+1有什么区别？
s+=1隐含了一个强制数据类型转换
s+=1分解为s=s+1,数据类型：s=s原数据类型+int转换为s=int+int,s=int,s=(s

原数据类似)int.

作者: 林奕全 时间: 2019-2-28 15:09
1.
单独使用：数据变量直接+1，或者-1.
混合使用：++在前，要先将数据变量+1，然后再进行打印输出。即：先加后用（- -同理）
++在后，先使用本来数据变量的值，然后再+1，再打印输出。即：先用后加（- -同理）
2.
自动类型转换：程序运算时，不需要进行人为的特殊处理，数据变量自动转换为范围大的类型进行运算；数据范围规则从小到大。
强制转换类型：程序运算时，需要进行特殊处理，将范围大的数据类型强制转换为范围小的类型进行运算。格式为：范围小的数据类型变量名称=（范围小的数据类型）范围大的数据类型
3.
&&是与；两者必须同时为true，输出结果才为true;否则为false
||是或；两者中只要有其中一者为true，即为true.
区别在于满足的条件不一样。
4.
方法：是将一个功能抽取出来，单独定义在一个大括号内，使它成为一个单独的功能。
注意事项:方法的执行顺序和调用顺序有关；main方法不能调用。
5.
s+=1包含了隐式的强制类型转换，而s=s+1没有。

作者: 蓝建华 时间: 2019-2-28 22:06
1、++和--单独使用和在运算中使用有什么区别？
答：++是自增加一
   --是自降一
2、什么是强转？什么是自动类型转换？
答：强行转换是用特殊的格式进行转换（数据类型变量名 = （需要强制的类型）值），但是要是注意只能从小到大转换否则会溢出，导致损失精度和只能在同一类型种进行转换。
   自动转换是系统根据数据类型从小到大进行转换，整数默认int，浮点型默认double.
3、&&和||的区别？
答：&&是需要满足所以条件。只要遇到有个不成立，就不会在执行剩下的条件,判为true，具有短路效果，只有全都条件都成立,那么才是false.
   ||是只要满足条件中的其中一条，就视为false.
4、什么是方法？定义和调用的时候有什么要注意的地方？
答：方法就是把一个功能抽取出来，单独定义写在一个大括号里面，再去调用它，增加了功能的复用性，减少了程序的沉余现象。
   方法的先后顺序不会影响执行的结果
   方法里面不能嵌套方法
   方法不能直接执行，需要调用
5、s+=1和s=s+1有什么区别？
答：执行的结果没区别，但是S+=1中带有个隐形的强制转换机制，而s=s+1中如果s 的数据类型小于int就会报错，会损失精度，溢出

作者: 管文祥 时间: 2019-3-1 14:30

请根据自己的理解，对当天内容进行总结
1、++和--单独使用和在运算中使用有什么区别？
答：在单独使用时，++和--都是进行增一或减一，跟前后没有差别
   在混合使用时，前++（或前--）先进行自增1（或自减1），然后再参与运算，后++（或后--）现参与运算，然后再自增1（或自减1）
2、什么是强转？什么是自动类型转换？
答：当大的数据类型向小的数据类型转换时称为强转
   当小的数据类型向大的数据类型转换时为自动类型转换
3、&&和||的区别？
答：&&在物理中称为逻辑与，只有当所有条件为真时，整个判断语句才为真，记做：有假为假，全真为真
      |  | 在物理中称为逻辑或，只要有一个条件为真，那么整个判断语句为真，记做：有真为真，全假为假
4、什么是方法？定义和调用的时候有什么要注意的地方？
答：方法是将程序的功能抽取出来，将代码单独定义在一个大括号内，形成一个单独的功能
   定义方法时需要注意：方法名不能重复定义；方法的定义顺序跟调用顺序无关；定义方法不能出现嵌套；不能再main方法中定义方法；方法定义后，只有调用才能实现方法的功能
5、s+=1和s=s+1有什么区别？
答：s+=1在数学逻辑上相当于s=s+1，不过在程序中，s+=1隐藏了一个强制类型转换的功能，也就是说，在提前定义了s的数据类型比默认的数据类型int或者double小的时候，就隐藏了一个数据类型转换，例如short s+=1的真正确使用为short s=(short)(s+1)

作者: 卢春旭 时间: 2019-3-1 21:42

1.单独使用没有区别；混合使用：前++ 先加后用后++ 先用后加

2、强制类型转换：取值范围大的数据类型转换为取值范围小的数据类型，需要手动操作。
自动类型转换：取值范围小的数据类型转换为取值范围大的数据类型，自动转换。

3、&& ：两个都为true时才是true，不然为false
|| ：有一个为true时都是true，不然为false

4、方法：将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能
定义时需注意方法不能定义在方法中，方法名要采用小驼峰式。方法定义的顺序与方法执行的顺序无关
调用时需注意不能调用main方法，方法执行的顺序与调用方法的顺序有关

5、s+=1中隐含了一个强制类型转换

作者: Wyt1935 时间: 2019-3-2 21:54
1、++和--单独使用和在运算中使用有什么区别？
单独使用的时候++或--放在操作对象的前面或后面都无所谓，在运算中使用的时候运算符在前就先加（减）后用，操作对象在前的时候就先用后加（减）。特别注意，在打印输出的时候，也算做一种“运算”，需要注意操作对象的位置。
2、什么是强转？什么是自动类型转换？
强转：大范围数据类型-->小范围数据类型；
自动类型转换：小范围数据类型 -->大范围数据类型
3、&&和||的区别？
&&：两个我都要
||：给一个就行
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法是对抽象行为的提炼，形成一个单独的功能。定义时需要注意不能产生嵌套，调用时需注意方法的参数和返回值情况。
5、s+=1和s=s+1有什么区别？
s+=1 <==> s=(s的数据类型)(s+1)
s=s+1 有可能无法保持s原始的数据类型，不行编译。

作者: 开心的小孩 时间: 2019-3-2 22:39
1、++和--单独使用和在运算中使用有什么区别？
前++和前--，先加/减后参与运算
后++和后--，先参与运算后加/减
2、什么是强转？什么是自动类型转换？
不是由程序自动完成的，需要手动进行转换
小的数据类型变量名 = （小的数据类型）大的数据范围；
自动类型转换是程序自动完成的，由小转大。
3.&&和||的区别？
&&表示并，条件均需满足；
||表示或，条件满足一个就行
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
定义格式：修饰符返回值类型方法名（方法参数）{
return；
}；
（1）不能嵌套定义，方法中不能定义方法
（2）方法的定义顺序和执行顺序无关，和调用顺序有关
（3）mian方法不能调用
5、s+=1和s=s+1有什么区别？
a+=1隐含了一个强制类型转换，而s=s+1没有

作者: 庄家琦 时间: 2019-3-4 18:42

请根据自己的理解，对当天内容进行总结

1、++和--单独使用和在运算中使用有什么区别？
单独使用直接获得;运算使用如果运算符在量的后面会等到";"后才会获得运算符的效果

2、什么是强转？什么是自动类型转换？
强转是手动的或者隐藏的吧类型大转小.自动类型转换是类型小的转类型大的

3、&&和||的区别？
&&是&&左右的boolean都是true才是true
||是||左右的boolean有一个是true就是true 否则是father

4、什么是方法？定义和调用的时候有什么要注意的地方？
抽取一个功能放在方法内.方便调用和重复使用
注意不能方法内在镶嵌方法;方法返回值要和返回值类型一致

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

+=隐含一个强转

作者: 郑海波 时间: 2019-3-4 21:41
1、++和--单独使用和在运算中使用有什么区别？
前++和前--，先加/减后运算
后++和后--，先运算后加/减
2、什么是强转？什么是自动类型转换？
强转就是强制类型转换
强制类型转换：不是由程序自动完成的，需要手动进行转换
自动类型转换：自动类型转换是程序自动完成的，由小转大
3、&&和||的区别？
&&：全都是true才是true，有一个false就是false。
||：只要有一个是true就是true，全都是false才是false。
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。

（1）、方法的执行顺序和调用顺序有关
（2）、main方法不能调用
（3）、不能嵌套定义，方法中不能定义方法
（4）、方法的定义顺序和执行顺序无关
（5）、s+=1和s=s+1有什么区别？
s+=1 相当于 s=s+1

作者: 黑马林伟明 时间: 2019-3-4 23:56
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别

。混合使用：

++在前，先加后运算

++在后，先运算后加

2、什么是强转？什么是自动类型转换？
自动类型转换是程序自动完成的，由小转大。
不是由程序自动完成的，需要手动进行转换

小的数据类型变量名 = （小的数据类型）大的数据范围;

3、&&和||的区别？
&&两边都是true结果才会是true
||两边都是false结果才会是false

4、什么是方法？定义和调用的时候有什么要注意的地方？
就是讲一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能
方法在定义完毕后，不会自己运行，必须被调用才能执行。在主方法中，直接写要调用的方法名就行了

5、s+=1和s=s+1有什么区别？
a+=1隐含了一个强制类型转换

作者: 小翔vvvv 时间: 2019-3-5 14:16
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别
混合使用：
++在前，先加后运算
++在后，先运算后加
2、什么是强转？什么是自动类型转换？
**二、什么是强制类型转换**
不是由程序自动完成的，需要手动进行转换
小的数据类型变量名 = （小的数据类型）大的数据范围；
自动类型转换是程序自动完成的，由小转大
3.&&和||的区别？
&&、||、！ &、|
短路效果:如果已经得到结果，那么不会进行后面的操作
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法定义的格式和方法定义的注意事项
修饰符返回值类型方法名（）{
return
}；
今天的格式：public static void 方法名（）{}；
注意：

（1）不能嵌套定义，方法中不能定义方法

（2）方法的定义顺序和执行顺序无关

**十三、方法调用的格式和方法调用的注意事项**

方法名称（）;

(1)方法的执行顺序和调用顺序有关

(2)main方法不能调用

5.s+=1和s=s+1有什么区别？
s+=1 ；
+ =里面隐含了强制，而
s=s+1；
没有

作者: 张广发 时间: 2019-3-5 21:35

1、++和--单独使用和在运算中使用有什么区别？
答
      单独使用：，前++（--）和后++（--）没有区别，都是让一个变量涨（降）一个数字1；
      混合使用：前++（--）是先加（减）再用；而后++（--）是先用在加（减）；
2、什么是强转？什么是自动类型转换？
答：
      强转：代码需要进行特殊的格式处理，不能自动完成；格式为：范围小的类型  变量名  =（范围小的类型）原本类型范围大的数据；
      自动转换：代码不需要特殊处理，自动完成类型转换；但需服从数据范围从小到大的要求
3、&&和||的区别？
答：
      &&：与（并且）；一错全错，全对才对；
      ||：或（或者；）一对全对，全错才错。
4、什么是方法？定义和调用的时候有什么要注意的地方？
答：
      概念：就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
      注意：方法定义的先后顺序无所谓，但不能产生嵌套包含关系；
               方法定义好之后，不会执行；想要执行，必须进行调用；
               main方法不能调用，只用由JVM来调用；
5、s+=1和s=s+1有什么区别？
答：如果s的数据类型比int大，则两者没有区别；
   如果s的数据类型比int小，则s+=1，隐含了一个强制类型转换，在编译时，右侧数据会被javac强转成左侧的数据类型；而s=s+1，会直接报错，需要进行s=s+（s的数据类型）1的强转。

作者: 余建强 时间: 2019-3-5 21:40

1. 为什么Java语言可以跨平台运行
答：因为Java程序运行在Java虚拟机（JVM）上，而对于不同的系统，都有专用的JVM运行在该操作系统上，起到翻译的作用。
2. JDK、JRE和JVM的区别
答：JVM（Java Virtual Machine）：Java虚拟机，是运行Java程序的假象计算机。
JRE（Java Runtime Environment）：是Java程序的运行时环境，JVM+核心类库。
JDK（Java Development Kit）：是Java程序开发工具包，JRE+开发工具。
3. 注释有几种，注释的作用
答：注释分为三种：单行注释、多行注释和文档注释。
单行注释：以“//”开头，直到本行结束为止；
多行注释：以“/*”开头，以“*/”结尾，中间的内容都属于注释。
文档注释：以“/**”开头，以“*/”结尾，中间的内容都属于注释。
作用：注释是程序源代码中解释说明性的文字，防止遗忘，便于他人阅读程序，对程序运行没有影响。文档注释可以通过javadoc工具提取出来自动生成API文档。
4. 什么是关键字
答：Java语言中一些被保留具有特殊用途的单词被称为关键字。Java一共有50个关键字，且都是小写的。
5. 什么是标识符，以及几种标识符命名的规则
答：Java语言中我们自己定义的名字，比如类的名字、方法的名字和变量的名字的等等，称为标识符。
标识符的命名规则有三个：
①标识符可以包含26个英文字母（区分大小写），0-9数字，$，_（下划线）；
②标识符不能以数字开头；
③标识符不能是关键字。
标识符的命名规范：类名的每个单词首字母大写。变量名和方法名的首字母小写，后面每个单词首字母大写。
6. 什么是常量，什么是变量，常量和变量的区别
答：常量是指在程序运行期间，固定不变的量。
变量是指在程序运行期间，可以变化的量。
常量和变量的区别在于，常量一旦被定义了，就无法再被修改，而变量在程序运行过程中起到容器的作用，允许被改变，输出时需要赋值。

作者: chenopen 时间: 2019-3-5 21:52
陈开明：
1、++和--单独使用和在运算中使用有什么区别？
单独使用，前++和后++没有什么区别，都是自增1；
运算中使用时候，前++是自己先加1，再将加1后的值赋给其他参数；
后++是先把自己的值赋给前面参数，自己后面再加1；
--和++一样。
2、什么是强转？什么是自动类型转换？
强制类型转换：将取值范围大的类型转换成取值范围小的类型。
自动转换：将取值范围小的类型转换成取值范围大的类型。
3、&&和||的区别？
&&：与运算，两边都为真，则真，一边有假，则为假。
||：或运算，只要有一边为真，则为真。
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法：就是将一个功能单独抽取出来，用一个单独大括号扩起来，形成单独功能模块。
定义：注意方法名，是否有返回值，是否有形参。方法必须定义在一类中方法外，方法不能定义在另一个方法的里面。
调用：方法名称是否一致，参数类型是否相同。
5、s+=1和s=s+1有什么区别？
s+=1是一个运算符，只运算一次，并带有强制转换的特点；
s=s+1则没有这个功能。

作者: 小翔vvvv 时间: 2019-3-6 18:10
叶凌青
1、++和--单独使用和在运算中使用有什么区别？
单独使用没有区别
混合使用：
++在前，先加后运算
++在后，先运算后加
2、什么是强转？什么是自动类型转换？
**二、什么是强制类型转换**
不是由程序自动完成的，需要手动进行转换
小的数据类型变量名 = （小的数据类型）大的数据范围；
自动类型转换是程序自动完成的，由小转大
3.&&和||的区别？
&&、||、！ &、|
短路效果:如果已经得到结果，那么不会进行后面的操作
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法定义的格式和方法定义的注意事项
修饰符返回值类型方法名（）{
return
}；
今天的格式：public static void 方法名（）{}；
注意：

（1）不能嵌套定义，方法中不能定义方法

（2）方法的定义顺序和执行顺序无关

**十三、方法调用的格式和方法调用的注意事项**

方法名称（）;

(1)方法的执行顺序和调用顺序有关

(2)main方法不能调用

5.s+=1和s=s+1有什么区别？
s+=1 ；
+ =里面隐含了强制，而
s=s+1；
没有

作者: 黑马林伟明 时间: 2019-3-10 21:30

1、++和--单独使用和在运算中使用有什么区别？
答；在单独使用的时候没有任何区别;在混合运算的时候如果是[先用后加][前++]那么变量立马+1然后拿着结果进行使用;如果是[先用后加][后++]那么首先使用变量原本的数值,然后再让变量+1。
2、什么是强转？什么是自动类型转换？
答；强转也叫显式转换,是指=左边的数据类型跟右边的数据类型不一样且在右边的取值范围内的时候需要用到强转,否则会数据溢出或丢失数据精度;自动类型转换也叫隐式转换,不需要我们手动转换,会自动将小的数据类型提升为大的数据类型再进行运算。
3、&&和||的区别？
答；区别在于:&&(与)是两边必须为True才为True,否则为False;||(或)只要两边有一个为True那么结果就是True;&&和||有阻断效果,当&&前面不满足和||前面满足的时候,就不会进行后续的运行了。
4、什么是方法？定义和调用的时候有什么要注意的地方？
答；创建方法是为了将不同的功能写在不同方法里,需要用的时候直接通过方法名调用;在定义的时候需要定义在类里面和main方法外;调用的时候需要在main方法中通过方法名();调用
5、s+=1和s=s+1有什么区别？
答；s+=1相当于s=s+1,但是s的数据类型要和1(int)的数据类型相同,否则需要进行强转

作者: 陈鉴 时间: 2019-3-10 21:40
1、++和--单独使用和在运算中使用有什么区别？
前++和前--，先加/减后运算
后++和后--，先运算后加/减
2、什么是强转？什么是自动类型转换？
强转就是强制类型转换
强制类型转换：不是由程序自动完成的，需要手动进行转换
自动类型转换：自动类型转换是程序自动完成的，由小转大
3、&&和||的区别？
&&：全都是true才是true，有一个false就是false。
||：只要有一个是true就是true，全都是false才是false。
4、什么是方法？定义和调用的时候有什么要注意的地方？
方法就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。

（1）、方法的执行顺序和调用顺序有关
（2）、main方法不能调用
（3）、不能嵌套定义，方法中不能定义方法
（4）、方法的定义顺序和执行顺序无关
（5）、s+=1和s=s+1有什么区别？
s+=1 相当于 s=s+1

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2