Java基础概念
1.关键字
被Java赋予特定含义的英文单词。字母全部小写。
class：用于创建一个类，类是Java最基本的组成单位。
2.字面量
可以告诉程序员数据在程序中的书写格式。
①字符串类型：用双引号括起来的内容 ②字符类型：用单引号括起来的，内容只能有一个 ③布尔类型：布尔值，表示真假，只有true、false ④空类型：一个特殊的值，空值是null
细节：null不能直接打印，若要打印null，只能用字符串的形式进行打印
3.变量
在程序执行过程中，其值有可能发生改变的量。
格式：数据类型 变量名＝数据值
注意事项：①只能存一个值 ②变量名不允许重复定义 ③一条语句可以定义多个变量 ④变量在使用之前一定要赋值 ⑤变量的作用域范围
4.数据类型
基本数据类型包括整数（byte short int long)浮点数（float double)字符（char)布尔（boolean)
它们的取值范围double(-128~127)＞float＞long＞int＞short＞byte
- 如果要定义一个long类型的变量，在数据值后面需要加一个L（l)作为后缀定义float类型变量，也需加F（f)后缀。
5.标识符
就是给类、方法、变量等起的名字
命名规则：
- 硬性要求：①由数字、字母、下划线和美元符（$）组成 ②不能以数字开头 ③不能是关键字 ④区分大小写
- 软性建议：方法变量：①标识符是一个单词的时候，全部小写 ②标识符由多个单词组成的时候，第一个单词首字母小写，其他首字母大写 类名：①标识符是一个单词的时候，首字母大写 ②标识符由多个单词组成的时候，每个字母的首字母大写
Scanner类：键盘录入
- 导包-important java.util.Scanner-导包的动作必须出现在类定义的上边
- 创建对象-开始使用，Scanner sc＝new Scanner(System.in)-这个格式中，只有sc是变量名，可变，其他不能变
- 接受数据-真正开始干活，int i＝sc.nextInt();-只有i是变量，可以变，其他都不能变。
算数运算符
运算符：对字面量或变量进行操作的符号。
代码中，如果有小数参与计算，结果可能不准确。整数参与计算，结果只能为整数。想有小数，必须有小数参与计算，如10/3＝3，但3.3333333335。
1.数字相加
数字进行运算时，数据类型不一样不能运算，需要转成一样的，即类型转换，类型转换分为隐式转换和强制转换。
- 隐式转换：由取值范围小的转为取值范围大的，是自动类型提升。（byte、short、char三种类型的数据在进行运算时，会直接先提升为int类型，再进行运算）
- 强制转换：由取值范围大的转为取值范围小的。格式为： 目标数据类型 变量名＝（目标数据类型）被强制转换的数据
2.字符串的“＋”操作
- 当“＋”操作中出现字符串时，这个“＋”是字符串连接符，而不是算术运算符，会将前后数据进行拼接，产生新字符串
- 连续进行“＋”操作，从左到右逐个进行1+2+“abc”+2+1结果为3abc21
3.字符相加
当字符+字符或字符+数字时，会把字符通过ASCII码表查询到对应的数字再进行计算（A 65） 字符串只有加操作
4.自增 自减
++和--无论是放在变量前还是后，单独写一行结果是一样的。但int b＝a++先用后加，int b＝++a先加后用
5.赋值运算符
a＋＝b即为a＝a+b
- 细节：＋＝、-＝、*＝、／＝、%＝都隐藏了一个强制类型转换
6.关系运算符
＝＝为判断是否相等，！＝为判断是否不相等
- 关系运算符的结果都是boolean类型，要么是true，要么是false。
7.逻辑运算符
& 逻辑与，并且，两边都为真，结果才为真
| 逻辑或，或者，两边都为假，结果才为假
^ 逻辑异或，相同为false,不同为true
! 逻辑非，取反（要么不写，要么只写一个）
短路逻辑运算符 &&和||
简单理解即为当左边的表达式能确定最终结果，那右边就不会参与运行了。
8.三元运算符
定义一个变量记录两个整数的最大值
作用：可以进行判断，根据判断的结果得到不同的内容。
格式：关系表达式？表达式1：表达式2；
先执行 关系表达式，若为真，执行1为结果；若为假，执行2为结果。
运算符中（）优先与所有。
流程控制语句
1.顺序结构语句
默认执行流程，按照代码的先后顺序，从上到下依次执行。
2.分支结构
- if语句（进行判断）格式1：if(关系表达式）{ 语句体；}
流程：1.首先计算关系表达式的值 2.如果关系表达式的值为true就执行语句体，为false不执行语句体 3.继续执行后面其他语句
注意：1.大括号的开头可以另起一行书写，但是建议写在第一行末尾 2.语句体中，如果只有一行代码，大括号可以省略不写 3.如果对一个布尔类型的变量进行判断，不要用==，直接把变量写在小括号即可。
格式2：if(关系表达式）{ 语句体1； }else{ 语句体2；}
格式3：if（关系表达式1）{语句体1；}else if（关系表达式2）{语句体2；} else{语句体n+1；}
从上往下依次执行，只要有一个为真，就执行相应的语句体，如果所有判断都为假，就执行else的语句体。
- switch语句
格式：switch（表达式）{case 值1： 语句体1； break； case 值2： 语句体2； break； default： 语句体n+1； break；}
流程：1.首先计算关系表达式的值 2.依次和case后面的值进行比较，如果有对应值，就执行相应语句，执行过程中，遇break结束 3.如果所有case后值和表达式不匹配，执行default里语句体，之后结束整个switch语句。
default的位置和省略：1.不一定写最下面，可以写在任意位置，习惯写最下面 2.default可以省略，不会有语法问题，但不建议。
不写break，会case穿透，如果有多个case的语句体重复，可以考虑用case穿透，简化代码。
switch和if第三种格式各自的使用场景：switch把有限个数据一一列举出来，让我们任远其一；if一般用于对范围的判断
3.循环语句
for 格式：for(初始化语句；条件判断语句；条件控制语句）{循环体语句；}
1.执行初始化语句 2.执行条件判断语句，结果false循环结束；结果true执行循环体语句 3.执行条件控制语句 4.回到2继续执行条件判断语句
初始化语句只执行一次，判断语句，结果false循环结束；结果true执行循环体语句
扩展：累加时1.求和的变量不能定义在循环的里面，因为变量只在所属的大括号里面有效 2.若我们把变量定义在循环里面，那么当前循环只能在本次循环中有效，本次循环结束后，变量就会从内存中消失，第二次循环开始时，又会定义一个新变量。
结论：如果我们要写累加求和变量，可以把变量定义在循环外面
while 格式：初始化语句； while（条件判断语句）{循环体控制语句；条件控制语句；}
对比：相同：运行规则相同
不同： for循环中，控制循环的变量，因为归属for循环的语法结构中，for循环结束后，不能被访问了。while循环中，控制循环的变量，对于while循环来说不归属其语法结构中，while循环结束后，该变量还可继续使用。
区别：for：知道循环次数或范围 while：不知道循环次数或范围，只知道循环结果
do...while 格式：初始化语句；do{循环体语句；条件控制语句；}while（条件判断语句）；
数组
指一种容器，可以用来存储同种数据类型的多个值
数组容器在存储数据的时候，需要结合隐式转换考虑
建议：容器的类型和存储的数据类型保持一致
格式：数据类型【】数组名 或 数据类型 数组名【】
1.数组的初始化
就是在内存中，为数组容器开辟空间，并将数据存入容器中的过程。
- 静态初始化：数据类型［］＝｛元素1，元素2......｝
- 动态初始化：初始化时只指定数组长度，由系统为数组分配初始化。数据类型［］数组名＝new 数据类型［数字长度］；
区别：动态初始化手动指定数组长度，由系统给出默认初始化值。静态初始化手动指定数组元素，系统会根据元素个数，计算出数组长度。
2.数组元素访问
格式：数组名［索引］；
索引（下标/角标）：从0开始，逐个加1增长，连续不间断。
利用索引对数组中的元素进行访问：1.获取数组里面的元素 格式：数组名［索引］ 获取数组中第一个元素，其实就是0索引上对应的元素 2.把数据存储到数组当中 格式：数组名［索引］＝具体数据或变量 细节：一旦覆盖之后，原来的数据就不在了
3.数组的遍历
将数组中所有内容取出来，取出来可以打印、求和、判断
注意：遍历指的是取出数据的过程，不要局限的理解为遍历就是打印
4.数组常见问题
当访问了数组中不存在的索引，就会引发索引越界异常。（知道索引范围可以避免）
5.数组的内存图
栈：方法运行时使用的内存，比如main方法运行，进入方法栈中执行。 堆：存储对象或者数组，new来创建，都存储在堆内存。 方法区：存储可以运行的class文件。 本地方法栈：JVM在使用操作系统功能的时候使用，和我们开发无关。 寄存器：给CPU使用，和我们开发无关。
方法
方法是程序中最小的执行单元。能提高代码的复用性和可维护性。
重复的代码，具有独立功能的代码可以抽取到方法中。
1.方法的定义格式
public static void 方法名（）{ 方法体（就是打包起来的代码）；}
调用：方法名（）；
方法必须先定义再调用，否则会报错
带参数的方法定义和调用：public static void 方法名（参数1，参数2，......）{.........}
调用：方法名（参数1，参数2，......);
方法调用时，参数的数量与数据类型必须与方法定义中小括号里面的数量一一对应。
形参：形式参数，方法定义中的参数
实参：实际参数，方法调用中的参数
带返回值方法的定义和调用：方法的返回值其实就是方法运行的最终结果。
public static 返回值类型 方法名（参数）{ 方法体；return 返回值；}
调用：直接调用：方法名（实参）； 赋值调用：整数类型 变量名=方法名（实参）； 输出调用：System.out.println（方法名（实参））；
注意：1.方法不调用就不执行 2.方法与方法之间是平级关系，不能互相嵌套定义 3.方法的编写顺序和执行顺序无关 4.方法的返回值类型为void，表示该方法没有返回值，没有返回值的方法可以省略return语句不写，如果要编写return，后面不能跟具体的数据 5.return语句下面，不能编写代码，因为永远执行不到，属于无效代码。
rerun关键字：1.方法没有返回值：可以省略不写，如果书写，表示结束方法 2.方法有返回值：必须要写，表示结束方法和返回结果。
2.方法的重载
- 在同一个类中，定义了多个同名的方法，这些同名的方法具有同种的功能
- 每个方法具有不同的参数类型或参数个数，这些同名的方法，就构成了重载关系
简单记：同一个类中，方法名相同，参数不同的方法，与返回值无关
3.方法的内存
基本数据类型：变量中存储的是真实的数据，存在自己空间中（赋值给其他变量，也是赋的真实值）
引用数据类型：（数组）变量中存储的是地址值。引用表示使用了其他空间中的数据
4.方法的值传递
传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实参值
传递引用数据类型时，传递的是地址值，形参的改变，影响实参的值
对象
1.设计对象并使用
类：是对象共同特征的描述 对象：真实存在的具体东西
在Java中，必须先设计类，才能获得对象
如何定义类：public class 类名{1.成员变量（属性，是名词） 2.成员方法（行为，是动词） 3.构造器 4.代码块 5.内部类 }
如何得到类的对象： 类名 对象名=new 类名（）；
如何使用对象：访问属性：对象名.成员变量 访问行为：对象名.方法名（......)
用来描述一类事物的类，专业叫做Javabean类，不写main方法的
描写main方法的类，叫做测试类。我们可以在测试类中创建Javabean类的对象并进行赋值调用。
类名首字母建议大写，需见名知意，驼峰模式
一个Java文件中可以定义多个class类，且只能一个类是public修饰，且public修饰的类名必须成为代码文件名。实际开发中还是建议一个文件定义一个class类
成员变量的完整定义格式是：修饰符 数据类型 变量名称=初始化值； （一般无需指定初始化值，存在默认值
2.封装
对象代表什么，就得封装对应的数据，并提供数据对应的行为
private关键字：1.是一个权限修饰符，可以修饰成员（成员变量和成员方法）。 2.被private修饰的成员只能在本类中才能被访问。 3.针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作。 4.提供setXxx（参数）方法，用于给变量赋值，方法用public修饰 5.提供getXxx（）方法，用于获取成员变量的值，方法用public修饰。
定义在方法里面的变量叫局部变量。定义在方法外面的变量，叫成员变量
就近原则：“谁离我近，我就用谁”一般打印局部变量，加this关键字，即可打印成员变量。
3.构造方法
在创建对象时，给成员变量进行赋值
作用：给成员变量进行初始化
格式：public class Student{修饰符 类名（参数）{方法体；} }
特点：1.方法名与类名相同，大小写也要一致 2.没有返回值类型，连void都没有 3.没有具体的返回值（不能由return带回结果数据）
执行时机：1.创建对象时由虚拟机调用，不能手动调用构造方法 2.每创建一次对象，就会调用一次构造方法
无参构造方法：初始化的对象时，成员变量的数据均采用默认值。
有参构造方法：初始化的对象时，同时可以为对象进行赋值。
- 定义：①如果没有定义构造方法，系统会给出一个默认的无参构造方法 ②如果定义了构造方法，系统将不再提供默认的构造方法
- 构造方法的重载：带参的构造方法和无参的构造方法，两者方法各相同，但参数不相同，这叫重载。
- 推荐使用方法：无论是否使用，都手动书写无参数构造方法，和带全部参数的构造方法
4.标准的JavaBean类
1.类名需要见名知意 2.成员变量用private修饰 3.提供至少两个构造方法（无参构造方法、带全部参数的构造方法） 4.成员方法（提供每一个成员变量对应的setXxx（）/getXxx（）；如果还有其他行为，也要写上）
字符串
API:(如何使用别人已经写好的东西）（应用程序编程接口）
目前时JDK中提供的各种功能的Java类，这些类将底层的实现封装了起来，我们不需要关心这些类如何实现，只要学习类如何使用
String（字符串）：字符串的内容不会改变，它的对象在创建后不能被更改。
- 1.String是Java定义好的一个类。定义在Java.lang包中，所以使用时无需导包
- Java程度中所有字符串文字，都被视为此类的对象
- 字符串不可变，它的值在创建后不能被更改
1.使用直接赋值的方式获取一个字符串对象
String s1＝"abc"
2.使用new的方式来获取一个字符串对象 空参构造：可以获取一个空的字符串对象 String s2＝new string() 有参构造：传递一个字符串，根据传递的字符串内容，再创建一次新的字符串对象 String s3＝new string(original:"abc") 传递一个字符数组，根据字符数组的内容，再创建一个新的字符串对象 需求：修改字符串内容，把abc变为数组｛‘a’，‘b’，‘c’｝再修改数组内容 char［］chs＝｛‘a’，‘b’，‘c’｝;String s4＝new String(chs); 传递一个字节数组，根据字节数组的内容，再创建一个新的字节对象 应用场景：以后在网络当中传输的数据其实都是字节信息，我们一般要把字节信息进行转换，转成字符串，此时就要用到这个构造了
1.Java的常用方法
基本数据类型比较的是数据值；引用数据类型比较的是地址值
new出来的记录堆里面的地址值；直接赋值的记录串池中的地址值
字符串比较 boolean equals 完全一样才是true，否则为false boolean equalsIgnoreCase 忽略大小写的比较
StringBuilder 看成是一个容器，创建之后里面的内容是可变的 作业：提高字符串的操作效率
构造方法：①public StringBuilder() 创建一个空白可变字符串对象，不含任何内容 ②public StringBuilder(String str)根据字符串的内容，来创建可变字符串对象
常用方法：
链式编程：当我们在调用一个方法时，不需要用变量接收它的结果，可以继续调用其中方法。
2.ArrayList
集合是一种容器，用来装数据的，类似于数组。数组定义完成并启动后，长度就固定了。集合大小可变，开发中用的更多
2 、 ArrayList 是集合中最常用的一种，ArrayList 是 泛 型类，可以约束存储的数据类 型。
常用方法：
第一步：创建ArrayList容器对象。一般使用空参数构造方法。
第二步：调用ArrayList类的常用方法对容器中的数据进行操作。
面向对象高级
1.静态(Static)
static，可以用来修饰成员变量，也能修饰成员方法。
Java中的成员变量按照有无static修饰分为两种：类变量、实例变量。
由于静态变量是属于类的，只需要通过类名就可以调用：类名.静态变量
实例变量是属于对象的，需要通过对象才能调用：对象.实例变量
需求：系统启动后，要求用于类可以记住自己创建了多少个用户对象。
2.继承
继承就是用extends关键字，让一个类和另一个类建立起一种父子关系。
特点：子类能继承父类的非私有成员（成员变量、成员方法）
子类的对象是由子类、父类共同完成的
继承的好处：减少重复代码的编写，提高代码的复用性
权限修饰符
权限修饰符就是用来限制类中的成员（成员变量、成员方法、构造器、代码块 … ）能够被访问的 范围 。
private(只能本类） 缺省（本类，同一个包中的类） protected(本类，同一个包中的类，子孙类中） public（任意位置）
3.多态
多态是在继承、实现情况下的一种现象，表现为：对象多态、行为多态。
多态的前提：有继承/实现关系；存在父类引用子类对象；存在方法重写
注意： 多态是对象、行为的多态，Java中的属性 ( 成员变量 ) 不谈多态
好处：在多态形式下，右边对象是解耦合的，更便于扩展和维护；定义方法时，使用父类类型的形参，可以接收一切子类对象，扩张性更强、更便利
自动类型转换： 父类 变量名 = new 子类 ( ) ; 强制类型转换：子类 变量名 = ( 子类 ) 父类
4.final关键字
final关键字是最终的意思，可以修饰类、修饰方法、修饰变量。
修饰类：该类被称为最终类，特点是不能被继承了。
修饰方法：该方法被称为最终方法， 特点是不能被重写了。
修饰变量：该变量只能被赋值一次
final 修饰变量的注意事项
final 修饰基本类型的变量，变量存储的数据不能被改变； final 修饰引用类型的变量，变量存储的地址不能被改变，但地址所指向对象的内容是可以被改变的
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
