9-java学习-多态、抽象类、接口-案例代码

一、多态

1.多态：一种事物，在不同时刻所表现出的不同状态。

多态的前提要有继承。没有继承，那么动态就无从谈起
多态要有方法重写，如果没有方法重写，多态也就没有意义
父类引用指向子类对象

public class MyTest {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();
        
        System.out.println("=======================");
        //多态：父类引用 指向 子类对象
        Animal an=new Cat();
        //多态的方式去调用成员方法，会以子类重写过后的为准
        an.eat();
    }
}
class Animal{
    public void eat(){
        System.out.println("吃饭");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

2. 多态的好处：能够提代码的复用性和维护性（靠继承保证）,可以提高代码的扩展性。

public class MyTest {
    public static void main(String[] args) {
        Zi zi = new Zi();
        System.out.println(zi.num);
        
        System.out.println("=====================");
        //多态的形式访问成员变量的特点，以父类的成员变量为准的。
        Fu fu=new Zi();
        System.out.println(fu.num);
        
        System.out.println("===================");
        //多态形式访问成员方法的特点,以子类重写过后的为准，如果子类没有重写，那就是调用父类的
        Fu fu1 = new Zi();
        fu1.show();
        fu1.show2();
    }
}

class Fu{
    public Fu(){
        System.out.println("父类构造");
    }
    int num=200;
    public void show(){
        System.out.println("fu show");
    }
    public static void show2() {
        System.out.println("fu show22222");
    }

}
class Zi extends Fu{
    public Zi() {
        System.out.println("zi 类 构造");
    }
    int num=500;
    @Override
    public void show() {
        System.out.println(" zi show");
    }
    public static void show2() {
        System.out.println("zi show22222");
    }
}

3.多态的弊端：就是不能调用子类独有的功能

public class MyTest {
    public static void main(String[] args) {
        
        Fu fu = new Zi();  //多态 就是向上转型
        fu.show();
       // fu.haha();就是不能调用子类独有的功能
        //向下转型
        Zi zi= (Zi) fu;
        zi.haha();
    }
}
class Fu{
    public void show(){
        System.out.println("fu show");
    }
}
class Zi extends Fu{
    @Override
    public void show() {
        System.out.println("zi show");
    }
    public void haha(){
        System.out.println("是子类特有的方法");
    }
}

孔子装爹

public class MyTest {
    public static void main(String[] args) {
       孔子爹 k爹 =new 孔子();
        System.out.println(k爹.age);//60
        k爹.teach();
        //做回他自己 向下转型
        孔子 k= (孔子) k爹;
        System.out.println(k.age);//30
        k.playGame();
    }
}

class 孔子爹{
    int age=60;
    public void teach(){
        System.out.println("讲授Java");
    }
}

class 孔子 extends 孔子爹 {
    int age=30;
    @Override
    public void teach(){
        System.out.println("讲论语");
    }
    public void playGame(){
        System.out.println("玩游戏");
    }
}

二、抽象类

1.抽象类不能直接创建对象,但是我们可以通过多态的形式间接来完成父类数据的初始化

一个类为抽象类，此类可以没有抽象方法
一个类中他有了抽象方法，那么此类必须为抽象类
抽象类中有构造方法，构造方法的作用。就是当创建子类对象时来完成父类数据的初始化
抽象类中，既可以有抽象方法。也可以有非抽象方法
抽象类中的所有抽象方法，是强制子类必须重新，非抽象方法，其实让子类继承即可，是否重写不带有强制性。
抽象类中可以定义成员变量，也可以定义常量

public class MyTest {
    public static void main(String[] args) {

        Animal an=new Cat();
    }
}
abstract class AA{
    int num;
    public static final int N=200;
    public void show(){
    }
}

abstract class BB{
    public abstract void haha();
    public abstract void haha2();
    public void show() {
        System.out.println("aaaa");
    }
}
class CC extends BB{
    @Override
    public void haha() {

    }
    @Override
    public void haha2() {
    }
}
abstract class DD extends BB{
    public abstract void dd();
}


class EE extends DD{
    @Override
    public void haha() {
    }
    @Override
    public void haha2() {
    }
    @Override
    public void dd() {
    }
}

2.重写抽象类中的抽象方法

abstract class Person{
    public String name;
    public int age;
    public abstract void eat();
    public abstract void sleep();
    public void show(){
        System.out.println("fu show");
    }
}
//alt+enter 纠错，提示你重写抽象类中的抽象方法
class Student extends Person{

    @Override
    public void eat() {
        System.out.println("学生1");
    }
    @Override
    public void sleep() {
        System.out.println("学生2");
    }
    public void talkLove(){
        System.out.println("学生3");
    }

}

class Teacher extends Person{

    @Override
    public void eat() {
        System.out.println("老师1");
    }

    @Override
    public void sleep() {
        System.out.println("老师2");
    }
    public void teach(){
        System.out.println("讲课");
    }
}

三、接口

1.定义接口

public class MyTest {
    public static void main(String[] args) {
        //Dog 实现了implements  一个接口     父接口 和 子类的关系
        Dog dog = new Dog();
        dog.lookDoor();
        dog.eat();
        dog.fire();
        FireInterface fireInterface=dog;
        fireInterface.fire();

        FireInterface fireInterface1 = new Cat();
        fireInterface1.fire();
        ((Cat) fireInterface1).eat();
        ((Cat) fireInterface1).catchMouse();
        //接口不能实例化
    }
}

public class Cat implements FireInterface{

    public void eat(){
        System.out.println("猫吃鱼");
    }

    public void catchMouse(){
        System.out.println("抓老鼠");
    }

    @Override
    public void fire() {
        System.out.println("猫经过学习，学会了钻火圈");
    }
}

public class Dog implements FireInterface{
    public void eat(){
        System.out.println("吃骨头");
    }
    public void lookDoor(){
        System.out.println("看门");
    }

    @Override
    public void fire() {
        System.out.println("狗会钻火圈了");
    }
}

public interface FireInterface {  
    //定义 接口 interface
    //提供一个抽象的功能，钻火圈
    public abstract void fire();
}

2.动物类：姓名，年龄，吃饭，睡觉。

动物培训接口：跳高
猫继承动物类
狗继承动物类
部分猫继承猫类并实现跳高接口
部分狗继承狗类并实现跳高接口

public class MyTest {
    public static void main(String[] args) {

        胖橘猫 胖橘猫 = new 胖橘猫();
        Animal an = 胖橘猫;
        an.name = "胖橘";
        an.age = 2;
        System.out.println(an.name);
        System.out.println(an.age);
        an.eat();
        an.sleep();
        ((胖橘猫) an).catchMouse();
        JumpIntterface jumpIntterface = 胖橘猫;
        jumpIntterface.jump();

        System.out.println("=================");
        an = new 狸花猫();
        an.name = "狸猫";
        an.age = 3;
        System.out.println(an.name);
        System.out.println(an.age);
        an.sleep();
        an.eat();
        ((狸花猫) an).catchMouse();
    }
}

public abstract class Animal {
    public String name;
    public int age;
    public abstract void eat();
    public abstract void sleep();
}

public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("吃饭);
    }
    @Override
    public void sleep() {
        System.out.println("睡觉");
    }
    public void catchMouse(){
        System.out.println("抓老鼠");
    }
}

public class Dog extends Animal{
    @Override
    public void eat() {
        System.out.println("吃饭");
    }
    @Override
    public void sleep() {
        System.out.println("睡觉");
    }
    public void lookDoor(){
        System.out.println("看看门");
    }
}

public class 旺财狗 extends Dog{
    @Override
    public void eat() {
        System.out.println("旺财 喜欢吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("旺财 不睡觉");
    }
}

public class 狸花猫 extends Cat {

