澳门在线威尼斯官方 > 电脑操作 > 11_Java面向对象_第11天,面向对象之

原标题:11_Java面向对象_第11天,面向对象之

浏览次数:84 时间:2019-11-17

 

前天内容介绍
1、接口
2、多态

代码裤子:

01接口的概念

* A:接口的概念
    接口是功能的集合,同样可看做是一种数据类型,是比抽象类更为抽象的”类”。
    接口只描述所应该具备的方法,并没有具体实现,具体的实现由接口的
    实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离,优化了程序设计。
    请记住:一切事物均有功能,即一切事物均有接口。

在线编制程序:https://mybinder.org/v2/gh/lotapp/BaseCode/master
在线预览:http://github.lesschina.com/python/base/oop/2.持续与多态.html

02接口的定义

  • A: 接口的定义
  • 与定义类的class分裂,接口定义时索要运用interface关键字。

    定义接口所在的仍为.java文件,虽然声明时使用的为interface关键字的编译后
    仍然会产生.class文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。
    
  • B : 定义格式

  • public interface 接口名 {

        抽象方法1;
        抽象方法2;
        抽象方法3;
    }
    
  • C: 定义步骤

  • 接受interface代替了原先的class,别的步骤与定义类相似:
    接口中的方法均为公共访问的抽象方法
    接口中无法定义普通的成员变量
    

2.继承 ¶

03接口的贯彻类

  • A: 类与接口的涉及
  • 类与接口的涉嫌为完成关系,即类达成接口。达成的动作相像世袭,只是关键字分歧,达成利用implements。

    其他类(实现类)实现接口后,就相当于声明:”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。
    
  • B: 类达成接口的格式

  • class 类 implements 接口 {

        重写接口中方法
    } 
    
  • C:注意事项

  • 在类完毕接口后,该类就能够将接口中的抽象方法世襲过来,此时此类须求重写该抽象方法,完结具体的逻辑。
    接口中定义功能,当需要具有该功能时,可以让类实现该接口,只声明了应该具备该方法,是功能的声明。
    在具体实现类中重写方法,实现功能,是方法的具体实现。
    

2.1.单继承 ¶

在OOP中,当我们定义二个Class的时候,能够从有些现成的Class世袭

新的Class称为子类,而被持续的class称为 基类 或然 父类

Python的继续格式 ==> xxx(base_class)

小明兴趣盎然的听着教师开新课,不一会就映注重帘了二个演示德姆o:

In [1]:

class Animal(object):
    def eat(self):
        print("动物会吃")

class Cat(Animal):
    # 注意一下Python的继承格式
    pass

class Dog(Animal):
    pass

def main():
    cat = Cat()
    dog = Dog()
    cat.eat()
    dog.eat()

if __name__ == "__main__":
    main()

 

动物会吃
动物会吃

 

当听见导师说:“ 私有的习性方法 不会被子类世袭 ”的时候,小明心里风度翩翩颤,联想到后边讲的 类属性实例属性实例方法类方法静态方法,于是赶紧写个德姆o验证一下:

In [2]:

class Animal(object):
    # 类属性
    name = '动物'

    def __init__(self):
        # 实例属性
        self.age = 1

    def __bug(self):
        """实例私有方法"""
        print("我是动物类身上的私有方法:bug")

    def eat(self):
        """实例方法"""
        print("我是实例方法,动物会吃哦~")

    @classmethod
    def call(cls):
        """类方法"""
        print("我是类方法,动物会叫哦")

    @staticmethod
    def play():
        """静态方法"""
        print("我是静态方法,动物会玩耍哦")


class Dog(Animal):
    pass


def main():
    dog = Dog()
    # 实例属性
    print(dog.age)
    # 实例方法
    dog.eat()

    # 类属性
    print(dog.name)
    # 类方法
    dog.call()
    Dog.call()
    Animal.call()

    # 静态方法
    dog.play()
    Dog.play()
    Animal.play()


if __name__ == '__main__':
    main()

 

