笔记

1. 存储单位

位（bit）:一个数字0或者一个数字1，代表一位。
字节（Byte）:每逢8位是一个字节，这是数据存储的最小单位
1 Byte = 8 bit

1 KB = 1024 Byte
1 MB = 1024 KB
1 GB = 1024 MB
1 TB = 1024 GB
1 PB = 1024 TB
1 EB = 1024 PB
1 ZB = 1024 EB

2. 命令提示符

启动：Win + R ,输入cmd
切换盘符 盘符名称
进入文件夹 cd 文件夹名称
进入多级文件夹 cd 文件夹1\文件夹2\文件夹3
返回上一级 cd …
直接回根路径 cd
查看当前内容 dir
清屏 cls(clear screen)
退出 exit

3. jvm、jre、jdk

Jvm(java virtual machine):虚拟机
Jre（java runtime environment）:java运行时的环境，包含jvm和运行时所需要的核心类库
Jdk(java development kit):是java程序开发工具包，包含jre和开发人员使用的工具

4. 数据类型转换
   当数据类型不一样时，将会发生数据类型转换

自动类型转换（隐式）

1. 特点：代码不需要进行特殊处理，自动完成
2. 规则：数据范围从小到大

强制类型转换（显式）
1. 特点：代码需要进行特殊的格式处理，不能自动完成
2. 格式：范围小的类型 范围小的变量名 = （范围小的类型） 原本范围大的数据；
注意事项：
1. 强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出。 小数转换成整数时发生向下取整。
2.byte/short/char 可以发生数学运算，如加法“+”。
3.byte/short/char在运算的时候，都会被首先提升成为int类型。
4.boolean类型不能发生数据类型转换。
5.Switch语句注意事项
1.多个case后面的数值不可以重复
2.switch后面小括号中只能是下列数据类型
基本数据类型：byte/short/char/int
引用数据类型：String字符串、enum枚举
3.switch语句格式可以很灵活：前后顺序可以颠倒，而且break语句还可以省略

“匹配哪一个case就从哪一个位置向下执行，直到遇到了break或者整体结束为止” switch穿透

6.for、while、do…while的区别
1.如果条件判断从来没有满足过，那么for循环和while循环将会执行0次；但是do。。。while至少会执行一次。
2.for循环的变量在小括号当中定义的时候，只有循环内部才可以使用。
3.while和do…while循环初始语句本来就在外面，所以出来循环之后还可以继续使用。

凡是次数确定的场景多用for循环；否则多用while循环。

7.方法、构造方法
方法其实就是若干语句的功能集合

注意：返回值类型固定写为void，这种方法只能够单独调用，不能进行打印调用或者赋值调用。

对于有返回值的方法，可以单独调用、打印调用或者赋值调用；
但是对于无返回值的方法，只能单独调用，不能打印调用或者赋值调用。

方法的重载（OverLoad）：多个方法的名称一样，但是参数列表不一样
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能。

方法重载与下列因素相关
1.参数个数不同
2.参数类型不同
3.参数的多类型顺序不同

与下列因素无关（错误写法，会报错）
1.与参数名称无关
2.与方法的返回值类型无关

构造方法
构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法、
格式：
Public 类名称（参数类型 参数名称）{
方法体
}

注意事项：
1.构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
2.构造方法不要写返回值类型，连void都不写
3.构造方法不能return一个具体的返回值
4.如果没有编写任何构造方法，那么编译器就会默认赠送一个构造方法，没有参数、方法体，什么事情都不做
5.一旦编写了至少一个构造方法，那么编译器将会不在赠送
6.构造方法也是可以进行重载的
重载：方法名称相同，参数列表不同。
8.数组
数组是一种容器，可以同时存放多个数据值

特点
1.数组是一种引用数据类型
2.数组当中的多个数据，类型必须统一
3.数组的长度在程序运行期间不可改变

数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值

1.动态初始化（指定长度）
2.静态初始化（指定内容）

