final

final关键字用于不同的上下文。首先,final是一个非访问修饰符,仅适用于变量、方法或类

final

  • final修饰的属性又叫常量,final修饰的属性在定义时,必须赋初值,并且不可被修改可以在一下位置赋值

    • 定义时直接赋值
    • 在构造器中
    • 在代码块中
  • 如果final修饰的属性是静态的,则初始化的位置不能在构造器中,因为,构造器是实例化,static是非实例化,随着类的加载而加载
  • final类不能继承,但是可以实例化对象
  • 类中含有final方法,这个类可以被继承,但是final方法不可以被重写

abstract

数据抽象是隐藏某些细节并仅向用户显示基本信息的过程

抽象可以通过抽象类或接口来实现

abstract关键字是非访问修饰符,用于类和方法

  • 抽象类:是一个受限制的类,不能实例化,子类可以通过继承实例化
  • 抽象方法:只能在抽象类中使用,它没有主体,主体由子类继承后提供
  • 抽象方法就是为了重写而诞生的,所以抽象方法不能使用private,final,static来修饰

    • private不能被继承
    • final不能被改变,自然不能重写
    • static是静态的,是随着类的加载而加载,不存在实例化,更不存在重写

设计模式 - 模板模式

在模板模式中,抽象类公开定义的方式/模板来执行其方法。它的子类可以根据需要覆盖方法实现,但调用方式与抽象类定义的方式相同。此模式属于行为模式类别

设计模式

创建一个模板方法为 final 的抽象类。

public abstract class Game {
   abstract void initialize();
   abstract void startPlay();
   abstract void endPlay();

   //template method
   public final void play(){

      //initialize the game
      initialize();

      //start game
      startPlay();

      //end game
      endPlay();
   }
}

创建扩展上述类的具体类。

public class Cricket extends Game {

   @Override
   void endPlay() {
      System.out.println("Cricket Game Finished!");
   }

   @Override
   void initialize() {
      System.out.println("Cricket Game Initialized! Start playing.");
   }

   @Override
   void startPlay() {
      System.out.println("Cricket Game Started. Enjoy the game!");
   }
}
public class Football extends Game {

   @Override
   void endPlay() {
      System.out.println("Football Game Finished!");
   }

   @Override
   void initialize() {
      System.out.println("Football Game Initialized! Start playing.");
   }

   @Override
   void startPlay() {
      System.out.println("Football Game Started. Enjoy the game!");
   }
}

使用Game的模板方法 play() 来演示定义的玩游戏方式。

public class TemplatePatternDemo {
   public static void main(String[] args) {

      Game game = new Cricket();
      game.play();
      System.out.println();
      game = new Football();
      game.play();        
   }
}

验证输出。

Cricket Game Initialized! Start playing.
Cricket Game Started. Enjoy the game!
Cricket Game Finished!

Football Game Initialized! Start playing.
Football Game Started. Enjoy the game!
Football Game Finished!

接口

  • 和抽象类一样,接口不能用于创建对象
  • 接口没有主体,主体由“实现”类提供
  • 在实现接口时,必须重写所有方法
  • 接口属性是默认的public,static,并且final
  • 接口不能包含构造函数,因为它不能用于实例化
  • 接口的核心功能体现在限制,它统一了方法名,方便维护代码和开发者使用

接口的多态特性

public interface UsbInterface {
    public void  start();
    public  void stop();
}
public class Phone implements UsbInterface{
    @Override
    public void start() {
        System.out.println("手机开始工作了。。。");
    }

    @Override
    public void stop() {
        System.out.println("手机停止工作了。。。");
    }
}
public class Camera implements UsbInterface{
    @Override
    public void start() {
        System.out.println("相机开始工作了。。。");
    }

    @Override
    public void stop() {
        System.out.println("相机停止工作了。。。");
    }
}
public class Computer {
    public void  work(UsbInterface usbInterface){
        usbInterface.start();
        usbInterface.stop();
    }
}
public class Run {
    public static void main(String[] args) {
        Phone phone = new Phone();
        Camera camera = new Camera();
        Computer computer = new Computer();
        computer.work(phone);
        computer.work(camera);
    }

}

接口的多态特性(多态数组)

public interface Usb {
    public void work();
}
public class Phone implements Usb{
    @Override
    public void work() {
        System.out.println("电话工作了。。。");
    }
    public void  call(){
        System.out.println("电话响了。。。");
    }
}
public class Camera implements Usb{
    @Override
    public void work() {
        System.out.println("相机工作了。。。" +
                "");
    }
}
public class interfacePolymorphism {
    public static void main(String[] args) {
        Usb[] usbs = new Usb[2];
        usbs[0]=new Phone(); //向上转型
        usbs[1]=new Camera();//向上转型
        for (int i = 0; i < usbs.length ; i++) {
            usbs[i].work(); //动态绑定
            if (usbs[i] instanceof Phone)  //判断编译类型usbs[i]的运行类型是否是Phone
                ((Phone) usbs[i]).call();  //向下转型
        }
    }
}

接口多态传递

public class InterfacePolyPass{
public static void main(String[]args){
//接口类型的变量可以指向,实现了该接口的类的对象实例IGig=newTeacher();
//如果IG继承了IH接口,而Teacher类实现了IG接口//那么,实际上就相当于Teacher类也实现了IH接口.//这就是所谓的接口多态传递现象.
IH ih=new Teacher();
   }
}
interface IH{
    void hi();
}
interface IG extends IH{    
}
class Teacher implements IG{
    @Override public void hi(){
    }
}
最后修改:2022 年 04 月 04 日 08 : 35 PM