Java学习总结--009多态+抽象类+接口

最新推荐文章于 2023-05-07 22:46:10 发布

sky-m

最新推荐文章于 2023-05-07 22:46:10 发布

阅读量231

点赞数

分类专栏： JAVA学习总结文章标签： Java 多态抽象类接口

本文链接：https://blog.csdn.net/web116629/article/details/89338258

版权

JAVA学习总结专栏收录该内容

76 篇文章 0 订阅

订阅专栏

多态

某一个事物，在不同时刻表现出来的不同状态。
前提：
a:要有继承关系。
b:要有方法重写。其实没有也是可以的，但是如果没有这个就没有意义。
c:要有父类引用指向子类对象。
父 f = new 子();

1.多态中的成员访问特点
a:成员变量
编译看左边，运行看左边。
b:构造方法
创建子类对象的时候，会访问父类的构造方法，对父类的数据进行初始化。
c:成员方法
编译看左边，运行看右边。
d:静态方法
编译看左边，运行看左边。

2.多态的好处
a:提高了代码的维护性(继承保证)
b:提高了代码的扩展性(由多态保证)
多态的弊端：不能使用子类特有的功能；
解决方法：把父类的引用强制转换为子类的引用。(向下转型)

public class MyTest {
    public static void main(String[] args) {
        //  09.05_ 案例演示 孔子装爹
        //孔子爹，是西开的一个高级讲师，会讲授java 李四闻名而来，请孔子爹到家里给他将java
        //就留孔子一个人在家，这时候张三也来让孔子爹来讲java 孔子爹这时候不在家，那孔子又不
        //想失去这个学生
        //所以孔子，假扮成他爹，给张三 讲论语
        //讲完之后，孔子好累，玩游戏休息下，那么卸下这套装备，去玩游戏
        孔子爹 坑爹 = new 孔子();
        System.out.println(坑爹.age);
        坑爹.teache();
        //向下转型，做回他自己
        孔子 k = (孔子) 坑爹;
        System.out.println(k.age);
        k.playGame();
    }
}
class 孔子爹 {
    int age = 60;
    public void teache() {
        System.out.println("讲授java");
    }
}
class 孔子 extends 孔子爹 {
    int age = 30;
    @Override
    public void teache() {
        System.out.println("讲授论语");
    }
    public void playGame() {
        System.out.println("玩王者荣耀");
    }
}

抽象类

在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类。
1.抽象类特点
a:抽象类和抽象方法必须用abstract关键字修饰；
抽象类格式: abstract class 类名 {}
抽象方法格式: public abstract void eat();
b:抽象类不一定有抽象方法，有抽象方法的类一定是抽象类；
c:抽象类中可以有构造方法,抽象类不能进行实例化；
构造方法用于子类访问父类数据时的初始化；
d:抽象类不能直接实例化；抽象类如何实例化呢?
按照多态的方式，由具体的子类实例化。其实这也是多态的一种，抽象类多态。
e:抽象类的子类
要么是抽象类；
要么重写抽象类中的所有抽象方法；
2.抽象类的成员特点
a:成员变量：既可以是变量，也可以是常量；
b:构造方法：有。
用于子类访问父类数据的初始化。
c:成员方法：既可以是抽象的，也可以是非抽象的。
3.抽象类的成员方法特性：
a:抽象方法：强制要求子类做的事情；
b:非抽象方法：子类继承的事情，提高代码复用性；
举个例子：

public class MyTest {
    public static void main(String[] args) {
      //  new Animal();//抽象类不能直接创建对象
        //我们可以采用多态间接的去实例化抽象类
        Animal an=new Cat();
        an.eat();
        an.sleep();
        an.show();
    }
}

//一旦一个类中，有了抽象方法，此类必须为抽象类
public abstract class Animal {
    public Animal() {
        System.out.println("父类的构造方法执行了");
    }
    //abstract 抽象的，可以修饰类，修饰方法
    public abstract void eat(); //抽象方法，此方法没有方法实现
    public abstract void sleep();
    //抽象类中既可以有抽象方法，也可以非抽象方法
    public void show(){
        System.out.println("这是父类的一个非抽象方法");
    }
}
class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫爱吃鱼");
    }
    @Override
    public void sleep() {
        System.out.println("猫白天睡觉");
    }
}

案例演示
假如我们在开发一个系统时需要对员工(Employee)类进行设计，员工包含3个属性：姓名、工号以及工资(salary)。
经理(Manager)也是员工，除了含有员工的属性外，另为还有一个奖金(bonus)属性。
然后定义工作的方法.
请使用继承的思想设计出员工类和经理类。

public class MyTest {
    public static void main(String[] args) {
        //A:
        //案例演示
        //假如我们在开发一个系统时需要对员工(Employee) 类进行设计，员工包含3个属性：姓名、工号以及工资(salary)。
        //经理(Manager) 也是员工，除了含有员工的属性外，另为还有一个奖金(bonus) 属性。
        //然后定义工作的方法.
        //        请使用继承的思想设计出员工类和经理类。
        Person p = new Employee();
        p.name="张三";
        p.num=1;
        p.salary=2000;
        System.out.println(p.name+"=="+p.num+"==="+p.salary);
        p.work();
        System.out.println("--------------------");
        p=new Manager();
        p.name = "lisi";
        p.num = 2;
        p.salary = 4000;
        ((Manager) p).bonus=2000;
        System.out.println(p.name+"==="+((Manager) p).bonus+"==="+p.num);
        p.work();
    }
}

