(兔C残篇)Java 面向对象的三个基本特征：多态，instanceof和类型转换，static关键字，强制类型转换，类中的加载顺序，抽象类，接口的定义与实现，N种内部类，异常的总结-CSDN博客

本文链接：https://blog.csdn.net/tianlei_/article/details/122934140

哔哩哔哩上有老友记的观看版权了，真赞，追剧上头，昨天忘了给自己打卡知识文章了。今天也差点忘了，第一季火速追完，接下来输出javase最后内容。涵盖内容如标题

1.多态

1.1 多态的实现

父类引用指向子实例，看到这句话的时候，或者说问到什么是多态的时候，我们常常会这样进行解释。

观察多态，我们会发现这样的规律，new一个对象时类型是确定的，可以指向的对象不确定了。如code

Student sOne = new Student();
Person sTwo = new Student();

这种情况，我们称为：父类引用指向子类实例。
父类在哪？哦对！父类是这么写的。

public class Person{//略}
public class Student extends Person{//略}

要想实现父类引用指向子类实例的这句话，前提是必须存在父子类关系。
那带来的好处是：都是学生，表现出的状态不同

  //还可以这样
  Object sThree = new Student();
  //别忘了，在java中，不显示指定extends，默认继承Object

1.2 多态中调用方法说明

1.如果父类中有一个方法，那子类也重写了父类的方法，也就是此时父类和子类拥有相同的方法，那调用时调用的哪？
调用时与指向的类型相关，但是如果子类没有重写父类中的方法，那么调用时，则调用父类的方法。

2.子类的方法中，可以直接使用对象名进行调用，但如果引用类似是父类，那调用时，需要进行强制类型转换。

3.对象名调用方法时主要看左边引用类型的定义，语法的右边只是构造创建和其关系不大。

1.3 总结

子类调用的方法都是自己的，或者是父类的。
父类调用的方法，都是自己的，不能调用子类的，如果想进行调用，需要做强制类型转换。(多态前提下)
Java中的方法调用是在运行时和对象动态绑定的。

1.4 多态的注意事项

多态是方法的多态
父类和子类必须有联系，否则 ClassCastException 类型转换异常
存在条件 1.继承关系，2.方法需要重新，3.父类引用指向子类对象

不能被重写的方法：

static静态方法
final 常量池中
private 私有方法

1.5 多态的概念

最后在阐述一下多态的概念。
同一方法可以根据发送对象的不同调用多种不同的方式
一个对象的类型是确定的，但可以指向对象的引用的类型有很多

//乱么？还行吧，这块东西就是有点大杂烩，我不想放上代码，那样的话整体出来会费好多功夫，乱起来，才能快起来，我每次都是这样的，这些都是平常学习完压在本里的东东，我想直接梭哈。然后玩上几天数组排序。继续 ↓

2. instanceof

判断一个对象是什么类型，两个类之间是否有父子类关系

x instanceof y //能不能通过编译
true通过，false失败
通过判断结果可得知两个类是否属于是同一种类型。

3.强制类型转换

如果利用多态的性质创建对象，并将父类的引用指向子类后(也就是前面提到的，在多态的前提下)，想调用子类中的方法，需要进行强制类型转换
即

//低的类型转向高的类型
Person p1 = new Student();
(Student)p1.子类方法();
//低转高是默认转换，不需要进行强制转换，高转低需要强制转换。

4. static 关键字

//静态修饰符

修饰属性，可以直接用类名调用类变量。如果没有用static关键字进行修饰，那就不属于静态的，则只能用对象名调用。
修饰方法，非静态方法的调用必须创建对象，静态方法直接用类名进行调用。
非静态方法可以调用静态方法，静态方法不能调用非静态方法。因为静态关键字进行修饰的，是和类一起进行加载的。
静态修饰符还可以用于包的导入，修饰成静态导入之后，可以直接应用，直接用其方法

import java.Lang.Math;
import static java.lang.Math.random;

5. 类中的加载顺序

先执行静态代码块，和类一起加载，只执行一次
匿名代码块，构造器之前
构造方法，创建一个类时，最先执行，但代码块的执行优先级高于构造器

6.抽象类

abstarct 关键字

在一个类上使用 abstarct 关键字，就修饰成了抽象类
用在方法上会修饰成抽象方法，只有名字的定义没有具体的实现过程，称为抽象方法
抽象类如果被继承，其子类则必须重写其父类的抽象方法
抽象类不能 new 出来，需要被子类继承实现
extends 是单继承，接口可以实现多继承
抽象方法必须存在于抽象类中
抽象类中可以定义普通的方法

6.1 抽象方法存在构造器吗？

评论区中讨论

7.接口

普通类：只有具体实现
抽象类：具体实现和规范(抽象方法)
接口：只有规范

通过 insterface 关键字实现，和class关键字同级
接口中不能写方法的具体实现，因为接口中的东西都是抽象的
使用类实现接口的规范时需要使用 implements 关键字，实现了接口的类，就需要重写接口中的方法
接口可以多实现，但也需要重写实现的接口中的方法，其好处是侧面实现了伪多继承
接口中定义的属性都是常量
public static final

7.1 接口特点的小结

约束
定义方法，非不同的"类"进行实现
其方法都是抽象的 public abstarct
其属性全是常量 public static final
接口不能被实例化，接口中没有构造方法
接口可以通过 impements 关键字实现多个
方法必须全部重写

8. N种内部类

概念：在类中，在继续定义一个类，就叫内部类，但同时内部类也分为：

成员内部类：类中定义一个类，调用时：通过外部类进行成员内部类的实例化

public class Outter{

public class Inner{}
}

//调用时：
Outer outer = new Outer();
Outer.Inner = outer.new Inner();

//成员内部类可以方法外部类的私有属性，还可以获取外部类的方法

静态内部类：在class 文件中，编写另外一个不带有public 的class

public class Person{

}
class Pone{
public static void main(String[] args){
System.out.println("我是静态内部类，嘎嘎");
}
}

局部内部类：在方法中定义一个类

public class Person{

public int getNumber(){

class Inner{}
return -1;
 }
}

匿名内部类：不将实例保存到变量

class Apple{
 public static void main(String[] args){
  new Apple.eat();
 }

public void eat(){}
}

9.异常的总结

概念：我们通常称没有正常执行，出现了问题而终止的现象叫做异常。
如：
方法递归互调： StackOverflowError
零作除数 ArithmeticException() : by zero
方法不写分号

java中将异常当做对象进行处理，基类为：java.lang.Throwwable
Throwwable类下分为：Error 和 Exception
前者是不可预料的，后者是可以预料的

Error：Error对象由 java虚拟机生成并抛处，大多数错误与代码编写者所执行的操作无关。
Exception：程序编写异常，又分为，编译时异常，和非编译时异常，编译时异常往往是因为我们编写的程序有问题，非编译时异常，往往是在编写过程中，在编译器中就会报红。

9.1 Error 和 Exception的区别：

前者不可以被处理，后者可被处理

9.2 异常知识点的关键字

try
catch
finally
throw
throws

9.3 实例demo

int a =1;
int b =0;

try{ //监控区域
System.out.println(a/b);
}catch(ArithmeticException e){ //括号中的参数为想要捕获的异常类型
//catch块可以定义多个，其最高为Throwwable，执行是顺序为从低到高，从上到下的
//也就是说如果将Throwwable定义为第一个，那其后面的比它小的类型，不会被执行到
System.out.println("程序出现异常");
}finally{
System.out.println("finally负责善后工作，往往常用于io流的关闭等");
}