www.2527.com_澳门新葡8455手机版_新京葡娱乐场网址_
做最好的网站

面向对象,JAVA之面向对象2

2019-05-24 23:04 来源:未知

第1一天面向对象

明天内容介绍

  • 接口

  • 多态

第0三天java面向对象

一.无冕    在Java中,类的存在延续是指在2个现成类的根基上去创设贰个新的类,创设出来的新类被称作子类,现存类被称作父类,子类会自动具备父类全体可接二连三的本性和章程。

1. 接口

1.  接口概念
    --------

接口是成效的会师,同样可作为是壹种数据类型,是比抽象类更为抽象的"类"。

接口只描述所应有有着的艺术,并未有具体完毕,具体的贯彻由接口的落到实处类(约等于接口的子类)来成功。那样将功用的定义与落实分离,优化了先后设计。

请记住:1切事物均有效果,即全部事物均有接口。

前几日内容介绍

持续的格式&使用: 在程序中,假如想声圣元个类承袭另七个类,要求使用extends关键字。

1. 接口的定义

与定义类的class区别,接口定义时必要使用interface关键字。

概念接口所在的仍为.java文件,纵然声称时利用的为interface关键字的编写翻译后还是会发生.class文件。这一点能够让大家将接口看做是1种只含有了效劳声称的例外类。

定义格式:

public interface 接口名 {

抽象方法一;

架空方法二;

泛泛方法3;

}

行使interface替代了原来的class,其余步骤与定义类一样:

  • 接口中的方法均为公共访问的肤浅方法
  • 接口中不可能定义普通的积极分子变量

·接口

格式:    class 子类 extends 父类 {}

一. 类达成接口

类与接口的涉及为促成关系,即类实现接口。达成的动作类似继承,只是关键字分歧,完毕应用implements。

任何类(实现类)完毕接口后,就约等于注明:"笔者应当具有这一个接口中的功用"。达成类还是要求重写方法以达成具体的作用。

格式:

class 类 implements 接口 {

    重写接口中方法

}

在类完结接口后,该类就能将接口中的抽象方法承继过来,此时此类必要重写该抽象方法,实现具体的逻辑。

  • 接口中定义功用,当要求具有该意义时,能够让类达成该接口,只注解了相应有所该措施,是法力的注解。
  • 在切实可行落到实处类中重写方法,完成效益,是方法的具体贯彻。

于是,通过以上八个动作将功能的评释与落到实处便分开了。(此时请重新考虑:类是切实事物的叙说,接口是成效的集结。)

·无名对象&final

子类在继续父类的时候,会自动具有父类的分子。

一. 接口中成员的特色

壹、接口中能够定义变量,不过变量必须有定位的修饰符修饰,public static final 所以接口中的变量也堪称常量,其值无法改造。后边我们会讲课static与final关键字

贰、接口中能够定义方法,方法也是有固定的修饰符,public abstract

3、接口不得以创制对象。

四、子类必须覆盖掉接口中负有的抽象方法后,子类才得以实例化。不然子类是一个抽象类。

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

    public static final int NUM = 3;// NUM的值不可能退换

    public abstract void show1();

    public abstract void show2();

}

 

//定义子类去掩盖接口中的方法。类与接口之间的涉嫌是兑现。通过首要字 implements

class 德姆oImpl implements 德姆o { //子类实现德姆o接口。

    //重写接口中的方法。

    public void show1(){}

    public void show2(){}

}

·多态

再而三的好处:

一. 接口的多达成

领悟了接口的性状后,那么想想怎么要定义接口,使用抽象类描述也从未难题,接口到底有吗用呢?

接口最器重的显示:解决多一连的流弊。将多延续这种机制在java中通过多实现存功了。

 

interface Fu1

{

    void show1();

}

interface Fu2

{

    void show2();

}

class Zi implements Fu一,Fu2// 多完成。同时落到实处八个接口。

{

    public void show1(){}

    public void show2(){}

}

 

怎么化解多一而再的坏处呢?

坏处:多三番五次时,当多少个父类中有平等效果时,子类调用会发生不明确性。

实际主题原因尽管在乎多一而再父类中功用有侧重点,而导致调用运转时,不分明运营哪个主体内容。

缘何多达成能消除了吗?

因为接口中的功效都未曾方法体,由子类来人所共知。

·接口

一、继承的出现增加了代码的复用性,提升软件开拓功用。

一. 类承袭类同不时候落到实处接口

接口和类之间能够经过兑现爆发关系,相同的时候也学习了类与类之间可以透过一连发生关系。当二个类已经接轨了1个父类,它又须求扩充数额外的成效,这时接口就派上用场了。

子类通过三番五次父类扩充效用,通过持续扩张的效用都以子类应该具有的底子功效。假若子类想要继续增加其余类中的功用吗?那时通过达成接口来完结。

class Fu {

    public void show(){}

}

interface Inter {

    pulbic abstract void show1();

}

class Zi extends Fu implements Inter {

    public void show1() {

    }

}

接口的出现制止了单承接的局限性。父类中定义的事物的基本成效。接口中定义的东西的扩充嘉杰能。

一.接口的概述

二、承继的产出让类与类之间发生了事关,提供了多态的前提。

一. 接口的多承接

学习类的时候,知道类与类之间可以经过持续产生关系,接口和类之间能够透过完结产生关系,那么接口与接口之间会有怎样关系。

两个接口之间能够使用extends实行后续。

interface Fu1{

    void show();

}

interface Fu2{

    void show1();

}

interface Fu3{

