wordpress 更新数据库,关键词优化一般收费价格,成都 做网站 模版,镇江网第07章_面向对象编程(进阶)
讲师#xff1a;尚硅谷-宋红康#xff08;江湖人称#xff1a;康师傅#xff09;
官网#xff1a;http://www.atguigu.com 本章专题与脉络 1. 关键字#xff1a;this
1.1 this是什么#xff1f; 在Java中#xff0c;this关键字不算难理解…第07章_面向对象编程(进阶)
讲师尚硅谷-宋红康江湖人称康师傅
官网http://www.atguigu.com 本章专题与脉络 1. 关键字this
1.1 this是什么 在Java中this关键字不算难理解它的作用和其词义很接近。 它在方法准确的说是实例方法或非static的方法内部使用表示调用该方法的对象 它在构造器内部使用表示该构造器正在初始化的对象。 this可以调用的结构成员变量、方法和构造器
1.2 什么时候使用this
1.2.1 实例方法或构造器中使用当前对象的成员
在实例方法或构造器中如果使用当前类的成员变量或成员方法可以在其前面添加this增强程序的可读性。不过通常我们都习惯省略this。
但是当形参与成员变量同名时如果在方法内或构造器内需要使用成员变量必须添加this来表明该变量是类的成员变量。即我们可以用this来区分成员变量和局部变量。比如 另外使用this访问属性和方法时如果在本类中未找到会从父类中查找。这个在继承中会讲到。
举例1
span stylebackground-color:#f8f8f8span stylecolor:#333333span stylecolor:#770088class/span span stylecolor:#0000ffPerson/span{ span stylecolor:#aa5500// 定义Person类/spanspan stylecolor:#770088private/span span stylecolor:#008855String/span span stylecolor:#000000name/span ; span stylecolor:#770088private/span span stylecolor:#008855int/span span stylecolor:#000000age/span ; span stylecolor:#770088public/span span stylecolor:#000000Person/span(span stylecolor:#008855String/span span stylecolor:#000000name/span,span stylecolor:#008855int/span span stylecolor:#000000age/span){ span stylecolor:#770088this/span.span stylecolor:#000000name/span span stylecolor:#981a1a/span span stylecolor:#000000name/span ; span stylecolor:#770088this/span.span stylecolor:#000000age/span span stylecolor:#981a1a/span span stylecolor:#000000age/span ; }span stylecolor:#770088public/span span stylecolor:#008855void/span span stylecolor:#000000setName/span(span stylecolor:#008855String/span span stylecolor:#000000name/span){span stylecolor:#770088this/span.span stylecolor:#000000name/span span stylecolor:#981a1a/span span stylecolor:#000000name/span;}span stylecolor:#770088public/span span stylecolor:#008855void/span span stylecolor:#000000setAge/span(span stylecolor:#008855int/span span stylecolor:#000000age/span){span stylecolor:#770088this/span.span stylecolor:#000000age/span span stylecolor:#981a1a/span span stylecolor:#000000age/span;}span stylecolor:#770088public/span span stylecolor:#008855void/span span stylecolor:#000000getInfo/span(){ span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#aa1111姓名/span span stylecolor:#981a1a/span span stylecolor:#000000name/span) ;span stylecolor:#770088this/span.span stylecolor:#000000speak/span();}span stylecolor:#770088public/span span stylecolor:#008855void/span span stylecolor:#000000speak/span(){span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#000000“年龄”/span span stylecolor:#981a1a/span span stylecolor:#770088this/span.span stylecolor:#000000age/span); }
}
/span/span
举例2
span stylebackground-color:#f8f8f8span stylecolor:#333333span stylecolor:#770088public/span span stylecolor:#770088class/span span stylecolor:#0000ffRectangle/span {span stylecolor:#008855int/span span stylecolor:#000000length/span;span stylecolor:#008855int/span span stylecolor:#000000width/span;
span stylecolor:#770088public/span span stylecolor:#008855int/span span stylecolor:#000000area/span() {span stylecolor:#770088return/span span stylecolor:#770088this/span.span stylecolor:#000000length/span span stylecolor:#981a1a*/span span stylecolor:#770088this/span.span stylecolor:#000000width/span;}
span stylecolor:#770088public/span span stylecolor:#008855int/span span stylecolor:#000000perimeter/span(){span stylecolor:#770088return/span span stylecolor:#1166442/span span stylecolor:#981a1a*/span (span stylecolor:#770088this/span.span stylecolor:#000000length/span span stylecolor:#981a1a/span span stylecolor:#770088this/span.span stylecolor:#000000width/span);}
span stylecolor:#770088public/span span stylecolor:#008855void/span span stylecolor:#000000print/span(span stylecolor:#008855char/span span stylecolor:#000000sign/span) {span stylecolor:#770088for/span (span stylecolor:#008855int/span span stylecolor:#000000i/span span stylecolor:#981a1a/span span stylecolor:#1166441/span; span stylecolor:#000000i/span span stylecolor:#981a1a/span span stylecolor:#770088this/span.span stylecolor:#000000width/span; span stylecolor:#000000i/spanspan stylecolor:#981a1a/span) {span stylecolor:#770088for/span (span stylecolor:#008855int/span span stylecolor:#000000j/span span stylecolor:#981a1a/span span stylecolor:#1166441/span; span stylecolor:#000000j/span span stylecolor:#981a1a/span span stylecolor:#770088this/span.span stylecolor:#000000length/span; span stylecolor:#000000j/spanspan stylecolor:#981a1a/span) {span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000print/span(span stylecolor:#000000sign/span);}span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span();}}
span stylecolor:#770088public/span span stylecolor:#008855String/span span stylecolor:#000000getInfo/span(){span stylecolor:#770088return/span span stylecolor:#aa1111长/span span stylecolor:#981a1a/span span stylecolor:#770088this/span.span stylecolor:#000000length/span span stylecolor:#981a1a/span span stylecolor:#aa1111宽/span span stylecolor:#981a1a/span span stylecolor:#770088this/span.span stylecolor:#000000width/span span stylecolor:#981a1a/spanspan stylecolor:#aa1111面积/span span stylecolor:#981a1a/span span stylecolor:#770088this/span.span stylecolor:#000000area/span() span stylecolor:#981a1a/spanspan stylecolor:#aa1111周长/span span stylecolor:#981a1a/span span stylecolor:#770088this/span.span stylecolor:#000000perimeter/span();}
}
/span/span
测试类
span stylebackground-color:#f8f8f8span stylecolor:#333333span stylecolor:#770088public/span span stylecolor:#770088class/span span stylecolor:#0000ffTestRectangle/span {span stylecolor:#770088public/span span stylecolor:#770088static/span span stylecolor:#008855void/span span stylecolor:#000000main/span(span stylecolor:#008855String/span[] span stylecolor:#000000args/span) {span stylecolor:#000000Rectangle/span span stylecolor:#000000r1/span span stylecolor:#981a1a/span span stylecolor:#770088new/span span stylecolor:#000000Rectangle/span();span stylecolor:#000000Rectangle/span span stylecolor:#000000r2/span span stylecolor:#981a1a/span span stylecolor:#770088new/span span stylecolor:#000000Rectangle/span();
span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#aa1111r1对象/span span stylecolor:#981a1a/span span stylecolor:#000000r1/span.span stylecolor:#000000getInfo/span());span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#aa1111r2对象/span span stylecolor:#981a1a/span span stylecolor:#000000r2/span.span stylecolor:#000000getInfo/span());
span stylecolor:#000000r1/span.span stylecolor:#000000length/span span stylecolor:#981a1a/span span stylecolor:#11664410/span;span stylecolor:#000000r1/span.span stylecolor:#000000width/span span stylecolor:#981a1a/span span stylecolor:#1166442/span;span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#aa1111r1对象/span span stylecolor:#981a1a/span span stylecolor:#000000r1/span.span stylecolor:#000000getInfo/span());span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#aa1111r2对象/span span stylecolor:#981a1a/span span stylecolor:#000000r2/span.span stylecolor:#000000getInfo/span());
span stylecolor:#000000r1/span.span stylecolor:#000000print/span(span stylecolor:#aa1111#/span);span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#aa1111---------------------/span);span stylecolor:#000000r1/span.span stylecolor:#000000print/span(span stylecolor:#aa1111/span);
span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#aa1111---------------------/span);span stylecolor:#000000r2/span.span stylecolor:#000000print/span(span stylecolor:#aa1111#/span);span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#aa1111---------------------/span);span stylecolor:#000000r2/span.span stylecolor:#000000print/span(span stylecolor:#aa1111%/span);}
}/span/span
1.2.2 同一个类中构造器互相调用
this可以作为一个类中构造器相互调用的特殊格式。 this()调用本类的无参构造器 this(实参列表)调用本类的有参构造器
span stylebackground-color:#f8f8f8span stylecolor:#333333span stylecolor:#770088public/span span stylecolor:#770088class/span span stylecolor:#0000ffStudent/span {span stylecolor:#770088private/span span stylecolor:#008855String/span span stylecolor:#000000name/span;span stylecolor:#770088private/span span stylecolor:#008855int/span span stylecolor:#000000age/span;
span stylecolor:#aa5500// 无参构造/spanspan stylecolor:#770088public/span span stylecolor:#000000Student/span() {
span stylecolor:#aa5500// this(,18);//调用本类有参构造器/span}
span stylecolor:#aa5500// 有参构造/spanspan stylecolor:#770088public/span span stylecolor:#000000Student/span(span stylecolor:#008855String/span span stylecolor:#000000name/span) {span stylecolor:#770088this/span();span stylecolor:#aa5500//调用本类无参构造器/spanspan stylecolor:#770088this/span.span stylecolor:#000000name/span span stylecolor:#981a1a/span span stylecolor:#000000name/span;}span stylecolor:#aa5500// 有参构造/spanspan stylecolor:#770088public/span span stylecolor:#000000Student/span(span stylecolor:#008855String/span span stylecolor:#000000name/span,span stylecolor:#008855int/span span stylecolor:#000000age/span){span stylecolor:#770088this/span(span stylecolor:#000000name/span);span stylecolor:#aa5500//调用本类中有一个String参数的构造器/spanspan stylecolor:#770088this/span.span stylecolor:#000000age/span span stylecolor:#981a1a/span span stylecolor:#000000age/span;}
span stylecolor:#770088public/span span stylecolor:#008855String/span span stylecolor:#000000getName/span() {span stylecolor:#770088return/span span stylecolor:#000000name/span;}span stylecolor:#770088public/span span stylecolor:#008855void/span span stylecolor:#000000setName/span(span stylecolor:#008855String/span span stylecolor:#000000name/span) {span stylecolor:#770088this/span.span stylecolor:#000000name/span span stylecolor:#981a1a/span span stylecolor:#000000name/span;}span stylecolor:#770088public/span span stylecolor:#008855int/span span stylecolor:#000000getAge/span() {span stylecolor:#770088return/span span stylecolor:#000000age/span;}span stylecolor:#770088public/span span stylecolor:#008855void/span span stylecolor:#000000setAge/span(span stylecolor:#008855int/span span stylecolor:#000000age/span) {span stylecolor:#770088this/span.span stylecolor:#000000age/span span stylecolor:#981a1a/span span stylecolor:#000000age/span;}
span stylecolor:#770088public/span span stylecolor:#008855String/span span stylecolor:#000000getInfo/span(){span stylecolor:#770088return/span span stylecolor:#aa1111姓名/span span stylecolor:#981a1a/span span stylecolor:#000000name/span span stylecolor:#981a1a/spanspan stylecolor:#aa1111年龄/span span stylecolor:#981a1a/span span stylecolor:#000000age/span;}
}/span/span
注意 不能出现递归调用。比如调用自身构造器。 推论如果一个类中声明了n个构造器则最多有 n - 1个构造器中使用了this(形参列表) this()和this(实参列表)只能声明在构造器首行。 推论在类的一个构造器中最多只能声明一个this(参数列表)
1.3 练习
练习1添加必要的构造器综合应用构造器的重载this关键字。 练习2
1按照如下的UML类图创建相应的类提供必要的结构 在提款方法withdraw()中需要判断用户余额是否能够满足提款数额的要求如果不能应给出提示。deposit()方法表示存款。
2按照如下的UML类图创建相应的类提供必要的结构 3按照如下的UML类图创建相应的类提供必要的结构 addCustomer 方法必须依照参数姓名构造一个新的 Customer对象然后把它放到 customer 数组中。还必须把 numberOfCustomer 属性的值加 1。 getNumOfCustomers 方法返回 numberofCustomers 属性值。 getCustomer方法返回与给出的index参数相关的客户。
4创建BankTest类进行测试。
内存解析图 2. 面向对象特征二继承(Inheritance)
2.1 继承的概述
2.1.1 生活中的继承 财产继承 绿化前人栽树后人乘凉 “绿水青山就是金山银山” 样貌 继承之外是不是还可以进化 继承有延续下一代延续上一代的基因、财富、扩展下一代和上一代又有所不同的意思。 2.1.2 Java中的继承
角度一从上而下
为描述和处理个人信息定义类Person 为描述和处理学生信息定义类Student 通过继承简化Student类的定义 说明Student类继承了父类Person的所有属性和方法并增加了一个属性school。Person中的属性和方法Student都可以使用。 角度二从下而上 多个类中存在相同属性和行为时将这些内容抽取到单独一个类中那么多个类中无需再定义这些属性和行为只需要和抽取出来的类构成继承关系。如图所示 再举例 2.1.3 继承的好处 继承的出现减少了代码冗余提高了代码的复用性。 继承的出现更有利于功能的扩展。 继承的出现让类与类之间产生了is-a的关系为多态的使用提供了前提。 继承描述事物之间的所属关系这种关系是is-a 的关系。可见父类更通用、更一般子类更具体。 注意不要仅为了获取其他类中某个功能而去继承 2.2 继承的语法
2.2.1 继承中的语法格式
通过 extends 关键字可以声明一个类B继承另外一个类A定义格式如下
span stylebackground-color:#f8f8f8span stylecolor:#333333[span stylecolor:#000000修饰符/span] span stylecolor:#770088class/span span stylecolor:#0000ff类A/span {...
}
[span stylecolor:#000000修饰符/span] span stylecolor:#770088class/span span stylecolor:#0000ff类B/span span stylecolor:#770088extends/span span stylecolor:#000000类A/span {...
}
/span/span
2.2.2 继承中的基本概念
类B称为子类、派生类(derived class)、SubClass
类A称为父类、超类、基类(base class)、SuperClass
2.3 代码举例
1、父类
span stylebackground-color:#f8f8f8span stylecolor:#333333span stylecolor:#770088package/span span stylecolor:#0000ffcom/span.span stylecolor:#000000atguigu/span.span stylecolor:#000000inherited/span.span stylecolor:#000000grammar/span;
span stylecolor:#aa5500/*/spanspan stylecolor:#aa5500* 定义动物类Animal做为父类/spanspan stylecolor:#aa5500*//span
span stylecolor:#770088public/span span stylecolor:#770088class/span span stylecolor:#0000ffAnimal/span {span stylecolor:#aa5500// 定义name属性/spanspan stylecolor:#008855String/span span stylecolor:#000000name/span;span stylecolor:#aa5500// 定义age属性/spanspan stylecolor:#008855int/span span stylecolor:#000000age/span;
span stylecolor:#aa5500// 定义动物的吃东西方法/spanspan stylecolor:#770088public/span span stylecolor:#008855void/span span stylecolor:#000000eat/span() {span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#000000age/span span stylecolor:#981a1a/span span stylecolor:#aa1111岁的/spanspan stylecolor:#981a1a/span span stylecolor:#000000name/span span stylecolor:#981a1a/span span stylecolor:#aa1111在吃东西/span);}
}
/span/span
2、子类
span stylebackground-color:#f8f8f8span stylecolor:#333333span stylecolor:#770088package/span span stylecolor:#0000ffcom/span.span stylecolor:#000000atguigu/span.span stylecolor:#000000inherited/span.span stylecolor:#000000grammar/span;
span stylecolor:#aa5500/*/spanspan stylecolor:#aa5500* 定义猫类Cat 继承 动物类Animal/spanspan stylecolor:#aa5500*//span
span stylecolor:#770088public/span span stylecolor:#770088class/span span stylecolor:#0000ffCat/span span stylecolor:#770088extends/span span stylecolor:#000000Animal/span {span stylecolor:#008855int/span span stylecolor:#000000count/span;span stylecolor:#aa5500//记录每只猫抓的老鼠数量/span
span stylecolor:#aa5500// 定义一个猫抓老鼠的方法catchMouse/spanspan stylecolor:#770088public/span span stylecolor:#008855void/span span stylecolor:#000000catchMouse/span() {span stylecolor:#000000count/spanspan stylecolor:#981a1a/span;span stylecolor:#000000System/span.span stylecolor:#000000out/span.span stylecolor:#000000println/span(span stylecolor:#aa1111抓老鼠已经抓了/spanspan stylecolor:#981a1a/span span stylecolor:#000000count/span span stylecolor:#981a1a/span span stylecolor:#aa1111只老鼠/span);}
}/span/span
3、测试类
span stylebackground-color:#f8f8f8span stylecolor:#333333span stylecolor:#770088package/span span stylecolor:#0000ffcom/span.span stylecolor:#000000atguigu/span.span stylecolor:#000000inherited/span.span stylecolor:#000000grammar/span;
span stylecolor:#770088public/span span stylecolor:#770088class/span span stylecolor:#0000ffTestCat/span {span stylecolor:#770088public/span span stylecolor:#770088static/span span stylecolor:#008855void/span span stylecolor:#000000main/span(span stylecolor:#008855String/span[] span stylecolor:#000000args/span) {span stylecolor:#aa5500// 创建一个猫类对象/spanspan stylecolor:#000000Cat/span span stylecolor:#000000cat/span span stylecolor:#981a1a/span span stylecolor:#770088new/span span stylecolor:#000000Cat/span();span stylecolor:#aa5500// 为该猫类对象的name属性进行赋值/spanspan stylecolor:#000000cat/span.span stylecolor:#000000name/span span stylecolor:#981a1a/span span stylecolor:#aa1111Tom/span;span stylecolor:#aa5500// 为该猫类对象的age属性进行赋值/spanspan stylecolor:#000000cat/span.span stylecolor:#000000age/span span stylecolor:#981a1a/span span stylecolor:#1166442/span;span stylecolor:#aa5500// 调用该猫继承来的eat()方法/spanspan stylecolor:#000000cat/span.span stylecolor:#000000eat/span();span stylecolor:#aa5500// 调用该猫的catchMouse()方法/spanspan stylecolor:#000000cat/span.span stylecolor:#000000catchMouse/span();span stylecolor:#000000cat/span.span stylecolor:#000000catchMouse/span();span stylecolor:#000000cat/span.span stylecolor:#000000catchMouse/span();}
}/span/span
2.4 继承性的细节说明
1、子类会继承父类所有的实例变量和实例方法
从类的定义来看类是一类具有相同特性的事物的抽象描述。父类是所有子类共同特征的抽象描述。而实例变量和实例方法就是事物的特征那么父类中声明的实例变量和实例方法代表子类事物也有这个特征。 当子类对象被创建时在堆中给对象申请内存时就要看子类和父类都声明了什么实例变量这些实例变量都要分配内存。 当子类对象调用方法时编译器会先在子类模板中看该类是否有这个方法如果没找到会看它的父类甚至父类的父类是否声明了这个方法遵循从下往上找的顺序找到了就停止一直到根父类都没有找到就会报编译错误。
所以继承意味着子类的对象除了看子类的类模板还要看父类的类模板。 2、子类不能直接访问父类中私有的(private)的成员变量和方法
子类虽会继承父类私有(private)的成员变量但子类不能对继承的私有成员变量直接进行访问可通过继承的get/set方法进行访问。如图所示 3、在Java 中继承的关键字用的是“extends”即子类不是父类的子集而是对父类的“扩展”
子类在继承父类以后还可以定义自己特有的方法这就可以看做是对父类功能上的扩展。
4、Java支持多层继承(继承体系) span stylebackground-color:#f8f8f8span stylecolor:#333333class A{}
class B extends A{}
class C extends B{}/span/span 说明 子类和父类是一种相对的概念 顶层父类是Object类。所有的类默认继承Object作为父类。 5、一个父类可以同时拥有多个子类
span stylebackground-color:#f8f8f8span stylecolor:#333333class A{}
class B extends A{}
class D extends A{}
class E extends A{}/span/span
6、Java只支持单继承不支持多重继承 span stylebackground-color:#f8f8f8span stylecolor:#333333public class A{}
class B extends A{}//一个类只能有一个父类不可以有多个直接父类。
class C extends B{} //ok
class C extends A,B... //error/span/span
2.5 练习
练习1定义一个学生类Student它继承自Person类 练习2
(1)定义一个ManKind类包括 成员变量int sex和int salary 方法void manOrWoman()根据sex的值显示“man”(sex1)或者“woman”(sex0) 方法void employeed()根据salary的值显示“no job”(salary0)或者“ job”(salary!0)。
(2)定义类Kids继承ManKind并包括 成员变量int yearsOld 方法printAge()打印yearsOld的值。
(3)定义类KidsTest在类的main方法中实例化Kids的对象someKid用该对象访问其父类的成员变量及方法。
练习3根据下图实现类。在CylinderTest类中创建Cylinder类的对象设置圆柱的底面半径和高并输出圆柱的体积。 3. 方法的重写override/overwrite
父类的所有方法子类都会继承但是当某个方法被继承到子类之后子类觉得父类原来的实现不适合于自己当前的类该怎么办呢子类可以对从父类中继承来的方法进行改造我们称为方法的重写 (override、overwrite)。也称为方法的重置、覆盖。
在程序执行时子类的方法将覆盖父类的方法。
3.1 方法重写举例
比如新的手机增加来电显示头像的功能代码如下
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.inherited.method;public class Phone {public void sendMessage(){System.out.println(发短信);}public void call(){System.out.println(打电话);}public void showNum(){System.out.println(来电显示号码);}
}
/span/span
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.inherited.method;//SmartPhone智能手机
public class SmartPhone extends Phone{//重写父类的来电显示功能的方法Overridepublic void showNum(){//来电显示姓名和图片功能System.out.println(显示来电姓名);System.out.println(显示头像);}//重写父类的通话功能的方法Overridepublic void call() {System.out.println(语音通话 或 视频通话);}
}/span/span
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.inherited.method;public class TestOverride {public static void main(String[] args) {// 创建子类对象SmartPhone sp new SmartPhone();// 调用父类继承而来的方法sp.call();// 调用子类重写的方法sp.showNum();}
}/span/span Override使用说明 写在方法上面用来检测是不是满足重写方法的要求。这个注解就算不写只要满足要求也是正确的方法覆盖重写。建议保留这样编译器可以帮助我们检查格式另外也可以让阅读源代码的程序员清晰的知道这是一个重写的方法。 3.2 方法重写的要求 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表。 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型。例如Student Person。 注意如果返回值类型是基本数据类型和void那么必须是相同 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限。public protected 缺省 private 注意① 父类私有方法不能重写 ② 跨包的父类缺省的方法也不能重写 子类方法抛出的异常不能大于父类被重写方法的异常 此外子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)或者同时声明为static的不是重写。因为static方法是属于类的子类无法覆盖父类的方法。
3.3 小结方法的重载与重写
方法的重载方法名相同形参列表不同。不看返回值类型。
方法的重写见上面。
1同一个类中
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.inherited.method;public class TestOverload {public int max(int a, int b){return a b ? a : b;}public double max(double a, double b){return a b ? a : b;}public int max(int a, int b,int c){return max(max(a,b),c);}
}/span/span
2父子类中
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.inherited.method;public class TestOverloadOverride {public static void main(String[] args) {Son s new Son();s.method(1);//只有一个形式的method方法Daughter d new Daughter();d.method(1);d.method(1,2);//有两个形式的method方法}
}class Father{public void method(int i){System.out.println(Father.method);}
}
class Son extends Father{public void method(int i){//重写System.out.println(Son.method);}
}
class Daughter extends Father{public void method(int i,int j){//重载System.out.println(Daughter.method);}
}/span/span
3.4 练习
练习1如果现在父类的一个方法定义成private访问权限在子类中将此方法声明为default访问权限那么这样还叫重写吗 (NO)
练习2修改继承内容的练习2中定义的类Kids在Kids中重新定义employeed()方法覆盖父类ManKind中定义的employeed()方法输出“Kids should study and no job.”
4. 再谈封装性中的4种权限修饰
权限修饰符public,protected,缺省,private
修饰符本类本包其他包子类其他包非子类private√×××缺省√√本包子类非子类都可见××protected√√本包子类非子类都可见√其他包仅限于子类中可见×public√√√√
外部类public和缺省
成员变量、成员方法等public,protected,缺省,private
1、外部类要跨包使用必须是public否则仅限于本包使用
1外部类的权限修饰符如果缺省本包使用没问题 2外部类的权限修饰符如果缺省跨包使用有问题 2、成员的权限修饰符问题
1本包下使用成员的权限修饰符可以是public、protected、缺省 2跨包下使用要求严格 3跨包使用时如果类的权限修饰符缺省成员权限修饰符类的权限修饰符也没有意义 5. 关键字super
5.1 super的理解
在Java类中使用super来调用父类中的指定操作 super可用于访问父类中定义的属性 super可用于调用父类中定义的成员方法 super可用于在子类构造器中调用父类的构造器
注意 尤其当子父类出现同名成员时可以用super表明调用的是父类中的成员 super的追溯不仅限于直接父类 super和this的用法相像this代表本类对象的引用super代表父类的内存空间的标识
5.2 super的使用场景
5.2.1 子类中调用父类被重写的方法 如果子类没有重写父类的方法只要权限修饰符允许在子类中完全可以直接调用父类的方法 如果子类重写了父类的方法在子类中需要通过super.才能调用父类被重写的方法否则默认调用的子类重写的方法
举例
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.inherited.method;public class Phone {public void sendMessage(){System.out.println(发短信);}public void call(){System.out.println(打电话);}public void showNum(){System.out.println(来电显示号码);}
}//smartphone智能手机
public class SmartPhone extends Phone{//重写父类的来电显示功能的方法public void showNum(){//来电显示姓名和图片功能System.out.println(显示来电姓名);System.out.println(显示头像);//保留父类来电显示号码的功能super.showNum();//此处必须加super.否则就是无限递归那么就会栈内存溢出}
}/span/span
总结 方法前面没有super.和this. 先从子类找匹配方法如果没有再从直接父类找再没有继续往上追溯 方法前面有this. 先从子类找匹配方法如果没有再从直接父类找再没有继续往上追溯 方法前面有super. 从当前子类的直接父类找如果没有继续往上追溯
5.2.2 子类中调用父类中同名的成员变量 如果实例变量与局部变量重名可以在实例变量前面加this.进行区别 如果子类实例变量和父类实例变量重名并且父类的该实例变量在子类仍然可见在子类中要访问父类声明的实例变量需要在父类实例变量前加super.否则默认访问的是子类自己声明的实例变量 如果父子类实例变量没有重名只要权限修饰符允许在子类中完全可以直接访问父类中声明的实例变量也可以用this.实例访问也可以用super.实例变量访问
举例
span stylebackground-color:#f8f8f8span stylecolor:#333333class Father{int a 10;int b 11;
}
class Son extends Father{int a 20;public void test(){//子类与父类的属性同名子类对象中就有两个aSystem.out.println(子类的a a);//20 先找局部变量找没有再从本类成员变量找System.out.println(子类的a this.a);//20 先从本类成员变量找System.out.println(父类的a super.a);//10 直接从父类成员变量找//子类与父类的属性不同名是同一个bSystem.out.println(b b);//11 先找局部变量找没有再从本类成员变量找没有再从父类找System.out.println(b this.b);//11 先从本类成员变量找没有再从父类找System.out.println(b super.b);//11 直接从父类局部变量找}public void method(int a, int b){//子类与父类的属性同名子类对象中就有两个成员变量a此时方法中还有一个局部变量a System.out.println(局部变量的a a);//30 先找局部变量System.out.println(子类的a this.a);//20 先从本类成员变量找System.out.println(父类的a super.a);//10 直接从父类成员变量找System.out.println(b b);//13 先找局部变量System.out.println(b this.b);//11 先从本类成员变量找System.out.println(b super.b);//11 直接从父类局部变量找}
}
class Test{public static void main(String[] args){Son son new Son();son.test();son.method(30,13); }
}/span/span
总结起点不同就近原则 变量前面没有super.和this. 在构造器、代码块、方法中如果出现使用某个变量先查看是否是当前块声明的局部变量 如果不是局部变量先从当前执行代码的本类去找成员变量 如果从当前执行代码的本类中没有找到会往上找父类声明的成员变量权限修饰符允许在子类中访问的 变量前面有this. 通过this找成员变量时先从当前执行代码的本类去找成员变量 如果从当前执行代码的本类中没有找到会往上找父类声明的成员变量权限修饰符允许在子类中访问的 变量前面super. 通过super找成员变量直接从当前执行代码的直接父类去找成员变量权限修饰符允许在子类中访问的 如果直接父类没有就去父类的父类中找权限修饰符允许在子类中访问的
特别说明应该避免子类声明和父类重名的成员变量
在阿里的开发规范等文档中都做出明确说明 5.2.3 子类构造器中调用父类构造器
① 子类继承父类时不会继承父类的构造器。只能通过“super(形参列表)”的方式调用父类指定的构造器。
② 规定“super(形参列表)”必须声明在构造器的首行。
③ 我们前面讲过在构造器的首行可以使用this(形参列表)调用本类中重载的构造器 结合②结论在构造器的首行this(形参列表) 和 super(形参列表)只能二选一。
④ 如果在子类构造器的首行既没有显示调用this(形参列表)也没有显式调用super(形参列表) 则子类此构造器默认调用super()即调用父类中空参的构造器。
⑤ 由③和④得到结论子类的任何一个构造器中要么会调用本类中重载的构造器要么会调用父类的构造器。 只能是这两种情况之一。
⑥ 由⑤得到一个类中声明有n个构造器最多有n-1个构造器中使用了this(形参列表)则剩下的那个一定使用super(形参列表)。 开发中常见错误 如果子类构造器中既未显式调用父类或本类的构造器且父类中又没有空参的构造器则编译出错。 情景举例1
span stylebackground-color:#f8f8f8span stylecolor:#333333class A{}
class B extends A{}class Test{public static void main(String[] args){B b new B();//A类和B类都是默认有一个无参构造B类的默认无参构造中还会默认调用A类的默认无参构造//但是因为都是默认的没有打印语句看不出来}
}/span/span
情景举例2
span stylebackground-color:#f8f8f8span stylecolor:#333333class A{A(){System.out.println(A类无参构造器);}
}
class B extends A{}
class Test{public static void main(String[] args){B b new B();//A类显示声明一个无参构造//B类默认有一个无参构造//B类的默认无参构造中会默认调用A类的无参构造//可以看到会输出“A类无参构造器}
}/span/span
情景举例3
span stylebackground-color:#f8f8f8span stylecolor:#333333class A{A(){System.out.println(A类无参构造器);}
}
class B extends A{B(){System.out.println(B类无参构造器);}
}
class Test{public static void main(String[] args){B b new B();//A类显示声明一个无参构造//B类显示声明一个无参构造 //B类的无参构造中虽然没有写super()但是仍然会默认调用A类的无参构造//可以看到会输出“A类无参构造器和B类无参构造器)}
}/span/span
情景举例4
span stylebackground-color:#f8f8f8span stylecolor:#333333class A{A(){System.out.println(A类无参构造器);}
}
class B extends A{B(){super();System.out.println(B类无参构造器);}
}
class Test{public static void main(String[] args){B b new B();//A类显示声明一个无参构造//B类显示声明一个无参构造 //B类的无参构造中明确写了super()表示调用A类的无参构造//可以看到会输出“A类无参构造器和B类无参构造器)}
}/span/span
情景举例5
span stylebackground-color:#f8f8f8span stylecolor:#333333class A{A(int a){System.out.println(A类有参构造器);}
}
class B extends A{B(){System.out.println(B类无参构造器);}
}
class Test05{public static void main(String[] args){B b new B();//A类显示声明一个有参构造没有写无参构造那么A类就没有无参构造了//B类显示声明一个无参构造 //B类的无参构造没有写super(...)表示默认调用A类的无参构造//编译报错因为A类没有无参构造}
}/span/span 情景举例6
span stylebackground-color:#f8f8f8span stylecolor:#333333class A{A(int a){System.out.println(A类有参构造器);}
}
class B extends A{B(){super();System.out.println(B类无参构造器);}
}
class Test06{public static void main(String[] args){B b new B();//A类显示声明一个有参构造没有写无参构造那么A类就没有无参构造了//B类显示声明一个无参构造 //B类的无参构造明确写super()表示调用A类的无参构造//编译报错因为A类没有无参构造}
}/span/span 情景举例7
span stylebackground-color:#f8f8f8span stylecolor:#333333class A{A(int a){System.out.println(A类有参构造器);}
}
class B extends A{B(int a){super(a);System.out.println(B类有参构造器);}
}
class Test07{public static void main(String[] args){B b new B(10);//A类显示声明一个有参构造没有写无参构造那么A类就没有无参构造了//B类显示声明一个有参构造 //B类的有参构造明确写super(a)表示调用A类的有参构造//会打印“A类有参构造器和B类有参构造器}
}/span/span
情景举例8
span stylebackground-color:#f8f8f8span stylecolor:#333333class A{A(){System.out.println(A类无参构造器);}A(int a){System.out.println(A类有参构造器);}
}
class B extends A{B(){super();//可以省略调用父类的无参构造System.out.println(B类无参构造器);}B(int a){super(a);//调用父类有参构造System.out.println(B类有参构造器);}
}
class Test8{public static void main(String[] args){B b1 new B();B b2 new B(10);}
}/span/span
5.3 小结this与super
1、this和super的意义
this当前对象 在构造器和非静态代码块中表示正在new的对象 在实例方法中表示调用当前方法的对象
super引用父类声明的成员
2、this和super的使用格式 this this.成员变量表示当前对象的某个成员变量而不是局部变量 this.成员方法表示当前对象的某个成员方法完全可以省略this. this()或this(实参列表)调用另一个构造器协助当前对象的实例化只能在构造器首行只会找本类的构造器找不到就报错 super super.成员变量表示当前对象的某个成员变量该成员变量在父类中声明的 super.成员方法表示当前对象的某个成员方法该成员方法在父类中声明的 super()或super(实参列表)调用父类的构造器协助当前对象的实例化只能在构造器首行只会找直接父类的对应构造器找不到就报错
5.4 练习
练习1修改方法重写的练习2中定义的类Kids中employeed()方法在该方法中调用父类ManKind的employeed()方法然后再输出“but Kids should study and no job.” 练习2修改继承中的练习3中定义的Cylinder类在Cylinder类中覆盖findArea()方法计算圆柱的表面积。考虑findVolume方法怎样做相应的修改
在CylinderTest类中创建Cylinder类的对象设置圆柱的底面半径和高并输出圆柱的表面积和体积。
附加题在CylinderTest类中创建一个Circle类的对象设置圆的半径计算输出圆的面积。体会父类和子类成员的分别调用。
练习3
1、写一个名为Account的类模拟账户。该类的属性和方法如下图所示。该类包括的属性账号id余额balance年利率annualInterestRate包含的方法访问器方法getter和setter方法返回月利率的方法getMonthlyInterest()取款方法withdraw()存款方法deposit()。 写一个用户程序测试Account类。在用户程序中创建一个账号为1122、余额为20000、年利率4.5%的Account对象。使用withdraw方法提款30000元并打印余额。 再使用withdraw方法提款2500元使用deposit方法存款3000元然后打印余额和月利率。
提示在提款方法withdraw中需要判断用户余额是否能够满足提款数额的要求如果不能应给出提示。 运行结果如图所示 2、创建Account类的一个子类CheckAccount代表可透支的账户该账户中定义一个属性overdraft代表可透支限额。在CheckAccount类中重写withdraw方法其算法如下
span stylebackground-color:#f8f8f8span stylecolor:#333333如果取款金额账户余额可直接取款
如果取款金额账户余额计算需要透支的额度判断可透支额overdraft是否足够支付本次透支需要如果可以将账户余额修改为0冲减可透支金额如果不可以提示用户超过可透支额的限额/span/span 要求写一个用户程序测试CheckAccount类。在用户程序中创建一个账号为1122、余额为20000、年利率4.5%可透支限额为5000元的CheckAccount对象。
使用withdraw方法提款5000元并打印账户余额和可透支额。
再使用withdraw方法提款18000元并打印账户余额和可透支额。
再使用withdraw方法提款3000元并打印账户余额和可透支额。
提示
1子类CheckAccount的构造方法需要将从父类继承的3个属性和子类自己的属性全部初始化。
2父类Account的属性balance被设置为private但在子类CheckAccount的withdraw方法中需要修改它的值因此应修改父类的balance属性定义其为protected。
运行结果如下图所示 6. 子类对象实例化全过程 span stylebackground-color:#f8f8f8span stylecolor:#333333Dog dog new Dog(小花,小红);/span/span 举例
span stylebackground-color:#f8f8f8span stylecolor:#333333class Creature {public Creature() {System.out.println(Creature无参数的构造器);}
}
class Animal extends Creature {public Animal(String name) {System.out.println(Animal带一个参数的构造器该动物的name为 name);}public Animal(String name, int age) {this(name);System.out.println(Animal带两个参数的构造器其age为 age);}
}
public class Dog extends Animal {public Dog() {super(汪汪队阿奇, 3);System.out.println(Dog无参数的构造器);}public static void main(String[] args) {new Dog();}
}
/span/span
7. 面向对象特征三多态性 一千个读者眼中有一千个哈姆雷特。 7.1 多态的形式和体现
7.1.1 对象的多态性
多态性是面向对象中最重要的概念在Java中的体现对象的多态性父类的引用指向子类的对象
格式父类类型指子类继承的父类类型或者实现的接口类型
span stylebackground-color:#f8f8f8span stylecolor:#333333父类类型 变量名 子类对象/span/span
举例
span stylebackground-color:#f8f8f8span stylecolor:#333333Person p new Student();Object o new Person();//Object类型的变量o指向Person类型的对象o new Student(); //Object类型的变量o指向Student类型的对象/span/span
对象的多态在Java中子类的对象可以替代父类的对象使用。所以一个引用类型变量可能指向(引用)多种不同类型的对象
7.1.2 多态的理解
Java引用变量有两个类型编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定运行时类型由实际赋给该变量的对象决定。简称编译时看左边运行时看右边。 若编译时类型和运行时类型不一致就出现了对象的多态性(Polymorphism) 多态情况下“看左边”看的是父类的引用父类中不具备子类特有的方法 “看右边”看的是子类的对象实际运行的是子类重写父类的方法
多态的使用前提① 类的继承关系 ② 方法的重写
7.1.3 举例
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class Pet {private String nickname; //昵称public String getNickname() {return nickname;}public void setNickname(String nickname) {this.nickname nickname;}public void eat(){System.out.println(nickname 吃东西);}
}/span/span
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class Cat extends Pet {//子类重写父类的方法Overridepublic void eat() {System.out.println(猫咪 getNickname() 吃鱼仔);}//子类扩展的方法public void catchMouse() {System.out.println(抓老鼠);}
}/span/span
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class Dog extends Pet {//子类重写父类的方法Overridepublic void eat() {System.out.println(狗子 getNickname() 啃骨头);}//子类扩展的方法public void watchHouse() {System.out.println(看家);}
}/span/span
1、方法内局部变量的赋值体现多态
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class TestPet {public static void main(String[] args) {//多态引用Pet pet new Dog();pet.setNickname(小白);//多态的表现形式/*编译时看父类只能调用父类声明的方法不能调用子类扩展的方法运行时看“子类”如果子类重写了方法一定是执行子类重写的方法体*/pet.eat();//运行时执行子类Dog重写的方法
// pet.watchHouse();//不能调用Dog子类扩展的方法pet new Cat();pet.setNickname(雪球);pet.eat();//运行时执行子类Cat重写的方法}
}/span/span
2、方法的形参声明体现多态
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class Person{private Pet pet;public void adopt(Pet pet) {//形参是父类类型实参是子类对象this.pet pet;}public void feed(){pet.eat();//pet实际引用的对象类型不同执行的eat方法也不同}
}/span/span
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class TestPerson {public static void main(String[] args) {Person person new Person();Dog dog new Dog();dog.setNickname(小白);person.adopt(dog);//实参是dog子类对象形参是父类Pet类型person.feed();Cat cat new Cat();cat.setNickname(雪球);person.adopt(cat);//实参是cat子类对象形参是父类Pet类型person.feed();}
}/span/span
3、方法返回值类型体现多态
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class PetShop {//返回值类型是父类类型实际返回的是子类对象public Pet sale(String type){switch (type){case Dog:return new Dog();case Cat:return new Cat();}return null;}
}/span/span
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class TestPetShop {public static void main(String[] args) {PetShop shop new PetShop();Pet dog shop.sale(Dog);dog.setNickname(小白);dog.eat();Pet cat shop.sale(Cat);cat.setNickname(雪球);cat.eat();}
}/span/span
7.2 为什么需要多态性(polymorphism)
开发中有时我们在设计一个数组、或一个成员变量、或一个方法的形参、返回值类型时无法确定它具体的类型只能确定它是某个系列的类型。
案例
1声明一个Dog类包含public void eat()方法输出“狗啃骨头”
2声明一个Cat类包含public void eat()方法输出“猫吃鱼仔”
3声明一个Person类功能如下 包含宠物属性 包含领养宠物方法 public void adopt(宠物类型Pet) 包含喂宠物吃东西的方法 public void feed()实现为调用宠物对象.eat()方法
span stylebackground-color:#f8f8f8span stylecolor:#333333public class Dog {public void eat(){System.out.println(狗啃骨头);}
}/span/span
span stylebackground-color:#f8f8f8span stylecolor:#333333public class Cat {public void eat(){System.out.println(猫吃鱼仔);}
}/span/span
span stylebackground-color:#f8f8f8span stylecolor:#333333public class Person {private Dog dog;//adopt领养public void adopt(Dog dog){this.dog dog;}//feed喂食public void feed(){if(dog ! null){dog.eat();}}/*问题1、从养狗切换到养猫怎么办 修改代码把Dog修改为养猫2、或者有的人养狗有的人养猫怎么办 3、要是还有更多其他宠物类型怎么办如果Java不支持多态那么上面的问题将会非常麻烦代码维护起来很难扩展性很差。*/
}/span/span
7.3 多态的好处和弊端
好处变量引用的子类对象不同执行的方法就不同实现动态绑定。代码编写更灵活、功能更强大可维护性和扩展性更好了。
弊端一个引用类型变量如果声明为父类的类型但实际引用的是子类对象那么该变量就不能再访问子类中添加的属性和方法。
span stylebackground-color:#f8f8f8span stylecolor:#333333Student m new Student();
m.school pku; //合法,Student类有school成员变量
Person e new Student();
e.school pku; //非法,Person类没有school成员变量// 属性是在编译时确定的编译时e为Person类型没有school成员变量因而编译错误。/span/span 开发中 使用父类做方法的形参是多态使用最多的场合。即使增加了新的子类方法也无需改变提高了扩展性符合开闭原则。 【开闭原则OCP】 对扩展开放对修改关闭 通俗解释软件系统中的各种组件如模块Modules、类Classes以及功能Functions等应该在不修改现有代码的基础上引入新功能 7.4 虚方法调用(Virtual Method Invocation)
在Java中虚方法是指在编译阶段不能确定方法的调用入口地址在运行阶段才能确定的方法即可能被重写的方法。
span stylebackground-color:#f8f8f8span stylecolor:#333333Person e new Student();
e.getInfo(); //调用Student类的getInfo()方法/span/span
子类中定义了与父类同名同参数的方法在多态情况下将此时父类的方法称为虚方法父类根据赋给它的不同子类对象动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。
举例 前提Person类中定义了welcome()方法各个子类重写了welcome()。 执行多态的情况下调用对象的welcome()方法实际执行的是子类重写的方法。 拓展 静态链接或早起绑定当一个字节码文件被装载进JVM内部时如果被调用的目标方法在编译期可知且运行期保持不变时。这种情况下将调用方法的符号引用转换为直接引用的过程称之为静态链接。那么调用这样的方法就称为非虚方法调用。比如调用静态方法、私有方法、final方法、父类构造器、本类重载构造器等。 动态链接或晚期绑定如果被调用的方法在编译期无法被确定下来也就是说只能够在程序运行期将调用方法的符号引用转换为直接引用由于这种引用转换过程具备动态性因此也就被称之为动态链接。调用这样的方法就称为虚方法调用。比如调用重写的方法针对父类、实现的方法针对接口。 7.5 成员变量没有多态性 若子类重写了父类方法就意味着子类里定义的方法彻底覆盖了父类里的同名方法系统将不可能把父类里的方法转移到子类中。 对于实例变量则不存在这样的现象即使子类里定义了与父类完全相同的实例变量这个实例变量依然不可能覆盖父类中定义的实例变量
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class TestVariable {public static void main(String[] args) {Base b new Sub();System.out.println(b.a);System.out.println(((Sub)b).a);Sub s new Sub();System.out.println(s.a);System.out.println(((Base)s).a);}
}
class Base{int a 1;
}
class Sub extends Base{int a 2;
}/span/span
7.6 向上转型与向下转型
首先一个对象在new的时候创建是哪个类型的对象它从头至尾都不会变。即这个对象的运行时类型本质的类型用于不会变。但是把这个对象赋值给不同类型的变量时这些变量的编译时类型却不同。
7.6.1 为什么要类型转换
因为多态就一定会有把子类对象赋值给父类变量的时候这个时候在编译期间就会出现类型转换的现象。
但是使用父类变量接收了子类对象之后我们就不能调用子类拥有而父类没有的方法了。这也是多态给我们带来的一点小麻烦。所以想要调用子类特有的方法必须做类型转换使得编译通过。 向上转型当左边的变量的类型父类 右边对象/变量的类型子类我们就称为向上转型 此时编译时按照左边变量的类型处理就只能调用父类中有的变量和方法不能调用子类特有的变量和方法了 但是运行时仍然是对象本身的类型所以执行的方法是子类重写的方法体。 此时一定是安全的而且也是自动完成的 向下转型当左边的变量的类型子类右边对象/变量的编译时类型父类我们就称为向下转型 此时编译时按照左边变量的类型处理就可以调用子类特有的变量和方法了 但是运行时仍然是对象本身的类型 不是所有通过编译的向下转型都是正确的可能会发生ClassCastException为了安全可以通过isInstanceof关键字进行判断
7.6.2 如何向上或向下转型
向上转型自动完成
向下转型子类类型父类变量
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class ClassCastTest {public static void main(String[] args) {//没有类型转换Dog dog new Dog();//dog的编译时类型和运行时类型都是Dog//向上转型Pet pet new Dog();//pet的编译时类型是Pet运行时类型是Dogpet.setNickname(小白);pet.eat();//可以调用父类Pet有声明的方法eat但执行的是子类重写的eat方法体
// pet.watchHouse();//不能调用父类没有的方法watchHouseDog d (Dog) pet;System.out.println(d.nickname d.getNickname());d.eat();//可以调用eat方法d.watchHouse();//可以调用子类扩展的方法watchHouseCat c (Cat) pet;//编译通过因为从语法检查来说pet的编译时类型是PetCat是Pet的子类所以向下转型语法正确//这句代码运行报错ClassCastException因为pet变量的运行时类型是DogDog和Cat之间是没有继承关系的}
}/span/span
7.6.3 instanceof关键字
为了避免ClassCastException的发生Java提供了 instanceof 关键字给引用变量做类型的校验。如下代码格式
span stylebackground-color:#f8f8f8span stylecolor:#333333//检验对象a是否是数据类型A的对象返回值为boolean型
对象a instanceof 数据类型A /span/span 说明 只要用instanceof判断返回true的那么强转为该类型就一定是安全的不会报ClassCastException异常。 如果对象a属于类A的子类Ba instanceof A值也为true。 要求对象a所属的类与类A必须是子类和父类的关系否则编译错误。
代码
span stylebackground-color:#f8f8f8span stylecolor:#333333package com.atguigu.polymorphism.grammar;public class TestInstanceof {public static void main(String[] args) {Pet[] pets new Pet[2];pets[0] new Dog();//多态引用pets[0].setNickname(小白);pets[1] new Cat();//多态引用pets[1].setNickname(雪球);for (int i 0; i pets.length; i) {pets[i].eat();if(pets[i] instanceof Dog){Dog dog (Dog) pets[i];dog.watchHouse();}else if(pets[i] instanceof Cat){Cat cat (Cat) pets[i];cat.catchMouse();}}}
}/span/span
7.7 练习
练习1笔试面试
题目1继承成员变量和继承方法的区别
span stylebackground-color:#f8f8f8span stylecolor:#333333class Base {int count 10;public void display() {System.out.println(this.count);}
}class Sub extends Base {int count 20;public void display() {System.out.println(this.count);}
}public class FieldMethodTest {public static void main(String[] args){Sub s new Sub();System.out.println(s.count);s.display();Base b s;System.out.println(b s);System.out.println(b.count);b.display();}
}
/span/span
题目2
span stylebackground-color:#f8f8f8span stylecolor:#333333//考查多态的笔试题目
public class InterviewTest1 {public static void main(String[] args) {Base base new Sub();base.add(1, 2, 3);// Sub s (Sub)base;
// s.add(1,2,3);}
}class Base {public void add(int a, int... arr) {System.out.println(base);}
}class Sub extends Base {public void add(int a, int[] arr) {System.out.println(sub_1);}// public void add(int a, int b, int c) {
// System.out.println(sub_2);
// }}
/span/span
题目3
span stylebackground-color:#f8f8f8span stylecolor:#333333//getXxx()和setXxx()声明在哪个类中内部操作的属性就是哪个类里的。
public class InterviewTest2 {public static void main(String[] args) {Father f new Father();Son s new Son();System.out.println(f.getInfo());//atguiguSystem.out.println(s.getInfo());//尚硅谷s.test();//尚硅谷 atguiguSystem.out.println(-----------------);s.setInfo(大硅谷);System.out.println(f.getInfo());//atguiguSystem.out.println(s.getInfo());//大硅谷s.test();//大硅谷 atguigu}
}class Father {private String info atguigu;public void setInfo(String info) {this.info info;}public String getInfo() {return info;}
}class Son extends Father {private String info 尚硅谷;public void setInfo(String info) {this.info info;}public String getInfo() {return info;}public void test() {System.out.println(this.getInfo());System.out.println(super.getInfo());}
}/span/span
题目4多态是编译时行为还是运行时行为
span stylebackground-color:#f8f8f8span stylecolor:#333333//证明如下
class Animal {protected void eat() {System.out.println(animal eat food);}
}class Cat extends Animal {protected void eat() {System.out.println(cat eat fish);}
}class Dog extends Animal {public void eat() {System.out.println(Dog eat bone);}
}class Sheep extends Animal {public void eat() {System.out.println(Sheep eat grass);}
}public class InterviewTest {public static Animal getInstance(int key) {switch (key) {case 0:return new Cat ();case 1:return new Dog ();default:return new Sheep ();}}public static void main(String[] args) {int key new Random().nextInt(3);System.out.println(key);Animal animal getInstance(key);animal.eat(); }
}/span/span
练习2
span stylebackground-color:#f8f8f8span stylecolor:#333333class Person {protected String nameperson;protected int age50;public String getInfo() {return Name: name \n age: age;}
}
class Student extends Person {protected String schoolpku;public String getInfo() {return Name: name \nage: age \nschool: school;}
}
class Graduate extends Student{public String majorIT;public String getInfo(){return Name: name \nage: age \nschool: school\nmajor:major;}
}
/span/span
建立InstanceTest 类在类中定义方法method(Person e); 在method中: (1)根据e的类型调用相应类的getInfo()方法。 (2)根据e的类型执行 如果e为Person类的对象输出 “a person”; 如果e为Student类的对象输出 “a student” “a person ” 如果e为Graduate类的对象输出 “a graduated student” “a student” “a person”
练习3定义三个类父类GeometricObject代表几何形状子类Circle代表圆形MyRectangle代表矩形。定义一个测试类GeometricTest编写equalsArea方法测试两个对象的面积是否相等注意方法的参数类型利用动态绑定技术编写displayGeometricObject方法显示对象的面积注意方法的参数类型利用动态绑定技术。 8. Object 类的使用
8.1 如何理解根父类
类 java.lang.Object是类层次结构的根类即所有其它类的父类。每个类都使用 Object 作为超类。 Object类型的变量与除Object以外的任意引用数据类型的对象都存在多态引用 span stylebackground-color:#f8f8f8method(Object obj){…} //可以接收任何类作为其参数Person o new Person();
method(o);
/span 所有对象包括数组都实现这个类的方法。 如果一个类没有特别指定父类那么默认则继承自Object类。例如 span stylebackground-color:#f8f8f8public class Person {...
}
//等价于
public class Person extends Object {...
}/span
8.2 Object类的方法
根据JDK源代码及Object类的API文档Object类当中包含的方法有11个。这里我们主要关注其中的6个
1、(重点)equals() 基本类型比较值:只要两个变量的值相等即为true。 span stylebackground-color:#f8f8f8int a5;
if(a6){…}/span 引用类型比较引用(是否指向同一个对象)只有指向同一个对象时才返回true。 span stylebackground-color:#f8f8f8Person p1new Person();
Person p2new Person();
if (p1p2){…}/span 用“”进行比较时符号两边的数据类型必须兼容(可自动转换的基本数据类型除外)否则编译出错
equals()所有类都继承了Object也就获得了equals()方法。还可以重写。 只能比较引用类型Object类源码中equals()的作用与“”相同比较是否指向同一个对象。 格式:obj1.equals(obj2) 特例当用equals()方法进行比较时对类File、String、Date及包装类Wrapper Class来说是比较类型及内容而不考虑引用的是否是同一个对象 原因在这些类中重写了Object类的equals()方法。 当自定义使用equals()时可以重写。用于比较两个对象的“内容”是否都相等 重写equals()方法的原则 对称性如果x.equals(y)返回是“true”那么y.equals(x)也应该返回是“true”。 自反性x.equals(x)必须返回是“true”。 传递性如果x.equals(y)返回是“true”而且y.equals(z)返回是“true”那么z.equals(x)也应该返回是“true”。 一致性如果x.equals(y)返回是“true”只要x和y内容一直不变不管你重复x.equals(y)多少次返回都是“true”。 任何情况下x.equals(null)永远返回是“false” x.equals(和x不同类型的对象)永远返回是“false”。 重写举例
span stylebackground-color:#f8f8f8span stylecolor:#333333class User{private String host;private String username;private String password;public User(String host, String username, String password) {super();this.host host;this.username username;this.password password;}public User() {super();}public String getHost() {return host;}public void setHost(String host) {this.host host;}public String getUsername() {return username;}public void setUsername(String username) {this.username username;}public String getPassword() {return password;}public void setPassword(String password) {this.password password;}Overridepublic String toString() {return User [host host , username username , password password ];}Overridepublic boolean equals(Object obj) {if (this obj)return true;if (obj null)return false;if (getClass() ! obj.getClass())return false;User other (User) obj;if (host null) {if (other.host ! null)return false;} else if (!host.equals(other.host))return false;if (password null) {if (other.password ! null)return false;} else if (!password.equals(other.password))return false;if (username null) {if (other.username ! null)return false;} else if (!username.equals(other.username))return false;return true;}}/span/span
面试题和equals的区别 从我面试的反馈85%的求职者“理直气壮”的回答错误… 既可以比较基本类型也可以比较引用类型。对于基本类型就是比较值对于引用类型就是比较内存地址 equals的话它是属于java.lang.Object类里面的方法如果该方法没有被重写过默认也是;我们可以看到String等类的equals方法是被重写过的而且String类在日常开发中用的比较多久而久之形成了equals是比较值的错误观点。 具体要看自定义类里有没有重写Object的equals方法来判断。 通常情况下重写equals方法会比较类中的相应属性是否都相等。
练习1
span stylebackground-color:#f8f8f8span stylecolor:#333333int it 65;
float fl 65.0f;
System.out.println(“65和65.0f是否相等” (it fl)); //char ch1 A; char ch2 12;
System.out.println(65和A是否相等 (it ch1));//
System.out.println(12和ch2是否相等 (12 ch2));//String str1 new String(hello);
String str2 new String(hello);
System.out.println(str1和str2是否相等 (str1 str2));//System.out.println(str1是否equals str2(str1.equals(str2)));//System.out.println(“hello” new java.util.Date()); //
/span/span
练习2
编写Order类有int型的orderIdString型的orderName相应的getter()和setter()方法两个参数的构造器重写父类的equals()方法public boolean equals(Object obj)并判断测试类中创建的两个对象是否相等。
练习3
请根据以下代码自行定义能满足需要的MyDate类,在MyDate类中覆盖equals方法使其判断当两个MyDate类型对象的年月日都相同时结果为true否则为false。 public boolean equals(Object o)
span stylebackground-color:#f8f8f8span stylecolor:#333333public class EqualsTest {public static void main(String[] args) {MyDate m1 new MyDate(14, 3, 1976);MyDate m2 new MyDate(14, 3, 1976);if (m1 m2) {System.out.println(m1m2);} else {System.out.println(m1!m2); // m1 ! m2}if (m1.equals(m2)) {System.out.println(m1 is equal to m2);// m1 is equal to m2} else {System.out.println(m1 is not equal to m2);}}
}
/span/span
2、(重点)toString()
方法签名public String toString()
① 默认情况下toString()返回的是“对象的运行时类型 对象的hashCode值的十六进制形式
② 在进行String与其它类型数据的连接操作时自动调用toString()方法
span stylebackground-color:#f8f8f8span stylecolor:#333333Date nownew Date();
System.out.println(“now”now); //相当于
System.out.println(“now”now.toString()); /span/span
③ 如果我们直接System.out.println(对象)默认会自动调用这个对象的toString() 因为Java的引用数据类型的变量中存储的实际上时对象的内存地址但是Java对程序员隐藏内存地址信息所以不能直接将内存地址显示出来所以当你打印对象时JVM帮你调用了对象的toString()。 ④ 可以根据需要在用户自定义类型中重写toString()方法 如String 类重写了toString()方法返回字符串的值。
span stylebackground-color:#f8f8f8span stylecolor:#333333s1hello;
System.out.println(s1);//相当于System.out.println(s1.toString());/span/span
例如自定义的Person类
span stylebackground-color:#f8f8f8span stylecolor:#333333public class Person { private String name;private int age;Overridepublic String toString() {return Person{ name name \ , age age };}
}/span/span
练习定义两个类父类GeometricObject代表几何形状子类Circle代表圆形。 3、clone()
span stylebackground-color:#f8f8f8span stylecolor:#333333//Object类的clone()的使用
public class CloneTest {public static void main(String[] args) {Animal a1 new Animal(花花);try {Animal a2 (Animal) a1.clone();System.out.println(原始对象 a1);a2.setName(毛毛);System.out.println(clone之后的对象 a2);} catch (CloneNotSupportedException e) {e.printStackTrace();}}
}class Animal implements Cloneable{private String name;public Animal() {super();}public Animal(String name) {super();this.name name;}public String getName() {return name;}public void setName(String name) {this.name name;}Overridepublic String toString() {return Animal [name name ];}Overrideprotected Object clone() throws CloneNotSupportedException {// TODO Auto-generated method stubreturn super.clone();}}/span/span
4、finalize() 当对象被回收时系统自动调用该对象的 finalize() 方法。不是垃圾回收器调用的是本类对象调用的 永远不要主动调用某个对象的finalize方法应该交给垃圾回收机制调用。 什么时候被回收当某个对象没有任何引用时JVM就认为这个对象是垃圾对象就会在之后不确定的时间使用垃圾回收机制来销毁该对象在销毁该对象前会先调用 finalize()方法。 子类可以重写该方法目的是在对象被清理之前执行必要的清理操作。比如在方法内断开相关连接资源。 如果重写该方法让一个新的引用变量重新引用该对象则会重新激活对象。 在JDK 9中此方法已经被标记为过时的。
span stylebackground-color:#f8f8f8span stylecolor:#333333public class FinalizeTest {public static void main(String[] args) {Person p new Person(Peter, 12);System.out.println(p);p null;//此时对象实体就是垃圾对象等待被回收。但时间不确定。System.gc();//强制性释放空间}
}class Person{private String name;private int age;public Person(String name, int age) {super();this.name name;this.age age;}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;}//子类重写此方法可在释放对象前进行某些操作Overrideprotected void finalize() throws Throwable {System.out.println(对象被释放--- this);}Overridepublic String toString() {return Person [name name , age age ];}}/span/span
5、getClass()
public final Class? getClass()获取对象的运行时类型 因为Java有多态现象所以一个引用数据类型的变量的编译时类型与运行时类型可能不一致因此如果需要查看这个变量实际指向的对象的类型需要用getClass()方法 span stylebackground-color:#f8f8f8span stylecolor:#333333public static void main(String[] args) {Object obj new Person();System.out.println(obj.getClass());//运行时类型
}/span/span
结果
span stylebackground-color:#f8f8f8span stylecolor:#333333class com.atguigu.java.Person/span/span
6、hashCode()
public int hashCode()返回每个对象的hash值。(后续在集合框架章节重点讲解)
span stylebackground-color:#f8f8f8span stylecolor:#333333public static void main(String[] args) {System.out.println(AA.hashCode());//2080System.out.println(BB.hashCode());//2112
}/span/span
8.3 native关键字的理解
使用native关键字说明这个方法是原生函数也就是这个方法是用C/C等非Java语言实现的并且被编译成了DLL由Java去调用。 本地方法是有方法体的用c语言编写。由于本地方法的方法体源码没有对我们开源所以我们看不到方法体 在Java中定义一个native方法时并不提供实现体。
1. 为什么要用native方法
Java使用起来非常方便然而有些层次的任务用java实现起来不容易或者我们对程序的效率很在意时例如Java需要与一些底层操作系统或某些硬件交换信息时的情况。native方法正是这样一种交流机制它为我们提供了一个非常简洁的接口而且我们无需去了解Java应用之外的繁琐的细节。
2. native声明的方法对于调用者可以当做和其他Java方法一样使用
native method的存在并不会对其他类调用这些本地方法产生任何影响实际上调用这些方法的其他类甚至不知道它所调用的是一个本地方法。JVM将控制调用本地方法的所有细节。 文章转载自： http://www.morning.vvbsxm.cn.gov.cn.vvbsxm.cn http://www.morning.xjwtq.cn.gov.cn.xjwtq.cn http://www.morning.rlqwz.cn.gov.cn.rlqwz.cn http://www.morning.fxzgw.com.gov.cn.fxzgw.com http://www.morning.wmdlp.cn.gov.cn.wmdlp.cn http://www.morning.lxkhx.cn.gov.cn.lxkhx.cn http://www.morning.kdtdh.cn.gov.cn.kdtdh.cn http://www.morning.hdrsr.cn.gov.cn.hdrsr.cn http://www.morning.ntyanze.com.gov.cn.ntyanze.com http://www.morning.lqynj.cn.gov.cn.lqynj.cn http://www.morning.gwkjg.cn.gov.cn.gwkjg.cn http://www.morning.dnhdp.cn.gov.cn.dnhdp.cn http://www.morning.zqwqy.cn.gov.cn.zqwqy.cn http://www.morning.ktrdc.cn.gov.cn.ktrdc.cn http://www.morning.kyytt.cn.gov.cn.kyytt.cn http://www.morning.trmpj.cn.gov.cn.trmpj.cn http://www.morning.wgkz.cn.gov.cn.wgkz.cn http://www.morning.rzsxb.cn.gov.cn.rzsxb.cn http://www.morning.rxwnc.cn.gov.cn.rxwnc.cn http://www.morning.huihuangwh.cn.gov.cn.huihuangwh.cn http://www.morning.kwjyt.cn.gov.cn.kwjyt.cn http://www.morning.dshxj.cn.gov.cn.dshxj.cn http://www.morning.jfxdy.cn.gov.cn.jfxdy.cn http://www.morning.yqsq.cn.gov.cn.yqsq.cn http://www.morning.dfbeer.com.gov.cn.dfbeer.com http://www.morning.zrnph.cn.gov.cn.zrnph.cn http://www.morning.lywcd.cn.gov.cn.lywcd.cn http://www.morning.sfswj.cn.gov.cn.sfswj.cn http://www.morning.bfmrq.cn.gov.cn.bfmrq.cn http://www.morning.jzfxk.cn.gov.cn.jzfxk.cn http://www.morning.vvbsxm.cn.gov.cn.vvbsxm.cn http://www.morning.qzqfq.cn.gov.cn.qzqfq.cn http://www.morning.gwtgt.cn.gov.cn.gwtgt.cn http://www.morning.gprzp.cn.gov.cn.gprzp.cn http://www.morning.ykqbs.cn.gov.cn.ykqbs.cn http://www.morning.ymqfx.cn.gov.cn.ymqfx.cn http://www.morning.nydtt.cn.gov.cn.nydtt.cn http://www.morning.bswhr.cn.gov.cn.bswhr.cn http://www.morning.nqbpz.cn.gov.cn.nqbpz.cn http://www.morning.bmmyx.cn.gov.cn.bmmyx.cn http://www.morning.dmtbs.cn.gov.cn.dmtbs.cn http://www.morning.dmchips.com.gov.cn.dmchips.com http://www.morning.yrdkl.cn.gov.cn.yrdkl.cn http://www.morning.lptjt.cn.gov.cn.lptjt.cn http://www.morning.lswgs.cn.gov.cn.lswgs.cn http://www.morning.ey3h2d.cn.gov.cn.ey3h2d.cn http://www.morning.cklgf.cn.gov.cn.cklgf.cn http://www.morning.bkslb.cn.gov.cn.bkslb.cn http://www.morning.xwnnp.cn.gov.cn.xwnnp.cn http://www.morning.rbrhj.cn.gov.cn.rbrhj.cn http://www.morning.wqrk.cn.gov.cn.wqrk.cn http://www.morning.rgxcd.cn.gov.cn.rgxcd.cn http://www.morning.mlbn.cn.gov.cn.mlbn.cn http://www.morning.leboju.com.gov.cn.leboju.com http://www.morning.bxqpl.cn.gov.cn.bxqpl.cn http://www.morning.gsrh.cn.gov.cn.gsrh.cn http://www.morning.wkws.cn.gov.cn.wkws.cn http://www.morning.mtktn.cn.gov.cn.mtktn.cn http://www.morning.hhmfp.cn.gov.cn.hhmfp.cn http://www.morning.mjtft.cn.gov.cn.mjtft.cn http://www.morning.cflxx.cn.gov.cn.cflxx.cn http://www.morning.kcbml.cn.gov.cn.kcbml.cn http://www.morning.qgdsd.cn.gov.cn.qgdsd.cn http://www.morning.hfrbt.cn.gov.cn.hfrbt.cn http://www.morning.xrmwc.cn.gov.cn.xrmwc.cn http://www.morning.sqqkr.cn.gov.cn.sqqkr.cn http://www.morning.nccqs.cn.gov.cn.nccqs.cn http://www.morning.mwzt.cn.gov.cn.mwzt.cn http://www.morning.cpgdy.cn.gov.cn.cpgdy.cn http://www.morning.jqwpw.cn.gov.cn.jqwpw.cn http://www.morning.c7507.cn.gov.cn.c7507.cn http://www.morning.ktrdc.cn.gov.cn.ktrdc.cn http://www.morning.wfwqr.cn.gov.cn.wfwqr.cn http://www.morning.kbfzp.cn.gov.cn.kbfzp.cn http://www.morning.kqbwr.cn.gov.cn.kqbwr.cn http://www.morning.zztkt.cn.gov.cn.zztkt.cn http://www.morning.qmbpy.cn.gov.cn.qmbpy.cn http://www.morning.lgsfb.cn.gov.cn.lgsfb.cn http://www.morning.ypwlb.cn.gov.cn.ypwlb.cn http://www.morning.c7623.cn.gov.cn.c7623.cn
