多态
多态是面向对象编程中最后一个（封装、继承、多态）也是最重要的特征。
程序设计当中，多态意味着，允许不同类的对象对同一消息做出不同的响应。
多态分为：
- 编译时多态 （设计时多态方法重载）
-
运行中多态 （程序运行时动态决定调用哪个方法）
一般所说的java中的多态大多是运行时多态。
必要条件
示例
新建一个Animal类，作为动物基类，有两个属性，name、month，和一个eat方法。
Animal的子类中有自己特有的子类属性和方法，
Cat中有weight、run()，
Dog中有sex、sleep()。
且都重写了父类Animal中的eat()方法。
新建Animal.java：
public class Animal {
private String name;
private int month;
public Animal(){
}
public Animal(String name, int month){
this.name = name;
this.month = month;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMonth() {
return month;
}
public void setMonth(int month) {
this.month = month;
}
public void eat(){
System.out.println("动物都有吃东西的能力");
}
}
新建Cat.java:
public class Cat extends Animal{
private double weight;
public Cat(){
}
public Cat(String name, int monnth, double weight){
super(name, monnth);
this.weight = weight;
}
public double getWeight() {
return weight;
}
public void setWeight(double weight) {
this.weight = weight;
}
public void run(){
System.out.println("小猫快乐地奔跑");
}
@Override
public void eat() {
super.eat();
System.out.println("猫吃鱼");
}
}
新建Dog.java:
public class Dog extends Animal {
private String sex;
public Dog(){
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public Dog(String name, int month, String sex){
this.setMonth(month);
this.setName(name);
this.setSex(sex);
}
public void sleep(){
System.out.println("小狗午睡");
}
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
然后在定义一个测试文件Test.java:
public class Test {
public static void main(String[] args){
Animal one = new Animal();
Animal two = new Cat();
Animal three = new Dog();
one.eat();
two.eat();
three.eat();
}
}
运行Test.java
虽然都是吃这种行为，也同样都是Animal类型的引用，但是随着它具体在程序运行时实例化的对象类型不同，那么它的执行的具体行为能力是不一样的，这就是在java中多态的表现。
向上转型
父类引用指向子类实例：Animal one = new Animal();
把一个子类对象转型为父类对象，向上转型(隐式转型、自动转型)，代码中是父类引用指向子类实例，
父类引用指向子类实例，可以调用子类重写父类的方法以及父类派生的方法，无法调用子类独有的方法。
注意：
父类中的静态方法无法被子类重写，所以向上转型之后，只能调用父类原有的静态方法
向下转型(强制类型转换)
子类引用指向父类实例，必须进行强制类型转换，可以调用子类特有的方法。
必须满足转型条件才能强转。
instanceof运算符可以进行判断，左边对象是否是他右边对象的实例，换句话说就是左侧对象是否满足右侧对象类型的特征如果是，返回true。
if (obj instanceof Cat)
父类中的静态方法(含有static修饰的方法)，只能被子类继承使用，无法被子类重写。
public static void say(){
}
抽象类
Java中使用抽象类，限制实例化
public abstract class A{
}
通过abstract 修饰的类叫做抽象类。
当一个类为抽象类时，就不允许实例化了，可以通过向上转型指向子类。
抽象类应用场景：
某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
当我们将父类设置为抽象类时，既可以借由父类和子类的继承关系限制子类随意性，同时也在一定程度上避免了无意义的实例化。
抽象方法
abstract 修饰的方法为抽象方法。
抽象方法要求：
- 不允许包含方法体
- 子类中必须重写父类中的抽象方法
- 如果不重写，子类自己必须被定义为抽象类
- 包含抽象方法的类必须是抽象类
总结：
- 抽象类不能直接实例化
- 子类如果没有重写父类所有的抽象方法，则也要定义为抽象类
- 抽象方法所在的类一定是抽象类
- 抽象类中可以没有抽象方法
- static、final、private关键字不能与abstract 并存。
接口
当多个类型之间具有相同的行为能力的时候，java中可以借由接口来进行类型之间的联系。
通过接口可以解决java当中单继承所带来的一些类型无法共享的问题。
- 接口定义了某一批类所需要的遵守的规范
- 接口不关心这些类的内部数据，也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
语法：
[修饰符] interface 接口名 [extends 父接口1，父接口2...]
{
零个到多个常量定义...
零个到多个抽象方法定义...
零个到多个默认方法定义...（jdk1.8新增）
零个到多个静态方法方法的定义...（jdk1.8新增）
}
- 接口可以实现多继承，即一个子接口可以同时继承多个父接口
- 实现接口的类如果不能实现所有接口中待重写的方法，则必须设置为抽象类。
- 一个类可以继承自一个父类，同时实现多个接口
内部类
在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。与之对应，包含内部类的类称为外部类。
内部类分为四种：
优势：内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包的其他类访问该类，更好的实现了信息隐藏。
1.成员内部类
内部类中最常见的就是成员内部类，也称为普通内部类。
如下：
package com.imooc.people;
//外部类
public class Demo {
int name;
public He getSex(){
return new He();
}
//成员内部类
class He{
public String sex(){
return "男";
}
}
}
获取内部类对象实例的三种方式：
public static void main(String[] args){
Demo a = new Demo();
a.name = 3;
//方式一
Demo.He h = new Demo().new He();
//方式二
h = a.new He();
//方式三
a.getSex();
}
- 内部类在外部使用时，无法直接实例化，需要借由外部类信息才能完成实例化
- 内部类的访问修饰符，可以任意，但是访问范围会受到影响
- 内部类可以直接访问外部类的成员；如果出现同名属性，优先访问内部类中定义的
- 可以使用外部类.this.成员的方式，访问外部类中同名的信息
- 外部类访问内部类信息，需要通过内部类实例，无法直接访问
- 内部类编译后.class文件命名：外部类$内部类.class
2.静态内部类
- 静态内部类中，只能直接访问外部类的静态成员，如果需要调用非静态成员，可以通过对象实例
- 静态内部类对象实例时，可以不依赖于外部类对象
- 可以通过外部类.内部类.静态成员的方式，访问内部类中的静态成员
- 当内部类属性与外部类属性同名时，默认直接调用内部类中的成员；
- 如果需要访问外部类中的静态属性，则可以通过 外部类.属性 的方式；
- 如果需要访问外部类中的非静态属性，则可以通过 new 外部类().属性的方式；
3.方法内部类
定义在外部类方法中的内部类，也称为局部内部类。
方法的约束对方法内部类同样有效。
- 定义在方法内部，作用范围也在方法内
- 和方法内部成员使用规则一样，class前面不可以添加public、private、protected、static
- 类中不能包含静态成员
- 类中可以包含final、abstract修饰的成员
4.匿名内部类
匿名内部类
public static void main(String[] args) {
PersonTest test=new PersonTest();
test.getRead(new Person(){
{
//构造代码块
}
@Override
public void read() {
System.out.println("男生喜欢看科幻类书籍");
}
});
test.getRead(new Person(){
@Override
public void read() {
System.out.println("女生喜欢读言情小说");
}
});
}
}
- 匿名内部类没有类型名称、实例对象名称
- 编译后的文件命名：外部类$数字.class
- 无法使用private、public、protected、abstract、static修饰
- 无法编写构造方法，可以添加构造代码块
- 不能出现静态成员
- 匿名内部类可以实现接口也可以实现继承父类，但是不可兼得
如果内容对你有帮助，记得关注作者给个赞哦~，后续会持续更新。
