day01：
1.代码块：
1.在Java中，使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块(多线程讲解)；
2.局部代码块：在方法中出现，限定变量生命周期，及早释放，提高内存利用率；
3.构造代码块：在类中方法外出现，多个构造方法方法中相同的代码存放到一起，每次调用构造都执行，并且在构造方法前执行；
4.静态代码块：在类中方法外出现，加了static修饰在类中方法外出现，并加上static修饰；用于给类进行初始化，在加载的时候就执行，并且值执行一次;
//优先级:
静态代码块 > 构造代码块 > 构造方法
2.继承 ：
1.定义：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
2.格式：class 子类 extends 父类{}
3.特点：
1.Java只支持单继承，不支持多继承。一个类只能有一个父类，不可以有多个父类。
2.Java支持多层继承(继承体系)
4.好处与坏处：
1.提高了代码的复用性，多个类相同的成员可以放到同一个类中；
2.提高了代码的维护，如果功能的代码需要修改，修改一处即可；
3.让类与类之间产生了关系是多态的前提 其实这也是继承的一个弊端：类的耦合性很强；
4.原则：满足低耦合，高内聚的开发原则；
5.注意事项：
1.子类只能继承父类所有非私有的成员(成员方法和成员变量) 其实这也体现了继承的另一个弊端：打破了封装性
2.子类不能继承父类的构造方法，但是可以通过super(后面讲)关键字去访问父类构造方法。
3.不要为了部分功能而去继承 我们到底在什么时候使用继承呢? 继承中类之间体现的是：”is a”的关系。
3.super与this的区别：
1.super的用法和this很像
this代表当前类的对象的地址值； super代表父类存储空间的标识；
访问成员变量 ：this.成员变量, super.成员变量;
访问构造方法 ：this(),super();
this(xxx),super(xxx);
访问成员方法 ：this.成员方法(),super.成员方法();
4.继承中的构造方法：
两个问题：
1.为什么子类中所有的构造方法默认都会访问父类中空参数的构造方法？
原因：子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。每一个构造方法的第一条语句默认都是：super()；
2.如果父类中没有构造方法，该怎么办呢?
原因：通过手动在父类添加无参构造方法
子类通过super去显示调用父类其他的带参的构造方法
子类通过this去调用本类的其他构造方法
本类其他构造也必须首先访问了父类构造一定要注意： super(…)或者this(….)必须出现在第一条语句；否则，就会有父类数据的多次初始化；
5.继承中成员变量的关系：
案例演示：子父类中同名和不同名的成员变量
结论：1.在子类方法中访问一个变量：
首先在子类局部范围找；
然后在子类成员范围找；
最后在父类成员范围找(肯定不能访问到父类局部范围)；如果还是没有就报错。
6.继承中成员方法的关系：
案例演示 子父类中同名和不同名的成员方法
结论： 通过子类对象去访问一个方法
首先在子类中找
然后在父类中找
如果还是没有就报错。(不考虑父亲的父亲…)
day02：
1.方法重写与方法重载：
方法重写的概念：子类和父类出现了一模一样的方法声明，子类的方法将父类的功能覆盖；方法重载的概念：方法名相同，参数列表不同（数据类型不同，参数个数不同），与返回值无关；
2.方法重写的规则：
一、子类中是否可以定义和父类相同的方法？
方法重写的原则：
1.参数列表必须完全与被重写的方法相同
2.返回值的类型必须完全与被重写方法的返回类型相同；（备注：这条信息是标准的重写方法的原则，但是在java1.5版本之前返回值类型必须一样，之后的java版本放宽了限制，返回值类型必须小于或者等于父类方法的返回值类型）现在，子类返回类型小于或等于父类方法返回类型
3.访问权限不能比父类中被重写方法的访问权限更低。例：父类方法声明为public，子类重写后方法就不能声明为project
4.父类的成员方法只能被它的子类重写
5.声明为final的方法不能被重写
6.声明为static的方法不能被重写，但是能够再次声明
7.子类和父类在同一个包中，那么子类可以重写父类的所有方法，除了声明为private和final的方法
8.子类和父类不在同一个包中，那么子类只能重写父类的声明为public和protected的非final方法
9.重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以
10构造方法不能被重写
11.如果不能继承一个方法，则不能重写这个方法
3.Final关键字：
1.概念：final表示最终的，不改变的，被final修饰的成员方法不能被子类重写；
2.特点：
可以修饰类:该类不能被继承；
可以修饰成员变量:此时常量是变量;1.如果常量是基本数据类型，变量值不能改变；
2.如果变量是引用数据类型，则被final修饰，对象名不能在开辟堆内存空间；
可以修饰成员方法:该方法不能被重写；
4.多态：
1.概念：对于一个事物，在不同时刻表现出来的不同状态。
2.成员方法特点：
对于F f = new Zi();
成员变量:编译看左边，运行看左边
成员方法: 编译看左边，运行看右边
静态方法: 编译看左边，运行看左边
构造方法：存在继承（分层初始化），先父类初始化后子类初始化
3.好处：
1.提高代码的复用性；（继承）
2.提高了代码的扩展性（多态）
4.坏处：不能访问子类的特有功能；
解决思路：1.创建子类的具体对象来访问子类的功；但占用内存资源；
2.向下转型：将父类引用强转为子类引用；
格式：子类名 对象名 = （子类名）父类的引用；------------>向下转型；
5.多态的前提：
1.必须存在继承关系，无继承无多态；
2.必须有方法重写，子类继承父类，将父类的功能覆盖掉，使用子类具体的功能；
3.父类引用子类对象：
格式： 父类名 对象名 = new 子类名（）；------------>向上转型；
day03：
1.抽象类（abstract）：
1.概念：在一个方法体中只声明，没有用具体的实物表现出来；
2.特点：
1. 如果一个类中有抽象方法，那么这个类是抽象类；
2. 如果一个类是抽象类，那么这个类不一定有抽象方法；
3.抽象类不能实例化，需要通过子类进行实例化，父类引用子类对象；----------抽象类多态
4.抽象类必须强制子类完成的事情，即将抽象类中的所有抽象方法重写；
5.抽象类的抽象方法：用于限定子类必须完成某些动作；
6.抽象类的非抽象方法：用于提高代码的服用性；
3.格式:
抽象类和抽象方法必须用abstract关键字修饰
abstract class 类名 {}
public abstract void eat();
2.抽象类的成员特点：
抽象类可以修饰类，成员方法；
1.成员方法: 可以定义抽象方法，也可以定义非抽象方法
2.成员变量: 可以定义常量，也可以定义变量；
3.构造方法： 有构造方法，但是不能实例化，主要用于子类访问父类数据的初始化；
3.与abstract冲突的关键字：
1.final , private,static关键字冲突；但与public，protect可以使用；
4.接口
1.概念（interface）:对事物的一种扩展功能（经过后天学习或者培训）；
2.格式： class 类名 implements 接口名 {}
3.成员特点：
成员变量：只能是常量，默认修饰符 public static final；
构造方法：没有，因为接口主要是扩展功能的，而没有具体存在；
public interface 接口名称 { }
成员方法：只能是抽象方法，默认修饰符 public abstract
5.面试题：
1.抽象类与接口的区别：
成员区别
抽象类：变量,常量;有抽象方法;非抽象方法
接口 ： 常量;抽象方法
关系区别
类与类：继承，单继承；
类与接口：实现，单实现，多实现；
接口与接口：继承，单继承，多继承
设计理念区别
抽象类：被继承体现的是：”is a”的关系。 共性功能
接口： 被实现体现的是：”like a”的关系。扩展功能
6.方法形式参数与方法返回值：
1. 方法形式参数：
类：需要的是该类的对象
抽象类：需要的是该抽象类的子类对象
接口：需要的是接口的子实现类对象
2.方法返回值：
类：其实返回的是该类的对象
抽象类：其实返回的是该类的子类对象
接口：其实返回的是该接口的子实现类对象
day04：
1.包：
1.概念：就是文件夹；
2.分类：
单级包：单个目录
多级包：多个文件夹使用.隔开；
3.划分：按功能或者模块划分；
4.实体类：
1.该类是一个具体类，属性私有化；
2.对外提供公共的访问方法；
3.需要实现接口，序列化接口（Serializable）；
2.内部类：
1.概念：一个类中定义另一个类；
内部类可以访问外部类的成员，包括私有；
外部类某成员访问内部类成员，必须通过对象来访问；
2.分类：
成员内部类：在外部类的成员位置中；
局部内部类：在局部位置（方法中）定义一个类；
1.当其他类访问成员内部类的成员对象时
格式为：外部类名.内部类名 对象名 = new 外部类名（）.new 内部类名（）；
2.被static修饰的成员内部类：
它里面的成员方法只能访问外部的静态成员；
静态成员内部类中成员访问方法：
格式： 外部类名.内部类名 对象名 = new 外部类名.内部类名（）；
对静态成员内部类：
外部类.内部类.静态成员；
3.局部内部类：
1.可以直接访问外部类成员，包括私有；
2.在外部类中的成员方法中，可以通过创建局部内部类对象来访问局部内部类成员；
JDK7以前（包括），局部内部类访问局部变量，必须在前面家final修饰
JDK7以后，会自动提供final，那么为什么要提供final修饰
原因：因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，
还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实
是一个常量值；
4.匿名内部类：（在方法的局部位置中）
格式： new 类名、接口名（）{
重写方法；
}；
5.接口的匿名内部类：本质继承该类或者实现该接口的子类对象；
格式： 接口名 对象名 = new 接口名(){
重写接口中的抽象方法；
}；
3…成员内部类修饰符：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qdN3fOh8-1596261018907)(C:\Users\张强\AppData\Roaming\Typora\typora-user-images\image-20200730172138442.png)]
4.常用类：
1.Object类：可以存储任何对象：
作为形参，可接受任何对象
作为返回值，可返回任何对象
其中的getClass（）:通常用于判断两个引用中实际存储对象类型是否一致；
public final Class getClass(){}
public int hashCode(){};哈希码
public boolean equals(Object obj){},默认实现为（this==obj）,比较两个对象地址是否相同；可进行覆盖
5.选择排序与冒泡排序：
1.选择排序的思想：从第一个数依次比较，小的值往前放，第一次比较完，最小值出现在最小索引处，比较的数次，长度-1；
2.冒泡排序的思想：两两比较，第一次比较完，最大值出现在最大索引处，依次下去，比较次数，n-1；
ublic final Class getClass(){}
public int hashCode(){};哈希码
public boolean equals(Object obj){},默认实现为（this==obj）,比较两个对象地址是否相同；可进行覆盖
#### 5.选择排序与冒泡排序：
1.选择排序的思想：从第一个数依次比较，小的值往前放，第一次比较完，最小值出现在最小索引处，比较的数次，长度-1；
2.冒泡排序的思想：两两比较，第一次比较完，最大值出现在最大索引处，依次下去，比较次数，n-1；
151
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
