【Java】多态、final关键字、抽象类、抽象方法

多态(Polymorphism)

【1】多态跟属性无关，多态指的是方法的多态，而不是属性的多态。

【2】案例代入：

public class Animal {//父类：动物：
public void shout(){
System.out.println("我是小动物，我可以叫。。。");
}
}

public class Cat extends Animal{
//喊叫方法：
public void shout(){
System.out.println("我是小猫，可以喵喵叫");
}
public void scratch(){
System.out.println("我是小猫，我可以挠人");
}
}

public class Dog extends Animal{
//喊叫：
public void shout(){
System.out.println("我是小狗，我可以汪汪叫");
}
public void guard(){
System.out.println("我是小狗，我可以看家护院，保护我的小主人。。。");
}
}

public class Pig extends Animal{
public void shout(){
System.out.println("我是小猪，我嗯嗯嗯的叫");
}
public void eat(){
System.out.println("我是小猪，我爱吃东西。。");
}
}

public class Girl {
//跟猫玩耍：
/*public void play(Cat cat){
cat.shout();
}*/
//跟狗玩耍：
/*public void play(Dog dog){
dog.shout();
}*/
//跟小动物玩耍：
public void play(Animal an){
an.shout();
}
}

public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//具体的猫：--》猫的对象
//Cat c = new Cat();
//具体的小女孩：--》女孩的对象
Girl g = new Girl();
//小女孩跟猫玩：
//g.play(c);
//具体的狗---》狗的对象：
//Dog d = new Dog();
//小女孩跟狗玩：
//g.play(d);
//具体的动物：--》动物的对象：
//Cat c = new Cat();
//Dog d = new Dog();
Pig p = new Pig();
Animal an = p;
g.play(an);
}
}

【3】总结：

（1）先有父类，再有子类：--》继承先有子类，再抽取父类 ----》泛化

（2）什么是多态：

多态就是多种状态：同一个行为，不同的子类表现出来不同的形态。

多态指的就是同一个方法调用，然后由于对象不同会产生不同的行为。

（3）多态的好处：

为了提高代码的扩展性，符合面向对象的设计原则：开闭原则。

开闭原则：指的就是扩展是开放的，修改是关闭的。

注意：多态可以提高扩展性，但是扩展性没有达到最好，以后我们会学习反射

（4）多态的要素：

一，继承： Cat extends Animal ,Pig extends Animal, Dog extends Animal

二，重写：子类对父类的方法shout()重写

三，父类引用指向子类对象：

Pig p = new Pig();
Animal an = p;

将上面的代码合为一句话：

Animal an = new Pig();

=左侧：编译期的类型

=右侧：运行期的类型

Animal an = new Pig();

g.play(an); //

public void play(Animal an){//Animal an = an = new Pig();
an.shout();
}

上面的代码，也是多态的一种非常常见的应用场合：父类当方法的形参，然后传入的是具体的子类的对象，

然后调用同一个方法，根据传入的子类的不同展现出来的效果也不同，构成了多态。

内存分析

向下转型，向上转型

现在我就想访问到eat()方法和weight属性：

public class Demo {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
Pig p = new Pig();
Animal an = p;//转型：向上转型
an.shout();
//加入转型的代码：
//将Animal转为Pig类型：
Pig pig = (Pig)an ;//转型：向下转型
pig.eat();
pig.age = 10;
pig.weight = 60.8;
}
}

对应内存：

思考之前的equals方法：

简单工厂设计模式

不仅可以使用父类做方法的形参，还可以使用父类做方法的返回值类型，真实返回的对象可以是该类的任意一个子类对象。

简单工厂模式的实现，它是解决大量对象创建问题的一个解决方案。将创建和使用分开，工厂负责创建，使用者直接调用即可。简单工厂模式的基本要求是

² 定义一个static方法，通过类名直接调用

² 返回值类型是父类类型，返回的可以是其任意子类类型

² 传入一个字符串类型的参数，工厂根据参数创建对应的子类产品

public class Test {
public static void main(String[] args) {
Girl g = new Girl();
//Cat c = new Cat();
//Dog d = new Dog();
//Pig p = new Pig();
Animal an = PetStore.getAnimal("狗");
g.play(an);
}
}

