JAVA入门

1自动转换 （隐式转换）
1）自动转换概念
代码执行过程中取值范围小的类型自动转换为取值范围大的类型 。

不同分类的数据类型,不能够论字节大小.

2）转换规则
范围小的类型向范围大的类型转换，但是注意byte、short、char 运算过程中直接转换为int.

byte、short、char  <  int  <  long  <  float  <  double

1.2 强制转换
1）强制转化的概念
概念理解：取值范围大的类型强制转换成取值范围小的类型。

转换格式： int i1 =(int)1.0;
数据类型 变量名 = （目标数据类型）被转数据值；

与自动转换的区别，自动转换时是Java自动执行的不需要我们参与，而强制转换需要我们自己手动执行。

2）转换原理图解
我们知道byte占有一个字节，取值范围是 [-128,127],我定义一个byte类型的变量，赋值一个在它范围之外的一个数，比如257。

因为超出了byte范围之外，所以要强转。那么计算结果是什么呢？

​
byte b1=(byte)257;
System.out.println(b1);
3）强转有风险，操作需谨慎！！！
精度损失：浮点转成整数，直接取消小数点，可能造成数据损失精度。

数据溢出：int 强制转成byte 砍掉3个字节，可能造成数据丢失。

int i=(int)3.9;// i=3   小数点去掉了，精度损失
byte b=(byte)257;// b=1 只拿到一个字节的数据，其余三个字节丢失（数据溢出）
第二章 运算符（Operator）
2.1 算数运算符
算数运算符包括：    
+    加法运算，字符串连接运算
-    减法运算
*    乘法运算
/    除法运算 求商运算
%    取模运算，两个数字相除取余数
++ 、 --    自增1自减1运算
本身这些加减乘除模跟我们小学时学的运算符功能是一致，但是我们要注意他们运算时候的一些特点如下：

2.1.1 运算符两侧的类型一致
运算符两侧的类型一致时，运算的结果也是和运算的数据类型一样的但（byte，short，char类型例外，他们会自动转换为int）。

int i1=100;
int i2=200;
int i3=i1+i2;//i1和i2都是int类型。结果可以赋值给int类型的i3
int i4=i1*i2;
在数据类型自动转换的时候讲过byte，short，char在运算的时候是直接自动提升为int类型的。再巩固下：

byte b1=10;
byte b2=20;
//byte b3=b1+b2;//错误: 不兼容的类型: 从int转换到byte可能会有损失
int b3=b1+b2;  //需要用int类型的变量接收，因为运算结果提升为int了。
System.out.println(b3);
同样，当short，char在混合运算的过程中，也是自动提升为int类型的。课后请实践下,加深印象。

2.1.2 运算两侧的类型不一致
当算术运算两侧的类型不一致的时候，结果和大类型保持一致。

double d1=100;
int i1=10;
// int i2=d1+i1;//错误: 不兼容的类型: 从double转换到int可能会有损失
double i2=d1+i1;
2.1.3 ++,-- 运算符
++ 运算，变量自增长1。-- 运算，变量自减少1。用法一致，效果相反。

1）独立运算

​ 变量在独立运算时，前++和后++没有区别 ，都是实现自动加1的功能。

​ 变量前++ ：例如 ++i

​ 变量后++ ：例如 i++

int i=1;
​
i++;//可以放在变量的后边     自动加1
​
System.out.println(i);// 输出结果为：2
++i;//也可以放在变量的前面    自动加1
​
System.out.println(i);// 输出结果为：3
2） 混合运算

和其他变量放在一起，先++和后++就产生了不同。

先++\-- ：先运算后取值

int i1 = 1;
int i2 = ++i1;
System.out.println(i1);//计算结果是2
System.out.println(i2);//计算结果是2
变量a自己加1，将加1后的结果赋值给b，也就是说a先 +1 计算得到2，然后复制给b,因此，a和b的结果都是2。

后++\-- ：先取值后运算

int a = 1;
int b = a++;
System.out.println(a);//计算结果是2
System.out.println(b);//计算结果是1
变量a先把自己的值1赋值给变量b，此时变量b的值就是1。然后变量a再去自己再加1。因此，a的结果是2，b的结果是1。

2.1.4 + 字符串中的拼接操作
+ 符号在遇到字符串的时候，表示连接、拼接的含义。

"a"+"b"的结果是“ab”，连接含义

System.out.println("5+5="+5+5);//输出5+5=55
注意:当道和加法运算结合在一起的时候,要注意用() 提升运算优先级

int i6 =5;
    int i7= 6;
    System.out.println(i6+"x"+i7+"="+i6*i7);
    //当道和加法运算结合在一起的时候,要注意用() 提升运算优先级
    System.out.println(i6+"+"+i7+"="+(i6+i7));
2.2 赋值运算符
运算符    说明
=    等于号
+=    加等于
-=    减等于
*=    乘等于
/=    除等于
%=    取模等
1）赋值运算符=
将=右边的值，赋给左边的变量。其实我们昨天在学习定义变量的时候就接触了。如：

int i1 = 5;     //将整数常量5赋值给i1。
int i2 =i1;     //将i1变量的值赋值给i2变量。
int i3 =i1+i2;  //将i1+i2的运算结果赋值给变量i3
2）+= ,-=,*=,/=,%=
运算符和赋值符的结合使用。当运算的时候，有时我们会遇到如下运算需求：

int i1=10;
i1=i1+100;//变量自身参与运算，结果赋值返回给自身
i1+=100;
System.out.println(i1);
​
int i2 =10;
i2=i2*10;
i2*= 10;
​
可以使用运算符和赋值符号相结合:

int i1=10;
i1+=100;//变量自身参与运算，结果赋值返回给自身
System.out.println(i1);
3）+= ,-=,*=,/=,%=：自动类型强转功能
在运算过程中，如果涉及到值强转，会自动操作不需要我们干涩。

byte b1=1;
//b1= b1+ 256;//编译报错
b1+=256; 
System.out.println(b1);//值为1，而不是257. int 强转为 byte ，溢出
​
int i1=10;
i1*=1.234;  
System.out.println(i1);//值为12，而不是12.34 double 强转为 byte ，精度损失
2.3 比较运算符
比较运算符    说明
==    比较符号两边数据是否相等，相等结果是true。
<    比较符号左边的数据是否小于右边的数据，如果小于结果是true。
>    比较符号左边的数据是否大于右边的数据，如果大于结果是true。
<=    比较符号左边的数据是否小于或者等于右边的数据，如果小于或者等于结果是true。
>=    比较符号左边的数据是否大于或者等于右边的数据，如果大于或者等于结果是true。
!=    不等于符号 ，如果符号两边的数据不相等，结果是true。
比较运算符，是两个数据之间进行比较的运算，运算结果都是布尔值true或者false 。

public static void main(String[] args) {
    System.out.println(1==1);//true 
    System.out.println(1<2);//true
    System.out.println(3>4);//false
    System.out.println(3<=4);//true
    System.out.println(3>=4);//false
    System.out.println(3!=4);//true
}
2.4 逻辑运算符
逻辑运算符其实就是与（并且），或（或者），非（不是），用来连接两个布尔类型结果的运算符。**其运算结果都是布尔值（true或false）

1>2 并且 1<2 false 并且 true -->false

逻辑运算符    称呼    使用说明
&&    双与<br>短路与    1. 两边都是true，结果是true <br>2. 一边是false，结果是false <br>短路特点：**一假即假**。符号左边是false，右边不再运算，效率比单与高。
||    或者<br>短路或    两边只要有一边是true,结果就是true,一真即真
！    取反    1. ! true 结果是false<br />2. ! false结果是true 男 --> 非女 -->不是女的
1）逻辑运算符的普通使用
    //逻辑与（并且） 一假即假
    System.out.println(true && true);//true
    System.out.println(true && false);//false
    System.out.println(false && true);//false，右边不计算
      //逻辑或（或者）一真即真
    System.out.println(false || false);//falase
    System.out.println(false || true);//true
    System.out.println(true || false);//true，右边不计算
        //逻辑非（不是）
    System.out.println(!false);//true
2） &&短路测试 一假即假
int i1=1;
int i2=1;
//          短路    false && true 
System.out.println(++i1<1 && i2++>1);//false 
System.out.println(i1); //2
System.out.println(i2); //1
3）|| 短路测试 一真即真
//  ||(短路或) 一真即真
int i1=1;
int i2=1;
//          短路     true || true 
System.out.println(++i1>1 || ++i2>1);
System.out.println(i1);//2
System.out.println(i2);//1
2.5 三元运算符
当一个布尔表达式的结果( true 或者 false) 需要对应两种不同的结果时, 我们可以使用三元运算符.

表达式可: 由变量或常量和操作符组成的式子构成。

比如: 成绩>= 60 分 true 及格 false 不及格

在java中 布尔表达式 ? 真值结果 : 假值结果

表达式: 我们使用运算符去连接若干个变量或者是常量时 1>2 -->false

格式如下:

三元运算符格式：
 数据类型 变量名 = 布尔类型表达式 ？ 真值 : 假值；
 
 
 int score=80;// 如果大于等于60 及格    否则 不及格
 
  String status = score>=60 ? "及格" : "不及格" ; // 不及格
​
System.out.println(status); // score=80 及格  score=59 不及格
String int double

"Hello" -->字符串常量 String

1 ----> int

三元运算符执行顺序：
布尔类型表达式结果是true，三元运算符整体结果为真值，赋值给变量。

布尔类型表达式结果是false，三元运算符整体结果为假值，赋值给变量。

public static void main(String[] args) {
    int a=1;
    int b=2;
    
    //a>b么?是 c=true,不是 c=false
    boolean c=a>b ? true : false;
  
    int i = (1==2 ? 100 : 200);
    System.out.println(i);//200
    int j = (3<=4 ? 500 : 600);
    System.out.println(j);//500
}
注意: 后面真值和假值的数据类型要和 变量接收的类型要匹配

第三章 方法入门 (Method)
Java方法是语句的集合，它们在一起执行一个功能。

方法是解决一类问题的步骤的有序组合

方法包含于类或对象中( 面向对象)

方法在程序中被创建，在其他地方被引用

方法的优点：

使程序变得更简短而清晰。

有利于程序维护。

可以提高程序开发的效率。

提高了代码的重用性。

 方法的定义
定义格式：

修饰符  返回值类型 方法名 （参数列表）｛
        代码...   
        return ;
｝

定义格式解释：

修饰符： 目前固定写法 public static 。

返回值类型： 目前固定写法 void ，其他返回值类型在后面的课程讲解。

方法名：(小驼峰)为我们定义的方法起名，满足标识符的规范，用来调用方法。

参数列表： 目前无参数， 带有参数的方法在后面的课程讲解。

return：方法结束。因为返回值类型是void，方法大括号内的return可以不写。

举例：

public static void methodName() {
    System.out.println("这是一个方法");
}
3.3 方法的调用
方法在定义完毕后，方法不会自己运行，必须被调用才能执行，我们可以在主方法main中来调用我们自己定义好的方法。在主方法中，直接写要调用的方法名字就可以调用了。

public static void main(String[] args) {
    //调用定义的方法method
    method();
}
//定义方法，被main方法调用
public static void method() {
    System.out.println("自己定义的方法，需要被main调用运行");
}