抽象类,多态

1.抽象类（abstract class）

1）概念：当一个类的方法过于抽象，使输出没有实际意义，这个方法就是抽象方法，抽象方法所在的类称为抽象类。

如：人是闭眼睡觉   鱼是睁眼睡觉    动物是怎样睡觉这个方法不能确定如何实现，动物这个类就是抽象类

——子类在金字塔底部   父类在顶部 

C extends B，B extends A，在继承过程中，形成一个继承金字塔，位于金字塔底部的类越来越具体(强大)，位于塔顶的越来越抽象(简单)。

2）语法

public abstract class  类名 {        }           [这个类是抽象类]

3）抽象类的特性

　[1].抽象类过于抽象，实例化后无语义=>不能实例化

public abstract class Animal{
    private String name;
    
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    
    public Animal(){
        
    }
    
    public Animal(String name){
        this.name = name;
    }
    
    public void sleep(){
        
    }
}

　　

 [2].如果一个方法过于抽象无法实现，需要把该方法声明为抽象方法。

声明方式：public abstract void sleep();

注：—抽象方法一定在抽象类中；

　　—抽象方法没有方法体；

　　—抽象类不一定都是抽象方法

public abstract class Animal{
    private String name;
    
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
    
    public Animal(){
        
    }
    
    public Animal(String name){
        this.name = name;
    }
    
    public abstract void sleep();
}

 [3].子类继承抽象类，一定要根据自身情况重写抽象类的抽象方法，除非子类也是抽象类。

public class Person extends Animal{
    
    public void sleep(){
        System.out.println("闭眼躺着睡觉...");
    }
}

2.重写和实现

1）.重写是指父类的方法不能满足子类的需求，子类会根据自身的需求重写父类的同名方法。

2）.实现是指子类继承抽象父类是，没有方法体，也就是没有实现方法，这时子类一定要对父类进行重写，这种重写方式成为方法的实现。

　　实现是重写的一种特殊方式，和重写一样，有继承才有实现。

3.final关键字

    用法：final是一个java的关键字，用于修饰局部变量、属性、方法、类，表示最终的意思。

[1].final修饰类表示最终类，无法被继承

public final class Animal{
}
public class Person extends Animal{
    
    
    public void sleep(){
        System.out.println("闭眼躺着睡觉...");
    }
    
}

[2].final修饰符方法，方法就不能被重写

public final void sleep(){
        System.out.println("animal:sleep");
}

[3].final 修饰属性，经常和static搭配使用，形成静态常量。

public static final String SEX_MALE = “Q仔”;
public static final String SEX_FEMALE = “Q妹”;

[4]. final修饰变量

修饰基本数据类型

final int a=10；  表示变量a=10不能被改变。

修饰引用数据类型（表示person中的内容(地址)不能被改变）

public class Test01{
    public static void main(String[] args){
        
        final Person person = new Person();
        person.sleep();
        
        person = new Person();
        person.sleep();
        
    }
}

思考:

[1]静态方法能被继承吗？   可以

[2]静态方法可以被重写吗？  不能，被隐藏了

4.开发工具

1）.eclipse:www.eclipse.org

下载地址:https://www.eclipse.org/downloads/packages/

IDEA:高级部分

2）配置智能提示

3）快捷键

快捷键	描述
ctrl+m	最大化/恢复编辑区
ctrl + +/-	放大/缩小字体
shift+alt+s	呼出source菜单
ctrl+alt+向上/向下	快速复制代码
ctrl+2,L	快速生成本地变量
alt+向上/向下	快速移动代码
ctrl+1	快速修复/建议代码

 5.多态

1）为何使用多态

软件设计原则———开闭原则        即  对拓展开放，对修改关闭。

为什么要使用多态？

对系统进行业务拓展，增加系统的可维护性。

 2）多态的概念   

自我解读：在父类中 对 不同子类实例的  相同方法 的结果不同。

生活中的多态：同一事物，由于条件不同，产生的结果不同

程序中的多态：同一引用类型，使用不同的实例而执行结果不同的。

——同:同一个类型，一般指父类。

——不同:不同的子类实例

——不同:针对同一方法执行的结果不同

packagecn.sxt05;

publicclass Test01 {
    publicstaticvoid main(String[] args) {
        
        // 多态
        // 同一引用类型
        Pet pet = null;
        // 父类引用引用子类对象
        pet = new Dog("二狗",100,0,"土狗");
        // 呈现多态
        pet.eat();
        
        pet = new Penguin("大脚", 90, 50, Penguin.SEX_FEMALE);
        // 呈现多态
        pet.eat();
    }
}

3）多态的步骤

——1.编写父类

——2.编写子类，子类一定 重写/实现 父类的方法

——3.运行时，父类类型引用子类对象 (Pet pet = new Dog()

6.多态的实现形式

[1]父类类型引用子类对象(本质)

// 多态
// 同一引用类型
Petpet = null;
// 父类引用引用子类对象
pet = new Dog("二狗",100,0,"土狗");
// 呈现多态
pet.eat();

解读：pet = new Dog() 父类类型引用子类对象，当调用eat方法时，执行的是被子类对象重写/实现的eat方法。

[2]父类作为方法形参实现多态（Pet pet）

Public void feed(Pet pet) {
        System.out.println(this.getName() + "正在喂" + pet.getName());
        pet.eat();
    }

[3]父类作为方法的返回值实现多态（Pet）

public Pet adoptPet(int type) {
        Pet pet = null;
        if(1 == type) {
            pet = newDog();
        }elseif(2 == type) {
            pet = newPenguin();
        }elseif(3 == type){
            pet = newCat();
        }
        returnpet;
    }

7.类型转化（引用数据类型转化）

在多态中存在两种类型转换，一种是自动类型转换，一种是强制类型转换。

1）自动类型转换也称向上类型转换。子类可以自动转换成父类   ( 狗是动物 )

Pet pet = null;
pet = new Dog();

2）强制类型转换也称向下类型转换。父类可以强制转换成子类  （动物是狗，所以要强制转换+（Dog））

         子类类型引用 = (子类)父类对象 如Dog dog=(Dog) pet;

一般而言，需要判断父类对象的真实类型，用instanceof关键字        (obj instanceOf类/接口判断obj是否是类/接口的实例)

publicclassTestInstanceOf {
    publicstaticvoid main(String[] args) {
        Dog dog = newDog();
        System.out.println(doginstanceof Dog);//true
        System.out.println(doginstanceof Pet); //true
        System.out.println(doginstanceof Object);//true
    }
}

如果要调用子类特有的方法时，一定要强制类型转换，通过instanceof鉴别具体类型

    publicvoidplay(Pet pet) {
        if(petinstanceof Dog) {
            Dog dog = (Dog) pet;
            dog.catchFlyDisc();
        }elseif(petinstanceof Penguin) {
            Penguin penguin = (Penguin) pet;
            penguin.swimming();
        }
    }

8.调试技巧

——stepover:单步调试，一次只执行一行代码。

——step into:进入方法调试 

——step return:返回/结束方法

——停止调试