动态初始化数组的格式：
数据类型[] 数组名称 = new 数据类型[数组长度]；

解析含义
左侧数据类型：也就是数组当中保存的数据，全都是统一的类型
左侧的中括号：代表我是一个数组
左侧数组名称：给数组取一个名字
右侧的new：代表创建数组的动作
右侧数据类型：必须和左边的数据类型保持一致
右侧中括号的长度：也就是数组当中，到底可以保存多少个数据，是一个int数字

静态初始化基本格式
数据类型[] 数组名称 = new 数据类型[] {元素1，元素2，元素3.。。。。。}；

省略格式
数据类型[] 数组名称 = {元素1，元素2.。。。。}；

注意事项
1.静态初始化没有直接指定长度，但是仍然会自动推算得到长度
2.静态初始化标准格式可以拆分成为两个步骤
3.动态初始化也可以拆分成为两个步骤
4.静态初始化一旦使用省略格式，就不能拆分成为两个步骤了

使用建议
如果不确定数组当中的具体内容，用动态初始化；否则，已经确定了具体内容用静态初始化

直接打印数组名称，得到的是数组对应的：内存地址哈希值

使用动态初始化数组的时候，其中的元素将会自动拥有一个默认值。规则如下：
如果是整数类型，那么默认为0；
如果是浮点类型，那么默认为0.0；
如果是字符类型，那么默认为’\u0000’；
如果是布尔类型，那么默认为false
如果是引用类型，那么默认为null。

注意事项
静态初始化其实也有默认值的过程，只不过系统自动马上将默认值替换成为了大括号当中的具体数值。

9.Java的内存划分为5个部分
1.栈（Stack）：存放的都是方法中的局部变量。方法的运行一定要在栈当中运行。
局部变量：方法的参数，或者是方法{}内部的变量
作用域：一旦超出作用域，立刻从栈内存当中消失
2.堆（Heap）:凡是new出来的东西，都在堆当中。
堆内存里面的东西都有一个地址值：16进制
堆内存里面的数据，都有默认值。规则
整数 默认为0
浮点数 默认为0.0
字符 默认为0.0
布尔 默认为’\u0000’
引用类型 默认为null
3.方法区（Method Area）:存储.class相关信息，包含方法的信息。

4.本地方法栈（Native Method Stack）:与操作系统相关。
5.寄存器（pc Register）:与CPU相关。

定义数组到改变数组元素值所发生的事情

10.类和对象

定义一个类，用来模拟“学生”事物。其中就有个两个组成部分：

属性（是什么）：
姓名
年龄
行为（能做什么）
吃饭
睡觉
学习

对应到java的类中
成员变量（属性）
String name;
int age;
成员方法（行为）
public void eat(){} //吃饭
public void sleep(){} //睡觉
public void study(){} //学习

注意事项
1.成员变量是直接定义在类当中的，在方法外面。
2.成员方法不要写static关键字

通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。
1.导包：也就是指出需要使用的类，在什么位置。
Import 包名称 . 类名称;
Import cn.itcast.day04.demo06.Student;
对于和当前类属于同一个包的情况，可以省略导包语句不写。

2.创建 格式：
类名称 对象名 = new 类名称（）；
Student stu = new Student();

3.使用，分为两种情况
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名（参数）
（也就是，使用谁，就用对象名点儿谁。）

注意事项
如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

当一个对象作为参数，传递到方法当中时，实际上传递进去的是对象的地址值。

11.封装
封装就是将一些细节信息隐藏起来，对于外界不可见

1.方法就是一种封装
2.关键字private也是一种封装

用private关键字将需要保护的成员变量进行修饰
一旦使用了private进行修饰，那么本类中仍然可以随意访问，但是超出了本类范围之外就不能再直接访问了。
12.匿名对象

创建格式:
New 类名称（）；

匿名对象只能使用唯一的一次，下次再用不得不再创建一个新对象。
使用建议：如果确定有一个对象只需要使用唯一的一次，就可以使用匿名对象。

13.字符串

