疯狂java


您现在的位置: 疯狂软件 >> 新闻资讯 >> 正文

Java基础多态学习笔记


 

多态——对象的多种形态(继承是多态实现的基础)
 
引用多态:父类的引用可以指向本类的对象;父类的引用可以指向子类的对象
方法多态:创建本类对象时,调用的方法为本类方法;创建子类对象时,调用的方法为子类重写的方法或者继承的方法
父类的引用不能调用子类独有的方法
复制代码
package com.test;
 
public class Animal {
    public int age = 1;
    public void eat() {
        System.out.println("动物具有吃东西的能力");
    }
}
复制代码
复制代码
package com.test;
 
public class Cat extends Animal{
    public int age = 2;
    public void eat() {
        System.out.println("兔子吃胡萝卜");
    }
    public void nature() {
        System.out.println("兔子胆小");
    }
}
复制代码
复制代码
package com.test;
 
public class Initail {
 
    public static void main(String[] args) {
        Animal animal = new Animal();
        Animal cat = new Cat();
        //Cat cat1 = new Animal();错误
        animal.eat();
        cat.eat();
        //cat.nature();错误
    }
}
复制代码
引用类型转换
向上类型转换(隐式/自动类型转换),是小类型到大类型的转换
向下类型转换(强制类型转换),是大类型到小类型的转换。这种转换存在风险,可能会发生数据的溢出
instanceof运算符(一个引用是否是某个类型或某个类型的子类型),可以解决引用对象的类型转换的安全性问题
复制代码
package com.test;
 
public class Initail {
 
    public static void main(String[] args) {
        Dog dog = new Dog();
        Animal animal = dog;//向上类型转换
        
        if (animal instanceof Dog) {
            Dog dog2 = (Dog)animal;
        } else {
            System.out.println("无法转换为Dog类型");
        }
        
        if (animal instanceof Cat) {
            Cat cat = (Cat)animal;
        } else {
            System.out.println("无法转换为Cat类型");
        }
    }
}
复制代码
  Dog类和Cat类都继承Animal类
  执行结果:
 
  无法转换为Cat类型
 
抽象类
语法定义:抽象类前使用abstract关键字修饰
应用场景:a、在某些情况下,某个父类只是知道其子类应该包含怎样的方法,但无法准确知道这些子类如何实现这些方法;b、从多个具有相同特征的类中抽象出一个抽象类,以这个抽象类作为子类的模板,从而避免了子类设计的随意性。
作用:限制规定子类必须实现某些方法,但不关注实现细节
使用规则:a、abstract定义抽象类;b、定义的抽象方法,只有声明,不需要实现c、包含抽象方法的类是抽象类d、抽象类中可以包含普通的方法,也可以没有抽象方法e、抽象类不能直接创建,可以定义引用变量指向子类对象
package cn.test;
 
public abstract class Telephone {
    public abstract void call();
    public abstract void sendMsg();
}
复制代码
package cn.test;
 
public class Cellphone extends Telephone {
    public void call() {
        System.out.println("用键盘打电话");
    }
    public void sendMsg() {
        System.out.println("用键盘发短信");
    }
}
复制代码
复制代码
package cn.test;
 
public class Smartphone extends Telephone {
 
    @Override
    public void call() {
        System.out.println("用语音打电话");
    }
 
    @Override
    public void sendMsg() {
        System.out.println("用语音发短信");
    }
 
}
复制代码
复制代码
package cn.test;
 
public class Initail {
    public static void main(String[] args) {
        Telephone phone1 = new Cellphone();
        phone1.call();
        Telephone phone2 = new Smartphone();
        phone2.call();
    }
}
复制代码
  执行结果:
 
  用键盘打电话
  用语音打电话
 
接口
概念:类是一种具体的实现体,而接口定义了某一批类所需要遵守的规范,接口不关心这些类的内部数据,也不关心这些类里方法的实现细节,它只规定这些类里必须提供某些方法。
接口定义:使用interface关键字,不再使用class关键字
语法:[修饰符] abstract interface 接口名 [extends 父接口1,父接口2...] {
        零到多个常量定义...
        零到多个抽象方法定义...
} 接口是用来被继承、被实现的,修饰符一般建议用public,不能使用protected和private
接口定义:常量:即使定义时不添加public static final 修饰符,系统也会自动加上;方法:接口中的方法只能是抽象方法,即使定义时不添加pubic static 修饰符,系统也会自动加上。
使用接口:一个类可以实现一个或多个接口,实现接口使用implements关键字。Java中一个类只能继承一个父类,是不够灵活的,通过实现多个接口可以做补充。
继承父类实现接口的语法:[修饰符] class 类名 extends 父类 implements 接口1,接口2...{//类体部分},继承父类必须在实现接口之前。
package cn.test;
 
public abstract interface IPlayGame {
    public abstract void playGame();
    public static final int NUM = 12;
}
复制代码
package cn.test;
 
public class Psp implements IPlayGame {
    @Override
    public void playGame() {
        System.out.println("游戏机能够打游戏");
    }
}
复制代码
复制代码
package cn.test;
 
public class Initail {
    public static void main(String[] args) {
        IPlayGame iplay2 = new Psp();
        iplay2.playGame();
        System.out.println(Psp.NUM);        
    }
}
复制代码
  执行结果:
 
  游戏机能够打游戏
  12