Java入门基础知识总结（一）

（一）数据类型转换

1、强制类型转换（显性）
格式：范围小的类型 范围小的变量名 = (范围小的类型) 原本范围大的数据;
缺点：有可能发生精度损失、数据溢出。
2、自动类型转换（隐性）
规则：数据范围由小到大。
注：1）byte/short/char这三种类型都可以进行数学运算，且在运算时，都会先被提升成为int类型，再计算。
2）boolean类型不能发生数据类型转换。

（二）运算符

1、算术运算符：
1）四则取模运算：加： +；减：- ；乘： * ；除：/ ；取模（取余数）：%；
注：若运算中有不同类型的数据，结果将是数据类型范围大的那种。
加号“+”有常见的三种用法：
1）于数值而言就是加法。
2）于字符char类型而言，char会被提升成为int，再运算。
3）于字符String（首字母大写，并不是关键字）而言，加号代表字符串连续操作。
任何数据类型和字符串进行连接时，结果都会变成字符串。
2）自增自减运算：自增运算符：++；自减运算符：–；
使用区别：
1）在单独适用时，前++和后++没有任何区别，即++num与num++;完全一样
2、在混合时。有【重大区别】
A.如果是【前++】，变量【马上+1】，然后拿着结果进行使用。【先加后用】
B.如果是【后++】，首先使用变量本来的数值，【再让变量+1】，【先用后加】
注：只有变量才能使用自增、自减运算符。常量不能。
2、赋值运算符：
（1）基本赋值运算符：就是一个等号“=”（将右侧的数据交给左侧的变量）。
(2)复合赋值运算符：
+= a +=3 相当于 a=a+3;
–= b --=4 相当于 b=b–4
= c=5 相当于 c=c*5
/= d/=6 相当于 d=d/6
%= e%=7 相当于 e=e%7
注：
1）只有变量才能使用赋值运算符，常量不行。
2）复合赋值运算符中隐含了一个强制类型转换。
3、比较运算符：
大于： >
小于： <
大于等于： >=
小于等于： <=
相等： == 【等号连写才是相等，一个等号代表的是赋值】
不相等： ！=
注：
1）比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false
2）如果进行多次判断，不能连着写。
4、逻辑运算符：
与（并且） && 全都是true，才为true，否则为false。
或（或者） || 至少一个是true，就为true，全部都是false，才为false。
非（取反） ！ 本来是true，变成false；本来是false，变成true。
与“&&”，或“||”，具有短路效果，如果根据左侧就可以判断得到最终结果，右侧的代码将不再执行，从而节省一定的性能。

注：
1）逻辑运算符只能用于boolean值。
2）与、或需要左右各自一个boolean值，但取反时只要有唯一的一个boolean值即可。
3、与、或两种运算符号，如果有多个条件，可以继续写。
两个条件：条件A && 条件B
多个条件：条件A && 条件B && 条件C
TIPS：
对于1<x<3的情况，应该拆分成两个部分，然后进行与运算符连接起来。
5、三元运算符：（？：否则）
一元运算符：只需要一个数据就可以进行操作的运算符。 eg：取反！、自增++、自减–
二元运算符：需要两个数据方可进行操作的运算符。 eg：加法+、赋值=
三元运算符：需要三个数据方可进行操作的运算符。
格式：
数据类型 变量名称=条件判断？表达式A：表达式B；
流程：
首先判断条件是否成立：
如果成立为true，将表达式A的值赋值给左侧的变量；
如果不成立为false，将表达式B的值赋值给左侧的变量。

注：
1、必须同时保证表达式A和表达式B都符合左侧数据类型的要求；
2、三元运算符的结果必须被使用。

（三）方法入门

1、概念：将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。
当我们需要此功能时，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。
2、定义格式：
修饰符 返回值类型 方法名(参数列表) {
代码···
return;
}
方法名称的命名规则和变量相同，使用小驼峰式。
方法体：也就是大括号当中可以包含任意条语句。

注：
（1）先后顺序无所谓。
（2）不能产生嵌套包含关系。
（3）方法定义好之后，是不会执行的。如想执行，必须进行方法的【调用】。