字符串的特点
1.字符串的内容永不可变【重点】
2.正是因为字符串不可改变，所以字符串是可以共享使用的。
3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字符数组

创建字符串的常见3+1种方式
三种构造方法：
public String(); 创建一个空白字符串，不含有任何内容。
public String(char[] array); 根据字符数组的内容，来创建对应的字符串。
public Stirng(byte[] array); 根据字节数组的内容，来创建对应的字符串。
一种直接创建
Stirng str = “Hello”; 右边直接用双引号

注意：直接写上双引号，就是字符串对象。

== 是进行对象地址值的比较，如果确实需要字符串的内容比较，
public boolean equals(Object obj);参数可以是任何对象，只有参数是一个字符串并且内容相同的才会给true；否则返回false。
备注：
1.任何对象都能用Object进行接收
2.equals方法具有对称性，也就是a.equals(b)和b.equals(a)效果一样。
3.如果比较双方一个常量一个变量，推荐把常量字符串写在前面
推荐:“abc.equals(str)” 不推荐“str.equals(“abc”)"

public boolean equalsIgnoreCase(String str); 忽略大小写，进行内容比较。

String当中与转换相关的常用方法
public char[] toCharArray(); 将当前字符串拆分为字符数组作为返回值
public byte[] getBytes(); 获得当前 字符串底层的字节数组
public String replace(CharSequence oldString ,CharSequence newString); 将所有出现的老字符串替换成为新的字符串，返回替换之后的结果新字符串
备注：CharSequence 意思就是说可以接受字符串类型

14.Static关键字

一旦使用static修饰成员方法，那么这就成为了静态方法。静态方法不属于对象，而是属于类的。

注意事项
1.静态不能直接访问非静态
原因：在内存当中是先有的静态内容，后有的非静态内容。
“先人不知道后人，但是后人知道先人”
2.静态方法当中不能有this
This代表当前对象，通过谁调用的方法，谁就是当前对象。

注意：
根据类名称访问静态成员变量的时候，全程和对象就没关系，只和类有关系。

静态代码块

Public class 类名称{
Static {
//静态代码块的内容
}
}

特点：当第一次用到本类时，静态代码块执行唯一的一次
静态内容总是优先于非静态，所以静态代码块比构造方法先执行

用来一次性地对静态成员变量进行赋值

15.Arrays工具类和Math

Arrays常用的方法
Arrays.toString(); 转换为字符数组
Arrays.sort(); 按照默认格式排序

Math的常用方法
public static double abs(double num);获取绝对值
public static double ceil(double num);向上取整
public static double floor(double num);向下取整
public static long round(double num);四舍五入

16.继承

继承主要解决的问题就是：共性抽取
继承关系当中的特点：
1.子类可以拥有父类的“内容”
2.子类还可以拥有自己专有的内容

在继承关系中，“子类就是一个父类”。也就是说，子类可以被当做父类看待。
例如父类是员工，子类是讲师，那么“讲师就是一个员工”

定义父类的格式：（一个普通的类定义）
Public class 父类名称 {
//….
}

定义子类的格式：
Public class 子类名称 extends 父类名称 {
//…
}

在父类的继承关系中，如果成员变量重名，则创建子类对象时，访问有两种方式：

直接通过子类对象访问成员变量
等号左边是谁，就优先用谁，没有则向上找
间接通过成员方法访问成员变量
该方法属于谁，就先用谁，没有则向上找。

局部变量： 直接写成员变量
本类的成员变量 this.成员变量
父类的成员变量 super.成员变量

在父子类的继承关系中，创建子类 对象，访问成员方法的规则：
创建的对象是谁，就优先用谁，如果没有则向上找

注意事项：
无论是成员方法还是成员变量，如果没有都是向上找父类，绝对不会向下找子类

Java语言是单继承的——一个类的直接父类只能有唯一一个。
Java语言可以多级继承——我父亲还有一个父亲，也就是爷爷。
一个子类的直接父类是唯一的，但是一个父类可以拥有很多个子类：可以有很多个兄弟姐妹，生二胎

