Java学习路程之多态、设计模式、抽象和接口

一.多态
1.多态练习

/*
 * 新建一个僵尸类
 * 
 * 铁桶僵尸 
 * 血量  初始200血
 * 方法:每次被打减少2滴血 被打死 打印 铁桶僵尸死了
 * 
 * 门框僵尸
 * 血量  300
 * 方法:每次被打减少5滴血 被打死 打印 门框僵尸死了
 * 
 * main函数中 封装一个打僵尸方法 (适用所有的僵尸)
 * 
 * 无参 有参 set/get方法
 * */
public class Day09 {
    public static void main(String[] args) {
        //父类的引用指向子类的空间
        Zombie bucketZombie = new BucketZombie();
        bucketZombie.setBlood(200);
        hitZombie(bucketZombie);
        Zombie dwZombie = new DwZombie();
        dwZombie.setBlood(300);
         hitZombie(dwZombie);
    }
    //通用打僵尸方法
    public void hitZombie(Zombie zombie){
        zombie.hit();
    }
}
//僵尸类
class Zombie{
    //血量变量
    private int blood;
    //构造方法
    public void Zombie(){

    }
    public void Zombie(int blood){
        this.blood = blood;
    }
    //set/get方法
    public void setBlood(int blood){
        this.blood = blood;
    }
    public int getBlood(){
        return blood;
    }
    //打僵尸的方法
    public void hit(){
        System.out.println("打僵尸");
    }
}
//铁桶僵尸类
class BucketZombie extends Zombie{
    //方法的重写
    public void hit(){
        while(true){
            if(getBlood() <= 0){
            System.out.println("铁桶僵尸死了");
            break;
            }
            //被打一次血量减少
            setBlood(getBlood() - 2);
            //剩余血量
            System.out.println(getBlood());
        }
    }
}
//门窗僵尸类
class DwZombie extends Zombie{
    //父类方法的重写
    public void hit(){
        if(getBlood <= 0){
            System.out.println("门窗僵尸死了");
            return;
        }
        //被打一次血量减少5点
        setBlood(getBlood() - 5);
        //剩余血量
        System.out.println(getBlood());
    }
}

2.

/* 定义主板类 
 * (多态 继承 方法重写)
* 主板:
* 启动方法  主板启动了
* 插卡方法  start和end
* (主板上可以插很多卡 例如 例如声卡 网卡 显卡 内存条)
* 声卡可以 start播放音乐 end关闭播放
* 网卡可以 start上网 end断网
*/
public class Day09 {
    public static void main(String[] args) {
        MainBoard mainBoard = new MainBoard();
         mainBoard.insertCard(new SoundCard());
          mainBoard.insertCard(new NetCard());
    }
}
//定义卡类
class Card{
    //开始方法
    public void start(){
        System.out.println("开始");
    }
    //结束方法
    public void end(){
        System.out.println("结束");
    }
}
//定义主板类
class MainBoard{
    //启动方法
    public void run(){
        System.out.println("启动");
    }
    //插卡方法
    public void insertCard(Card card){
        card.start();
        card.end();
    }
}

//声卡类
class SoundCard extends Card{
    //父类方法的重写
    //开始播放音乐
    public void start(){
        System.out.println("播放音乐");
    }
    //关闭播放
    public void end(){
        System.out.println("关闭播放");
    }
}
//网卡类
class NetCard extends Card{
    //开始上网
    public void start(){
        System.out.println("开始上网");
    }
    //断网
    public void end(){
        System.out.println("断网");
    }
}

二.设计模式
1.单例设计模式
核心:在程序运行当中无论如何创建对象,该对象有且只有一个存在.
分为:
饿汉式单例
懒汉式单例
区别:

public class Day09 {
    public static void main(String[] args) {
        //两个引用输出结果一致,具体实现见图
        HSingle hSingle1 = HSingle.getInstance();
        HSingle hSingle1 = HSingle.getInstance();
    }
}
//饿汉式单例
class HSingle{
     //第二步创建对象
    private static HSingle hSingle = new HSingle();
    //第一步构造方法私有化
    private HSingle(){
    }
    //第三步开放一个供外部调用的方法
    public static HSingle getInstance(){
        return hSingle;
    }
}
//懒汉式单例
class LSingle{
    //第二步声明对象
    private static LSingle lSingle = null;
    //第一步私有化构造方法
    private LSingle(){
    }
    //第三步提供外部调用的方法
    public static LSingle getInstance(){
        if(lSingle == null){
            //创建对象
            lSingle = new LSingle();
        }
        return lSingle;
    }
}

