抽象类,多态

1.抽象类（abstract class）

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

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

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

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

2）语法

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

3）抽象类的特性

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

 1 public abstract class Animal{
 2     private String name;
 3     
 4     public void setName(String name){
 5         this.name = name;
 6     }
 7     public String getName(){
 8         return this.name;
 9     }
10     
11     public Animal(){
12         
13     }
14     
15     public Animal(String name){
16         this.name = name;
17     }
18     
19     public void sleep(){
20         
21     }
22 }

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

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

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

　　—抽象方法没有方法体；

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

 1 public abstract class Animal{
 2     private String name;
 3     
 4     public void setName(String name){
 5         this.name = name;
 6     }
 7     public String getName(){
 8         return this.name;
 9     }
10     
11     public Animal(){
12         
13     }
14     
15     public Animal(String name){
16         this.name = name;
17     }
18     
19     public abstract void sleep();
20 }

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

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

2.重写和实现

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

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

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

3.final关键字

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

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

 1 public final class Animal{
 2 }
 3 public class Person extends Animal{
 4     
 5     
 6     public void sleep(){
 7         System.out.println("闭眼躺着睡觉...");
 8     }
 9     
10 }

[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）多态的概念

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

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

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

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

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

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

 1 packagecn.sxt05;
 2 
 3 publicclass Test01 {
 4     publicstaticvoid main(String[] args) {
 5         
 6         // 多态
 7         // 同一引用类型
 8         Pet pet = null;
 9         // 父类引用引用子类对象
10         pet = new Dog("二狗",100,0,"土狗");
11         // 呈现多态
12         pet.eat();
13         
14         pet = new Penguin("大脚", 90, 50, Penguin.SEX_FEMALE);
15         // 呈现多态
16         pet.eat();
17     }
18 }

3）多态的步骤

——1.编写父类

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

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

6.多态的实现形式

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

1 // 多态
2 // 同一引用类型
3 Petpet = null;
4 // 父类引用引用子类对象
5 pet = new Dog("二狗",100,0,"土狗");
6 // 呈现多态
7 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）

 1 public Pet adoptPet(int type) {
 2         Pet pet = null;
 3         if(1 == type) {
 4             pet = newDog();
 5         }elseif(2 == type) {
 6             pet = newPenguin();
 7         }elseif(3 == type){
 8             pet = newCat();
 9         }
10         returnpet;
11     }

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

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

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

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

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

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

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

1 publicclassTestInstanceOf {
2     publicstaticvoid main(String[] args) {
3         Dog dog = newDog();
4         System.out.println(doginstanceof Dog);//true
5         System.out.println(doginstanceof Pet); //true
6         System.out.println(doginstanceof Object);//true
7     }
8 }

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

1     publicvoidplay(Pet pet) {
2         if(petinstanceof Dog) {
3             Dog dog = (Dog) pet;
4             dog.catchFlyDisc();
5         }elseif(petinstanceof Penguin) {
6             Penguin penguin = (Penguin) pet;
7             penguin.swimming();
8         }
9     }

8.调试技巧

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

——step into:进入方法调试

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

——停止调试