    void show2();

}

interface Zi extends Fu1,Fu2,Fu3{

    void show3();

}

在开拓中一经多少个接口中存在同样格局,那时若有个类达成了这个接口,那么快要兑现接口中的方法,由于接口中的方法是虚幻方法,子类达成后也不会发出调用的不鲜明性。

接口是效果的聚众,一样可视作是一种数据类型,是比抽象类更为抽象的”类”。

在类的存在延续中,须要小心一些主题材料,具体如下:

一. 接口的思维

前面学习了接口的代码体现,未来来学习接口的合计,接下里从生活中的例子进行求证。

举例:笔者们都知道Computer上留有很八个插口,而那个插口能够插入相应的设施,这几个器械为啥能插在地点吧?主要缘由是那几个设施在生育的时候符合了这些插口的行使规则,不然将不恐怕插入接口中,更力不从心使用。开采这一个插口的面世让我们选用越来越多的设施。

总结:接口在支付中的它好处

  1. 接口的面世扩展了意义。

  2. 接口其实就是暴漏出来的条条框框。

  3. 接口的产出回落了耦合性,即设备与设施之间达成驾驭耦。

 

接口的现身有利后期使用和掩护,一方是在应用接口(如Computer),1方在落到实处接口(插在插口上的配备)。举个例子:台式机使用那几个规则(接口),计算机外围设备达成这么些规则(接口)。

 

 

接口只描述所应有负有的法子,并不曾具体贯彻,具体的贯彻由接口的落实类(约等于接口的子类)来完毕。那样将作用的定义与实现分离,优化了先后设计。

一、在Java中,类只协助单承接,不允多数持续,相当于说3个类只可以有3个一向父类二、三个类能够一连二个父类                      3、在Java中,多层承袭是足以的,即2个类的父类能够再去继续其余的父类,比如C类承袭自B类,而B类又能够去承继A类,这时,C类也可称作A类的子类                        ​ 四、在Java中,子类和父类是1种周旋概念,也正是说二个类是有些类父类的同期,也得以是另2个类的子类。举例地方的这种情形中,B类是A类的子类,同一时候又是C类的父类。

1. 接口和虚幻的分别

知情了接口观念和接口的用法后,接口和抽象类的区分是怎样呢?接口在生存呈现也基本调节,那在程序中接口是哪些展现的啊?

经超过实际例实行分析和代码演示抽象类和接口的用法。

1、举例:

犬:

行为:

吼叫;

吃饭;

缉毒犬:

行为:

吼叫;

吃饭;

缉毒;

 

2、思考:

由于犬分为诸多样类,他们吼叫和就餐的主意不雷同,在讲述的时候不能够具体化,相当于吼叫和吃饭的一坐一起不可能明了。当描述行为时,行为的求实动作不可能明显,那时,能够将以此作为写为架空行为,那么那一个类约等于抽象类。

不过当缉毒犬有其它附加功效时,而以此效应并不在那么些事物的系统中。这时能够让缉毒犬具有犬科自个儿特色的还要也可能有别的附加成效,能够将这一个额外功能定义接口中。

    如下代码演示:

interface 缉毒{

    public abstract void 缉毒();

}

//定义犬科的那些提示的共性功效

abstract class 犬科{

public abstract void 吃饭();

public abstract void 吼叫();

}

// 缉毒犬属于犬科1种,让其持续犬科,获取的犬科的特色,

//由于缉毒犬具备缉毒功用,那么它壹旦完成缉毒接口就能够,这样即确定保障缉毒犬具有犬科的特点,也享有了缉毒的职能

class 缉毒犬 extends 犬科 implements 缉毒{

 

    public void 缉毒() {

    }

    void 吃饭() {

    }

    void 吼叫() {

    }

}

class 缉毒猪 implements 缉毒{

    public void 缉毒() {

    }

}

 

3、通过地点的事例计算接口和抽象类的区分:

相同点:

  • 都位居承袭的上边,用于被此外类完结或继续;
  • 都不能够一贯实例化对象;
  • 都饱含抽象方法,其子类都必须覆写那一个抽象方法;

区别:

  • 抽象类为部分方法提供达成,制止子类重复完结这几个主意,进步代码重用性;接口只好分包抽象方法;
  • 三个类只可以继续贰个直接父类(大概是抽象类),却能够兑现三个接口;(接口弥补了Java的单承继)
  • 抽象类是其1东西中应当有所的您内容, 承接体系是一种 is..a关系

  • 接口是以此东西中的额外内容,承继种类是一种 like..a关系

 

相互的采纳:

  • 先行选择接口,尽量少用抽象类;
  • 内需定义子类的作为,又要为子类提供共性作用时才选择抽象类;

·接口的格式&使用

持续-子父类中成员变量的特点

1. 多态

1.  多态概述
    --------

多态是继封装、承袭之后,面向对象的第3大特征。

现实事物平日会反映出各类样子,如学员,学生是人的一种,则3个切实的同班张叁既是学员也是人,即出现三种形态。    

Java作为面向对象的言语,同样能够描述1个事物的有余形态。如Student类承接了Person类,2个Student的对象便既是Student,又是Person。

Java中多态的代码展现在叁个子类对象(达成类对象)既可以给那几个子类(实现类对象)引用变量赋值,又足以给这几个子类(完毕类对象)的父类(接口)变量赋值。

如Student类可感到Person类的子类。那么多少个Student对象既能够赋值给八个Student类型的引用,也得以赋值给多个Person类型的引用。

