好看的电商网站模板下载,东莞做网站的,acm手表网站,wordpress采集定时发布目录 抽象抽象的概念抽象方法和抽象类的格式抽象方法和抽象类的使用抽象方法和抽象类的注意事项● 练习1. 写一个父类图形类#xff0c;其中有方法#xff0c;功能计算面积为抽象方法。2. 抽象类继承。判断对错,没错的分析运行结果3. 发红包,群内用户类作为父类#xff0c;有… 目录 抽象抽象的概念抽象方法和抽象类的格式抽象方法和抽象类的使用抽象方法和抽象类的注意事项● 练习1. 写一个父类图形类其中有方法功能计算面积为抽象方法。2. 抽象类继承。判断对错,没错的分析运行结果3. 发红包,群内用户类作为父类有收红包方法群主类作为子类有发红包的方法 接口接口的定义基本格式接口的使用接口的1.常量定义和使用接口的2.抽象方法定义接口的3.默认方法定义默认方法的使用接口的4.静态方法定义接口的5.私有方法定义接口内使用静态非静态私有方法使用 继承父类并实现多个接口● 练习1. 写一个实现类D 实现两个接口A,B继承一个父类C 多态多态的格式与使用多态中成员变量的使用特点多态中成员方法的使用特点使用多态的好处对象的向上转型向下转型● 练习1. 多态中成员方法调用判断以下输出2. 多态中成员变量判断对错或结果3. 多态中成员方法间接访问成员变量。判断对错或结果4. 接口多态综合练习接口的基本使用对象的上下转型以及接口作为方法的参数。 抽象
抽象的概念
例如父类是一个图形有一个计算面积的方法。而子类是三角形正方形圆形等。计算面积的方法各不相同父类的计算面积方法就是一个抽象方法。 即如果父类当中的方法不确定如何进行{}方法体实现那么这就应该是一个抽象方法。
抽象方法和抽象类的格式
public abstract class Fu{public abstract void eat();
}抽象方法 就是加上abstract关键字然后去掉大括号分号结束 抽象类抽象方法所在的类必须是抽象才行。在class之前写上abstract即可 抽象类中也可以写普通方法
抽象方法和抽象类的使用
不能直接new抽象类对象必须用一个子类继承抽象父类子类必须覆盖重写抽象父亲当中所有的抽象方法。除非子类也是抽象类 覆盖重写实现子类去掉抽象方法的abstract关键字然后补上方法体大括号{}创建子类对象进行使用
抽象方法和抽象类的注意事项
Alt Enter在子类继承红线处自动重写父的抽象方法体
抽象类不能创建对象编译报错。 只能创建其非抽象子类的对象抽象类中可以有构造方法要实现方法体是供子类创建对象时初始化父类成员使用的。 因为子类构造中默认有super()或者自己指定所以父类构造器中初始化变量就可以执行。抽象类中不一定包含抽象方法但是有抽象方法的类必定是抽象类抽象类中的子类必须重写抽象父类中所有的抽象方法否则编译无法通过而报错。除非该子类也是抽象类。
● 练习
1. 写一个父类图形类其中有方法功能计算面积为抽象方法。
子类正方形三角形圆形。分别重写其抽象方法为自己类的计算面积方法。
A:
public abstract class Graphics {public abstract double area();
}public class Square extends Graphics{double length;double width;public Square(int length, int width){this.length length;this.width width;}Overridepublic double area() {return length * width;}
}public class Circle extends Graphics{double diameter;public Circle(double diameter){this.diameter diameter;}Overridepublic double area() {return Math.PI * diameter * diameter;}
}public class Triangle extends Graphics{double high;double bottom;public Triangle(double high, double bottom){this.high high;this.bottom bottom;}Overridepublic double area() {return (high * bottom) / 2;}
}public class MainTest{public static void main(String[] args) {Square sq1 new Square(3, 5);Triangle tr1 new Triangle(6, 8);Circle ci1 new Circle(8);System.out.println(sq1.area());System.out.println(tr1.area());System.out.println(ci1.area());}
}2. 抽象类继承。判断对错,没错的分析运行结果
public abstract class A{public A(){sout(A的构造); }public abstract void eat();public abstract void sleep();
}
public class B extends A{public B(){sout(B的构造);}Overridepublic void eat(){sout(B吃东西);}Overridepublic void sleep(){sout(B睡觉);}
}
public class C extends A{
}
public abstract class D{public void sleep(){sout(D睡觉);}
}
public class MainTest{public static void main(String[] args) {A a new A();B b new B();b.eat();D d new D();d.sleep(); }
}A: ● public class C extends A{ A是抽象类C没有实现A全部的抽象方法所以必须是抽象类
}
public class MainTest{public static void main(String[] args) {● A a new A(); 抽象类不可以new对象B b new B();//正确因为B实现了抽象父类A的所有抽象方法b.eat();● D d new D();//错抽象类不可以new● d.sleep(); }
}结果
A的构造
B的构造
B吃东西3. 发红包,群内用户类作为父类有收红包方法群主类作为子类有发红包的方法
① 群主的一笔金额从群主的余额中扣除平均分成n等份让成员领取。 ② 成员领取后保存到成员余额中 优化③ 该类每自动生成一个对象就自动赋值id编号随人数增加 A 分析
发红包方法参数发多少份发多少钱。返回一个ArrayListInteger把要发的钱平均分成n份剩的余额自动存到最后一个红包。收红包方法参数就是这个List集合随机的在集合里选一个下标元素收红包。为啥要用这个集合主要是收了红包以后要在集合里把自己收的那一份删除。优化思考①怎么快速把红包加到这些群成员的余额建立一个群成员类的ArrayListMember集合循环调用每个群成员对象的收红包方法。优化思考②让红包不是均等而是随机分配金额最小的红包不为0即可。
public class Member {static int idCount 0;int id;int balance;public Member(){idCount;this.id idCount;}public Member(int balance){this.balance balance;idCount;this.id idCount;}public static int getIdCount() {return idCount;}public int getId() {return id;}public int getBalance() {return balance;}void setBalance(int balance){this.balance balance;}public void receive(ArrayListInteger redList){int size redList.size();int random (int)(Math.random() * size);//double范围[0,size) [0,size-1]Random r new Random();int random2 r.nextInt(size);//int范围[0,size)this.balance redList.get(random);redList.remove(random);//直接删除这一位list长度--。}public void show(){System.out.println(----------------------);System.out.println(群成员的id this.id);System.out.println(余额 this.balance);}
}群主类属于特殊的成员类
public class Leader extends Member{public Leader(int balance){this.balance balance;}public Leader(){}public ArrayListInteger send(int count, int money){if(money getBalance()){System.out.println(余额不足请重新设置红包金额);return null;}ArrayListInteger redList new ArrayList();//分配红包过程因为都是整数如果每份都是小数的话取整。把剩下的放到最后一个红包即可int ave money / count;int last money - (ave * count);for (int i 0; i count; i) {redList.add(ave);}int size redList.size();redList.set(size - 1, redList.get(size - 1) last);setBalance(getBalance() - money);return redList;}}// for test
public class MainTest {public static void main(String[] args) {//System.out.println(请依次输入群主成员1);Leader l1 new Leader(3456);Member m1 new Member(0);Member m2 new Member(0);Member m3 new Member(0);ArrayListInteger redList l1.send(3, 50);m1.receive(redList);m2.receive(redList);m3.receive(redList);l1.show();m1.show();m2.show();m3.show();}
}----------------------
群成员的id1
余额3406
----------------------
群成员的id2
余额16
----------------------
群成员的id3
余额18
----------------------
群成员的id4
余额16优化随机金额红包一个群里的成员全部自动抢红包。
把属性balance极其gettersetter子类balance的有参构造send返回值类型receive参数从int改为double。 想要控制double小数点后位数用printf输出printf(%.2f,num); public void receive(ArrayListDouble redList){int size redList.size();int random (int)(Math.random() * size);//double范围[0,size) [0,size-1]//不推荐random2生成的随机数经常不够随机//Random r new Random();//int random2 r.nextInt(size);//int范围[0,size)this.balance redList.get(random);redList.remove(random);//直接删除这一位list长度--。}public void show(){System.out.println(----------------------);System.out.println(群成员的id this.id);System.out.printf(余额 %.2f, this.balance);System.out.println();}public ArrayListDouble send(int count, double money){if(money getBalance()){System.out.println(余额不足请重新设置红包金额);return null;}ArrayListDouble redList new ArrayList();//红包最小金额设置0.1最大是总金额的0.6反正就是比一半多一点double min 0.1;double max money * 0.6;double last money;//最后剩余的Random r new Random();for (int i 0; i count - 1; i) {double num r.nextDouble()*(max - min) min;//0.0 ~ 1.0 - 0.0 ~ max - min - min ~ maxlast - num;redList.add(num);}redList.add(last);setBalance(getBalance() - money);return redList;}----------------------
群成员的id1
余额3388.11
----------------------
群成员的id2
余额2.70
----------------------
群成员的id3
余额59.58
----------------------
群成员的id4
余额5.62接口
接口的定义基本格式
接口就是多个类的公共规范。接口是一种引用数据类型最重要的内容就是其中的抽象方法。
public interface 接口名称{//接口内容
}换成了关键字interface之后编译生成的字节码文件仍然是 .java - .class 如果Java7那么接口中可以包含的内容有
常量抽象方法只定义不实现 如Java8额外包含默认方法静态方法 Java9额外包含私有方法
接口的使用
1.接口不能直接使用必须有一个“实现类”来“实现”该接口
public class 实现类名称 implements 接口名称{//……
}2.接口的实现类必须覆盖重写实现 接口中所有的抽象方法 实现去掉abstract 关键字加上方法体大括号 3.创建实现类的对象进行使用。 建议实现类名接口名 Impl 注意如果实现类并没有覆盖重写接口中所有的抽象方法那么这个实现类就必须是抽象类。因为抽象方法所在的类必为抽象类
以下[括号内]关键字意为可省略的不写也依然存在的意思
接口的1.常量定义和使用
接口当中也可以定义“成员变量”但是必须使用public static final三个关键字进行修饰。其实就是接口的常量
[public] [static] [final] 数据类型 常量名称 数据值final一旦赋值不可以修改
1.接口当中的常量可以省略public static final但不写也是默认有 2.接口当中的常量必须进行赋值不能不赋值 复习 类中成员变量数组有默认值。局部变量没有默认值没赋值不可使用 访问时接口名.常量名
public static final int NUM_OF_MY_CLASS 12;3.接口中常量的名称使用完全大写的字母下划线分隔推荐命名规则
接口的2.抽象方法定义
[public] [abstract] 返回值类型 方法名称(参数列表);注意 1.接口中的抽象方法修饰符必须是两个固定的关键字[public] [abstract] 不可以private等 2.这两个关键字修饰符可以选择性地省略。都不写也默认是抽象方法 3.方法的三要素可以随意定义
接口的3.默认方法定义
[public] default 返回值类型方法名称参数列表{//方法体
}默认方法一定是public默认方法也可以被覆盖重写不重写也不报错 备注接口当中的默认方法可以解决接口升级的问题 比如两个实现类都实现了一个接口但该接口后来添加了新方法。如果是抽象方法的话就需要两实现类都重写该方法。但默认方法就可以直接继承即可更方便
默认方法的使用
a为一个实现类对象 a.methodAbs();//调用抽象方法实际运行的是右侧实现类复习因为new谁就用谁的方法而实现类重写了这个方法 1.接口的默认方法可以通过接口实现类对象直接调用。如实现类中没有重写就向上找 2.接口的默认方法也可以被接口实现类进行覆盖重写
接口的4.静态方法定义
[public] static 返回值类型 方法名称参数列表{方法体
}就是将abstract或者default换成static即可带上方法体 注意不能通过接口实现类的对象来调用来调用接口中的静态方法 一个类可以实现多个接口静态方法可能冲突
但接口中不可以用实现类调用static方法只能用接口名调用static方法注意其中区别已知普通类中类名. 对象名. 都可以用来调用static方法
通过接口名称直接调用其中的静态方法 接口名.静态方法名(参数)
接口的5.私有方法定义接口内使用静态非静态
接口中需要抽取一个共有方法用来解决接口中两个默认方法之间重复代码的问题 1.普通私有方法解决多个默认方法之间重复代码的问题
private 返回值类型 方法名称参数{方法体
}2.静态私有方法解决多个静态方法之间重复代码问题
private static 返回值类型 方法名参数{方法体
}private方法只有接口自己才能调用不能被实现类或别人使用
私有方法使用
两个默认方法调用一个私有方法
public default void methodDefault1(){默认方法1methodCommon();
}
public default void methodDefault2(){默认方法2methodCommon();
}
private void methodCommon(){}两个静态方法调一个私有静态方法
public static void methStatic1(){静态方法1methodStaticCommon();
}
public static void methStatic2(){静态方法2methodStaticCommon();
}
pirvate static void methodStaticCommon(){}继承父类并实现多个接口
接口中没有静态代码块或构造方法
static{……
}(复习第一次用到本类时静态代码块执行唯一的一次。一般用来一次性的对静态成员变量赋值。静态内容总是优先于非静态静态代码比构造方法先执行。 shift F6 重命名类 Ctrl C/V 复制整个类 实现接口时 Alt Enter 选要实现的方法 Java中所有类都是Object的直接子类或间接子类
一个类的直接父类是唯一的但是一个类可以同时实现多个接口
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{//覆盖重写所有抽象方法
}如果实现类所实现的多个接口当中存在重复的抽象方法那么只需要覆盖重写一次即可。
❓怎么判断是否重复返回值和名参数列表全一致吗方法的三要素
A: 方法名和参数相同即为重复方法与返回值无关 1与返回值无关返回值不同方法名和参数相同也属于重复方法。只需要保证子类重写的方法返回值是父类方法的子类型即可例如Object做父类返回值 只是此处子方法返回值可以是Integer但不能是Object,因为接口B中返回值Integer不可以当Object的父 复习重写3要素①方法名和参数列表都相同②只需要保证重写方法的返回值类型 父类此处是父接口方法即可。③重写的子类方法的权限 父类方法
public interface MyInterfaceA {Object method1();
}
public interface MyInterfaceB {Integer method1();
}
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{Overridepublic Integer method1(){System.out.println();return 1;}
}2与参数有关若参数不同就不是同一个方法。在实现类中都继承就需要都重写属于重载方法。
public interface MyInterfaceA {Object method1();
}
public interface MyInterfaceB {Integer method1(int num);
}
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB{Overridepublic Integer method1(){System.out.println();return 1;}public Integer method1(int num){return 1;}
}如果实现类没有覆盖重写所有接口与当中的所有抽象方法那么实现类就必须是一个抽象类。如多个接口中存在重复的默认方法实现类一定要对冲突的默认方法进行覆盖重写。一个类如果直接父类当中的方法和接口当中的默认方法产生了冲突优先用父类当中的方法因为继承优先于接口实现也不用重写冲突的方法
public class Zi extends Fu implements MyInterface{}注意:
多个父接口当中的抽象方法如果重复没关系。因为没有方法体实现类中重写一次即可。抽象类作为子类或子接口可以不重写该方法多个父接口当中的默认方法如果重复有关系。子接口必须进行默认方法的覆盖重写而且带着default关键字接口中default不能省略与普通类方法的权限修饰符 留空即default 不同。
● 练习
1. 写一个实现类D 实现两个接口A,B继承一个父类C
接口A写所有可有内容5种的完整写法 接口B写所有可有内容的省略写法 其中A,B 中1常量名重复1抽象方法重复 1抽象方法只方法名,参数相同1私有方法重复。A,B,C 1默认方法重复,1静态方法重复。B,C 1默认方法重复分析哪些不能实现及原因 A: 总结一个实现类实现多个接口和一个父类的情况下
多个接口中常量名冲突用接口名调用即可。实现类对象只能调不冲突的常量不然混淆多个接口中抽象方法冲突实现类重写一次即可。抽象子类或子接口无需重写多个接口中默认方法冲突子必须重写一次。一个父接口和父类的默认方法冲突不用重写优先使用父类该重名方法。静态方法只能用接口名调用不可以用实现类调用。复习普通类中类名对象名都可以调用静态方法重写时注意若多个父接口中的重名方法返回值不同。子中重写方法的返回值类型 父方法即可。此处大小指的是父子类关系例如Object类 Integer类
public interface MyInterA {public static final int NUM 10;public abstract Object abMethod1();public abstract Integer abMethod2();public default void deMethod1(){System.out.println(接口A的默认方法A,B,C中重名);
// method1();
// method2();}public static void stMethod1(){System.out.println(接口A的静态方法A,B,C中重名);
// method2();//method1();调不了静态方法中调用非静态方法得new对象但接口不能new对象}/*复习1.静态方法中调用①静态方法或变量内部直接调外部静态导入也是直接调外部类名.* ②非静态方法统一用对象名.调用* 2.非静态方法中调用①内部类不论静态或非静态都直接调* ②外部类静态用类名.非静态用对象.*///因为Java8不能写这些
// private void method1(){
// System.out.println(A的重复代码私有);
// }
// private static void method2(){
// System.out.println(A的重复代码私有静态);
// }
}public interface MyInterB {int NUM 20;int BNUM 30;Float abMethod1();Integer abMethod2();public default void deMethod1(){System.out.println(接口B的默认方法1A,B,C中重名);
// method1();
// method2();}public default void deMethod2(){System.out.println(接口B的默认方法2BC中重名);}public static void stMethod1(){System.out.println(接口B的静态方法A,B,C中重名);
// method2();//method1();调不了静态方法中调用非静态方法得new对象但接口不能new对象}public static void stMethod2(){System.out.println(接口B自己的静态方法);}//因为Java8不能写这些
// private void method1(){
// System.out.println(B的重复代码私有);
// }
// private static void method2(){
// System.out.println(B的重复代码私有静态);
// }}public class MyClassC {void deMethod1(){System.out.println(------类C的默认方法1A,B,C中重名------);method1();method2();System.out.println(------------------------------------);}public void deMethod2(){System.out.println(类C的默认方法2B,C中重名);}public static void stMethod1(){System.out.println(----类C的静态方法A,B,C中重名---);method2();System.out.println(-------------------------------);//method1();调不了静态方法中调用非静态方法得new对象但接口不能new对象}private void method1(){System.out.println(类C的重复代码私有);}private static void method2(){System.out.println(类C的重复代码私有静态);}
}public class MyClassD extends MyClassC implements MyInterA, MyInterB{
// Override
// public Double abMethod1() {
// return null;
// }/*复习虽然该抽象方法A接口返回值为Object,B接口返回值为Float,重写时子类方法返回值 父类返回值即可*/Overridepublic Float abMethod1() {System.out.println(类D重写的抽象方法1);return null;}Overridepublic Integer abMethod2() {System.out.println(类D重写的抽象方法2);return null;}public void deMethod1(){System.out.println(默认方法1接口AB默认方法和类C方法重名所以需要实现类D重写一次);System.out.println(但实际上A,B默认方法都无法调用到只能super调用父类C的该名称方法);super.deMethod1();}}public class Main {public static void main(String[] args) {MyClassD d1 new MyClassD();System.out.println(因为接口中常量都为static,所以类名或实现类对象调用都可以。但在父接口常量重名时不可用实现类对象调用因为混淆);System.out.println(MyInterA.NUM);System.out.println(MyInterB.NUM);System.out.println(d1.BNUM);d1.abMethod1();d1.abMethod2();/*默认方法1ABC中重名优先使用父类C的但是接口AB中也重名需要在实现类D中重写*/d1.deMethod1();/*默认方法2 BC中重名优先用父类C的D中不用重写。直接用*/d1.deMethod2();/*静态方法用类名or接口名调用*/System.out.println();MyInterA.stMethod1();MyInterB.stMethod2();MyClassC.stMethod1();}
}自己分析输出结果
因为接口中常量都为static,所以类名或实现类对象调用都可以。但在父接口常量重名时不可用实现类对象调用因为混淆
10
20
30
类D重写的抽象方法1
类D重写的抽象方法2
默认方法1接口AB默认方法和类C方法重名所以需要实现类D重写一次
但实际上A,B默认方法都无法调用到只能super调用父类C的该名称方法
------类C的默认方法1A,B,C中重名------
类C的重复代码私有
类C的重复代码私有静态
------------------------------------
类C的默认方法2B,C中重名接口A的静态方法A,B,C中重名
接口B自己的静态方法
----类C的静态方法A,B,C中重名---
类C的重复代码私有静态
-------------------------------多态
面向对象三大特征封装性、继承性、多态性。 extends继承或者implements实现是多态性的前提。
小明是一个学生但同时也是一个人。小明是一个对象这个对象既有学生形态也有人类形态。 一个对象拥有多种形态这就是对象的多态性
多态的格式与使用
Polymorephism - Mulit 代码中体现多态性 父类引用指向子类对象
格式
父类名称 对象名 new 子类名称();或
接口名称 对象名 new 实现类名称();复习前篇 子父类重名方法new 的是谁就用谁的方法没有则向上找。
多态中成员变量的使用特点
public class Fu {int num 10;
void method(){System.out.println(num);}void methodFu(){System.out.println(num);}
}public class Zi extends Fu{int num 20;int age 16;void method(){System.out.println(子类method);System.out.println(num);}
}public class Main {public static void main(String[] args) {Fu obj new Zi();obj.method();//20子类方法obj.methodFu();//10父类特有方法System.out.println(obj.num);//10//直接调用重名变量看左侧引用是谁//System.out.println(obj.age);错误写法变量看左边引用父类没有不会向下找}
}复习前篇 重名变量1) 直接调 左边既引用是谁就用谁的变量 2) 间接访问利用类中方法类中方法都是优先调用本类变量。调用的方法属于哪个类就是哪个类中的变量
多态中成员方法的使用特点
在多态的代码当中成员方法的访问规则是 看new的是谁就优先用谁没有则向上找。
成员变量编译看左运行还看左 成员方法编译看左运行看右
public class Fu {int num 10;void showNum(){System.out.println(num);}void method(){System.out.println(重名方法method);}void methodFu(){System.out.println(父类特有methodFu);}}public class Zi extends Fu{int num 20;int age 16;void showNum(){System.out.println(num);}void method(){System.out.println(重名方法method);}void methodZi(){System.out.println(子类特有methodZi);}
}分析结果obj.methodZi()编译错误
public class Main {public static void main(String[] args) {Fu obj new Zi();obj.method();//编译看左Fu有该方法。运行看右Zi有该方法运行子类obj.methodFu();//编译看左Fu有该方法。运行看右Zi无该方法就向上找运行父类//obj.methodZi();//编译看左Fu类没有该方法编译出错}
}❓扩展若重名方法内调用重名变量
pulbic class Fu{int num 10;void method(){System.out.println(num);//10}
}public class Zi extends Fu{int num 20;void method(){System.out.println(num);//20}
}A分析方法所在类内的该变量若有直接调没有则向上找 多态情况编译看左Fu有方法method,运行看右Zi有method方法运行子类方法
public static void main(String[] args){Fu obj new Zi();obj.method();//20
}使用多态的好处 如不用多态只用子类写法
Teacher one new Teacher();
one.work();//讲课
Assistent two new Assistant();
two.work();//辅导我现在唯一要做的事情就是调用work方法其他功能不关心
如果使用多态的写法对比一下
Employee one new Teacher();
one.work();//讲课
Employee two new Assistant();
two.work();//辅导好处无论右边new的时候换成哪个子类对象等号左边调用方法都不会改变。改代码更灵活
对象的向上转型向下转型 public interface Animal {void eat();
}public class Cat implements Animal{Overridepublic void eat() {System.out.println(猫吃鱼);}public void catchMice(){System.out.println(猫抓老鼠);}
}public class Dog implements Animal{Overridepublic void eat() {System.out.println(狗吃骨头);}public void door(){System.out.println(狗看家);}
}对象的向上转型其实就是多态写法 Animal animal new Cat();含义右侧创建一个子类对象把它当做父类来看待使用。注意此时类对象不可以调用子类Cat特有的方法因为对于成员方法编译看左运行看右。父类Animal没有子类特有的方法编译出错
格式父类名 对象名 new 子类名称();创建了一只猫当做动物看待没问题。 注意事项向上转型一定是安全的。从小范围转向了大范围。动物范围比猫更广 类似于 double num 100; //√整数默认类型为intint取值范围 double 范围。int - double 自动类型转换。从小范围的猫向上转换成为更大范围的动物 对象的向上转型就是父类引用指向子类对象 Animal animal new Cat();animal.eat();//猫吃鱼对象的向下转型其实是一个还原的动作。 格式 子类名称 对象名 子类名称父类对象 含义将父类对象还原成为本来的子类对象。 Animal animal new Cat();本来是猫向上转型成为动物 Cat cat (Cat) animal;本来是猫已经被当做动物了还原回来成为本来的猫 a. 必须保证对象本来创建的时候就是猫才能向下转型成为猫 b. 如果对象创建的时候本来不是猫比如是狗Dog类其他的子类或父类本身Animal现在非要向下转型成为猫就会报错。 ClassCastException类转换异常
❓如何才能知道一个父类引用的对象本来是什么子类 格式 对象 instanceof 类名称 这将会得到一个boolean值结果也就是判断前面的对象不能当做后面类型的实例。向下转型前一定要用instanceof判断因为不确定接口有几个实现类
注意如果方法形参规定是父类或父接口传实参为子类或实现类不是多态写法但传参了也符合向上转型。也是从小范围类型赋值给大范围 分两步向上转型和传参再向上转型都可以
public class Main {public static void getPet(Animal animal){if(animal instanceof Dog){System.out.println(得到的宠物是狗狗);Dog dog (Dog)animal;// ● 向下转型必须原对象就是Dog类所以一定先instanceof判断dog.door();//还原后才可以调用子类特有的方法}else if(animal instanceof Cat){System.out.println(得到的宠物是猫猫);Cat cat (Cat)animal;cat.catchMice();}}public static void main(String[] args) {//向上转型
// Dog dog1 new Samoyed();
// Samoyed sam1 (Samoyed)dog1;
// sam1.personality();
/*此处实验向下转型只能还原也不能把父类强转成子类。
转的类型必须跟开始的对象类型一致只有引用不一致*/
// Dog dog2 new Dog();
// Samoyed sam2 (Samoyed)dog2;
// sam2.personality();//模拟向上转型Animal a1 new Cat();//①向上转型Dog a2 new Dog();Animal a3 a2;//②分两步向上转型getPet(a2);//③子类传参给形参是父接口的也属于向上转型getPet(new Dog());//④匿名对象传也可以a1.eat();a3.eat();//不能调用子类特有方法如door(),catchMice();}
}得到的宠物是狗狗
狗看家
得到的宠物是狗狗
狗看家
猫吃鱼
狗吃骨头● 练习
1. 多态中成员方法调用判断以下输出
public class Fu {void method(){System.out.println(父类method);}void methodFu(){System.out.println(父类特有methodFu);}
}public class Zi extends Fu{void method(){System.out.println(子类method);}
}public class Main {public static void main(String[] args) {//判断以下输出Fu obj new Zi();obj.method();obj.methodFu();}
}A:new的是谁用谁的方法没有则向上找
子类method
父类特有methodFu2. 多态中成员变量判断对错或结果
public class Fu {int num 10;void method(){System.out.println(num);}void methodFu(){System.out.println(num);}
}public class Zi extends Fu{int num 20;int age 16;void method(){System.out.println(子类method);System.out.println(num);}
}public class Main {public static void main(String[] args) {Fu obj new Zi();obj.method();obj.methodFu();System.out.println(obj.num);System.out.println(obj.age);}
}A: 记 成员变量编译看左运行看左。成员方法编译看左运行看右 方法属于哪个类优先调用本类的变量若无才向上找 public static void main(String[] args) {Fu obj new Zi();obj.method();//编译看左Fu,有。运行看右Zi也有运行子类方法obj.methodFu();//编译看左Fu有。运行看右Zi无向上找运行父类方法System.out.println(obj.num);//直接调用成员变量始终看左执行父类变量● System.out.println(obj.age);//错变量看左父类Fu没这个变量编译错误也不可能向下找}子类method
20
10
103. 多态中成员方法间接访问成员变量。判断对错或结果
public class Fu {int num 10;void showNum(){System.out.println(num);}void method(){System.out.println(父类重名方法method);}void methodFu(){System.out.println(父类特有methodFu);}
}public class Zi extends Fu{int age 16;void showNum(){System.out.println(num);}void method(){System.out.println(子类重名方法method);}void methodZi(){System.out.println(子类特有methodZi);}
}public class Main {public static void main(String[] args) {Fu obj new Zi();obj.method();obj.methodFu();obj.methodZi();obj.showNum();}
}A: public static void main(String[] args) {Fu obj new Zi();obj.method();//编译看左Fu有该方法。运行看右运行子类方法obj.methodFu();//编译看左运行看右。Zi中没有向上找运行父类方法● 错 obj.methodZi();//编译看左Fu中无错误obj.showNum();//编译看左运行看右。运行子类方法但Zi中没有num向上找。只要Fu中num,不是private私有的就行}子类重名方法method复习权限 private - 类内部使用 (default) 比上多一个使用区 - 同一个包 protected 比前两多一个 - 子类 public 比前几个多 - 任何地方
4. 接口多态综合练习接口的基本使用对象的上下转型以及接口作为方法的参数。 A: 分析use接口有无对电脑极其开关机操作无关只是使用设备时需要作为链接的标准作为参数。鼠标键盘等属于usb设备需要实现use接口。use接口中功能就是打开和关闭。 具体设备有自己的特有功能类似点击打字之类。 public class Iaptop {public void powerOn(){System.out.println(打开笔记本);}public void useDevice(USB usb){usb.open();//因为多态引用为接口对象为实现类。不可以调用实现类特有的方法。// 复习对于成员方法编译看左运行看右//所以想要调用子类特有方法进行还原即向下转型后调用即可if(usb instanceof Mouse){Mouse mouse (Mouse)usb;mouse.click();}else if(usb instanceof Keyboard){//注意不可以直接else必须加if判断因为不能确定接口只有这两个实现类Keyboard keyboard (Keyboard)usb;keyboard.type();}usb.close();
// System.out.println(使用设备);}public void powerOff(){System.out.println(关闭笔记本);}
}public interface USB {public abstract void open();public abstract void close();}public class Mouse implements USB{Overridepublic void open() {System.out.println(打开鼠标);}Overridepublic void close() {System.out.println(关闭鼠标);}public void click(){System.out.println(点击);}
}public class Keyboard implements USB{Overridepublic void open() {System.out.println(打开键盘);}Overridepublic void close() {System.out.println(关闭键盘);}public void type(){System.out.println(打字);}
}
public class Main {public static void main(String[] args) {Iaptop c1 new Iaptop();c1.powerOn();//多态4种向上转型。//usb1 和 usb3 是一步向上转型和分两步向上转型//usb2 和 usb4 是实现类传参给接口也是向上转型USB usb1 new Mouse();Keyboard usb2 new Keyboard();USB usb3 usb2;c1.useDevice(usb1);c1.useDevice(usb2);//相当于形参是double,实参是int。从小范围到大范围传参自动类型转换c1.useDevice(usb3);c1.useDevice(new Mouse());c1.powerOff();}
}打开笔记本
打开鼠标
点击
关闭鼠标
打开键盘
打字
关闭键盘
打开键盘
打字
关闭键盘
打开鼠标
点击
关闭鼠标
关闭笔记本