17.重写（Override）
概念：在继承关系当中，方法的名称一样，参数列表也一样. 覆盖、覆写

重载（Overload）:方法的名称一样，参数列表不一样

方法的覆盖重写特点：创建的是子类对象，则优先用子类方法。

方法覆盖重写的注意事项：
1.必须保证父子类之间方法的名称相同，参数列表也相同。
@Override；写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

2.子类方法的返回值必须【小于等于】父类方法的返回值范围。
小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类）。

3.子类方法的权限必须【大于等于】父类方法的权限修饰符。
小扩展提示:public > protected > (default) > private
备注（default)不是关键字default,而是什么都不写，留空

父类构造方法的访问特点
1.子类构造方法当中有一个默认隐含的”super()”调用，所以一定是先调用父类构造，后执行的子类构造。
2.子类构造可以通过super关键字来调用父类重载构造
3.super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造。

18.super关键字、this关键字
super用法
1.在子类的成员方法中，访问父类的成员变量
2.在子类的成员方法中。访问父类的成员方法
3.在子类的构造方法中，访问父类的构造方法。

Super关键字用来访问父类内容，而this关键字用来访问本类内容。

this小结
1.在本类的成员方法中，访问本类的成员变量
2.在本类的成员方法中，访问本类的另一个方法。
3.在本类的构造方法中，访问本类的另一个构造方法。
3.1 this（…）调用也必须是构造方法的第一个语句，唯一一个。
3.2 super和this两种构造调用，不能同时使用。

19.抽象
如果父类当中的方法不确定如何进行{}方法体实现，那么这就应该是一个抽象方法。

如何使用抽象类和抽象方法
1.不能直接new创建抽象类对象
2.必须用一个子类来继承抽象父类
3.子类必须覆盖重写抽象父类当中所有的抽象方法。
覆盖重写（实现）：子类去掉抽象方法的abstract关键字，然后补上方法体大括号。
4.创建子类对象进行使用。

一个抽象类不一定含有抽象方法，只要保证抽象方法所在的类是抽象类，即可。

20.接口
接口就是多个类的公共规范
接口是一种引用数据类型，最重要的内容就是其中的抽象方法

接口的定义：
public interface 接口名称 {
//接口内容
}

备注：换成了关键字interface之后,编译生成的字节码文件仍然是：.java.class

如果是java 7，那么接口中可以包含的内容有：
1.常量
2.抽象方法

如果是java 8，还可以额外包含有：
3.默认方法
4.静态方法

如果是java 9，还可以包含有：
5.私有方法

一、接口中的抽象方法
接口使用步骤
1.接口不能直接使用，就必须有一个“实现类”来“实现”该接口。
抽象方法;
[public] [abstract] 返回值类型 方法名称（参数列表）；
注意：实现类必须覆盖重写接口所有的抽象方法，除非实现类是抽象类

格式：
public class 实现类名称 implements 接口名称 {
//、、、、
}

2.接口的实现类必须覆盖重写（实现）接口中所有的抽象方法
3.创建实现类的对象，进行使用

注意事项：
如果实现类并没有覆盖重写接口中所有的抽象方法，那么这个实现类自己就必须是抽象类

二、接口中的默认方法
从java8开始，接口里允许定义默认方法

public default 返回值类型 方法名称（参数列表）{
方法体
}

备注：接口当中的默认方法，可以解决接口升级的问题、函数模型的拼接、浪么大表达式

1.接口的默认方法，可以通过接口实现类对象，直接调用。
2.接口的默认方法，也可以被接口实现类进行覆盖重写。

三、接口中的静态方法
从java8开始允许定义静态方法

Public static 返回值类型 方法名称（参数列表）{
方法体
}

不能通过接口实现类的对象来调用接口当中的静态方法，通过接口名称直接调用其中的静态方法

四、接口的私有方法
从java9开始，接口当中允许定义私有方法
注意：private的方法只有接口自己才能使用，不能被实现类或别人使用。