终极多态显示为父类引用变量能够针对子类对象。

多态的前提是必须有子父类关系照旧类达成接口关系,不然不或者成功多态。

在运用多态后的父类引用变量调用方法时,会调用子类重写后的点子。

1.接口的格式

成员变量:假如子类父类中出现分歧名的积极分子变量,这时的拜会是平素不别的难点。当子父类中出现了同名成员变量时,在子类中若要访问父类中的成员变量,必须使用主要字super来产生。super用来代表近来指标中带有的父类对象空间的引用。

壹. 多态的概念与使用格式

多态的定义格式:就是父类的引用变量指向子类对象

父类类型变量名 = new 子类项目();

变量名.方法名();

 

  • 普通类多态定义的格式

父类变量名 = new 子类();

如:    class Fu {}

    class Zi extends Fu {}

    //类的多态使用

Fu f = new Zi();

 

  • 抽象类多态定义的格式

抽象类变量名 = new 抽象类子类();

如:    abstract class Fu {

public abstract void method();

     }

class Zi extends Fu {

public void method(){

         System.out.println("重写父类抽象方法");

}

}

//类的多态使用

Fu fu= new Zi();

 

  • 接口多态定义的格式

接口变量名 = new 接口完毕类();

如: interface Fu {

         public abstract void method();

}

class Zi implements Fu {

         public void method(){

System.out.println("重写接口抽象方法");

}

}

//接口的多态使用

Fu fu = new Zi();

 

 

  • 在意事项

    同三个父类的章程会被差别的子类重写。在调用方法时,调用的为顺序子类重写后的艺术。

如 Person p1 = new Student();

Person p2 = new Teacher();

p一.work(); //p一会调用Student类中重写的work方法

p二.work(); //p二会调用Teacher类中重写的work方法

当变量名指向不相同的子类对象时,由于各类子类重写父类方法的内容不一,所以会调用不一样的艺术。

与定义类的class不相同,接口定义时须求利用interface关键字。

在子类中,访问父类中的成员变量格式:

1. 多态-成员的特色

/*

* 多态中,成员特点

*

* 成员变量:

* 编写翻译的时候, 参谋父类中有未有其壹变量,如若有,编写翻译成功,没有编写翻译失利

* 运营的时候, 运维的是父类中的变量值

* 编写翻译运营全看父类

*

* 成员方法:

* 编写翻译的时候, 参考父类中有未有那些办法,要是有,编写翻译成功,未有编写翻译失利

* 运营的时候, 运转的是子类的重写方法

*

* 编写翻译看父类,运维看子类

*/

通晓了多态的骨干使用后,那么多态出现后类的积极分子有何变化吗?前边学习承接时,大家知道子父类之间成员变量有了本身的一定变化,那么当多态出现后,成员变量在使用上有未有变化吗?

多态出现后会导致子父类中的成员变量有微弱的改动。看如下代码

class Fu {

    int num = 4;

}

class Zi extends Fu {

    int num = 5;

}

class Demo {

    public static void main(String[] args)     {

        Fu f = new Zi();

        System.out.println(f.num);

        Zi z = new Zi();

        System.out.println(z.num);

    }

}

  • 多态成员变量

当子父类中出现同名的成员变量时,多态调用该变量时:

编写翻译时代:参谋的是引用型变量所属的类中是或不是有被调用的分子变量。未有,编译战败。

运维时期:也是调用引用型变量所属的类中的成员变量。

轻易易行记:编写翻译和运行都参照等号的左侧。编写翻译运营看左边。

    

多态出现后会导致子父类中的成员方法有微弱的生成。看如下代码

class Fu {

    int num = 4;

    void show()    {

        System.out.println("Fu show num");

    }

}

class Zi extends Fu {

    int num = 5;

    void show()    {

        System.out.println("Zi show num");

    }

}

class Demo {

    public static void main(String[] args)     {

        Fu f = new Zi();

        f.show();

    }

}

  • 多态成员方法

编写翻译时期:参考引用变量所属的类,假设未有类中未有调用的格局,编写翻译败北。

运行时期:参谋引用变量所指的目的所属的类,并运营指标所属类中的成员方法。

一句话来讲:编写翻译看左侧,运维看右侧。

 

概念接口所在的仍为.java文件,固然声称时使用的为interface关键字的编写翻译后如故会发生.class文件。那点能够让我们将接口看做是1种只含有了功能声称的独辟蹊径类。

        super.父类中的成员变量

1. instanceof关键字

大家能够通过instanceof关键字来判别某些对象是还是不是属于某种数据类型。如桃李的对象属于学生类,学生的对象也属于人类。那么些指标属于哪一个类的判断是要有持续关系(父类变量与子类)才行。

采纳格式:

boolean b = 对象 instanceof 数据类型;

    如

Person p壹 = new Student(); // 前提条件,学生类已经连续了人类

boolean flag = p1 instanceof Student; //flag结果为true

boolean flag2 = p2 instanceof Teacher; //flag结果为false

 

定义格式:

1.子父类中成员方法的风味

1. 多态-转型

多态的转型分为向上转型与向下转型两种:
  • 迈入转型:当有子类对象赋值给一个父类引用时,正是进化转型,多态本身正是升高转型的进程。

利用格式:

父类类型变量名 = new 子类品种();

如:Person p = new Student();

  • 向下转型:三个业已前进转型的子类对象足以应用强制类型转变的格式,将父类引用转为子类引用,那几个进度是向下转型。固然是一直开立父类对象,是无能为力向下转型的!

动用格式:

