Java小白兔
命令提示符（cmd）
启动 win+R，cmd回车
切换盘符 盘符名称：
进入文件夹 cd 文件夹名称
进入多级文件夹 cd 文件夹1\文件夹2\文件夹3
返回上一级 cd..
直接回根路径 cd \
查看当前内容 dir
清屏 cls(clear screen)
退出 exit
ip ipconfig
Java程序开发三个步骤
1.Java源程序(记事本)
2.编译(javac)
3.运行(java (去掉后缀名))(随后生成字节码文件)
常量
1.字符串常量（双引号，中间内容可以为空）
2.整数常量
3.浮点数常量
4.字符常量（char单引号，中间有且仅有一个字符，没有不行）
5.布尔常量
6.空常量（不能直接用来打印输出）
数据类型：
1.基本数据类型
整数型 byte short int long
浮点型 float double
字符型 char
布尔型 boolean
注意：（1）.字符串不是基本类型，而是引用类型。
（2）.浮点型可能只是一个近似值，并非精确的值。
（3）.数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但是float是4字节，long是8字节。
（4）.浮点数当中默认类型是double，如果一定要用float，需要加上一个F，如果是整数，默认为int类型，若一定要用long需要加上L
2.引用数据类型
数据类型转换
自动类型转换（隐式）
1.规则：数据范围从小到大
2.特点：自动完成，不需要特殊处理。
例如：long num=100；//将右侧int变量赋给左侧long变量进行存储。
强制类型转换（显式）：
1.格式：范围小的类型 范围小的变量名 = （范围小的类型）原本大的数据
2.需要特殊处理，不能独自完成。
注意:
1.强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。
2.byte/short/char这三种类型都可以进行数学运算，例如加法
3.byte/short/char这三种类型在运算的时候都会首先被提升为int类型再计算。
byte num1 = 40；
byte num1 = 50；
int result = num1 + num2；//byte result = （byte）num1 + num2；
4.对于byte/short/char这三种类型来说，如果右侧赋的值没有超过范围，java编译器会议自动补上（byte）（short）（char）；若超过了，报错。E：char zifu = 65；//结果为A。
5.boolean类型不能进行数据类型转换。
6.编译器的常量优化：右侧表达式中全都是常量，没有任何变量，则编译器javac将会直接将若干个常量表达式计算得结果。E：short result = 5 + 8；//13；
数字和字符的对照关系表（编码表）：
ASCII码表：美国信息交换标准码America Standard Code For Information Interchange
Unicode码表:万国码。
48--‘0’
65--‘A’
97--‘a’
算数运算
注意事项：
1.一旦运算当中有不同类型数据，结果将会是数据类型范围大的那个。E：int + double --double + double
四则运算中的+
1.数值
2.char会被提升为int 类型（ASCII、Unicode）
3.对于字符串String来说，加号代表字符串连接操作，任何数据类型和字符串连接时，结果都会变成字符串。（但注意优先级。小括号中间的优先算）
自增自减运算符
混合运算A.前++，先加后用
B.后++，先用后加
……
赋值运算
运算符
A.基本赋值运算符 =
B.+= a += 1 ---- a = a+1
-= 、 *= 、 /= 、 %=
比较运算
运算符：>、<、>=、<=、==（相等）、!=
注意事项：
1.比较运算符的结果一定是已给boolean值
2.如果要进行多次比较，不能按照数学中那样连着写。
逻辑运算
运算符：与（并且）&&、或（或者）||、非（取反）！
tip：1<x<3应该拆成两部分，然后用与运算符连接起来。
三元运算符------需要三个数据才可以进行操作的运算符
格式：数据类型（int） 变量名称（result） = 条件判断 ？ 表达式A ： 表达式B；
流程：首先判断条件是否成立
若成立则result = A；若不成立，则result = B；
注意：
1.当用三元运算符赋值变量时，A和B都要符合左侧变量的变量类型。
2.三元运算符的结果必须被使用。（要么给变量，要么打印出来）
方法的定义（方法其实就是若干个语句的功能集合）
完整格式：
修饰符 返回值类型 方法名称（参数类型 参数名称，...【有多个参数，用逗号隔离】）{ 方法 return 返回值； }
return：停止当前方法，并带着返回值回到调用处。
一个方法中可以有多个return语句，但必须在同一时间内 只有一个可以发生。
返回值：必须和方法头中的返回值类型保持对应。
注意：
1.方法定义的先后顺序无所谓
2.方法不能嵌套
3. 定义好之后要调用才有效果
调用： 方法名（）；
方法调用的三种方式：
1.单独调用：方法名称（参数）；
2.打印调用：System.out.println(方法名称)；
3.赋值调用：数据类型 变量名称 = 方法名称（参数）
注意：返回值类型void只能单独调用，其他两种则不行
控制语句
A.判断语句
B.选择语句switch
注意：1.多个case后面数值不能重复
2.小括号中的数据类型：基本数据类型:byte
、short 、char 、int。 引用数据类型：String、enum枚举
3.switch语句格式很灵活，break语句可以省略，匹配哪一个就向下执行，直到碰到break或整体结束。
C.循环语句
基本组成部分
1.初始化语句
2.条件判断
3.循环体
4.步进语句
(1)for循环
(2)while循环：标准格式：while(条件判断){循环体}
扩展格式：初始化语句；
while(条件判断){循环体；步进语句}
(3)do while循环：标准格式：do{循环体}while（条件判断);
扩展格式：初始化语句；
do{循环体；步进语句}while(条件判断)；
~~三种循环的区别；
1.若循环未满足过，for 循环和while循环将不会执行，但do-while循环要无条件执行一次。
2.for循环的变量在小括号中定义，只能在大括号内部使用，而while和do-while初始化变量语句本身就在外部，所以大括号之外还可以用。
break关键字
1.用在switch语句中，一执行，整个switch语句立刻结束
2.还能用在循环语句中，一执行，整个循环立即结束，打断循环
——————————————次数确定的话，多用for，其他多用while
continue语句：一旦执行，跳过本次循环，开始下一次循环（如果还有的话）
死循环标准格式while（true）{ 循环体 }
有参和无参
有参：小括号中有内容，需要知道一些数据条件才可以完成任务
无参：小括号中没有内容，你需要任何数据条件，就能独立完成任务
方法重载
数组
特点：1. 数组是一种引用数据类型
- 数组当中的多个数据必须同一类型
- 数据的长度在程序运行期间不改变
初始化：
- 动态初始化（指定长度）
数据类型【】 数组名称 = new 数据类型【数组长度】
- 静态初始化（指定内容）
标准格式：数据类型【】 数组名称 = new 数据类型【】{ 元素1，元素2.... }
++省略格式
数据类型【】 数组名称 = { }；
注意：1.静态初始化中大括号中的元素自动推算长度。
2.两种方式的标准格式都可以分为两步。但静态初始化的省略格式不行。
3.直接打印数组名称，得到的是数组对应的内存地址哈希值。
Java的内存划分为五部分
- 栈（stack）： 存放的都是方法中的 局部变量 。方法运行一定要在栈中运行。
局部变量：方法的参数，（方法内部的变量）
作用域： 一旦超出作用域，立刻从栈中消失。
- 堆（Heap）：凡是new出来的东西，都在堆里
堆内存里面的东西都有一个地址值：16进制
里面数据都有都有默认值（同初始化注意4）
- 方法区（Method Area）：存储.Class相关信息，包含方法的信息
- 本地方法栈（Native Method Stack）；与操作系统有关
- 寄存器：与cpu有关
数组索引越界异常
ArrayIndexOutOfBoundsException
原因：索引编号写错了。
空指针异常
所有的引用类型变量，都可以赋值为一个null值，但是代表其中什么都没有。
如果只赋值了一个null，没有进行new创建，就会有空指针异常：NullPointerException
遍历数组和反转数组
初始化语句：int min = 0，max = array.length - 1；
条件判断：min<max;
步进表达式：min++，max--
循环体：用第三个变量倒手
要解决方法中 产生多个数据结果数据进行返回，那么就要用数据作为一个返回值类型即可。
任何数据类型都可以作为方法的返回值类型和参数类型。
面向过程：当需要实现一个功能的时候，每一个功能都要亲自去做，详细处理每个细节。
强调步骤。
面向对象：当需要实现一个功能的时候，不关心具体步骤，而是找个具有该功能的帮手，帮 忙做事。俗称偷懒。强调对象（有能力帮助的对象）。
类
用来刻画描述一个事物，包括它的属性和行为。
对象
一类事物的具体表现，是类的一个实例，包含类中所具有的所有属性和行为。
·类是一类事物的描述，是抽象的（手机设计图纸）
·对象是一类事物的实例，是具体的（手机）
·类是对象的模板，对象是类的实体
实例化就是创建
类的定义
注意事项：
- 成员变量是直接定义在类当中的，在方法外边
- 成员方法不要写static关键字
对象的创建
通常情况下，一个类不能直接使用，需要根据类创建一个对象，才能使用。
步骤
- 导包：指出所用的类在什么位置
import 包名称.类名称；
对于和当前类属于同一个包的情况，import可省略
只有java.lang包下单内容不需要导包，其他的包都需要import
- 创建
格式：类名 对象名=new 类名（）；
·匿名对象：只能使用一次，下次使用要再创建一个，如果能确定一个对象只使用一次，就可以使用匿名。
- 使用
【1】成员变量：对象名.成员变量名
【2】成员方法：对象名.成员方法名（参数）
使用对象类型作为方法的参数
当一个对象作为参数传递到方法中时，实际上传进去的是地址值。
使用对象类型作为方法的返回值
成员变量和成员变量
- 定义的位置不一样
局部变量在方法内部，而成员变量在外部，直接在类当中。
- 作用范围不一样
局部变量出了方法不可用，但成员变量整个类都可以用。
- 默认值不一样
局部变量没有默认值，想使用必须手动赋值。成员变量没有赋值的话会有默认值，和数组规则一样。
- 内存位置不一样 （了解）
局部变量位于栈内存，而成员变量位于堆内存
- 生命周期不一样（了解）
局部变量随着栈的产生和消失，而成员变量跟随对象的诞生和消失（垃圾回收站）。
注意：方法的参数是局部变量。但直接打印出来不会报错，因为在方法调用的同时，参数必然会被赋值。
面向对象的三大特征
封装
封装性在Java中的体现：
1.方法就是一种封装
2.关键字private也是一种封装（private保护成员变量，防止不合理的数值输入）
原因：Private在本类中任意访问，但超出本类就不可以直接访问了。 这就要设置间接访问，
方法：就是定义一对Getter/Setter方法，命名必须叫setXxx或者是getXxx，而boolean类型的getter方法要写成isXxx
注意：但对于Getter来说不能有参数，返回值类型和成员变量对应，而Setter不能有返回值，参数类型和成员变量一致。
封装就是将一些细节信息隐藏起来，对外界不可见。（比如改变方法内部的写法不影响调用）
this关键字
当方法的局部变量和类的成员变量重名时，要调用成员变量，this.成员变量名
this在方法里面，通过谁调用的方法谁就是方法中this。
构造方法（用来专门创建对象，比如用new时就是在调用构造方法）
格式：public 类名称（参数类型 参数名称）{ 方法体 }
- 没有编写任何构造方法，编译器自动送一个构造方法，没有参数，方法体，什么都不用做。
- 一旦编写了一个构造方法，编译器便不再赠送。
- 构造方法也可以重载。
Scanner（需要键盘输入）
.nextInt（） .next（）
Random
Int num = r.nextInt（3）；代表的是【0，3），左闭右开。
Arraylist
虽然数组的长度不可以发生改变，但Arraylist集合的长度是可以改变的。
有一个<>表示泛型，也就是统一装的什么类型（可直接写入引用类型，而不可以是基本类型）。
而如果要向ArrayList中存储基本类型数据，必须要使用基本类型对应的“包装类”,把包装类写在<>中。
byte Byte
short Short
int Integer
long Long
float- Float
double Double
char Character
boolean Boolean
- 对于ArrayList集合来说，直接打印的是内容而不是地址值。若内容为空则打印出 【】。
常用方法：
String
字符串的常量池
程序当中直接写上的双引号 字符串，就在字符串量池中。
注意：
- 对于引用类型来说，==进行的是地址值的比较。
- 对于基本类型来说，==进行的是数值的比较。
- 双引号直接写的字符串在常量池当中，new的不在池中。
字符串的内容比较
两种方法：1 . public boolean equals （Object obj），参数可为任何对象。
注意：(1)任何对象都能用Object进行接收。
(2)equals方法具有对称性
(3)如果比较双方一个常量一个变量，最好把常量字符串写在前面，避免变量空值报错。
2.public boolean equalsIgnoreCase(String string)忽略大小写内容比较（只限英文字母。）
注意事项：
Split 方法的参数其实是一个正则表达式。
如果按照英文句点“.”切分，必须写“\\ .”
Static
一旦使用了static关键字，那么内容不再属于对象自己，而是属于类的，所以凡是本类的对象，都共享一份。
一旦使用static修饰成员方法，那它就是静态方法，不属于对象属于类。
如果没有static，必须要创建对象，然后通过对象才能使用它。
如果有static，就不用创建对象，直接用类名就能调用。
对于静态方法来说，可以通过对象名及逆行调用，但推荐用类名称进行调用。
本类中的静态方法，可以省略类名称。
注意：
1.静态不能直接访问非静态（因为先有静态，后又的非静态）
2.静态方法中不能写this。(因为静态方法都不用对象，this指当前对象)
静态代码块
public class 类名称{ static { } }
特点：当第一次用到本类时，静态代码块执行唯一的一次。
用途：用来一次性地对成员变量进行赋值。
Arrays
注意：
1.若是数值，sort默认按升序从小到大排。
2.如果是字母，默认按字母升序排。
Math
继承
在继承的关系中，”子类就是一个父类”。也就是，子类可以被当作父类看待。
是关系is-a；
在父子类的继承关系中，如果变量重名，创建子类对象时，有两种方式：
- 直接通过子类对象访问成员变量(super.变量名)
等号左边是谁，就优先用谁，没有则向上找。
- 间接通过成员方法访问成员变量
该方法属于谁，就优先用谁，没有则向上找。
在父子类的继承关系中，创建子类对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，没有就向上找。
重写/覆盖（override）:方法名称一样，参数列表也一样。
重载（overlode）:法名称一样，参数列表不一样。
方法覆盖重写注意事项：
- 必须保证父子类之间方法的名称相同，参数列表也得相同。
@override：写在方法前面，用来检测是不是有效的正确覆盖重写。
如果返回值或者权限修饰符不一样，则：
- 子类方法的返回值必须【小于等于】父类方法的返回值范围。
注意：Java.lang.Object是所有类的公共最高父类。
- 子类方法的权限必须【大于等于】父类方法的权限修饰符。
注意：public>protect>(default)>private
default指的是什么都不写。
继承构造方法
- 子类构造方法中当中有一个默认隐含的“super（）”(无参)调用，所以一定是先
用父类构造，再执行子类构造。
- 子类构造方法中可以通过super关键字来调用父类重载构造。
- super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类调用多 个super构造
super的用法
this的用法
- 在本类的成员方法中，访问本类的成员变量。
- 再本类的成员方法中，访问本类的另一个成员方法。（this.方法名（））
- 再本类的构造方法中，访问本类的另一个构造方法。
3注意：A.this(...)调用也必须是构造方法的第一个语句，唯一一个。
B.super this 两种构造调用不能同时使用
抽象方法
如果父类当中的方法不确定如何进行{}方法体的实现，那就是抽象方法。
抽象方法没有大括号，直接分号结束。
如何使用出抽象类和抽象方法：
- 不能直接创建new抽象类对象。
- 必须用一个子类来继承抽象父类。
- 子类必须覆盖重写抽象父类中的所有的抽象方法。
覆盖重写：子类去掉抽象方法中的abstract关键字，然后补上大括号。
- 创建子类对象进行使用。
接口
接口是一种引用数据类型，最重要的内容是其中的抽象方法。
定义接口：public interface 接口名称{ }
接口中内容包括：常量，抽象方法，默认方法，静态方法。（Java8，若是Java9，还有 私有方法）
接口使用方法
- 接口不能直接使用，必须有一个“实现类”来“实现”该接口。
格式：public class 实现类名称 implements 接口名称{ }
- 接口的实现类必须覆盖重写（实现）所有的抽象方法。
实习：去掉abstract关键字，加上方法体大括号。
- 创建实现类对象
如果实现类并没有覆盖重写接口中的所有抽象方法，那么这个实现类自己就必须是抽象类。
注意事项：
- 接口是没有静态代码或者构造方法的。
- 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
- 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重 写一次。
- 如果实现类所实现的多个接口中，存在重复的默认方法，那么实现类一定要对 冲突的默认方法进行覆盖重写。
5.一个类如果直接父类中的方法和接口中的默认方法发生了冲突，优先使用父类中 的方法。
接口默认方法：解决接口升级的问题
Public default 返回值类型 方法名称（参数列表）{方法体}
- 接口的默认方法，可以通过接口实现类对象，直接调用。
- 接口的默认方法，也可以被接口实现类进行覆盖重写。
接口静态方法
public static 返回值类型 方法名称（参数列表）{方法体}
注意：不能通过接口实现类的对象来调用接口当中的静态方法。
而是直接通过接口名称来直接调用。
接口私有方法：解决两个默认方法之间的重复代码的问题。(不能让实现了类使用，应该是 私有的)
从Java9 开始
- 普通私有方法：解决多个默认代码之间的重复代码问题。
private 返回值类型 方法名称（参数列表）{ 方法体 }
- 静态私有方法：解决多个静态方法之间重复代码问题。
private static 返回值类型 方法名称（参数列表）{ 方法体 }
接口中的成员变量
（public static final ） 数据类型 常量名称 = 数据值
注意：1.接口当中的常量，可以省略public static final 不写也是这样（灰色的关键字）。
2.接口当中的常量，必须赋值。
3.接口当中的常量名称，是完全大写的字母，用下划线分开各个单词。
接口之间的多继承
【1】类与类之间是单继承的，直接父类只有一个。【2】类与接口之间是多继承的，一个类可以实现多个接口。【3】而接口与接口之间是多继承的。
注意；
- 多个父接口当中的抽象方法如果重复没有影响。
- 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重 写【default 不能省略】
面向对象的多态性
一句话：父类引用指向子类对象。（子类对象有父类的属性，就比如小华是学生，小华 也是人，他有多种形态，就是对象的多态性）
格式：
父类名称 对象名 = new 子类名称（）；
接口名称 对象名 = new 实现类名称（）；
使用多态性的好处
无论右边new的时候换成哪个对象，等号左边调用方法不会变化。
向上转型
但向上转型也有弊端，就是不能调用子类特有的方法。
向下转型
注意事项：
必须保证对象本来创建的时候就是猫，才能向下转型成为猫。
访问成员变量（和继承相似）
- 直接通过对象名称访问成员变量，看等号左边是谁，就优先用谁，没有则向上找。
- 直接通过成员方法访问成员变量， 看该方法属于谁，就优先用谁，没有则向上找。 （编译看左，运行看右）。
final 修饰一个类
不能拥有任何子类。其中所有的成员方法都无法进行覆盖重写。
final 修饰一个方法
不能再被覆盖重写。对于类和方法来说，abstract和final关键字不能同时使用，矛盾。
final 修饰一个变量
对于基本类型来说，不可变的说的是变量中的数据不可变。
对于引用类型来说，不可变的说的是变量中的地址值不可变。
final 修饰一个变量：成员变量有默认值，所以加上final后手动赋值，不再给默认值
成员内部类
格式：修饰符 class 外部类名称{
修饰符 class 内部类名称{
//.......
}
//.......
}
注意：内用外，任意访问，外用内，需要内部类对象。
使用方法
- 间接方式：在外部类的方法当中，使用内部类，main只是调用外部类的方法。
- 直接方式：外部类名称. 内部类名称 对象名 = 外部类名称(). new 内部类名称()；
内部类访问外部类成员变量
外部类名称 . this . 外部类成员变量名。
局部内部类
定义在一个方法内部，超出方法范围之外便不能用了。
定义类时的权限修饰符规则
- 外部类：public/（default）
- 成员内部类：public/protected/（default）/private
- 局部内部类：什么都不写
匿名内部类
如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，那么就可以省略掉定义类的过程，而使用匿名内部类的方法。
格式：接口名称 对象名称 = new 接口名称（）{ //覆盖重写所有抽象方法 }
注意：
- 匿名内部类，在【创建对象】的时候，只能使用唯一的一次。
（接口名称 对象名称 = new 接口名称（）{ //覆盖重写所有抽象方法 } )
如果希望多次创建对象，而且类的内容一样的时候，就必须单独定义实现类了。
- 匿名对象，在【调用方法】的时候，只能使用唯一的一次。
(new 接口名称（）{ //覆盖重写所有抽象方法 } )
如果希望同一个对象调用多次方法，必须给对象起个名字。
- 匿名内部类是省略了【实现类/子类名称】，但匿名对象是省略了对象名称