public class PetStore {//宠物店 ---》工厂类
//方法：提供动物
public static Animal getAnimal(String petName){//多态的应用场合（二）
Animal an = null;
if("猫".equals(petName)){//petName.equals("猫") --》这样写容易发生空指针异常
an = new Cat();
}
if("狗".equals(petName)){
an = new Dog();
}
if("猪".equals(petName)){
an = new Pig();
}
return an;
}
}

final

【1】修饰变量；

public class Test {
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//第1种情况：
//final修饰一个变量，变量的值不可以改变，这个变量也变成了一个字符常量，约定俗称的规定：名字大写
final int A = 10;//final修饰基本数据类型
//A = 20; 报错：不可以修改值
//第2种情况：
final Dog d = new Dog();//final修饰引用数据类型，那么地址值就不可以改变
//d = new Dog(); -->地址值不可以更改
//d对象的属性依然可以改变：
d.age = 10;
d.weight = 13.7;
//第3种情况：
final Dog d2 = new Dog();
a(d2);
//第4种情况：
b(d2);
}
public static void a(Dog d){
d = new Dog();
}
public static void b(final Dog d){//d被final修饰，指向不可以改变
//d = new Dog();
}
}

【2】修饰方法；

final修饰方法，那么这个方法不可以被该类的子类重写：

【3】修饰类；

final修饰类，代表没有子类，该类不可以被继承：

一旦一个类被final修饰，那么里面的方法也没有必要用final修饰了（final可以省略不写）

【4】案例：JDK提供的Math类：看源码发现：

（1）使用Math类的时候无需导包，直接使用即可：

（2）Math类没有子类，不能被其他类继承了

（3）里面的属性全部被final修饰，方法也是被final修饰的，只是省略不写了

原因：子类没有必要进行重写。

（4）外界不可以创建对象：

Math m = new Math();

（5）发现Math类中的所有的属性，方法都被static修饰

那么不用创建对象去调用，只能通过类名.属性名类名.方法名去调用

抽象类，抽象方法

【1】抽象类和抽象方法的关系：

抽象类中可以定义0-n个抽象方法。

【2】抽象类作用：

在抽象类中定义抽象方法，目的是为了为子类提供一个通用的模板，子类可以在模板的基础上进行开发，先重写父类的抽象方法，然后可以扩展子类自己的内容。抽象类设计避免了子类设计的随意性，通过抽象类，子类的设计变得更加严格，进行某些程度上的限制。

使子类更加的通用。

【3】代码：

package com.star.test03;
//4.一个类中如果有方法是抽象方法，那么这个类也要变成一个抽象类。
//5.一个抽象类中可以有0-n个抽象方法
public abstract class Person {
//1.在一个类中，会有一类方法，子类对这个方法非常满意，无需重写，直接使用
public void eat(){
System.out.println("一顿不吃饿得慌");
}
//2.在一个类中，会有一类方法，子类对这个方法永远不满意，会对这个方法进行重写。
//3.一个方法的方法体去掉，然后被abstract修饰，那么这个方法就变成了一个抽象方法
public abstract void say();
public abstract void sleep();
}
//6.抽象类可以被其他类继承：
//7.一个类继承一个抽象类，那么这个类可以变成抽象类
//8.一般子类不会加abstract修饰，一般会让子类重写父类中的抽象方法
//9.子类继承抽象类，就必须重写全部的抽象方法
//10.子类如果没有重写父类全部的抽象方法，那么子类也可以变成一个抽象类。
class Student extends Person{
@Override
public void say() {
System.out.println("我是东北人，我喜欢说东北话。。");
}
@Override
public void sleep() {
System.out.println("东北人喜欢睡炕。。");
}
}
class Demo{
//这是一个main方法，是程序的入口：
public static void main(String[] args) {
//11.创建抽象类的对象：-->抽象类不可以创建对象
//Person p = new Person();
//12.创建子类对象：
Student s = new Student();
s.sleep();
s.say();
//13.多态的写法：父类引用只想子类对象：
Person p = new Student();
p.say();
p.sleep();
}
}

【4】面试题：

（1）抽象类不能创建对象，那么抽象类中是否有构造器？

抽象类中一定有构造器。构造器的作用给子类初始化对象的时候要先super调用父类的构造器。

（2）抽象类是否可以被final修饰？

不能被final修饰，因为抽象类设计的初衷就是给子类继承用的。要是被final修饰了这个抽象类了，就不存在继承了，就没有子类。