子类类型变量名 = (子类类型) 父类类型的变量;

如:Student stu = (Student) p; //变量p 实际上指向Student对象

 

public interface接口名{

当在程序中通过对象调用方法时,会先在子类中搜寻有未有照管的法子,若子类中设有就能够施行子类中的方法,若子类中不设有就能够推行父类中相应的办法。

1. 多态的裨益与弊端

当父类的引用指向子类对象时,就时有产生了前进转型,即把子类类型对象转成了父类类型。向上转型的受益是隐藏了子类类型,升高了代码的扩大性。

但发展转型也可能有坏处,只好利用父类共性的从头到尾的经过,而可望不可即利用子类特有功用,成效有限制。看如下代码

//描述动物类,并抽出共性eat方法

abstract class Animal {

    abstract void eat();

}

 

// 描述狗类,承继动物类,重写eat方法,扩张lookHome方法

class Dog extends Animal {

    void eat() {

        System.out.println("啃骨头");

    }

 

    voidwww.2527.com, lookHome() {

        System.out.println("看家");

    }

}

 

// 描述猫类,承继动物类,重写eat方法,扩大catchMouse方法

class Cat extends Animal {

    void eat() {

        System.out.println("吃鱼");

    }

 

    void catchMouse() {

        System.out.println("抓老鼠");

    }

}

 

public class Test {

    public static void main(String[] args) {

        Animal a = new Dog(); //多态方式,创造1个狗对象

        a.eat(); // 调用对象中的方法,会实践狗类中的eat方法

        // a.lookHome();//使用Dog类特有的点子,要求向下转型,不能够直接选用

          

        // 为了选取狗类的lookHome方法,须要向下转型

// 向下转型历程中,也许会生出类型转变的错误,即ClassCastException极度

        // 那么,在转此前须求做健壮性决断

        if( !a instanceof Dog){ // 判别当前指标是不是是Dog类型

                 System.out.println("类型不合作,无法更动");

                 return;

        }

        Dog d = (Dog) a; //向下转型

        d.lookHome();//调用狗类的lookHome方法

    }

}

 

我们来总括一下:

  • 怎么着时候使用向上转型:

当不须求面对子类类型时,通过升高扩展性,大概接纳父类的意义就能够一挥而就相应的操作,那时就能够动用向上转型。

如:Animal a = new Dog();

a.eat();

  • 怎样时候利用向下转型

当要运用子类特有机能时,就供给动用向下转型。

    如:Dog d = (Dog) a; //向下转型

     d.lookHome();//调用狗类的lookHome方法

  • 向下转型的补益:能够运用子类特有意义。
  • 弊病是:必要面临现实的子类对象;在向下转型时便于生出ClassCastException类型转换至极。在转移在此以前务必做项目剖断。

如:if( !a instanceof Dog){…}

 

空泛方法一;

成员方法特殊景况——覆盖

1. 多态-举例

我们精通多态使用,以及多态的底细难点后,接下去演习下多态的利用。

  • 毕先生和毕姥爷的逸事

/*

叙述毕先生和毕姥爷,

毕先生具有讲课和看摄像功用

毕姥爷具备讲课和钓鱼成效

*/

class毕姥爷 {

    void 讲课() {

        System.out.println("政治");

    }

 

    void 钓鱼() {

        System.out.println("钓鱼");

    }

}

 

// 毕先生承继了毕姥爷,就有具有了毕姥爷的教授和钓鱼的功力,

// 但毕先生和毕姥爷的上书内容分裂样,因而毕先生要覆盖毕姥爷的任课作用

class毕老师extends毕姥爷 {

    void 讲课() {

        System.out.println("Java");

    }

 

    void 看电影() {

        System.out.println("看电影");

    }

}

 

publicclass Test {

    public static void main(String[] args) {

        // 多态方式

        毕姥爷 a = new 毕先生(); // 向上转型

        a.讲课(); // 这里表象是毕姥爷,其实确实讲课的依旧是毕先生,由此调用的也是毕先生的上书功用

        a.钓鱼(); // 这里表象是毕姥爷,但目的实际是毕先生,而毕先生承袭了毕姥爷,即毕先生也富有钓鱼功用

 

        // 当要调用毕先生特有的看摄像效用时,就不可能不实行类型转变

        毕先生 b = (毕先生) a; // 向下转型

        b.看电影();

    }

}

 

学学到此处,面向对象的三大特色学习完了。

总计下封装、承接、多态的功力:

  • 装进:把对象的性质与方法的贯彻细节隐藏,仅对外提供一些集体的拜访格局
  • 后续:子类会自动具有父类全体可继续的质量和办法。
  • 多态:合作承袭与艺术重写升高了代码的复用性与扩大性;倘使未有艺术重写,则多态同样未有意义。
 

空泛方法二;

子类中冒出与父类毫无二致的章程时,汇合世覆盖操作,也可以称作override重写、复写大概覆盖。

一. 台式机计算机案例

1.  案例介绍
    --------

定义USB接口(具有开启成效、关闭作用),台式机要运用USB设备,即台式机在生育时索要预留能够插入USB设备的USB接口,即便是台式机具有利用USB设备的效用,但具体是什么样USB设备,台式机并不关注,只要符合USB规格的器械都得以。鼠标和键盘要想能在管理器上运用,那么鼠标和键盘也必须遵循USB标准,不然鼠标和键盘的生产出来不能利用

实行描述台式机类,达成台式机使用USB鼠标、USB键盘

  • USB接口,包蕴开启功效、关闭作用
  • 笔记本类,包涵运转效果、关机效率、使用USB设备功用
  • 鼠标类,要符合USB接口
  • 键盘类,要符合USB接口

泛泛方法3;

二.格局重写(覆盖)的选取:

1. 案例须求分析

阶段一:

选取台式机,台式机有运转效果,必要台式机对象来运作这些效应

阶段二:

想采用3个鼠标,又有八个作用使用鼠标,并多了五个鼠标对象。

阶段三:

还想采纳3个键盘,又要多2个功力和五个对象

主题素材:每多三个效应就必要在记录本对象中定义贰个艺术,不爽,程序扩大性极差。

下跌鼠标、键盘等外围设备和台式机Computer的耦合性。

}

