一、多态
1、同一方法可以根据发送对象的不同而采用多种不同的行为方式
2、一个对象的实际类型是确定的，但可以指向对象的引用类型有很多
3、多态存在的条件：有继承关系、子类重写父类方法、父类引用指向子类对象
4、多态是方法的多态，属性没有多态性
5、instanceof
X instanceof Y//如果X和Y之间存在父子关系，那么这个式子的结果是true
二、static关键字详解
1、匿名代码块、静态代码块、构造方法
java
public class Person {
{//匿名代码块可用于赋初值
System.out.println("匿名代码块");
}
static {//只在初试时执行一次
System.out.println("静态代码块");
}
public Person(){
System.out.println("构造器");
}
}结果：
2、静态导入包
java
public class Main {
public static void main(String[] args) {
System.out.println(Math.random());//在原本的情况下，我们要使用Random函数必须要在前面带一个Math类
}
}在使用静态导入包之后，我们就可以直接使用Random函数而不用带Math
java
//静态导入包，加了一个static
import static java.lang.Math.random;
public class Main {
public static void main(String[] args) {
System.out.println(random());
}
}三、抽象类
1、abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法,那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。
2、抽象类中可以没有抽象方法，但是抽象方法的类一定要声明为抽象类
3、抽象类，不能使用new关键字来创建对象，它是用来让子类继承的
4、抽象方法，只有方法的声明，没有方法的实现
java
//抽象类，要加修饰符abstract
public abstract class Action {
//约束，别人帮我们实现
//abstract，抽象方法，只有方法的名字，没有方法的实现
public abstract void doSomething();
}5、子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类。
我们发现在Action01中直接继承Action会报错，因为Action还有个抽象的子类没有实现，如果Action01不是抽象子类，那么继承了Action就必须实现Action的抽象方法doSomething（）;
类只有一个单继承！ ，但是接口可以实现多继承！
四、接口
1、普通类:只有具体实现
2、抽象类:具体实现和规范(抽象方法)都有!
3、接口:只有规范!自己无法写方法，约束和实现分离：面向接口编程
4、接口就是规范，定义的是一组规则，体现了现实世界中"如果你是...则必须能....."的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你好人，则必须干掉坏人;如果你是坏人，则必须欺负好人
5、接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
6、、OO的精髓，是对对象的抽象，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如c++、java、c等)，就是因为设计模式所研究的，实际上就是如何合理的去抽象。
7、声明类的关键字是class,声明接口的关键字是interface
java
//interface是定义的关键字，在接口里面只定义不实现，所以接口都需要一个实现类
public interface UserService {
//接口中的所有定义其实都是抽象的public abstract
//可以看到public abstract即使写上也是灰色，所以可以不写
public abstract void run();
//增删改查
void add(String name);
void delete(String name);
void update(String name);
void query(String name);
}
java
public interface TimeService {
void timer();
}
java
//这是userService的实现类
//类 可以实现接口 implements 接口
//实现了接口的类，就需要重写接口中的方法
public class UserServiceImpl implements UserService ,TimeService{
@Override
public void run() {
}
@Override
public void add(String name) {
}
@Override
public void delete(String name) {
}
@Override
public void update(String name) {
}
@Override
public void query(String name) {
}
@Override
public void timer() {
}
}
五、内部类
1、内部类就是在一个类的内部定义一个类，比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对于B类来说就是外部类了。一个java类中可以有多个class类，但是只能有一个public class
2、成员内部类
java
public class Outer {
//外部类和内部类
private int id =77;
public void out(){
System.out.println("这是外部类的方法");
}
//写一个内部类
public class Inner{
public void in(){
System.out.println("这是内部类的方法");
}
//在内部类中可以获得外部类的私有属性
public void GetId(){
System.out.println(id);
}
}
}
java
import static java.lang.Math.random;
public class Main {
public static void main(String[] args) {
//首先通过new来实例化一个outer类
Outer outer = new Outer();
//通过外部类来实例化内部类
Outer.Inner inner = outer.new Inner();
inner.in();
inner.GetId();
}
}输出结果
3、静态内部类
4、局部内部类
java
public class Outer {
//外部类和内部类
public void method(){
//局部内部类
class Inner{
public void in(){
}
}
}
}5、匿名内部类
java
import static java.lang.Math.random;
public class Main {
public static void main(String[] args) {
//没有名字初始化类，不用将实例保存到变量中
new Apple().eat();
//接口也是一样的只不过说要重写接口中的方法
new UserService01(){
@Override
public void Hello() {
}
};
}
}
class Apple{
public void eat(){
System.out.println("1");
}
}
interface UserService01{
void Hello();
}六、异常
1、异常，Exception，意思是例外。这些，例外情况，或者叫异常，怎么让我们写的程序做出合理的处理。而不至于程序崩溃。
异常指程序运行中出现的不期而至的各种状况,如:文件找不到、网络连接失败、非法参数等。
2、异常发生在程序运行期间,它影响了正常的程序执行流程。
3、检查性异常:最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的。例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
4、运行时异常:运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
5、错误:错误不是异常，而是脱离程序员控制的问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到的。
6、异常体系框架：java把异常当做对象来处理，并定义一个java.lang.Throwable作为所有异常的超类，在java API中已经定义了许多异常类，这些异常分为两大类，错误Error和异常Exception
7、Error
- Error类对象由Java虚拟机生成并抛出，大多数错误与代码编写者所执行的操作无关。
- Java虚拟机运行错误(Virtual MachineError)，当JVM不再有继续执行操作所需的内存资源时，将出现OutOfMemoryError。这些异常发生时，Java虚拟机(JVM)一般会选择线程终止;
- 还有发生在虚拟机试图执行应用时，如类定义错误(NoClassDefFoundError)、链接错误(LinkageError)。这些错误是不可查的，因为它们在应用程序的控制和处理能力之外，而且绝大多数是程序运行时不允许出现的状况。
8、Exception
在Exception分支中有一个重要的子类RuntimeException(运行时异常)
- ArrayIndexOutOfBoundsException(数组下标越界)
- NullPointerException(空指针异常)
- ArithmeticException(算术异常)
- MissingResourceException(丢失资源)
- ClassNotFoundException(找不到类）等异常，这些异常是不检查异常，程序中可以选择捕获处理，也可以不处理。
- 这些异常一般是由程序逻辑错误引起的，程序应该从逻辑角度尽可能避免这类异常的发生;
- Error和Exception的区别: Error通常是灾难性的致命的错误，是程序无法控制和处理的，当出现这些异常时，Java虚拟机(JVM)一般会选择终止线程;Exception通常情况下是可以被程序处理的，并且在程序中应该尽可能的去处理这些异常。
9、捕获异常
java
package com.exception;
public class Demo01 {
public static void main(String[] args) {
int a = 1;
int b = 0;
//快捷键 ctrl+alt+T
try{//try监控区域，在这里放置我们想要捕捉异常的代码
System.out.println(a/b);
}catch (ArithmeticException e){//(想要捕获的异常类型)catch可以有很多个，捕获多个异常：从小到大
System.out.println("程序出现异常，变量b不能为0");
}finally{//进行一个善后操作
System.out.println("finally");
}
}
}输出结果
但是在没有捕获异常的情况下，这里是会出现一个报错：
java
package com.exception;
public class Demo01 {
public static void main(String[] args) {
int a = 1;
int b = 0;
// try{//try监控区域，在这里放置我们想要捕捉异常的代码
// System.out.println(a/b);
// }catch (ArithmeticException e){
// System.out.println("程序出现异常，变量b不能为0");
// }finally{
// System.out.println("finally");
// }
System.out.println(a/b);
}
}
快捷键：ctrl+alt+T
10、抛出异常throw、throws
java
package com.exception;
public class Demo01 {
public static void main(String[] args) {
new Demo01().test(1,0);
}
public void test(int a,int b){
if(b==0){
throw new ArithmeticException();//主动抛出异常，一般在方法中使用
}
}
}
java
package com.exception;
public class Demo01 {
public static void main(String[] args) {
//同时在调用时要捕获异常
try {
new Demo01().test(1,0);
} catch (ArithmeticException e) {
e.printStackTrace();
}
}
//假设这个方法上处理不了，在方法上抛出异常
public void test(int a,int b) throws ArithmeticException{
if(b==0){
throw new ArithmeticException();//主动抛出异常
}
}
}