1
我是实例方法,动物会吃哦~
动物
我是类方法,动物会叫哦
我是类方法,动物会叫哦
我是类方法,动物会叫哦
我是静态方法,动物会玩耍哦
我是静态方法,动物会玩耍哦
我是静态方法,动物会玩耍哦

 

来张图就懂了,不是 私有的 都能访谈:

图片 1

那时,小明老开心了,单回头生龙活虎想 ==> 不正确啊,dog应该有其对应的不二等秘书籍呢,C#有 虚方法重写,Python怎么搞?在 子类里面又 怎么调用父类方法呢?

对此小明的升迁老师很欢快,于是点名小潘来写多少个子类调用父类的demo(老师明天从窗户里看到小潘有预习卡塔 尔(阿拉伯语:قطر‎:

In [3]:

# 调用父类的方法
class Father(object):
    def eat(self):
        print("文雅的吃饭")


class Son(Father):
    def eat(self):
        # 调用父类方法第1种(super().方法)
        super().eat()


class GrandSon(Son):
    def eat(self):
        # 调用父类方法第2种(记得传self)
        Son.eat(self)


def main():
    xiaoming = Son()
    xiaoming.eat()

    xiaoli = GrandSon()
    xiaoli.eat()


if __name__ == '__main__':
    main()

 

文雅的吃饭
文雅的吃饭

 

平常大家选择 super().方法来调用父类方法

第三种格局 类名.方法(self)千万别忘记传self哦

对了,C#是用base关键词,别搞混了

小明这时可超级慢活了,风头怎可以被小潘全体掠夺呢,赶紧问问意气风发旁相像预习的伟哥

一刹那间淡定的发了份重写父类方法的demo给老师:

In [4]:

# 重写父类方法==>子类和父类有同名方法
class Father(object):
    def __init__(self, name):
        self.name = name

    def eat(self):
        print("%s喜欢文雅的吃饭" % self.name)


class Son(Father):
    def __init__(self, name):
        super().__init__(name)

    def eat(self):
        print("%s喜欢大口吃饭大口喝酒" % self.name)


def main():
    xiaoming = Father("小明")
    xiaoming.eat()

    xiaopan = Son("小潘")
    xiaopan.eat()


if __name__ == "__main__":
    main()

 

小明喜欢文雅的吃饭
小潘喜欢大口吃饭大口喝酒

 

名师惊喜交集的说道:“小明同学啊,你也年轻了,怎么跟子女同后生可畏啊?案例不错,可是怎可以人身攻击人家小潘了?”

当子类和父类都设有同样的 eat()方法时,我们说,子类的 eat()蒙面了父类的 eat()

在代码运营的时候,总是会调用子类的 eat() 那样,大家就收获了三回九转的另二个实惠: 多态

04接口中成员变量的本性

  • A:成员变量特点
    • a 接口中得以定义变量,不过变量必得有稳固的修饰符修饰,public static final 所以接口中的变量也称之为常量,其值无法改造。前面我们会讲课static与final关键字
  • B:案例

  • interface 德姆o { ///定义一个称呼为德姆o的接口。
        public static final int NUM = 3;// NUM的值不能改变
    }
    

2.2.多继承 ¶

在讲 多态事先,大家先引进一下Python的 多继承 对,你未有听错

Java、C#都是单世袭,多达成。Python和C++同样,能够多一而再三番五次,先不要嘲讽, 标准使用实则很有益于的

来个案例看看:

In [5]:

# 多继承引入
class Father(object):
    def eat(self):
        print("文雅的吃饭")


class Mom(object):
    def run(self):
        print("小碎步")


class Son(Father, Mom):
    pass


def main():
    son = Son()
    son.eat()
    son.run()


if __name__ == '__main__':
    main()

 

文雅的吃饭
小碎步

 

后续能够把父类的兼具机能都一贯拿过来,那样就不要重0初叶写代码,子类只需求新扩大自个儿有意的点子,也得以把父类不符合的主意覆盖重写

潜心二个景况,假设父类里面有同名方法如何做了?到底调哪个吧?

使用 子类名.__mro__能够看在调方法的时候找出顺序

相同同名方法都是 先看本身有未有,然后看后续顺序,例如那边 先看Mom再看Father

In [6]:

# 如果父类里面有同名方法怎么知道调哪个?
class Father(object):
    def eat(self):
        print("文雅的吃饭")


class Mom(object):
    def eat(self):
        print("开心的吃饭")


class Son(Mom, Father):
    pass


def main():
    son = Son()
    son.eat()
    print(Son.__mro__)  # 一般同名方法都是先看自己有没有,然后看继承顺序,比如这边先看Mom再看Father


if __name__ == '__main__':
    main()

 

开心的吃饭
(<class '__main__.Son'>, <class '__main__.Mom'>, <class '__main__.Father'>, <class 'object'>)

 

Python的多继承最好是当C#抑或Java里面包车型大巴接口使用,那样结构不会混杂( 极其情状除了)

来个例子:

class Animal(object):
    pass

class Flyable(object):
    """飞的方法"""
    pass

class Runable(object):
    """跑的方法"""
    pass

class Dog(Animal, Runable):
    pass

class Cat(Animal, Runable):
    pass

class Bird(Animal, Flyable):
    pass

class Dack(Animal, Runable, Flyable):
    """鸭子会飞也会跑"""
    pass

和C#一样,Python的 父类构造函数不会被两次三番

其实从财富角度也不应有被接二连三,假诺有1w个子类,那每一种子类里面都有多个父类方法,出主意那是何等浪费的后生可畏件事情?


05接口中成员方法的性子

  • A: 成员方法特点

    • a 接口中得以定义方法,方法也是有一定的修饰符,public abstract
    • b 子类必得覆盖掉接口中颇有的虚幻方法后,子类才可以实例化。否则子类是二个抽象类。
  • B: 案例

  • interface 德姆o { ///定义一个称谓为德姆o的接口。

        public abstract void show1();
        public abstract void show2();
    }
    
    //定义子类去覆盖接口中的方法。类与接口之间的关系是 实现。通过 关键字 implements
    class DemoImpl implements Demo { //子类实现Demo接口。
        //重写接口中的方法。
        public void show1(){}
        public void show2(){}
    }
    

2.3.C#继承 ¶

下课后,小明认真构思总括,然后比较Python写下了C#版的后续:

概念二个生人

public class Person
{
    public string Name { get; set; }
    public ushort Age { get; set; }

    public Person(string name, ushort age)
    {
        this.Name = name;
        this.Age = age;
    }
    public void Hi()//People
    {
        Console.WriteLine("Name: " + this.Name + " Age: " + this.Age);
    }
    public virtual void Show()//People
    {
        Console.WriteLine("Name: " + this.Name + " Age: " + this.Age);
    }
}

概念一个学员类

public class Student : Person
{
    #region 属性
    /// <summary>
    /// 学校
    /// </summary>
    public string School { get; set; }
    /// <summary>
    /// 班级
    /// </summary>
    public string StrClass { get; set; }
    /// <summary>
    /// 学号
    /// </summary>
    public string StrNum { get; set; }
    #endregion

    #region 构造函数
    /// <summary>
    /// 调用父类构造函数
    /// </summary>
    /// <param name="name"></param>
    /// <param name="age"></param>
    public Student(string name, ushort age) : base(name, age)
    {

    }
    public Student(string name, ushort age, string school, string strClass, string strNum) : this(name, age)
    {
        this.School = school;
        this.StrClass = strClass;
        this.StrNum = strNum;
    } 
    #endregion

    /// <summary>
    /// new-隐藏
    /// </summary>
    public new void Hi()//Student
    {
        Console.WriteLine("Name: " + this.Name + " Age: " + this.Age + " School: " + this.School + " strClass: " + this.StrClass + " strNum: " + this.StrNum);
    }
    /// <summary>
    /// override-覆盖
    /// </summary>
    public override void Show()//Student
    {
        Console.WriteLine("Name: " + this.Name + " Age: " + this.Age + " School: " + this.School + " strClass: " + this.StrClass + " strNum: " + this.StrNum);
    }
}

调用一下:

Person p = new Student("app", 10, "北京大学", "001", "01001");
p.Hi(); p.Show();

Console.WriteLine();

Student s = p as Student;
s.Hi(); s.Show();

结果:

Name: app Age: 10
Name: app Age: 10 School: 北京大学 strClass: 001 strNum: 01001
Name: app Age: 10 School: 北京大学 strClass: 001 strNum: 01001
Name: app Age: 10 School: 北京大学 strClass: 001 strNum: 01001

06兑现类依然四个抽象类

A: 接口的实现类
   一个类如果实现类接口,有两种操作方法:
   第一:实现类是非抽象类,就需要重写接口中所有的抽象方法.
   第二:实现类也声明为抽象类,那么实现类可以不重写接口中的抽象方法。

2.4C#接口的多实现 ¶

概念多少个接口:

public interface IRun
{
    //什么都不用加
    void Run();
}

public interface IEat
{
    void Eat();
}

概念三个Dog类来完结八个接口,那样dog就有了run和eat的不二秘诀了

var dog = new Dog();
dog.Eat();
dog.Run();

结果:

狗狗吃
狗狗跑

07类和接口的多落成

  • A:接口的多达成
    打听了接口的特色后,那么用脑筋想怎么要定义接口,使用抽象类描述也尚无难题,接口到底有甚用啊?
    接口最关键的展现:消灭多三番一遍的害处。将多三番三回这种机制在java中通过多落成到位了。

  • B 多达成的帮助和益处

    • 怎么解决多一而再一连的坏处呢?
    • 坏处:多延续时,当八个父类中有相近效果时,子类调用会爆发不分明性。
    • 实质上宗旨原因纵然在于多三回九转父类中效率有核心,而形成调用运转时,不明确运转哪个主体内容。
    • 怎么多完结能缓慢解决了啊?
    • 因为接口中的功能都还未有方法体,由子类来明显。
  • C :案例演示

      interface Fu2{
          void show2();
      }
      class Zi implements Fu1,Fu2 {    // 多实现。同时实现多个接口。
          public void show1(){}
          public void show2(){}
      }
    

3 多态 ¶

08类在世襲类的还要落到实处多接口

  • A: 继承的还要落实接口
    • 接口和类之间能够透过落到实处产生关系,同期也学习了类与类之间能够由此持续发生关系。当三个类已经接二连三了一个父类,它又要求扩充数额外的意义,那时接口就派上用途了。
    • 子类通过一而再父类扩张功用,通过持续扩充的功效都是子类应该具备的底子功效。假设子类想要继续扩大其他类中的功效吗?此时通过兑现接口来成功。
    • 接口的面世制止了单世袭的局限性。父类中定义的事物的基本功效。接口中定义的东西的恢弘成效。
  • B: 代码演示
  • class Fu {

        public void show(){}
    }
    interface Inter {
        pulbic abstract void show1();
    }
    class Zi extends Fu implements Inter {
        public void show1() {
        }
    }
    
    接口的出现避免了单继承的局限性。父类中定义的事物的基本功能。接口中定义的事物的扩展功能。
    

3.1.Python ¶

说多态以前说说类型剖断,早先咱们用 type() or isinstance()

认清三个变量和另七个变量是或不是是同三个类型==> type(a)==type(b)

剖断三个变量是不是是有些项目==> type(a)==A or isinstance(a,A)

In [7]:

# 判断一个变量是否是某个类型 ==> isinstance() or type
class Animal(object):
    pass


class Dog(Animal):
    pass


def main():
    dog = Dog()
    dog2 = Dog()
    print(type(dog) == Dog)
    print(type(dog) == type(dog2))
    print(type(dog))

    print(isinstance(dog, Dog))
    print(isinstance(dog, Animal))
    # arg 2 must be a type or tuple
    # print(isinstance(dog, dog2))


if __name__ == '__main__':
    main()

 

True
True
<class '__main__.Dog'>
True
True

 

小明老欢悦了,终于讲明多态了,不禁问道:“ 多态的益处是啥?”

小潘瞥了一眼小明~“废话,明确为了 屏蔽子类差距用的啊,像轻松工厂不就干的那些事?"

小明楞了楞,眼Baba的看着老师继续教授。

设计形式大家会找个专项论题讲讲,今后给您们说的是Python的幼功。

Python是动态语言的“ 钻水鸭类型”,它并不须求严峻的存在延续种类。

多少个指标只要“看起来像秋沙鸭,走起路来像赤麻鸭”,那它就足以被看做是硬尾鸭(最终会贴叁个案例卡塔 尔(英语:State of Qatar)

C#贯彻多态有数不清方式,比方虚方法,举例抽象类,举个例子接口等等...

小明迷迷糊糊的问道:“那 Python怎么落到实处多态呢?”

教员职员和工人看了一眼打断他教学的小明,然后继续商讨~来个大概案例:

In [8]:

class People(object):
    def eat(self):
        print("人类会吃饭")

class Father(object):
    def eat(self):
        print("优雅的吃饭")

class Teacher(object):
    def eat(self):
        print("赶时间的吃饭")

# C# 或者 Java里面 写成 eat(People obj)
def eat(obj):
    obj.eat()

def main():
    teacher = Teacher()
    father = Father()
    eat(teacher)
    eat(father)

if __name__ == '__main__':
    main()

 

赶时间的吃饭
优雅的吃饭

 

多态的好处在于,固然那时笔者再来个Son子类,有eat()方法编写准确,不用管原本的代码是什么调用的

本次小明懂了,为了装一下,说道:”老师老师,作者记得C# 也许 Java里面是写成 eat(People obj) 的啊?“

教员职员和工人安慰的笑了眨眼之间间,说道:”记得刚才说的 填鸭式啊?Python这么写有个好处哦,大家来看个案例,然后您自个儿计算“

In [9]:

class People(object):
    def eat(self):
        print("人类会吃饭")

class Father(object):
    def eat(self):
        print("优雅的吃饭")

class Teacher(object):
    def eat(self):
        print("赶时间的吃饭")

class Dog(object):
    def eat(self):
        print("舔着吃")

def eat(obj):
    obj.eat()

def main():
    teacher = Teacher()
    father = Father()
    eat(teacher)
    eat(father)

    # 我们添加一个不是People子类的Dog类,只要有eat方法,参数一样就可以直接调
    dog = Dog()
    eat(dog)

if __name__ == '__main__':
    main()

 

赶时间的吃饭
优雅的吃饭
舔着吃

 

小明溘然大声说道:”老师老师,笔者知道了,Python那是吧类的接轨和接口世襲融入起来了呀,实现多态就一定于C#个中的接口实现多态啊!!!“

教员职员和工人点评道:”你姑且能够这么通晓,那么些大家后边还有恐怕会三番五回说的,这种填鸭式的手法刚起头确实会有一点点不便于,用着用着您就能够感到挺方便的“


小明认真考虑计算,然后比较Python和小潘一齐写下了 C#版的多态

09接口的多世袭

  • A: 接口的多袭承
    • 学习类的时候,知道类与类之间能够经过持续产生关系,接口和类之间
    • 能够通过贯彻发生关系,那么接口与接口之间会有啥关联。
    • 五个接口之间能够使用extends举行继续。
  • B 代码演示
    interface Fu1{
    void show();
    }
    interface Fu2{
    void show1();
    }
    interface Fu3{
    void show2();
    }
    interface Zi extends Fu1,Fu2,Fu3{
    void show3();
    }

      在开发中如果多个接口中存在相同方法,这时若有个类实现了这些接口,那么就要实现接
      口中的方法,由于接口中的方法是抽象方法,子类实现后也不会发生调用的不确定性。
    

3.2.C#虚方法完毕多态 ¶

概念一个人类:

public class Person
{
    #region 字段+属性
    /// <summary>
    /// 姓名
    /// </summary>
    private string _name;
    public string Name
    {
        get
        {
            return _name;
        }

        set
        {
            _name = value;
        }
    }
    /// <summary>
    /// 性别
    /// </summary>
    private bool _gender;
    public bool Gender
    {
        get
        {
            return _gender;
        }

        set
        {
            _gender = value;
        }
    }
    /// <summary>
    /// 年龄
    /// </summary>
    public short Age { get; set; }
    #endregion

    #region 构造函数
    public Person() { }
    public Person(string name, bool gender)
    {
        this.Name = name;
        this.Gender = gender;
    }
    public Person(string name, bool gender, short age) : this(name, gender)
    {
        this.Age = age;
    }
    #endregion

    #region 方法
    /// <summary>
    /// 打招呼
    /// </summary>
    public virtual void SaiHi()
    {
        Console.WriteLine("我是一个人类!");
    }
    #endregion
}

概念三个女孩类:

public class Gril : Person
{
    #region 构造函数
    public Gril() { }
    public Gril(string name, bool gender) : base(name, gender) { }
    public Gril(string name, bool gender, short age) : base(name, gender, age) { }
    #endregion

    /// <summary>
    /// 重写父类方法
    /// </summary>
    public override void SaiHi()
    {
        string genderStr = Gender == true ? "男孩" : "女孩";
        Console.WriteLine($"你好,我叫{Name},今年{Age}岁了,我是一个腼腆的小{genderStr}");
    }
}

概念三个男孩类:

public class Boy : Person
{
    #region 构造函数
    public Boy() { }
    public Boy(string name, bool gender) : base(name, gender) { }
    public Boy(string name, bool gender, short age) : base(name, gender, age) { }
    #endregion

    //public void SaiHi()
    public override void SaiHi()
    {
        string genderStr = Gender == true ? "男孩" : "女孩";
        Console.WriteLine($"你好,我叫{Name},今年{Age}岁了,我是一个腼腆的小{genderStr}");
    }
}

调用:

static void Main(string[] args)
{
    Person[] persons = { new Person(), new Boy("铁锅", true, 13), new Gril("妞妞", false, 22) };
    foreach (var item in persons)
    {
        //看看item里面到底放的是什么
        Console.WriteLine(item.ToString());
        item.SaiHi();
        Console.WriteLine();
    }
}

结果:

Polymorphism1.Person
我是一个人类!
Polymorphism1.Boy
你好,我叫铁锅,今年13岁了,我是一个腼腆的小男孩
Polymorphism1.Gril
你好,我叫妞妞,今年22岁了,我是一个腼腆的小女孩

 


10接口思想

  • A:接口的考虑
    • 前边学习了接口的代码呈现,将来来读书接口的考虑,接下里从生活中的例子进行求证。
    • 比喻:大家都领悟计算机上留有很五个插口,而这一个插口可以插入相应的装备,这一个设施为啥能插在上边吧?
    • 重点原因是那几个器械在生养的时候适合了那些插口的应用法则,不然将不可能插入接口中,更爱莫能助接纳。发掘那一个插口的产出让大家利用越来越多的配备。
  • B: 接口的功利

    • 小结:接口在付出中的它收益
    • 1、接口的产出扩展了效果。
    • 2、接口其实便是暴漏出来的平整。
    • 3、接口的产出暴跌了耦合性,即设备与器材之间达成精通耦。

    • 接口的现身成利于早先时期使用和保安,一方是在使用接口(如Computer卡塔尔,一方在落到实处接口(插在插口上的装备卡塔尔。比如:台式机使用这些准则(接口卡塔 尔(阿拉伯语:قطر‎,电脑外围设备落成那一个准绳(接口卡塔 尔(英语:State of Qatar)。

3.3.C#抽象类实现多态 ¶

概念二个动物类:

public abstract class Animal
{
    /// <summary>
    /// 抽象类中可以有正常的方法
    /// </summary>
    public void Action()
    {
        Console.WriteLine("动物可以动");
    }

    /// <summary>
    /// 抽象方法必须在抽象类中
    /// </summary>
    public abstract void Call();
}

概念五个猫科动物类(子类必需达成父类抽象方法,假使不兑现,那么该类也亟须是抽象类卡塔尔

/// <summary>
/// 猫科动物---子类必须实现父类抽象方法,如果不实现,那么该类也必须是抽象类
/// </summary>
public abstract class Feline : Animal
{
}

概念多少个猫类

public class Cat : Feline
{
    /// <summary>
    /// 子类必须实现父类抽象方法,如果不实现,那么该类也必须是抽象类
    /// </summary>
    public override void Call()
    {
        Console.WriteLine("喵喵叫~~~");
    }
}

概念一个狗类

public class Dog : Animal
{
    /// <summary>
    /// 子类必须实现抽象类中的抽象方法
    /// </summary>
    public override void Call()
    {
        Console.WriteLine("汪汪叫~~~");
    }
}

调用:

Animal[] animals = { new Dog(), new Cat() };
foreach (var item in animals)
{
    item.Call();
}

结果:

汪汪叫~~~
喵喵叫~~~

 


11接口和抽象类的分别

  • A: 掌握了接口理念和接口的用法后,接口和抽象类的界别是如何啊?接口在生存展现也基本调节,那在程序中接口是什么样展现的呢?
    通超过实际例举办解析和代码演示抽象类和接口的用法。
  • B: 举例:
    • 犬:
      行为:
      吼叫;
      吃饭;
    • 缉毒犬:
      行为:
      吼叫;
      吃饭;
      缉毒;
  • C:思考:
    • 由于犬分为超多体系,他们吼叫和吃饭的不二诀要不相像,在描述的时候无法具体化,也正是吼叫和就餐的表现无法明了。
    • 当描述行为时,行为的具体动作不可能明显,这时候,能够将这些作为写为架空行为,那么那一个类也正是抽象类。
    • 唯独当缉毒犬有别的额外作用时,而这么些成效并不在这里个东西的连串中。当时能够让缉毒犬具备犬科本身特点的同一时候也许有此外附加作用,能够将以此附加功效定义接口中。
  • D: 代码演示
  • interface 缉毒{

        public abstract void 缉毒();
    }
    //定义犬科的这个提醒的共性功能
    abstract class 犬科{
    public abstract void 吃饭();
    public abstract void 吼叫();
    }
    // 缉毒犬属于犬科一种,让其继承犬科,获取的犬科的特性,
    //由于缉毒犬具有缉毒功能,那么它只要实现缉毒接口即可,这样即保证缉毒犬具备犬科的特性,也拥有了缉毒的功能
    class 缉毒犬 extends 犬科 implements 缉毒{
    
        public void 缉毒() {
        }
        void 吃饭() {
        }
        void 吼叫() {
        }
    }
    class 缉毒猪 implements 缉毒{
        public void 缉毒() {
        }
    }
    
  • E: 接口和抽象类差异总括

  • 相同点:

        都位于继承的顶端,用于被其他类实现或继承;
        都不能直接实例化对象;
        都包含抽象方法,其子类都必须覆写这些抽象方法;
    区别:
        抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;接口只能包含抽象方法;
        一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)
        抽象类是这个事物中应该具备的你内容, 继承体系是一种 is..a关系
        接口是这个事物中的额外内容,继承体系是一种 like..a关系
    
    二者的选用:
        优先选用接口,尽量少用抽象类;
        需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;
    

本文由澳门在线威尼斯官方发布于电脑操作,转载请注明出处:11_Java面向对象_第11天,面向对象之

关键词:

上一篇:好用的linux软件合集,下的Gif录制工具

下一篇:没有了