    @Override
    public void eat() {
        System.out.println("狸花猫喜欢吃火腿肠");
    }

    @Override
    public void sleep() {
        System.out.println("狸花猫偶尔睡觉");
    }
}

public class 胖橘猫 extends Cat implements JumpIntterface{

    @Override
    public void eat() {
        System.out.println("胖橘喜欢吃小鱼干");
    }

    @Override
    public void sleep() {
        System.out.println("胖橘天天睡觉");
    }

    @Override
    public void jump() {
        System.out.println("胖橘学会了跳高");
    }
}

public class 赛虎狗 extends Dog implements JumpIntterface{
    @Override
    public void eat() {
        System.out.println("赛虎喜欢吃狗粮");
    }

    @Override
    public void sleep() {
        System.out.println("赛虎也天天睡觉");
    }

    @Override
    public void jump() {
        System.out.println("赛虎学会了跳高");
    }
}

北冥有鱼524

发布了49 篇原创文章 · 获赞 9 · 访问量 1461

私信关注

9-java学习-多态、抽象类、接口-案例代码

9-java学习-多态、抽象类、接口-案例代码

一、多态

1.多态：一种事物，在不同时刻所表现出的不同状态。

2. 多态的好处：能够提代码的复用性和维护性（靠继承保证）,可以提高代码的扩展性。

3.多态的弊端：就是不能调用子类独有的功能

孔子装爹

二、抽象类

1.抽象类 不能直接创建对象,但是我们可以通过多态的形式间接来完成父类数据的初始化

2.重写抽象类中的抽象方法

三、接口

1.定义接口

2.动物类：姓名，年龄，吃饭，睡觉。

猜你喜欢

1.抽象类不能直接创建对象,但是我们可以通过多态的形式间接来完成父类数据的初始化