如何调用方法：格式：
方法名称（）；

（四）编译器的两点优化

对于byte/short/char三种类型而言，如果右侧赋值的数值没有超过范围，Java编译器将会自动隐含地为我们补上一个(byte)(short)(char).
1、如果没有超过左侧范围，编译器补上强转。
2、如果右侧没有超过左侧范围，直接编译报错。

（五）顺序结构

public static void main(String[] args) {
//顺序执行，根据编写的顺序，由上至下运行
System.out.println(1);
System.out.println(2);
System.out.println(3);
}

（六）判断语句

1、单if语句：
if(){
}
2、标准的if—else语句：
if(){
} else {
}
3、if—else if—else 语句：
if() {
else if(){
} else{
}
}

(七) 选择语句—switch

注：
1、case后面的数值不能重复。
2、switch后面小括号当中只能是下列数据类型：
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举
3、switch语句格式可以很灵活，前后顺序无所谓，且break语句可以省略。
“匹配哪个case就从哪个位置向下执行，直到遇到了break或者整体结束为止。”

（八）循环语句

1、for语句：
for(int i=1;i<=100;i++) {
}
2、while语句：
1）标准格式：
while(条件判断) {
循环体
}

2）初始化语句；
while（条件判断） {
循环体；
进步语句；
}
3、do—while：
1）标准格式：
do {
循环体
} while (条件判断);

2）扩展格式：
初始化语句
do {
循环体
步进语句
} while (条件判断);
4、三种循环的区别：
1）条件判断从未满足过时，for循环和while循环将会执行8次，但do-while循环会执行至少一次。
2）for循环的变量在小括号当中定义，只有循环内部才能使用。while循环和do-while循环的初始化语句本来就在外面，出来循环之后还能继续使用。
5、break关键字的常见用法：
1）可以用在switch语句中，一旦执行，整个switch语句立刻结束。
2）可以用在循环语句当中，一旦执行，整个循环语句立刻结束，打断循环。
建议：凡是次数确定的场景多用for循环，否则多用while循环。
6、continue关键字：循环控制语句。（一旦执行，立刻跳过当前此循环剩余内容，开始下一次循环。）
7、死循环：永远停不下来的循环。
8、嵌套循环：一个循环的循环体时另一个循环。

(九)数组

1、定义：存储数据长度固定的容器，保证多个数据的数据类型要一致。
2、数组的初始化：在内存当中创建一个数组，并且香气中赋予一些默认值；
3、常见的格式初始化：
1）动态初始化（指定长度）；
（1）格式：
数据类型[ ]数组名称=new 数据类型[数组长度]；
2）静态初始化（指定内容）；
（1）标准格式：
数据类型[ ] 数组名称 = new 数据类型[ ] {元素1，元素2，…}；
（2）省略格式：
数据类型[ ] 数组名称 = {元素1，元素2，…};
注：
（1）静态初始化虽然没有直接指定长度，但是会自己进行推算得到长度；
（2）静态初始化标准格式可以拆分成两个步骤；
（3）动态初始化也可以拆分成两个步骤；
（4）静态初始化省略格式不可以拆分成两个步骤；
4、访问数组元素进行获取：
1）直接打印数组名称所获得的是数组对应的内存地址（哈希值）；
索引访问数组中的元素：
数组名 [索引]=数值；【为数组中的元素赋值】
变量 =数组名[索引]；【获取出数组中的元素】
访问数组元素的格式：
数组名称[索引值]；
注释： 索引值：为一个int型数字，代表数组当中元素的编号（索引值从0开始，一直到“数组的长度-1”为止。）
5、访问数组元素进行赋值：
使用动态初始化数组是，数组中的元素将自动拥有一个默认值。如下：
如果是整数型，则默认为0；
如果是浮点型，则默认为0.0；
如果是字符型，则默认为‘\u0000’；
如果是布尔型，则默认为false；
如果是引用类型，则默认为null；
注：静态初始化也有默认值的过程，知识系统会自动将默认值替换成了大括号内的具体数值。

（十）Java中的内存划分