public abstract class Person {
    //姓名、
    //工号以及工资(salary)。
    public String name;
    public int num;
    public double salary;
    public abstract void work();
}

public class Employee extends Person{
    @Override
    public void work() {
        System.out.println("员工敲代码");
    }
}

public class Manager extends Person{
    public double bonus;
    @Override
    public void work() {
        System.out.println("经理管理员工");
    }
}

1.一个类如果没有抽象方法，可不可以定义为抽象类?如果可以，有什么意义?
答案: 可以 . 不能创建对象.
2.abstract不能和哪些关键字共存?
private 冲突
final 冲突
static 不能共存无意义

接口

为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现。
interface 用来定义接口。
1.接口特点
a:接口用关键字interface表示格式: interface 接口名 {}
b:类实现接口用implements表示格式: class 类名 implements 接口名 {}
c:接口不能实例化
按照多态的方式来实例化。
d:接口的子类
1）可以是抽象类。但是意义不大。
2）可以是具体类。要重写接口中的所有抽象方法。

2.接口成员特点
成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。方法前面存在默认修饰符 public abstract
接口中成员变量前面有默认的修饰符 public static final
建议：自己手动给出。

3.类与类,类与接口,接口与接口的关系
a:类与类：
继承关系,只能单继承,可以多层继承。
b:类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
c:接口与接口：
继承关系,可以单继承,也可以多继承。

4.抽象类和接口的区别
抽象类和接口的区别；
抽象类，抽取所有子类的共性功能，并强制子类对共性功能进行重写；
接口，定义的是整个继承体系当中的一些额外的扩展功能，哪些类想要具备这些扩展功能，可以具体去实现某个接口。
抽象类中有构造方法，接口没有构造方法；
抽象类中既可以有抽象方法，也可以有非抽象方法，接口中全是抽象方法；
抽象类中既可以有成员变量，也可以有常量，接口中全是公共的静态的常量；

A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
C:设计理念区别
抽象类被继承体现的是：”is a”的关系。抽象类中定义的是该继承体系的共性功能。
接口被实现体现的是：”like a”的关系。接口中定义的是该继承体系的扩展功能。
注意：JDK1.8之后在接口中提供了用default修饰的方法，可以给出功能的具体实现，子类可以继承下去用。
案例：

public class MyTest {
    public static void main(String[] args) {
        //A:
        //案例演示
        //动物类：姓名，年龄，吃饭，睡觉。
        //动物培训接口：跳高
        //        猫继承动物类
        //狗继承动物类
        //  部分猫继承猫类并实现跳高接口
        //部分狗继承狗类并实现跳高接口
        //
        //通过抽象类测试基本功能。
        //通过接口测试扩展功能。
        //只测试猫，狗的测试留给学生自己练习
        KittyCat cat = new KittyCat();
        Animal an = cat;
        an.name = "kitty";
        an.age = 1;
        System.out.println(an.name + "===" + an.age);
        an.eat();
        an.sleep();
        JumpInterface jumpInterface = cat;
        jumpInterface.jump();

        System.out.println("---------------");
        TomCat tomCat = new TomCat();
        an = tomCat;
        an.name = "tom";
        an.age = 2;
        System.out.println(an.name + "===" + an.age);
        an.eat();
        an.sleep();
        System.out.println("----------------------------------");
        WangCaiDog wc = new WangCaiDog();
        an = wc;
        an.name = "旺财";
        an.age = 3;
        System.out.println(an.name + "===" + an.age);
        an.sleep();
        an.eat();
        //WangCaiDog w= (WangCaiDog) an;
        //w.lookDoor();
        ((WangCaiDog) an).lookDoor();
        jumpInterface = wc;
        jumpInterface.jump();

        System.out.println("-----------------");
        XiaoTianDog xiaoTianDog = new XiaoTianDog();
        an = xiaoTianDog;
        an.name = "哮天犬";
        an.age = 10000;
        an.eat();
        an.sleep();
        //向下转型
        ((XiaoTianDog) an).fashu();
    }
}

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

public interface JumpInterface {
    void jump();
}

public class Cat extends Animal{
    @Override
    public void eat() {
    }
    @Override
    public void sleep() {
    }
}

public class KittyCat extends Cat implements JumpInterface{
    @Override
    public void eat() {
        System.out.println("kitty猫吃蛋糕");
    }
    @Override
    public void sleep() {
        System.out.println("kitty猫整体睡觉");
    }
    @Override
    public void jump() {
        System.out.println("kitty猫学会跳高了");
    }
}

public class TomCat extends Cat{
    @Override
    public void eat() {
        System.out.println("汤姆猫想吃杰瑞");
    }
    @Override
    public void sleep() {
        System.out.println("汤姆猫假装睡觉");
    }
    public void actor(){
        System.out.println("汤姆猫是一个演员");
    }
}

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

public class WangCaiDog extends Dog implements JumpInterface{
    @Override
    public void eat() {
        System.out.println("旺财吃的是狗粮");
    }
    @Override
    public void sleep() {
        System.out.println("旺财晚上睡觉");
    }
    public void lookDoor(){
        System.out.println("旺财看门");
    }
    @Override
    public void jump() {
        System.out.println("旺财学会里跳高");
    }
}