首页 > 编程语言> 文章详细

Day11 Java 多态、抽象

2022-01-15 23:01:47 阅读：172 来源： 互联网

标签：Java void 多态 abstract class Day11 抽象类 public

多态：某一事物在不同时刻表现出来的不同状态。例如：水有液态，固态和气态等。

多态的前提：

1、要有继承关系

2、要有方法的重写，没有重写意义不大。

3、要有父类的引用指向子类的对象：父类名 f =new 子类名（。。。）;

多态访问成员的特点：

1、成员变量编译看左，运行看左

2、构造方法创建子类对象的时候，先访问父类中的构造方法，对父类的数据先进行初始化 3、成员方法编译看左，运行看右。因为成员方法存在重写，所以访问看右边

4、静态成员方法编译看左，运行也看左。由于被static修饰的成员都是与类相关的，这里不是重写，所以运行的时候，访问的还是左边的。

多态的弊端1：多态无法访问父类中的方法名一样的方法

解决办法：不使用多态

弊端2：多态无法访问子类中特有的方法

解决办法：向下转型，类似于强制类型转换

格式：子类类名变量名 = （子类类名）父类的引用;

对象之间的转型问题：

向上转型：Fu f = new Son()；这其实就是多态的格式

向下转型：Son s = (Son)f;该转型要求转型的类与父类引用存在继承关系，并且一开始创建多态的时候，使用的是该类。

猫狗案例：

class Animal{
    public void eat(){
        System.out.println("吃东西");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");;
    }
    public void run(){
        System.out.println("猫抓老鼠");
    }
}
class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
    public void look(){
        System.out.println("狗看家");
    }
}
public class Test1 {
    public static void main(String[] args) {
        Animal a=new Cat();
        a.eat();
//    这里无法执行a.run()，因为多态无法访问子类的特有方法，需要向下转型：
        Cat c=(Cat)a;//向下转型
        c.eat();
        c.run();
        Animal a2=new Dog();
        a2.eat();//这里同上无法执行a2.look(),需要向下转型才可以执行
        Dog d=(Dog)a2;
        d.eat();
        d.look();

    }
}

抽象：将一个不具体的功能叫做抽象方法，如果一个类中有抽象方法，就把这个类称之为抽象类。

抽象类的特点：

1、抽象类和抽象方法都需要一个关键字来修饰：abstract

修饰一个类，放在class前面，例：abstract class Animal{};

修饰一个方法，一般放在权限修饰符后面：

定义一个抽象的show方法：public abstract void show();

2、有抽象方法的类一定是抽象类，但是抽象类不一定有抽象方法，具体的类不能有抽象方法，抽象类中可以存在抽象方法，也可以存在有方法体的方法。

3、抽象类不能被实例化，如何调用：

通过多态的形式，使用具体的子类去实例化调用方法，专业术语为：抽象多态

4、如果继承抽象类的是一个具体子类，需要重写该抽象类中所有的抽象方法；如果继承抽象类的也是一个抽象类，可以不去重写父类中的方法，也可以选择性的去重写。

abstract class Animal{
    public abstract void eat();
    public abstract void drink();
//    注意：抽象方法没有方法体{}，连大括号都没有，直接以分号结尾
//    Java抽象方法不能有主体
}
class Dog extends Animal{
        @Override
        public void eat(){
        System.out.println("狗吃肉");
    }
    public void drink(){
        System.out.println("狗喝水");
    }
}
//选择性重写抽象方法
abstract class Demo{
    public abstract void fun();
    public abstract void fun2();
}
abstract class Demo2 extends Demo{
    public void fun(){
        System.put.println("抽象类Demo2重写了fun方法");
    }
}
public class AbstractDemo1 {
    public static void main(String[] args) {       
        //利用具体子类多态形式创建对象
        //抽象多态的形式
        Animal3 a = new Dog3();
        a.eat();
        a.drink();


    }
}

抽象类的成员特点：

成员变量：既可以是变量，也可以是常量

构造方法：可以存在构造方法，但是抽象类不能被实例化，这里的构造方法方法理论上说没有意义，但实际上构造方法在这里提供了一个在继承中初始化父类的作用。

成员方法：可以是抽象方法，但是具体的子类必须要重写该方法；也可以不是抽象方法，提高代码的复用性。

abstract class Animal{
    int a=20;
    int b=100;
    Animal(){
        System.out.println("这是Animal中无参构造方法");
    }
    public abstract void eat();
    public abstract void show(){
        System.out.println("父类中不是抽象方法的show");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}
public class AbstractDemo2 {
    public static void main(String[] args) {
        Animal4 a = new Cat4();
        System.out.println(a.a);
        System.out.println(a.b);
        a.eat();
        a.show();
    }
}

抽象类中可以存在哪些关键字？

abstract关键字不能和哪些关键字共存？

private; static; final;

标签：Java,void,多态,abstract,class,Day11,抽象类,public
来源： https://blog.csdn.net/m0_64350718/article/details/122516478

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Day11 Java 多态、抽象