1、一个数组的内存图：
2、两个数组的内存图：
3、两个引用指向同一数组的内存图：

4、常见问题：
1）、数组索引越界异常；
数组中的索引编码由0起，一直到“数组的长度-1”为止；
如果访问数组元素时索引编号不存在，则发生数组索引越界异常；
2）、空指针异常：
所有的引用类型变量均可以赋值为个null值，但并不代表什么都没有；
数组必须进行new初始化才能使用其中的元素
仅赋值个null没进行new的创建，将会发生空指针异常。
5、如何获取数组的长度：
格式：
数组名称.length;
将会得到个int型数据，代表长度；
注:数组创建后，程序运行期间，长度无法改变。
6、数组的遍历输出：
遍历数组：对数组中的每个元素进行逐个处理，默认的处理方式为打印输出；

for (int i = 0; i <array.length ; i++) {
            System.out.println(array[i]);
        }

7、数组元素反转：
8、数组作为方法参数：
当调用方法时，先方法的小括号进行传参，传递进去的为数组的地址值；
9、数组作为方法返回值：
一个方法可以有多个参数，但禁止个已有0或1个返回值。
一个方法中产生多个结果进行返回：
（解决方案：使用 一个数组作为返回值类型。）
任何数据类型决斗可以作为方法的参数类型或返回值类型；
数组作为方法的参数或返回值，传递进去的都为数组的地址值；

（十一）复习简单方法的使用

1、定义格式：public static void 方法名称() {
方法体
}
2、调用格式：方法名称 ();

注：
(1)不考虑方法定义的先后顺序。
(2) 方法定义必须是挨着的，不可以在一个方法的内部定义另一个方法。
(3)方法定义后无法自行执行，需要进行方法的调用后方可执行。

（十二）方法

1、方法的定义格式：
1)方法：若干语句的功能集合；
定义方法的完整格式：
修饰符 返回值类型 方法名称（参数类型 参数名，~~~·）{
方法体
return 返回值；
}

注意：return后的“返回值”，必须与方法名称前的“返回值类型”保持对应。
定义一个两个int数字相加的方法。 三要素：
返回值类型:int;
方法名称：sum;
参数列表：int a,int b；
2、方法的三种调用格式：
1）单独调用：方法名称(参数);
2）打印调用：System.out.println(方法名称(参数))；
3）赋值调用：数据类型 变量名称=方法名称(参数);

注意：此前学习的方法，返回类型固定写为void，这种方法只能进行单独调用，无法进行打印调用或赋值调用。
3、有参数与无参数的区别：
1）有参数：小括号中有内容，当一个方法需要一些数据条件才能完成任务时，就是有参数；
2）无参数：小括号中留空，一个方法不需要任何的数据条件，可以独立完成任务时，就是无参数；
4、有无返回值的区别：
1）有返回值：你帮我算，算完后将结果告诉我；
2）五返回值：你独立运算，算完后你负责显示结果，无需告诉我；

注：
（1）对于有返回值的方法三种调用方法均可使用；
（2）对于五返回值的方法，只能使用单独调用；
5、使用方法的注意事项：
1）方法定义在类当中，但不能在方法当中再去定义方法，不能进行嵌套；
2）方法定义时前后顺序不做要求；
3）方法定义后不会直接执行，需要其执行时一定要进行调用；
4）当方法有返回值时，必须写上“return 返回值;”；
5）return后的返回值数据必须与方法的返回值类型对应起来；
6）对于一个void没有返回值的方法，不可以写return后的返回值，只能写return 自己；
7）对于void方法中最后一行的return值可以忽略不写；
8）一个方法中可以有多个return语句，但必须保证仅有一个语句会被执行，且两个return不可以连写；

（十三）方法重载

1、定义：指在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同即可，与修饰符和返回值类型无关。（多个方法的名称相同 ，但参数列表不同）；
2、优点：只需记住唯一一个方法名称即可实现类似的多个功能；
3、注意：
（1）与方法重载有关的因素：
1）参数个数不同；
2）参数类型不同；
3）参数的多类型顺序不同；
（2）与方法重载无关的因素：
1）参数的名称；
2）方法的返回值类型；