当子类必要父类的机能,而效果核心子类有和好特有内容时,能够重写父类中的方法,那样,即沿袭了父类的作用,又定义了子类特有的始末。

1. 完成代码步骤

  • 概念鼠标、键盘,台式机三者之间应当遵守的平整

interface USB {

    void open();// 开启作用

 

    void close();// 关闭作用

}

 

  • 鼠标完毕USB规则

class Mouse implements USB {

    publicvoid open() {

        System.out.println("鼠标开启");

    }

 

    publicvoid close() {

        System.out.println("鼠标关闭");

    }

}

 

  • 键盘实现USB规则

class KeyBoard implements USB {

    publicvoid open() {

        System.out.println("键盘开启");

    }

 

    publicvoid close() {

        System.out.println("键盘关闭");

    }

}

 

  • 概念笔记本

class NoteBook {

    // 笔记本开启运转效果

    publicvoid run() {

        System.out.println("台式机运营");

    }

 

    // 台式机使用usb设备,那时当台式机对象调用这几个功用时,必须给其传递三个契合USB规则的USB设备

    publicvoid useUSB(USB usb) {

        // 判定是不是有USB设备

        if (usb != null) {

            usb.open();

            usb.close();

        }

    }

 

    publicvoid shutDown() {

        System.out.println("台式机关闭");

    }

}

 

publicclass Test {

    publicstaticvoid main(String[] args) {

        // 创设笔记本实体对象

        NoteBook nb = new NoteBook();

// 台式机开启

        nb.run();

 

        // 成立鼠标实体对象

        Mouse m = new Mouse();

        // 台式机使用鼠标

        nb.useUSB(m);

 

// 创造键盘实体对象

        KeyBoard kb = new KeyBoard();

        // 台式机使用键盘

        nb.useUSB(kb);

 

        // 台式机关闭

        nb.shutDown();

    }

}

 

·接口的施用

在子类中,访问父类中的成员方法格式:

1. 总结

1.  知识点总结
    ----------
  • 接口:明白为是三个特种的抽象类,但它不是类,是叁个接口
-   接口的特点:


    1,定义一个接口用interface关键字


            interface
Inter{} 

        2,一个类实现一个接口,实现implements关键字


            class
Demo implements Inter{} 

        3,
接口不能直接创建对象 

        
通过多态的方式,由子类来创建对象,接口多态     

-   接口中的成员特点:


        成员变量:


            只能是final
修饰的常量 

            默认修饰符:
public static final 

        构造方法:


            无


        成员方法:


            只能是抽象方法


            默认修饰符:
public abstract 

-   类与类,类与接口,接口与接口之间的关系


        类与类之间:继承关系,单继承,可以是多层继承


        类与接口之间:
实现关系,单实现,也可以多实现 

        接口与接口之间:继承关系,单继承,也可以是多继承            


        Java中的类可以继承一个父类的同时,实现多个接口


 
  • 多态:掌握为同一种物质的多样样子
-   多态使用的前提:

            1,有持续或许完成关系

            2,要方法重写

            三,父类引用指向子类对象

  • 多态的积极分子访问特点:

            方法的运营看右侧,别的都看左侧

  • 多态的利润:

            升高了程序的增添性

  • 多态的害处:

            不能访问子类的蓄意效率

  • 多态的分类

    • 类的多态

abstract class Fu {

public abstract void method();

}

class Zi extends Fu {

public void method(){

         System.out.println("重写父类抽象方法");

}

}

//类的多态使用

Fu fu= new Zi();

 

  • 接口的多态

interface Fu {

    public abstract void method();

}

class Zi implements Fu {

    public void method(){

System.out.println("重写接口抽象方法");

}

}

//接口的多态使用

Fu fu = new Zi();

 

  • instanceof 关键字

        格式: 对象名 instanceof 类名

        返回值: true, false

        成效: 推断钦命的对象 是还是不是为 给定类创造的目的

接口中的方法全都以画个饼来解除饥饿方法,直接new接口来调用方法没有趣,Java也不一致意那样干

        super.父类中的成员方法();

类与接口的关系为完毕关系,即类实现接口。完结的动作类似承接,只是关键字不相同,完毕利用implements

方法重写的注意事项

其它类(完毕类)完结接口后,就一定于申明:”我应当负有这些接口中的成效”。达成类还是须求重写方法以贯彻具体的效果。

​ 子类方法覆盖父类方法,必须求保险权力大于等于父类权限。

格式:

小结:当三个类是另一个类中的1种时,能够透过连续,来继续属性与效率。假设父类具有的作用内容供给子类特殊定义时,举行艺术重写。

class类implements接口{

贰.抽象类    分析事物时,发掘了共性内容,就出现上扬收取。会有那般壹种独特情况,正是方法效果声称同样,但方法效果宗旨分歧。那么此时也能够抽出,但只抽出方法评释,不收取方法主体。那么此格局正是一个华而不实方法。

重写接口中艺术

抽象方法定义的格式:                                public abstract 重临值类型 方法名(参数);

}