1.普通私有方法：解决多个普通方法之间重复代码的问题
Private 返回值类型 方法名称（参数列表）{
方法体
}

2.静态私有方法：解决多个静态方法之间重复代码的问题
Private static 返回值类型 方法名称（参数列表）{
参数列表
}

五、接口当中也可以定义“成员变量”，但是必须用public、static、final三个关键字修饰，从效果上看，这其实就是接口的【常量】。
Public static final 数据类型 常量名称 = 数据值；

备注：一旦使用final键字进行修饰，说明不可改变

注意事项
1.接口当中的常量，可以省略public static final,注意：不写也照样是这样。
2.接口当中的常量，必须进行赋值，不能不赋值。
3.接口中常量的名称，使用完全大写的字母，用下划线进行分隔。（推荐命名规则）

使用接口的时候，需要注意：
1.接口是没有静态代码块或者构造方法的。
2.一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。
格式：
public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB{
//覆盖重写所有抽象方法
}

3.如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
4.如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类
5.如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
6.一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先用父类当中的方法。

接口与接口之间的多继承
1.类与类之间是单继承的。直接父类只有一个。
2.类与接口之间是多实现的，一个类可以实现多个接口。
3.接口与接口之间是多继承的。

注意事项：
1.多个父接口当中的抽象方法如果重复，没关系
2.多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，而且带着default关键字。

21.多态
extends、继承或者implemts实现，是多态的前提

多态指的是对象！也就是对象的多态。

多态性的体现：父类引用指向子类对象

格式：
父类名称 对象名 = new 子类名称（）；
或者：
接口名称 对象名 = new 实现类名称（）；

成员变量：编译看左边，运行还看左边
成员方法：编译看左边，运行看右边

22.对象的向上转型、向下转型

1.对象的向下转型，其实就是多态写法
格式：父类名称 对象名 = new 子类名称（）； Animal animal =new Cat();
含义：右侧创建一个子类对象，把它当做父类来看待使用。创建了一只猫，当做动物看待。
注意事项：向上转型一定是安全的。从小范围转向了大范围，从小范围的猫，向上转换成为更大范围的动物。

类似于：
Double num = 100;//正确，int double,自动类型转换。

2.对象的向下转型，其实就是一个【还原】的动作。
格式:子类名称 对象名 = （子类名称）父类对象；
含义：将父类对象，【还原】成为本来的子类对象。

Animal animal = new Cat();//本来是猫，已经被当做动物了，还原回来成为本来的猫

注意事项：
.必须保证对象本类创建的时候，就是猫，才能向下转型成为猫。
b.如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。
ClassCastException（类转换异常）
类似于： int num = (int) 10.0;//可以 int num = (10.5);//不可以，精度损失

关键字instanceof
对象 instanceof 类名称
得到一个Boolean值结果，也就是判断前面的对象能不能当做后面类型的实例。

23.关键字final
Final关键字代表最终、不可改变的

常见四种用法
1.可以用来修饰一个类
Public final class 类名称{
//…
}
含义：当前这个类不能有任何的子类。（太监类）
注意：一个类如果是final的，那么其中所有的成员方法都无法覆盖重写（因为没有儿子）

2.可以用来修饰一个方法
当final关键字用来修饰一个方法的时候，这个方法就是最终方法，也就是不能被覆盖重写、
格式：
修饰符 final 返回值类型 方法名称（参数列表）{
方法体
}
注意事项：对于类、方法来说，abstract关键字和final关键字不能同时使用，因为矛盾。

3.可以用来修饰一个局部变量
“一次赋值，终生不变”
对于基本类型来说，不可改变的是变量当中的数据不可改变
对于引用类型来说，不可改变的是变量当中的地址值不可改变

4.还可以用来修饰一个成员变量
对于成员变量来说，如果使用final关键字修饰，那么这个变量也照样是不能改变
1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了
2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。二者选其一
3.必须保证类当中所有重载的构造方法，都最终会对final的成员变量进行赋值。