多态的概述及代码体现
事务存在的多种形态。
多态前提
要有继承关系
要有方法重写
要有父类引用指向子类对象
package java1;
public class ba_10 {
public static void main(String[]args) {
animal1 p1=new cat11();
p1.eat();
System.out.println(p1.num3);
}
}
class animal1{
int num3=10;
public void eat() {
System.out.println(“动物鱼”);
}
}
class cat11 extends animal1 {
int num3=30;
public void eat() {
System.out.println(“猫吃鱼”);
}
}
9.2
多态中成员访问方法之成员变量特点
father p1=new son;
son访问的是父类，super里的内容。所以输出的是father的变量和方法
father p1=new father;访问的是自己的对象，所以就近原则，用的是自己的内容
package java1;
public class ba_10 {
public static void main(String[]args) {
animal1 p1=new cat11();
p1.eat();
System.out.println(p1.num3);
}
}
class animal1{
int num3=10;
public void eat() {
System.out.println(“动物鱼”);
}
}
class cat11 extends animal1 {
int num3=30;
public void eat() {
System.out.println(“猫吃鱼”);
}
}
9.3
多态中成员访问特点之成员方法
动态绑定
编译看左边，运行看右边。
package java1;
public class ba_10 {
public static void main(String[]args) {
father1 p1=new son1();
p1.show();
//System.out.println(p1.num3);
}
}
class father1{
int num=10;
public void show() {
System.out.println(“我是爸爸”);
}
}
class son1 extends father1 {
int num=30;
public void show() {
System.out.println(“我是儿子”);
}
}
9.4多态中成员访问特点之静态成员方法。
成员变量：
编译看左边，运行看左边
成员方法：
编译看左边，运行看右边。动态绑定。（因为子类对象对父类对象的方法进行了一次重写，所以，地址值对象里的方法是子类的方法。）
静态方法：
编译看左边，运行看左边。
（静态和类相关，算不上重写，所以，访问还是左边）
只有非静态成员方法，编译看左边，运行看右边。
package java1;
public class ba_10 {
public static void main(String[]args) {
father1 p1=new son1();
p1.show();
//System.out.println(p1.num3);
}
}
class father1{
int num=10;
public static void show() {
System.out.println(“我是爸爸”);
}
}
class son1 extends father1 {
int num=30;
public static void show() {
System.out.println(“我是儿子”);
}
}
9.5超人的故事。
父类引用子类对象——就是向上转型
父类引用子类对象要使用子类的方法——完成向下转型后，才能使用子类的特有方法。
Man p1=new superman(); //父类引用子类对象，向上转型
Superman sm=(superman)p1; //强制转换，向下转型
package java1;
public class SuperMan {
public static void main(String[]args) {
Man p1=new deomo_SuperMan();
System.out.println(p1.name);
p1.talk();
System.out.println(“有人要跳楼,超人要救人，p1无法调用子类lfy方法，怎么解决？”);
//向上向下转型 父类引用子类对象，就是向上转型
//现有向上转型，再有向下转型
deomo_SuperMan s1m=(deomo_SuperMan)p1;
//deomo_SuperMan sm=(deomo_SuperMan)p1;//开始变身！
s1m.fly();
}
}
class Man{
String name=”约翰”;
public void talk() {
System.out.println(“约翰谈生意”);
}
}
class deomo_SuperMan extends Man{
String name=”超人”;
public void talk() {
System.out.println(“超人谈生意”);
}
public void fly() {
System.out.println(“飞出去救人”);
}
}
9.7多态的弊端
不能使用子类特有的属性和方法。
好处：提高代码的维护性
提高了代码的扩展性
当做参数的时候用多态最好，因为扩展性强
package java1;
public class feiji {
public static void main(String[]args) {
method(new gongju());
method(new danche());
method(new che());
gongju a=new che();
che b=(che)a;
b.lunzi();
//关键字 instanceof 判断前边的饮用是否是后边的数据类型
}
/*public static void method (che c) {
c.run();
}
public static void method (danche c) {
c.run();
}*///当做参数的时候用多态最好，因为扩展性强
public static void methid(gongju a) {}
//如果要使用子类特有属性要强转。
public static void method (gongju a) {
if(a instanceof che) {
che c=(che)a;
c.lunzi();
c.run();
}else if(a instanceof danche) {
danche c=(danche)a;
c.run();
c.qidanche();
}
}
}
class gongju{
public void run() {
System.out.println(“公有方法”);
}
}
class che extends gongju{
public void run() {
System.out.println(“车公有方法”);
}
public void lunzi() {
System.out.println(“车的特有方法”);
}
}
class danche extends gongju{
public void run() {
System.out.println(“单车公有方法 “);
}
public void qidanche() {
System.out.println(“单车特有方法”);
}
}
9.9抽象类的概述及其特点
抽象，就是看不懂的。
特点
抽象类和抽象方法必须用abstract关键词修饰
Abstract class 类名{}
Public Abstract void run();
抽象类不一定有抽象方法，但抽象方法的类一定是抽象类或者是接口。
抽象类不能实例化，那么有什么巧妙办法实例化抽象类呢？
抽象类的子类
要么是抽象类
要么是重写抽象类中所有抽象方法。
package java1;
public class jiu_10 {
public static void main(String[]args) {
tian a=new ren();
a.run();
ren b=new ren();
b.run();
}
}
abstract class tian{
public abstract void run();
}
abstract class di{
public abstract void eat();
}
class ren extends tian{
public void run() {
System.out.println(“对抽象类进行实例化通过继承实现，而且必须重写父类抽象类的抽象方法”);
}
}
9.10抽象类的成员特点
1，成员变量，既可以是变量，也可以是常亮。Abstract是否可以修饰成员变量？不能修饰成员变量
2，构造方法，有
3，成员方法，既可以是抽象的，也可以是非抽象的。
抽象类的成员方法特性
1，抽象方法，强制要求子类做的事情
2，非抽象方法，子类继承的事情，提高代码的复用性。
抽象的方法。
package java1;
public class jiu_100 {
public static void main(String[]args) {
//domo c=new domo_a();
//c.zou();
//c.run();
method(new domo_a());
//method(new domo());父类是个抽象类，所以无法进行创建对象
}
public static void method(domo a) {
if(a instanceof domo_a) {
a.run();
a.zou();
}
}
}
abstract class domo{
int a=10;//成员变量既可以是变量也可以使常量
final int b=20;//抽象类的成员变量既可以是变量也可以使常量
//abstract 不能修饰成员变量，因为值本来就是固定的，无法修饰。
public domo() {
System.out.println(“抽象类父类空参构造”);
}
public void run() {} //非抽象的成员方法
public abstract void zou();//抽象的成员方法，是强制要求子类做的事情。
}
class domo_a extends domo{
public void zou() {
System.out.println(“抽象的方法，子类必须要重写。必须得用”);
}
}
9.11葵花宝典练习题
package javahome;
public class jiu_11 {
public static void main(String[]args) {
method(new yuebuqun());
method(new aobai());
method(new dongfangbubai());
}
public static void method(kuihuabaodian a) {
if(a instanceof yuebuqun) {
yuebuqun c=(yuebuqun)a;
c.zigong();
c.yuebuqun();
}else if(a instanceof dongfangbubai) {
dongfangbubai c=(dongfangbubai)a;
c.zigong();
c.dongfangbubai();
}else if(a instanceof aobai) {
aobai c=(aobai)a;
c.zigong();
c.aobai();
}
}
}
abstract class kuihuabaodian{
public abstract void zigong();
}
class yuebuqun extends kuihuabaodian{
public void zigong() {
System.out.println(“岳不群用小刀自宫”);
}
public void yuebuqun() {
System.out.println(“我是岳不群”);
}
}
class dongfangbubai extends kuihuabaodian{
public void zigong() {
System.out.println(“东方不败用菜刀自宫”);
}
public void dongfangbubai() {
System.out.println(“我是东方不败”);
}
}
class aobai extends kuihuabaodian{
public void zigong(){
System.out.println(“鳌拜找太监帮他自宫”);
}
public void aobai() {
System.out.println(“我是鳌拜”);
}
}
9.12抽象类 猫狗练习
package javahome;
public class jiu_12 {
public static void main(String[]args) {
dog a=new dog(“旺财”,8);
System.out.println(a.getAge()+a.getName());
a.eat();
a.show();
cat b=new cat(“喵喵”,20);
System.out.println(b.getAge()+b.getName());
b.eat();
b.show();
}
}
abstract class animal{
private String name;
private int age;
public animal() {}
public animal(String name,int age) {
this.name=name;
this.age=age;
}
public void setName(String name) {
this.name=name;
}
public String getName(){
return this.name;
}
public void setAge(int age) {
this.age=age;
}
public int getAge() {
return this.age;
}
public abstract void eat() ;
}
class dog extends animal{
public dog() {}
public dog(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println(“狗吃骨头”);
}
public void show() {
System.out.println(“狗会汪汪”);
}
}
class cat extends animal{
public cat() {}
public cat(String name,int age) {
super(name,age);
}
public void eat() {
System.out.println(“猫吃鱼”);
}
public void show() {
System.out.println(“猫会喵喵”);
}
}
9.13抽象练习，老师
9.14抽象练习，员工
9.15 抽象类中的面试题
9.16接口的概述及其特点
接口概述：
从狭义上讲，就是java中的interface
从广义上讲，对外提供规则的都是接口
接口特点
1，接口用关键字interface表示
2，Interface 接口名（）
3，类实现接口用implements表示
4，Class 类名 implements 接口名 ｛｝
5，接口不能实例化
6，那么，接口如何实例化呢？
7，按照多态的方式来实例化
8，接口的子类
9，可以是抽象类，但意义不大。
10，可以是具体类，要重写接口中的所有抽象方法（推荐方案）
package javahome;
public class jiu_16 {
public static void main(String[]args) {
demo12 a=new demo9();
a.run();
}
}
interface demo12{
public abstract void run() ;
}
class demo9 implements demo12{
public void run() {
System.out.println(“这是继承接口的实例化显示”);
}
}
//接口和抽象类最大的区别是，接口里必须都是抽象方法，而抽象类中不一定有抽象方法
9.17接口的成员特点
成员变量：只能是常量，并且是静态的并公共的，公共静态常量
默认修饰符，public static final
建议，自己手动给出
构造方法：接口没有构造方法
成员方法：只能是抽象方法
默认修饰符public abstract
建议手动给出
一个类如果不写继承的任何类的话，默认继承object类
package javahome;
public class jiu_16 {
public static void main(String[]args) {
demo12 a=new demo9();
a.run();
System.out.println(demo12.num);
}
}
interface demo12{
public static final int num=10;
public static final int num2=20;
public abstract void run() ;
}
class demo9 implements demo12{
public void run() {
System.out.println(“这是继承接口的实例化显示”);
}
}
//接口和抽象类最大的区别是，接口里必须都是抽象方法，而抽象类中不一定有抽象方法
9.18
接口与接口的关系
继承关系，可以单继承，也可以多继承
接口与类的关系
实现关系，可以单实现，也可以多实现
9.19抽象类和接口的区别