抽象类定义的格式: abstract class 类名 {  }

在类实现接口后,该类就能够将接口中的抽象方法承接过来,此时此类必要重写该抽象方法,完毕具体的逻辑。

抽象类的特色:

叁.案例代码一:

一、抽象类和抽象方法都亟待被abstract修饰。抽象方法自然要定义在抽象类中。    二、抽象类不得以平素创造对象,原因:调用抽象方法未有意义。                                三、唯有覆盖了抽象类中兼有的空洞方法后,其子类本领够创造对象。不然该子类依然多少个抽象类。

packagecom.itheima_01;

据此持续抽象类,更加多的是在商量,是面临共性类型操作会更简明。

/*

叁.接口:精通为是1个非常的抽象类,但它不是类,是三个接口

* Java语言的连续是单纯承继,一个子类只可以有3个父类(3个孙子不得不有三个亲爹)

接口的特色:

* Java语言给我们提供了1种体制,用于拍卖继承单一的局限性的,接口

一,定义二个接口用interface关键字 interface Inter{}

*

二,二个类实现1个接口,达成implements关键字    class 德姆o implements Inter{}

*接口:接口是三个比抽象类还浮泛的类,接口里具有的方法全都是空虚方法,接口和类的涉嫌是促成,implements

3, 接口不可能直接成立对象

*interface

通过多态的法门,由子类来创造对象,接口多态

*

接口中的成员特点:

*格式:

分子变量:只可以是final 修饰的常量

*interface接口名{

暗许修饰符: public static final

*

分子方法:只好是空虚方法

*}

暗中同意修饰符: public abstract

*

类与类,类与接口,接口与接口之间的涉嫌

*/

类与类之间:承继关系,单承接,能够是多层继承

publicclassInterfaceDemo {

类与接口之间: 实现关系,单达成,也得以多达成

publicstaticvoidmain(String[] args) {

接口与接口之间:承接关系,单承接,也得以是多再而三

BillGates gates =newBillGates();

Java中的类能够继续叁个父类的还要,完毕多少个接口

gates.code();

四.多态:理解为一样种物质的有余模样

}

多态使用的前提:

}

1,有承继也许实现关系

classBoss {

二,要方法重写

publicvoidmanage() {

三,父类引用指向子类对象

System.out.println("管理公司");

多态的成员访问特点:方法的运维看右侧,其他都看左侧

}

多态的益处:进步了程序的扩大性

}

多态的弊病:不可能访问子类的特有功用

classProgrammer {

多态的归类

publicvoidcode() {

  类的多态

System.out.println("敲代码");

abstract class Fu { 

}

public abstract void method();

}

}

//Bill盖茨