2.模板设计模式
当你的程序大部分代码都相同,只有少部分需要修改时可以使用模板设计模式(利用抽象类)

public class Day09 {
    public static void main(String[] args) {
        School student = new XM();
        student.study();//输出:报名缴费 文科 毕业
    }
}
abstract class School{
    //  学习
    public void study() {
        System.out.println("报名缴费");
        //  选择学科
        chooseSubject();
        System.out.println("毕业");
    }
    //  抽象方法
    public abstract void chooseSubject();
}
//学生类
class XM extends School{
    //方法的重写
    @Override
    public void chooseSubject() {
        System.out.println("文科");
    }
}

class LS extends School{
    @Override
    public void chooseSubject() {
        System.out.println("理科");
    }

}

2.练习
打印一个程序的执行时间(使用模板设计模式)

public class Demo07 {
    public static void main(String[] args) {
        Program pro = new XH();
        pro.getTime();
    }
}
abstract class Program{
    //计算程序执行时间方法
    public void getTime(){
        //开始
        long start = System.currentTimeMillis();
         program();
        //结束
        long stop = System.currentTimeMillis();
        //执行时间
        System.out.println("程序执行时间:" + (stop - start));
    }
    //声明抽象方法表示程序
    public abstract void program();
}
//定义一个程序类
class XH extends Program{
    public void program() {
        //执行的程序
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j +"*"+ i +"="+j*i+"\t");
            }
            System.out.println();
        }
    }
}

三.抽象
1.含义:无法对事物进行具体的描述
关键词: abstract
修饰类该类是抽象类,修饰方法该方法是抽象方法
2.注意:
1).抽象方法没有实现部分
2)抽象方法必须在抽象类中才能声明
3)抽象类中可以没有抽象方法
4)抽象类不可以直接创建出对象,但是可以通过多态的形式创建
5)继承抽象类的子类必须实现抽象类的抽象方法
2.抽象类中可以有变量、常量、抽象方法、成员方法、构造方法

public class Day09 {
    public static void main(String[] args) {
        //抽象类不能直接创建对象
        //Animal animal = new Animal();
        //使用的方法  以多态的方法创建
        Animal animal = new Cat();
        animal.eat();
        //向下转型
        Cat cat = (Cat)animal;  
        cat.catchMice();
    }
}
//动物类
abstract class Animal{
    //声明抽象方法
    public abstract void eat();
    public void Amimal() {
        System.out.println("我是构造方法");
    }
}
/猫类
class Cat extends Animal{
    //实现抽象方法
    public void eat() {
        System.out.println("猫吃鱼");
    }
    //特有方法
    public void catchMice() {
        System.out.println("抓老鼠");
    }
}

四.接口
1.定义
接口:
狭义:使用关键字interface定义接口
广义:制定一个规范让人来遵守
2.结构
interface 接口名 {}
注意:
1.使用接口时用关键词interface
2.接口类不能直接创建对象
3.接口类不能声明成员方法
4.接口类不能有构造方法
5.使用多态的方式创建对象

public class Day09 {
    public static void main(String[] args) {
        //接口类不能直接创建对象
        //Inter inter = new Inter();
        //使用多态的形式类创建对象
        Inter inter = new interImpl();
        inter.fn();
    }
}

//声明一个接口
interface Inter{
   //系统会在成员变量前加上 public static final,实际声明的是一个静态常量
    public static final int num = 10;
    //抽象方法
    public abstract void fn();
    //不能有构造方法
    //接口不能直接创建对象,而构造方法在创建对象时系统会自动调用,对象不能声明故构造方法也就不能声明了
    //public Inter() {};
}
class interImpl implements Inter{
    //实现接口中的抽象方法
    public void fn() {
        System.out.println("我是实现类的fn方法");
        System.out.println(num);
    }
}

练习:

public class Day09 {

}
//动物类
abstract class Animal1{
    //抽象方法
    public abstract void speak();
}
//猫类
class Cat1 extends Animal1{
    //实现抽象方法
    public void speak() {
        System.out.println("喵喵喵");
    }
}
//接口
interface interCat{
    //声明抽象方法
    public abstract void jump();
}
//实现接口//加菲猫类
class JFcat extends Cat implements interCat{
     //实现接口中的抽象方法
    public void jump() {
        System.out.println("人指导训练");
    }
}