多态
同一个对象 体现出来的多种不同形态（身份）将一种行为表现出不同的效果
要想实现多态的效果 需要现有的继承关系
体现：
1：父类类型的引用 指向 子类的对象
Person p = new Teacher();
2.该引用只能调用父类中定义的属性或方法
3.如果子类将父类中的方法重写，那么调取方法后执行的结果是子类重写之后的那个结果
如果父类与子类有同名的属性 执行父类的属性
如果父类与子类有同名的方法（重载） 执行子类重写之后的方法
4.若想要调用子类中独有的成员
（强制类型转化） 造型 铸型 （向上/下 转型）
5.造型时（强制向下转型时）可能会出现一个运行时异常
classcastexception 造型 铸型 异常
如果想要避免造型的异常 可以用instanceof关键字来进行判断
对象 instanceof 类
内部类
指的是在java中可以将一个类定义在另一个类的内部
内部类可以定义在 类的内部（与类成员层次一致）
内部类可以定义在 方法/块 内部（与内成员相差一个层次 方法的局部变量一个层次）
1.*成员内部类
将一个类直接定义在类的里面，作为成员，与属性或方法层次一致
成员内部类可以与正常类一样 使用不同的修饰符来修饰
好处1.省略了一个.java文件 2.成员内部类中可以访问外部类的所有成员 包括私有的
若想要在内部类中通过对象.的方式来调用外部类成员 外部类.this.外部类成员;
内部类存在后 源代码进行编译 产生有个字节码 Demo$innerDemo.class
2.局部内部类
将一个类定义在方法/块里面，作为成员的内部结构，与临时的局部变量一个层次
局部内部类像是一个局部的变量一样，不能用public protected private 及static修饰
只能用abstract 或者final
局部内部类的命名规则demo$1innertestmethod demo$2innertestmethod
局部内部类使用的变量只能时final修饰
3*.匿名内部类
成员匿名内部类
局部匿内部类
public interface Test{
public void test();
}
public class Son implements Test{
public void test(){
}
}
Test t = new Test(){
public void test(){
}
};
通常接口或抽象类的具体子类这样写
开发中为了省略一个类文件 上述写法比较常见
匿名内部类很特殊 只有类体 没有类的所有结构 （修饰符 名字 继承 实现）
不能用任何修饰符来修饰 匿名内部类 也没有构造方法
4.静态内部类
成员静态内部类
不需要外部类对象，通过正常的方式直接创建内部类
只能在类中定义 作为成员
今天该内部类不需要外部类对象操作 可以直接创建对象
静态内部类可以范围更外部类的静态成员
==============================================================
数据类型
基本 8个
引用 数据[] 类class 抽象类abstract class 接口interface 枚举 enum 注解@interface
枚举类
一个类中的对象 认为个数是有限且固定的 可以将每一个对象一一列举出来
1.试试若没有枚举类型的时候 如何手动设计（静态常量 单例模式） Day（类 当作描述星期7个对象）
private 构造方法
public static final属性 = new
2.JDK1.5版本之后我们可以直接定义enum类型
我们自己定义的 enum类型直接默认继承Enum（java.lang)包
我们自己定义的enum类型不能再写extends 但是可以实现
Enum类型
有两个属性
name---->枚举对象的名字 name()获取name的属性
ordinal—>枚举对象在类中罗列的顺序 类似index 也从0开始 ordinal()获取序号
一些常用的方法
valueOf() 通过给定的name获取对应的枚举对象
values() 获取全部的枚举对象—> 返回一个数组 day[]
compareTo() 可以比较两个枚举对象int
tostring（） 由于这个方法没有fianl修饰 可以覆盖/重写
3.swith内部判断枚举的应用
4.我们也可以在enum中描述自己的一些属性和方法
必须在enum类中的第一行 描述一些枚举的样子 最后需要分号结束
可以定义自己的属性
类创建的过程中 帮我们创建枚举类型的对象
需要给枚举类型提供对应样子的构造方法 构造方法只能private修饰 可以重载
overload —方法重载
1.概念：一个类中的一组方法 相同的方法名字 不同的参数列表 这样的一组方法构成了方法重载
参数列表不同的体现
1.参数的个数 2.参数的类型 3.参数的顺序
2.作用：为了让使用者便于记忆与调用 只需要记录一个名字 执行不同的操作
3.自己设计方法重载
调用方法的时候 首先通过方法名字定位方法
如果方法名字有一致 可以通过参数的数据类型定位方法
如果没有与传递参数类型一致的方法 可以找一个参数类型可以进行（自动）转化
4.JDK1.5版本后的新写法
int…x —> 动态参数列表 个数可以动态 0 —n都可以
x 本质上就是一个数组 有length属性 有[index]
动态参数列表的方法 不能与相同意义的数组类型的方法构成方法重载 本质是一样的
动态参数列表的方法 可以不传参数 相当于0个
数组的方法必须传参 Null都可以
动态参数列表在方法的参数中只能存在一份儿 而且必须防止在方法参数的末尾
利用类来描述显示生活中的事情
利用对象去具体的执行操作
类的内部成员
属性—静态描述类的特征（变量 存值）name
方法—动态描述类的行为（做事情）eat
构造方法—用来创建当前类的对象（方法）
程序块—理解为就是一个方法（啥也没有 只有方法 没有名字、返回值、参数、修饰符）
类中的第三个成员
构造方法—做事情
1.作用 构建（构造）当前类的对象
2.写法： 权限修饰符 与类名一致的方法名（参数列表） 【抛出异常】{
创建一个当前类的对象
返回对象；
}
3.用法：通过new关键字调用
4.特点：
1.每一个类都有构造方法，若自己在类中没有定义，系统会默认提供一个无参数的构造方法
若在类中自己定义了构造方法，则默认无参数的构造方法就会被覆盖
2.构造方法是否存在方法重载？—存在构造方法重载
5.每一个类都有构造方法
若不定义 系统会默认提供构造方法
在创建对象的同时 想要并要做一些事情 默认蹄冻的构造方法是不会做的
这个时候 我们可以自己定义构造方法（无参数的构造方法内做事 也可以定义带参数的）
类的第四个成员—程序块（代码块）
1.作用：跟普通方法一样 做事情的
2.写法：可以认为程序块是一个没有修饰符 没有参数列表 没有返回值 没有名字的特殊方法
{
}
3.用法：块也需要调用才可以执行 我们自己无法调用它 毕竟它啥也没有 那么它是怎么被调用的呢？
块在每一次我们调用构造方法之前 系统会帮我们自动的去调用一次程序块 让它自己执行一次
4.特点 没有什么重载的概念 但是你可以写多个 然后每一次我们调用构造方法的时候他就会全部被调用出来
5.块可以在里面写一些程序 which 我想要在创建对象之前就执行一次
this 关键字的使用
构造方法中 属性与变量重名 必须需要一个代替词代替对象
1.是一个关键字（指代词） 代替的是某一个对象（当前调用属性或方法时的那个对象）
2.this既然代替的是一个对象
this 可以调用属性 方法
this 可以调用构造方法 在一个构造方法内可以调用另一个构造方法
通过this(); 省略了构造方法的名字（必须与类名一致）
必须在另一个构造方法内调用 必须在程序的第一行
构造方法 一般方法 有顺序 认为构造方法早于一般方法
在一般方法内调用构造方法是不被允许的
3.this调用的过程可以放置在哪个位置写？
调用属性或方法 这一行代码 可以放置在类中的任何成员位置 上下位置随意
类中的四个成员
1.属性—静态描述特征（存值）
权限修饰符【特征修饰符】 属性类型 属性名字 【=值】；
2.方法–动态描述行为（做事情）
权限修饰符【特征修饰符】 返回值类型 方法名字 【参数列表】 【抛出异常】{方法体}
最主要的是方法设计的参数及返回值问题 传递 调用 执行 内存
3.构造方法—创建当前类对象（做事情 唯一的事情）
权限修饰符 与类名相同的方法名【参数列表】【抛出异常】{方法体}
4.程序块—特殊的方法（没名字 做事情 不用我们调用 构建对象之前调用)
{方法体}
5.this关键字的使用
用来代替某一个对象
可以调用一般属性或一般方法 放置在任何类成员中
可以调用构造方法 只能放在另一个构造方法内 只能放在程序的第一行
关于Scanner类及其中方法的使用
1.导包 java.util
2.创建对象 scanner input = new Scanner(System.in);
3.做事情 int value = input.nextint();
string value = input.nextline();
nextint(nextFloat nextByte) next nextline
1.读取方式上来讲 大家都以回车符作为结束符号
除了nextline 以外其余的方法都不读取回车符
2.读取的返回结果来及看 nextint---> nextfloat --float
next--string nextline--->string
next方法看到回车或者空格都认为结束 nextline 只认为回车符结束
输入abc def g 输入abc ged d
abc abcgedd
3.利用包装类做String与基本类型的转化问题
int value = integer.parseint("123"); //如果字符串不是一个整数形式就会产生错误
Float.pasefloat("123,45");
类和类之间的关系
A is-a B 泛化（继承 实现）
A has-a B 包含（组合 聚合 关联）
A ues-a B 依赖 need-a
继承
1.子类继承父类，通过一个关键字 extends
2.子类的对象可以调用父类中的（public protected）属性和方法 当作自己的来使用
3.子类可以添加自己独有的属性和方法
4.子类从父类中继承过来的方法不能满足子类需要，可以在子类中重写（覆盖）父类的方法 更多指的是内容
5.每一个类都有继承类，如果不写extends关键字，默认继承Object，如果写了extends则继承后面那个父类
可以理解为Object十分重要 是任何一个引用类型的父类（直接或间接的继承Object）Object类没有父类
6.java中继承是单个存在的（单继承）每一个类只能有一个继承类（在extends关键字后面只能写一个类）
目的是为了让类变得更加的安全 可以通过传递的方式实现多继承 后续还有多实现
7.继承在内存的存储形式
================================================================================
Object类中的方法
hashcode() 将对象在内存中的地址经过计算得到一个int整数
public native int hashcode();
equals() 用来比较两个对象的内容 Object默认效果比较地址
如果想要改变其规则 可以进行方法重写
public boolean equals(Object obj){
return( this== Obj)
}
tostring 打印输出时将对象变成string字符串
public string tostring(){
return this.getClass().getname()+"@"+integer.HexString(this.hascode());
}
getclass() 获取对象对应类的类映射（反射）
wait() 线程进入挂起等待状态 存在方法重载
notify() 线程唤醒
notifyAll() 唤醒所有
protected:finalize() 权限修饰符时protected 在对象被GC回收的时候默认调用执行的方法
protected finally finalize(){
}
protected:clone() 权限修饰符时protected 为了克隆对象
继承关系
1.子类想要继承父类，通过extends关键字来实现
2.子类继承了父类，可以调用父类中（pulic protected）的属性和方法
2.1构造方法严格意义来说 不算做子类继承过来
只是单纯的在子类调用构造方法是默认调用父类的构造方法
2.2程序块严格意义来说 不算做子类继承过来的（子类调用不到 没有名字）
程序块子类不能直接调用 子类执行构造方法之前
默认调用了父类的构造方法 子类执行构造方法之前
默认调用了父类的构造方法 父类构造方法之前自动执行父类的块
3.子类除了能继承父类的属性和方法外，子类还可以添加自己独有的成员（属性，方法）
4.当父类继承过来的方法无法满足子类的需要，可以进行方法重写（override)
4.1关于 方法重写 和发方法重载的区别
方法重写override 方法重载overload
1.类 产生两个继承关系的类 一个类中的一组方法
子类重写父类的方法
2.权限 子类可以大于父类 没有要求
3.特征 final static abstract 没有要求
父类方法是final 子类不能重写
父类方法是static 子类不存在
父类方法是abstract 子类必须重写
（子类是具体必须重写 否则 子类是抽象类 剋不重写
4.返回值 子类可以小与等于父类 没有要求
5.名字 子类与父类一致 一个类中的好多方法名必须一致
6.参数 子类与父类一致 每一个方法的参数必须不一致（个数 类型 顺序）
7.异常 运行时 编译时 没有要求
如果父类方法抛出运行时异常 子类可以不予理会
如果父类方法抛出编译时异常 子类抛出异常的个数和类型都要小于等于父类
5.每一个类都有继承类，若定义了extends关键字，则直接继承该类（简介继承OBject），若没有定义extends 就默认继承Object类
Object是所有引用类型的父类，它本身没有父类
6.java中类的继承是单继承，只得是一个extends关键字后面只允许写一个类，可以通过传递的形式来实现多继承（后续多实现）
7.深入理解继承在内存中的存储结构
8.this 与 super关键字的区别
this和super都是代替对象
this 代替的是当前对象的父亲对象、
this和super都可以调用一般的属性和方法，放置在类成员的任意位置
方法之间是可以来回调用的，执行时要除以栈溢出的问题
this 和super都可以调用构造方法，只能放在另一个构造方法第一行
但利用this或super调用构造方法时，他们两个不可以同时出现 因为他们都想抢第一行
main 方法
public stayic void main(){
}
public 访问权限修饰符 共有的
static 特征修饰符 静态的 有且只有一份
void 方法执行完没有返回值 关键字
main 方法名字 主要的
主方法中的args 参数一样可以传递
1.主方法不是我们调用的 JVM虚拟机启动的时候 虚拟机调用的
2，主方法里面有args参数 是一个String[] 类型 我们时可以传递参数进去 给JVM
例如：：：
public static void main(){
System.out.println(args.lenth);
for(String value: args){
Ststem.out.println(value);
}
}
然后在运行时传参进来 就可以输出了
面向过程的编程思想
解决问题的时候按照一定的流程
钟点工–>大象装冰箱总共分几步
1.开门 2.大象装里面 3.关门
以过程为本–服用–增加冗余
大段的过程 拆分成小段—到底是哪一个实体来做的
面向对象的编程思想
解决问题的时候按照显示生活中的规律来考虑问题
考虑在这个问题的过程中 有几个实体参与进来
理解为 实体动作 动作的支配者 没有实体 动作就发生不了
人 冰箱 大象
分析每一类个体都有什么特点 做了哪些事情
大象 特点：大 体积重
冰箱 特点：有门 有容积
人 特点：能做事情 ----开冰箱 装大象 关门
类和对象
类—人类 抽象的笼统的概念 描述一类事物 肯定是具有相同的特征行为
人类有名字 有年龄 有性别 —静态描述特征（特征） 》属性
可以吃饭 可以说话 可以学习—动态动作 行为（做的事情）》方法
人类叫李灵？ 人类吃了一碗大米饭？
对象–具体的人 人类中的一个具体的人 叫 李灵 具有和人类一样的行为 特点特征行为
这个具体的人 有名字 有年龄 有性别 可以吃饭 可以学习
在现实生活中 对象是先有的 总结出来的概念（类）后产生的
在计算及中利用面对对象的思想来做事
需要自己先定义一个类（型）
想要做事情 需要在描述的类中创建一个具体的个体（对象）出来
个体（对象）来做事
如何在计算机中创建（描述）一个类
1.先创建一个类
2.类的里面利用属性或方法去描述这个类
3.创建一个当前类的对象 让对象调用属性/方法做事
对象的创建在哪都可以
类的方法 - —>做一件事情
权限修饰符 【特征修饰符】 返回值类型 方法名字（参数列表） 【抛出异常】【{
方法体
}】 框起来的是可有可无的
权限修饰符 返回值类型 方法名字 （参数列表）{
}
public protected 默认 private
1.无参数 无返回值
2.无参数 有返回值
3.有参数 无返回值
4.有参数 有返回值
人类有名字 有年龄 有性别—属性
人类可以吃饭 可以做事情
类和对象
类—抽象笼统的概念 person
具有一组相同的特征或行为
属性—静态描述类的特征
权限修饰符【特征修饰符】 属性类型 属性名字（参数列表）{方法执行体}
方法中最主要的两个结构 方法的参数列表 方法的返回值类型
参数列表可以理解为方法昨晚事情之前需要提供的条件 可以多个条件
返回值可以理解为方法做完事情之后得到的结果（只有一个）
类描述好了之后需要创建当前类的对象 通过new的方式
person p = new person();
通过p.的方式进行调用属性（存值/取值） 调用方法（执行一次）
形参 和 实参
形参可以理解为是方法执行时的临时变量空间
实参可以理解为是方法调用时传递进去的参数
方法调用时未见实参的内容传递给形参
如果内容是基本类型 传递的是值 形参改变 实参不变
如果内容是引用类型 传递的是引用 形参改变 实参跟着改变
命令提示符（cmd）
启动： win + r
切换盘符 盘符名称
进入文件夹 cd 文件夹名称
进入多级文件夹 cd 文件夹1\文件夹2\文件夹3
返回上一级 cd …
查看回根路径 cd
查看当前内容 dir
清屏 cls
退出 exit
for循环
~正常的for循环以及加强的for循环
1.正常的for 有三个必要条件 index 索引 找到某一个元素的位置 可以通过index直接访问数组的某一个位置 存值
以及取值
2.增强的for 有两个条件 用来取值的变量用来遍历的数组 没有index索引好处的写法 无法准确找到元素的位置
~基本数据类型和应用数据类型在内存结构上的区别
所有的变量空间都存储在栈内存
变量空间可以存储基本数据类型 也可以存储引用数据类型
如果变量空间存储的是基本数据类型 存储的是值 一个变量的值改变 另一个不会跟着改变
如果变量空间存储的是引用数据类型 存储的是引用（地址） 一个变量地址对应的值改变 另一个跟着改变
数组（容器）
数组时一组数据类型相同的数据的组合，将这些数据统一的管理起来
数组本身时一个引用数据类型，数组内存贮的类型看可以时基本类型，也可以时引用类型
数组的特点
一：数组本身时一个引用数据类型
二：数组是在堆内存中的一连串连续的地址存在
三：数组在初始化时必须指定长度
四：堆内存的数组空间长度一旦确定 不能再次发生改变
五：栈内存的变量中存储的时数组的地址引用
六：数组内部存储的类型可以是基本的 也可以是引用类型的
1.创建一个数组 记录1-100之间的偶数
设计程序的时候出现的小问题
①：创建一个数组 是否要动态初始化
元素个数比较少 静态 元素个数比较多 但是有规律 动态 元素很多 没有规律
②：用两个循环 一个为了存值 另一个为了确保正确 输出检查
存放时直接看结果可能由于存放误操作–看时正确 之后就发生突变
存放时不一定要查看 而且最好一个循环就做一个事情
二维数组
1.数组的概念 特点
2.数组的定义/声明
里面存储的类型[] 数组名字；
int[][] array;
3.数组的初始化
静态初始化—有长度 有元素
int[][] array = {{1,2},{3,4,5},{6,7,4}};
int[][] array = new int[][]{{1,2},{3,4,5},{6,7,4}}; //new int 可以省略
动态初始化—有长度 没有元素 （元素为默认值）
int[][] array = new int[3][2];
4.数组元素的访问
通过元素在数组中的我位置—index索引
int value = array[0][0]; //前面表示小数组位置 后面表示小数组中元素的位置
System.out.println(value);//1 array[1][2];//5
5.数组元素的遍历/轮询
for(int i = 0; i < array.length; i++){
for(int j = 0; j < array[i].length;j++){
int value = array[i][j];
System.out.println(value + “\t”);
}
}
方法二：//加强for循环
for(int[] arr : array){
for(int value : arr){
System.out.println(value);
}
}
修饰符
权限修饰符 公共的 本类 同包 子类 当前工程的任意类中
public 受保护的 本类 同包 子类（在子类范围内 子类对象自己可以访问）
默认不写 默认的 本类 同包 （package关键字后面的包名完全一致）
private 私有的 本类
特征修饰符
final 最终的 不可更改的
static 静态的
abstract 抽象的
native 本地的
transient 瞬时的 短暂的------->序列化
synchronized 同步的 最后三个线程问题
volatile 不稳定的 保护属性或方法的线程安全
特征修饰符
final 最终的 不可更改的
修饰变量
如果在定义变量时没有赋予初始值
给变量一次存值的机会（因为变量在栈内存空间内 没有默认值 如果不给机会存值 就不可以使用）
一旦变量被存储了一个值 若用final修饰后 则不然再次改变----> 相当于常量了（值不可以改变）
注意变量类型时基本类型还是引用类型
如果修饰的变量是基本数据类型 则变量内的值不然更改----常量
如果修饰的变量是引用数据类型 则变量内的地址引用不可更改—对象唯一
修饰属性
全局变量 存储在堆内存的对象空间内的一个空间
属性如果没有赋值 那么它会以默认值存在
属性用final修饰后 必须给属性赋予初始值 否则编译报错
特点与修饰符一致
注意变量类型时基本类型还是引用类型
如果修饰的变量是基本数据类型 则变量内的值不然更改----常量
如果修饰的变量是引用数据类型 则变量内的地址引用不可更改—对象唯一
修饰方法
方法是最终的方法 不可以更改
子类继承父类的方法 子类不可以（更改/重写/覆盖）父类的被final修饰的方法
修饰类本身
类是最终的 不可以更改的
（太监类） 此类不可以被其他子类继承
通常都是一些定义好的工具类
scanner/math/integer/string~~~~
stataic
静态的 修饰属性 修饰方法 修饰快 修饰类（内部类）
1.静态元素在类加载时即被初始化，创建的很早，创建时只有类，还没有对象
2.静态元素存储在静态元素区中，每一个类可以有一个单独自己的区域，与别的类不冲突
3.静态元素去不能被gc管理，可以管理粗暴的认为静态元素常驻内存
4.静态元素只加载一次（只存在一份），全部类对象及类本身共享
5.可以理解为静态元素与对象没有关系，属于类
6.由于静态元素在加载时可能没有创建对象，我们可以通过类名字直接访问
7.静态元素可以直接访问静态元素（都存在静态元素区中）
8.非静态元素可以直接访问静态元素（非静态----》堆内存对象空间里 静态元素---》？静态区）
9.静态元素不可以访问非静态元素（静态元素时单独存在---》找寻非静态元素 有一堆一样的 说不清楚）
10.静态元素中不可以使用this 或super关键字（静态元素可以理解为属于类 this/super代替对象）
静态常量的应用场景
增强程序的可读性 static final 属性 = 0
=====================================================================================
存在继承关系的类 加载机制及执行过程
new Person();
1.加载父类
2.父类会产生自己的静态空间 属性 方法 快
执行静态块
3.加载子类
4.子类会产生自己的静态空间 属性 方法 块
执行静态块
5.开辟对象空间
6.加载父类的非静态成员 属性 方法 块 构造方法
7.执行块 执行父类的构造方法
8.加载子类的非静态成员 属性 方法 块 构造方法
9.执行块 执行子类构造方法
10.将对象空间的地址引用交给变量来存储
native 本地的
java源代码中看到native就再也看不见后续代码
后续会调用其他编程语言c++ c执行内存的操作 帮我们操作内存
Object类中的一个方法hashcode
abstract 抽象的----（很不具体 没有具体执行 只是个概念）
1.what to discribe?
修饰方法
用abstract修饰符修饰的方法只有方法的结构没有方法执行体 叫做抽象方法
当然注意native修饰的方法虽然也没有方法体 但是不是抽象方法 只是执行的过程时其他语言写的 看不见
修饰类
用abstract修饰符修饰的类叫做抽象类
2.修饰后有什么特点
抽象类中必须有抽象方法么？ 不是必须含有抽象方法
抽象方法必须放在抽象类中吗？ 目前是必须放在抽象类或接口中 普通类不允许含有抽象方法
3.什么叫抽象类 有什么特点？
1.和普通类差不多 就是允许含有抽象方法了
2.类如何使用？ 创建对象？
抽象类含有构造方法 但是我们不能通过调用构造方法直接创建对象
！！！抽象类只能通过子类单继承来做事情
为什么不让我们调用构造方法创建对象？
3.类和类的关系
具体类不能直接单继承抽象类 （将父类的抽象方法具体化 或子类也变成抽象类）
4.抽象类中可以全部是具体成员 也可以全部都是抽象方法
接口-----抽象类抽象到极致 质的变化
接口可以理解为是抽象类抽象到极致—》还是一个类的结构 不能用class修饰 改用interface修饰
public interface test{
Systerm.ou.println(" ");
}
5.什么是接口----通常是为了定义规则
接口也是一个类的结构 只不过用interface修饰
不能含有一般的属性 只能用默认的 公有的静态常量public static final
不能个含有一般方法 只能含有公有的抽象的方法 （1.8 default修饰具体方法—只定义规则）
不能含有一般程序块 也不能含有static程序块 块本身就是具体的 接口中不然有具体的
不能含有构造方法
不能创建对象
只能通过子类多实现（implements)来做事
public class A implements b,c,d{
}
抽象类----直接多实现—接口 可以
具体类----直接多实现—接口 不可以（必须将接口中的抽象方法具体化 自己变成抽象类）
接口 —多继承—接口 可以直接多实现