class Zi extends Fu {

classBillGatesextendsProgrammer {

public void method(){

}

System.out.println(“

三.接口中成员的特色

}

一、接口中得以定义变量,然则变量必须有固定的梳洗符修饰,public static final所以接口中的变量也称之为常量,其值不能够改动。后边大家会讲课fnal关键字

}

二、接口中得以定义方法,方法也会有固定的修饰符,public abstract

//类的多态使用

三、接口不能创造对象。

Fu fu= new Zi();

四、子类必须覆盖掉接口中兼有的画个饼来解除饥饿方法后,子类才方可实例化。不然子类是四个抽象类。

接口的多态

一.案例代码贰:

interface Fu {

packagecom.itheima_01;

public abstract void method();

/*

}

*接口的分子特点:

class Zi implements Fu {

*只能有抽象方法

public void method(){

*不得不有常量

System.out.println(“重写接口抽象方法”

*默许使用public&abstract修饰方法

}

*唯其如此采纳public&abstract修饰方法

}

*暗中认可使用public static final来修饰成员变量

//接口的多态使用

*

Fu fu = new Zi();

*建议:建议我们手动的给上暗中认可修饰符

instanceof 关键字

*

格式: 对象名 instanceof 类名                    重返值: true, false                                        功能: 判断钦点的对象 是还是不是为 给定类创造的目的

*注意:

*接口不可能成立对象(不能够实例化)

*类与接口的关系是贯彻关系,二个类完毕2个接口必须贯彻它具备的方法

*/

publicclassInterfaceDemo2 {

publicstaticvoidmain(String[] args) {

//Animal a = new Animal();

//Animal.num;

}

}

interfaceAnimal {

publicstaticfinalint*num*= 10;

publicabstractvoideat();

}

classCatimplementsAnimal {

publicvoideat() {

}

}

肆.接口和类的关系

A:类与类之间:承继关系,三个类只好1直接轨3个父类,不过帮助多种承继

B:类与接口之间:唯有完毕关系,1个类能够兑现八个接口

C:接口与接口之间:只有承袭关系,1个接口能够继续五个接口

1.案例代码三:

packagecom.itheima_01;

/*

*

*类与类:承接关系,单1承袭,多层传承

*类与接口:实现关系,多完成

*接口与接口的关联:承袭关系,多一连

*/

publicclassInterfaceDemo3 {

publicstaticvoidmain(String[] args) {

}

}

interfaceInterAextendsInterB {

publicabstractvoidmethod();

}

interfaceInterB {

publicabstractvoidfunction();

}

interfaceInterCextendsInterA {

}

classDemoimplementsInterC {

@Override

publicvoidmethod() {

//TODOAuto-generated method

stub

}

@Override

publicvoidfunction() {

//TODOAuto-generated method

stub

}

}

5.接口的思辨

日前学习了接口的代码展现,今后来学学接口的思维,接下里从生活中的例子进行验证。

比喻:我们都驾驭Computer上留有很七个插口,而这个插口能够插入相应的配备,那几个设备为啥能插在上面吧?主要原因是这几个器具在生产的时候符合了那一个插口的运用规则,不然将无法插入接口中,更无法运用。开掘这几个插口的产出让我们应用更加多的器械。

接口的产出有利于中期使用和掩护,一方是在动用接口(如Computer),1方在促成接口(插在插口上的设备)。例如:台式机使用那个规则(接口),计算机外围设备达成那一个规则(接口)。

集中种类中山高校量用到接口

Collection接口

List接口

ArrayList实现类

LinkedList实现类

Set接口

六.接口亮点

1.类与接口的关系,达成关系,而且是多完成,一个类能够兑现五个接口,类与类之间是持续关系,java中的承袭是纯净承接,三个类只好有八个父类,打破了后续的局限性。

二.对外提供规则(USB接口)

叁.大跌了先后的耦合性(能够达成模块化开荒,定义好规则,各种人实现和煦的模块,进步了支出的频率)

7.接口和抽象类的区分

1.共性:

不停的展开抽出,抽取出抽象的,未有实际落到实处的点子,都不可能实例化(不能够创造对象)

二.不同一:与类的涉嫌

(一)类与接口是兑现关系,而且是多完成,3个类能够达成三个接口,类与抽象类是后续关系,Java中的承继是纯净承袭,多层承继,贰个类只好继续贰个父类,可是足以有三伯类

(2)区别2: 成员

a.成员变量

抽象类能够有成员变量,也足以有常量

接口只好有常量,暗中同意修饰符public static final

b.成员方法

抽象类能够有抽象方法,也能够有非抽象方法

接口只可以有抽象方法,暗中同意修饰符public abstract

c.构造方法

抽象类有构造方法,为子类提供

接口未有构造方法

捌.选手案例

一.案例代码4:

//Person类

package com.itheima_02;

public class Person {

private String name;//姓名

private int age;//年龄

private String gender;//性别

public Person() {

super();

// TODO Auto-generated constructor stub

}

public Person(String name, int age, String

gender) {

super();

this.name = name;

this.age = age;

this.gender = gender;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public int getAge() {

return age;

}

public void setAge(int age) {

this.age = age;

}

public String getGender() {

return gender;

}

public void setGender(String gender) {

this.gender = gender;

}

public void eat() {

System.out.println("吃饭...");

}

public void sleep() {

System.out.println("Zzz....");

}

}

//Player类

package com.itheima_02;

//运动员

public abstract class Player extends Person {

//学习

public abstract void study();

}

//Coach类

package com.itheima_02;

//教练

public abstract class Coach extends Person {

//教

public abstract void teach();

}

//PingPangPlayer类

package com.itheima_02;

public class PingPangPlayerextends Player {

@Override

public void study() {

System.out.println("学习抽球");

}

}

//

BasketbalPlayer类

package com.itheima_02;

public class BasketbalPlayer extends Player

implements SpeakEnglish{

@Override

public void study() {

System.out.println("学习扣篮");

}

@Override

public void speak() {

System.out.println("说英语");

}

}

//

PingPangCoach类

package com.itheima_02;

public class PingPangCoach extends Coach{

@Override

public void teach() {

System.out.println("教抽球");

}

}

//

BasketbalCoach类

package com.itheima_02;

public class BasketbalCoach extends Coach

implements SpeakEnglish{

@Override

public void teach() {

System.out.println("教扣篮");

}

@Override

public void speak() {

System.out.println("说英语");

}

}

//

SpeakEnglish类

package com.itheima_02;

public interface SpeakEnglish {

public abstract void speak();

}

//

InterfaceTest类

package com.itheima_02;

/*

*篮球健儿和教练

乒球选手和教练

于今篮球运动员和教练要出访,必要学习土耳其语

请根据你所学的文化,深入分析出来什么是类,哪些是抽象类,哪些是接口

*/

public class InterfaceTest {

public static void main(String[] args) {

//创建篮球选手的靶子

BasketbalPlayer bp = new BasketbalPlayer();

bp.setName("女兆日月");

bp.setAge(35);

bp.setGender("男");

bp.eat();

bp.study();

bp.speak();

System.out.println("------------");

//创立乒球练习

PingPangCoach ppc = new PingPangCoach();

ppc.setName("刘胖子");

ppc.setAge(40);

ppc.setGender("男");

ppc.eat();

ppc.teach();

}

}

2.多态

1.多态概述

多态是继封装、承袭之后,面向对象的第一大特点。

现实事物常常会反映出多样模样,如桃李,学生是人的一种,则二个实际的同班张三既是学员也是人,即现身二种形象。

Java作为面向对象的言语,同样能够描述2个事物的有余形状。如Student类承袭了Person类,三个Student的指标便既是Student,又是Person。

贰.多态的定义与行使格式

多态的定义格式:就是父类的引用变量指向子类对象

父类类型变量名= new子类类型();

变量名.方法名();

A:普通类多态定义的格式

父类变量名= new子类();

如:class Fu {}

class Zi extends Fu {}

//类的多态使用

Fu f = new Zi();

B:抽象类多态定义的格式

抽象类变量名= new抽象类子类();

如:abstract class Fu {

public abstract void method();

}

class Zi extends Fu {

public void method(){

System.out.println(“重写父类抽象方法”);

}

}

//类的多态使用

Fu fu= new Zi();

C:接口多态定义的格式

接口变量名= new接口完毕类();

如:interface Fu {

publicabstract void method();

}

class Zi implements Fu {

publicvoid method(){

System.out.println(“重写接口抽象方法”);

}

}

//接口的多态使用

Fu fu = new Zi();

一.案例代码5:

packagecom.itheima_01;

/*

*多态的前提:

*子父类的承袭关系

*主意的重写

*父类引用指向子类对象

*

*动态绑定:运维时期调用的章程,是凭借其现实的体系

*

*

*

*

*/

publicclassPoymorphicDemo {

publicstaticvoidmain(String[] args) {

/*Cat c = new Cat();

c.eat();*/

//父类引用Animal a

//指向=

//子类对象new Cat()

Animal a =newCat();

a.eat();

}

}

classAnimal {

publicvoideat() {

System.out.println("吃东西");

}

}

classCatextendsAnimal {

publicvoideat() {

System.out.println("猫吃鱼");

}

}

三.多态成员的特点

A:多态成员变量

当子父类中现身同名的积极分子变量时,多态调用该变量时:

编写翻译时期:参谋的是引用型变量所属的类中是不是有被调用的成员变量。未有,编写翻译退步。

运营时期:也是调用引用型变量所属的类中的成员变量。

简单来讲记:编写翻译和平运动作都参照等号的左侧。编写翻译运营看右侧。

B:多态成员方法

编写翻译时期:参考引用变量所属的类,尽管未有类中未有调用的法子,编写翻译退步。

运作时期:参谋引用变量所指的对象所属的类,并运维指标所属类中的成员方法。

简单的讲:编译看左侧,运维看左边

一.案例代码陆:

packagecom.itheima_01;

/*

*

*多态的分子特点:

*成员变量编写翻译时看的是左手,运转时看的左臂

*分子方法编写翻译时看的是右边,运维时看左侧

*静态方法编写翻译时看的是左臂,运营时看的也是左边手

*

*

*编写翻译时看的都以右边,运维时成员方法看的是左边手,其余(成员变量和静态的主意)看的都以右侧

*

*/

publicclassPoymorphicDemo2 {

publicstaticvoidmain(String[] args) {

Dad d =newKid();

//System.out.println(d.num);

//d.method();

d.function();//使用变量去调用静态方法,其实一定于用变量类型的类名去调用

}

}

classDad {

intnum= 20;

publicvoidmethod() {

System.out.println("作者是父类方法");

}

publicstaticvoidfunction() {

System.out.println("小编是父类静态方法");

}

}

classKidextendsDad {

intnum= 10;

publicvoidmethod() {

System.out.println("小编是子类方法");

}

publicstaticvoidfunction() {

System.out.println("笔者是子类静态方法");

}

}

四.多态中进步转型与向下转型

多态的转型分为向上转型与向下转型二种:

A:向上转型:当有子类对象赋值给贰个父类引用时,就是进化转型,多态本身正是进化转型的长河。

运用格式:

父类类型变量名= new子类类型();

如:Person p = new Student();

B:向下转型:贰个业已发展转型的子类对象能够选择强制类型转变的格式,将父类引用转为子类引用,这些进度是向下转型。假诺是直接开立父类对象,是不可能向下转型的

接纳格式:

子类类型变量名= (子类类型)父类类型的变量;

如:Student stu = (Student) p;//变量p实际上指向Student对象

1.案例代码7:

packagecom.itheima_01;

/*

*

*多态中的向上转型和向下转型:

*

*引用类型之间的转移

*腾飞转型

*追加(子类型调换到父类型)

*向下转型

*由大到小

*中央数据类型的转移

*自行类型调换

*追加

*byte short char ---int---long --- float --- double

*强制类型转变

*由大到小

*

*

*

*/

publicclassPoymorphicDemo3 {

publicstaticvoidmain(String[] args) {

Animal2 a =newDog();//向上转型

//a.eat();

Dog d = (Dog)a;//向下转型

d.swim();

}

}

classAnimal2 {

publicvoideat() {

System.out.println("吃东西");

}

}

classDogextendsAnimal2 {

publicvoideat() {

System.out.println("啃骨头");

}

publicvoidswim() {

System.out.println("狗刨");

}

}

5.多态的优缺点

1.案例代码八:

packagecom.itheima_01;

/*

*

*多态的得失

*亮点:能够增加可维护性(多态前提所保障的),升高代码的可扩大性

缺点:不可能直接待上访问子类特有的分子

*/

publicclassPoymorphicDemo4 {

publicstaticvoidmain(String[] args) {

MiFactory factory =newMiFactory();

factory.createPhone(newMiNote());

factory.createPhone(newRedMi());

}

}

classMiFactory {

/*public void createPhone(MiNotemi) {

mi.call();

}

public void createPhone(RedMimi) {

mi.call();

}*/

publicvoidcreatePhone(Phone p) {

p.call();

}

}

interfacePhone {

publicvoidcall();

}

//小米Note

classMiNoteimplementsPhone{

publicvoidcall() {

System.out.println("小米Note打电话");

}

}

//红米

classRedMiimplementsPhone {

publicvoidcall() {

System.out.println("BlackBerry打电话");

}

}

�W�����

TAG标签:
版权声明:本文由澳门新葡8455手机版发布于www.2527.com,转载请注明出处:面向对象,JAVA之面向对象2