疯狂java


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

抽象类与接口的应用


 

  抽象类和接口不能直接实例化,因为其内部包含了各个抽象方法,抽象方法本身都是未实现的方法,所以无法调用。通过对象多态性,子类发生了向上转型之后,所调用的全部方法都是被覆写过了的方法。

  为抽象类实例化:

  [java]

  abstract class A{ // 定义抽象类A

  public abstract void print() ; // 定义抽象方法print()

  };

  class B extends A { // 定义子类,继承抽象类

  public void print(){ // 覆写抽象方法

  System.out.println("Hello World!!!") ;

  }

  };

  public class AbstractCaseDemo01{

  public static void main(String args[]){

  A a = new B() ; // 通过子类为抽象类实例化

  a.print() ;

  }

  };

  为接口实例化:

  [java]

  interface A{ // 定义抽象类A

  public abstract void print() ; // 定义抽象方法print()

  };

  class B implements A { // 定义子类,继承抽象类

  public void print(){ // 覆写抽象方法

  System.out.println("Hello World!!!") ;

  }

  };

  public class InterfaceCaseDemo01{

  public static void main(String args[]){

  A a = new B() ; // 通过子类为抽象类实例化

  a.print() ;

  }

  };

  2、抽象类的应用----定义模板

  [java]

  abstract class Person{

  private String name ; // 定义name属性

  private int age ; // 定义age属性

  public Person(String name,int age){

  this.name = name ;

  this.age = age ;

  }

  public String getName(){

  return this.name ;

  }

  public int getAge(){

  return this.age ;

  }

  public void say(){ // 人说话是一个具体的功能

  System.out.println(this.getContent()) ; // 输出内容

  }

  public abstract String getContent() ; // 说话的内容由子类决定

  };

  class Student extends Person{

  private float score ;

  public Student(String name,int age,float score){

  super(name,age) ; // 调用父类中的构造方法

  this.score = score ;

  }

  public String getContent(){

  return "学生信息 --> 姓名:" + super.getName() +

  ";年龄:" + super.getAge() +

  ";成绩:" + this.score ;

  }

  };

  class Worker extends Person{

  private float salary ;

  public Worker(String name,int age,float salary){

  super(name,age) ; // 调用父类中的构造方法

  this.salary = salary ;

  }

  public String getContent(){

  return "工人信息 --> 姓名:" + super.getName() +

  ";年龄:" + super.getAge() +

  ";工资:" + this.salary ;

  }

  };

  public class AbstractCaseDemo02{

  public static void main(String args[]){

  Person per1 = null ; // 声明Person对象

  Person per2 = null ; // 声明Person对象

  per1 = new Student("张三",20,99.0f) ; // 学生是一个人

  per2 = new Worker("李四",30,3000.0f) ; // 工人是一个人

  per1.say() ; // 学生说学生的话

  per2.say() ; // 工人说工人的话

  }

  };

  3、接口的实际应用----指定标准

  [java]

  interface USB{ // 定义了USB接口

  public void start() ; // USB设备开始工作

  public void stop() ; // USB设备结束工作

  }

  class Computer{

  public static void plugin(USB usb){ // 电脑上可以插入USB设备

  usb.start() ;

  System.out.println("=========== USB 设备工作 ========") ;

  usb.stop() ;

  }

  };

  class Flash implements USB{

  public void start(){ // 覆写方法

  System.out.println("U盘开始工作。") ;

  }

  public void stop(){ // 覆写方法

  System.out.println("U盘停止工作。") ;

  }

  };

  class Print implements USB{

  public void start(){ // 覆写方法

  System.out.println("打印机开始工作。") ;

  }

  public void stop(){ // 覆写方法

  System.out.println("打印机停止工作。") ;

  }

  };

  public class InterfaceCaseDemo02{

  public static void main(String args[]){

  Computer.plugin(new Flash()) ;

  Computer.plugin(new Print()) ;

  }

  };

  4、工厂设计模式

  [java]

  interface Fruit{ // 定义一个水果接口

  public void eat() ; // 吃水果

  }

  class Apple implements Fruit{

  public void eat(){

  System.out.println("** 吃苹果。") ;

  }

  };

  class Orange implements Fruit{

  public void eat(){

  System.out.println("** 吃橘子。") ;

  }

  };

  public class InterfaceCaseDemo03{

  public static void main(String args[]){

  Fruit f = new Apple() ; // 实例化接口

  f.eat() ;

  }

  };

  此过渡端在程序中就称为工厂设计。

  [java]

  interface Fruit{ // 定义一个水果接口

  public void eat() ; // 吃水果

  }

  class Apple implements Fruit{

  public void eat(){

  System.out.println("** 吃苹果。") ;

  }

  };

  class Orange implements Fruit{

  public void eat(){

  System.out.println("** 吃橘子。") ;

  }

  };

  class Factory{ // 定义工厂类

  public static Fruit getInstance(String className){

  Fruit f = null ;

  if("apple".equals(className)){ // 判断是否要的是苹果的子类

  f = new Apple() ;

  }

  if("orange".equals(className)){ // 判断是否要的是橘子的子类

  f = new Orange() ;

  }

  return f ;

  }

  };

  public class InterfaceCaseDemo05{

  public static void main(String args[]){

  Fruit f = Factory.getInstance(args[0]) ; // 实例化接口

  if(f!=null){ // 判断是否取得实例

  f.eat() ;

  }

  }

  };

  5、代理设计模式

  [java]

  interface Network{

  public void browse() ; // 浏览

  }

  class Real implements Network{

  public void browse(){

  System.out.println("上网浏览信息") ;

  }

  };

  class Proxy implements Network{

  private Network network ; // 代理对象

  public Proxy(Network network){

  this.network = network ;

  }

  public void check(){

  System.out.println("检查用户是否合法。") ;

  }

  public void browse(){

  this.check() ;

  this.network.browse() ; // 调用真实的主题操作

  }

  };

  public class ProxyDemo{

  public static void main(String args[]){

  Network net = null ;

  net = new Proxy(new Real()) ;// 指定代理操作

  net.browse() ; // 客户只关心上网浏览一个操作

  }

  };

  6、适配器设计

  [java]

  interface Window{ // 定义Window接口,表示窗口操作

  public void open() ; // 打开

  public void close() ; // 关闭

  public void activated() ; // 窗口活动

  public void iconified() ; // 窗口最小化

  public void deiconified();// 窗口恢复大小

  }

  abstract class WindowAdapter implements Window{

  public void open(){} ; // 打开

  public void close(){} ; // 关闭

  public void activated(){} ; // 窗口活动

  public void iconified(){} ; // 窗口最小化

  public void deiconified(){};// 窗口恢复大小

  };

  class WindowImpl extends WindowAdapter{

  public void open(){

  System.out.println("窗口打开。") ;

  }

  public void close(){

  System.out.println("窗口关闭。") ;

  }

  };

  public class AdapterDemo{

  public static void main(String args[]){

  Window win = new WindowImpl() ;

  win.open() ;

  win.close() ;

  }

  };

  7、内部类的扩展

  抽象类中包含一个接口

  [java]

  abstract class A{ // 定义抽象类

  public abstract void printA() ; // 抽象方法

  interface B{ // 定义内部接口

  public void printB() ; // 定义抽象方法

  }

  };

  class X extends A{ // 继承抽象类

  public void printA(){

  System.out.println("HELLO --> A") ;

  }

  class Y implements B{ // 定义内部类实现内部接口

  public void printB(){

  System.out.println("HELLO --> B") ;

  }

  };

  };

  public class InnerExtDemo01{

  public static void main(String args[]){

  A.B b = new X()。new Y() ;

  b.printB() ;

  }

  };

  接口中定义一个抽象类

  [java]

  interface A{ // 定义接口

  public void printA() ; // 抽象方法

  abstract class B{ // 定义内部抽象类

  public abstract void printB() ; // 定义抽象方法

  }

  };

  class X implements A{ // 实现接口

  public void printA(){

  System.out.println("HELLO --> A") ;

  }

  class Y extends B{ // 继承抽象类

  public void printB(){

  System.out.println("HELLO --> B") ;

  }

  };

  };

  public class InnerExtDemo02{

  public static void main(String args[]){

  A.B b = new X()。new Y() ;

  b.printB() ;

  }

  };